@@ -1565,6 +1565,7 @@ pub fn build(b: *std.Build) void {
         b.step("test-ts-context-menus", "Compare compiled context menus with complete native request and action races").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-context-menu-tests", &.{ "compiled context menus", "compiled automation interactions preserve context-menu" })).step);
         b.step("test-ts-web-panes", "Compare complete compiled embedded WebView pane coordination with native behavior").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-web-pane-tests", &.{"compiled web panes"})).step);
         b.step("test-ts-extent-program", "Compare compiled retained-table programs with complete native state and callback order").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-extent-program-tests", &.{ "compiled extent", "compiled estimate", "compiled variable" })).step);
+        b.step("test-ts-scroll-mutation", "Compare complete compiled scroll mutation programs with native state and effect ordering").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-scroll-mutation-tests", &.{ "compiled scroll mutation", "TypeScript app adapter supplies placement" })).step);
         b.step("test-ts-virtual-windows", "Compare complete compiled virtual window coordination and fixed-only views").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-virtual-window-tests", &.{"compiled virtual window"})).step);
         b.step("test-ts-staged-rebuild", "Compare complete compiled staged split and anchor rebuild programs").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-staged-rebuild-tests", &.{"compiled staged rebuild"})).step);
         b.step("test-ts-widget-continuity", "Compare complete compiled rebuild semantics and fling continuity").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-widget-continuity-tests", &.{"compiled widget continuity"})).step);
 
@@ -60,6 +60,7 @@
   "src/context_menus.ts",
   "src/web_panes.ts",
   "src/extent_program.ts",
+  "src/scroll_mutation.ts",
   "src/widget_paint.ts",
   "src/widget_presentation.ts",
   "src/widget_paint_walk.ts",
 
@@ -212,6 +212,7 @@ export function native_window_policy(request: Uint8Array): Uint8Array {
   if (request[0] === 98) return nscvContextMenus(request);
   if (request[0] === 99) return nscvWebPanes(request);
   if (request[0] === 100) return nscvExtentProgram(request);
+  if (request[0] === 101) return nscvScrollMutation(request);
   if (request[0] === 89) return nscvBuiltinCoordination(request);
   if (request[0] === 81) return nscvWindowLifecycle(request);
   if (request[0] === 80) return nscvViewCoordination(request);
 
@@ -0,0 +1,86 @@
+/** Scroll mutation capability programs (101). Native retains the complete
+ * states, f32 physics/geometry and callbacks. This owner sequences admission,
+ * numeric capabilities, retained writes, events, accessibility and damage.
+ * Facts are refreshed after each stage; no pointer or identity crosses here.
+ * Modes: axis, textarea, driver, keyboard, kinetic region, kinetic finish,
+ * and a batched kinetic-region selection over at most 1024 copied node facts.
+ * Facts: valid=1, scroll=2, textarea=4, model-owned=8, y=16, x=32,
+ * native=64, rubberband=128, viewport=256, moved=512, needs-step=1024.
+ * Capabilities (see native Kind): 0–4 observations/delegation, 5–10 axis
+ * arithmetic/store/compare, 11–16 geometry/event/semantics/revision/damage,
+ * 17–23 driver/target/state/both-axis writes, 24–31 kinetic probes/steps/damage.
+ */
+function nscvScrollMutation(request: Uint8Array): Uint8Array {
+  if (request[1] === 6) {
+    if (request.length < 16 || request[0] !== 101 || request[2] !== 0 || request[3] !== 0 ||
+        request[4] !== 0 || request[5] !== 0 || request[6] !== 0 || request[7] !== 0)
+      throw new Error("invalid kinetic selection header");
+    const w = new DataView(request.buffer, request.byteOffset, request.byteLength), count = w.getUint32(8, true);
+    if (count > 1024 || request.length !== 16 + count || w.getUint32(12, true) !== 0)
+      throw new Error("invalid kinetic selection facts");
+    const result = new Uint8Array(8 + count); result[0] = 101; result[1] = 6;
+    new DataView(result.buffer).setUint32(4, count, true);
+    for (let i = 0; i < count; i++) result[8 + i] = (request[16 + i]! & (2 | 8 | 64)) === 2 ? 1 : 0;
+    return result;
+  }
+  if (request.length !== 16 || request[0] !== 101 || request[1]! > 5 || request[2]! > 4 ||
+      request[3]! > 2 || request[4]! > 1 || request[5] !== 0 || request[6] !== 0 || request[7] !== 0)
+    throw new Error("invalid scroll mutation header");
+  const w = new DataView(request.buffer, request.byteOffset, request.byteLength);
+  const mode = request[1]!, phase = request[2]!, source = request[3]!, facts = w.getUint32(8, true);
+  if (facts > 2047 || w.getUint32(12, true) !== 0 || (mode === 3 && source > 1) ||
+      (mode === 5 ? phase !== 0 : mode === 4 ? phase > 4 : phase > 2))
+    throw new Error("invalid scroll mutation facts");
+  const actions: number[] = [];
+  let next = 255;
+  const granted = (facts & (request[4] === 1 ? 16 : 32)) !== 0;
+  if (mode === 5) {
+    if ((facts & 512) !== 0) actions.push(14, 15);
+  } else if (phase === 0) {
+    if ((facts & 1) !== 0) {
+      if (mode === 0) {
+        if ((facts & 4) !== 0) { if (granted) actions.push(4); }
+        else if ((facts & 2) !== 0 && (facts & 8) === 0 && granted) { actions.push(0); next = 1; }
+      } else if (mode === 1) {
+        if ((facts & 4) !== 0) { actions.push(1); next = 1; }
+      } else if ((facts & 2) !== 0 && (facts & 8) === 0 && (mode !== 4 || (facts & 64) === 0)) {
+        actions.push(0); next = 1;
+      }
+    }
+  } else if (phase === 1) {
+    if ((facts & 256) === 0) { if (mode === 4) actions.push(24); }
+    else if (mode === 0 || mode === 1) {
+      actions.push(mode === 0 ? 2 : 3);
+      actions.push(source === 0 ? 7 : mode === 0 && (facts & 128) !== 0 && (facts & 64) === 0 ? 5 : 6);
+      // Detented engine input cancels momentum even at an unchanged offset.
+      // Textareas never retain this temporary velocity in the first place.
+      if (mode === 0 && source === 2) actions.push(8);
+      actions.push(mode === 0 ? 9 : 10); next = 2;
+    } else {
+      actions.push(2);
+      if (mode === 4) { if ((facts & 16) !== 0) actions.push(25); next = 2; }
+      else {
+        if ((facts & 16) !== 0) actions.push(mode === 2 ? 17 : 19);
+        if ((facts & 32) !== 0) actions.push(mode === 2 ? 18 : 20);
+        actions.push(21); next = 2;
+      }
+    }
+  } else if (mode === 4 && phase === 2) {
+    actions.push((facts & (16 | 1024)) === (16 | 1024) ? 27 : 29);
+    if ((facts & 32) !== 0) actions.push(26);
+    next = 3;
+  } else if (mode === 4 && phase === 3) {
+    actions.push((facts & (32 | 1024)) === (32 | 1024) ? 28 : 30);
+    actions.push(21); next = 4;
+  } else if ((facts & 512) !== 0) {
+    if (mode <= 1) actions.push(11);
+    else actions.push(22);
+    if (mode !== 1) actions.push(mode === 0 ? 12 : 23, 13);
+    if (mode === 4) actions.push(31);
+    else actions.push(14, 15, 16);
+  }
+  const result = new Uint8Array(8 + actions.length);
+  result[0] = 101; result[1] = mode; result[2] = next; result[3] = actions.length;
+  for (let i = 0; i < actions.length; i++) result[8 + i] = actions[i]!;
+  return result;
+}
@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { stripTypeScriptTypes } from "node:module";
+import { readFileSync } from "node:fs";
+const source = readFileSync(new URL("../src/scroll_mutation.ts", import.meta.url), "utf8");
+const { nscvScrollMutation: program } = await import(`data:text/javascript;base64,${Buffer.from(stripTypeScriptTypes(source) + "\nexport { nscvScrollMutation };").toString("base64")}`);
+function request(mode = 0, phase = 0, facts = 1 | 2 | 16 | 32, source = 0, vertical = 1): Uint8Array {
+  const b = new Uint8Array(16); b.set([101, mode, phase, source, vertical]);
+  new DataView(b.buffer).setUint32(8, facts, true); return b;
+}
+function plan(...args: Parameters<typeof request>): [number, number[]] {
+  const p = program(request(...args)); return [p[2], [...p.subarray(8)]];
+}
+test("scroll mutation keeps retained writes before unchanged exits and publishes after geometry", () => {
+  assert.deepEqual(plan(0, 1, 1 | 2 | 16 | 256, 2), [2, [2, 6, 8, 9]]);
+  assert.deepEqual(plan(0, 2, 1 | 2 | 16 | 256), [255, []]);
+  assert.deepEqual(plan(0, 2, 1 | 2 | 16 | 256 | 512), [255, [11, 12, 13, 14, 15, 16]]);
+  assert.deepEqual(plan(1, 1, 1 | 4 | 256, 1), [2, [3, 6, 10]]);
+  assert.deepEqual(plan(1, 2, 1 | 4 | 256 | 512), [255, [11, 14, 15, 16]]);
+  assert.deepEqual(plan(2, 1, 1 | 2 | 16 | 32 | 256), [2, [2, 17, 18, 21]]);
+  assert.deepEqual(plan(3, 1, 1 | 2 | 32 | 256, 1), [2, [2, 20, 21]]);
+  assert.deepEqual(plan(2, 2, 512), [255, [22, 23, 13, 14, 15, 16]]);
+});
+test("scroll mutation admission separates textarea native momentum and rubber band ownership", () => {
+  assert.deepEqual(plan(0, 0, 1 | 4 | 8 | 16), [255, [4]]);
+  assert.deepEqual(plan(0, 0, 1 | 4 | 16, 0, 0), [255, []]);
+  for (const facts of [0, 1, 1 | 2 | 8 | 16, 1 | 2]) assert.deepEqual(plan(0, 0, facts), [255, []]);
+  assert.deepEqual(plan(1, 0, 1 | 4), [1, [1]]);
+  assert.deepEqual(plan(4, 0, 1 | 2 | 16 | 64), [255, []]);
+  assert.deepEqual(plan(2, 0, 1 | 2 | 16 | 64), [1, [0]]);
+  assert.deepEqual(plan(0, 1, 256 | 128, 1), [2, [2, 5, 9]]);
+  assert.deepEqual(plan(0, 1, 256 | 128 | 64, 1), [2, [2, 6, 9]]);
+  assert.deepEqual(plan(0, 1, 256 | 128, 0), [2, [2, 7, 9]]);
+});
+test("scroll mutation kinetic stages store stopped axes and refresh once after all regions", () => {
+  assert.deepEqual(plan(4, 1, 0), [255, [24]]);
+  assert.deepEqual(plan(4, 1, 256 | 16), [2, [2, 25]]);
+  assert.deepEqual(plan(4, 2, 16 | 32 | 1024), [3, [27, 26]]);
+  assert.deepEqual(plan(4, 2, 32), [3, [29, 26]]);
+  assert.deepEqual(plan(4, 3, 32 | 1024), [4, [28, 21]]);
+  assert.deepEqual(plan(4, 3, 0), [4, [30, 21]]);
+  assert.deepEqual(plan(4, 4, 512), [255, [22, 23, 13, 31]]);
+  assert.deepEqual(plan(5, 0, 512), [255, [14, 15]]);
+  assert.deepEqual(plan(5, 0, 0), [255, []]);
+});
+test("scroll mutation rejects truncated reserved and invalid state and owns result bytes", () => {
+  const b = request(), result = program(b), saved = result.slice();
+  for (let n = 0; n < 16; n++) assert.throws(() => program(b.subarray(0, n)));
+  assert.throws(() => program(new Uint8Array([...b, 0])));
+  for (const at of [0, 1, 2, 3, 4, 5, 6, 7, 9, 12, 15]) {
+    const bad = b.slice(); bad[at] = 255; assert.throws(() => program(bad));
+  }
+  assert.throws(() => program(request(5, 1)));
+  assert.throws(() => program(request(3, 0, 0, 2)));
+  assert.throws(() => program(request(0, 3)));
+  b.fill(255); program(request(4, 3)); assert.deepEqual(result, saved);
+});
+test("scroll mutation batches kinetic admission with bounded independently owned masks", () => {
+  const b = new Uint8Array(16 + 1024); b[0] = 101; b[1] = 6;
+  new DataView(b.buffer).setUint32(8, 1024, true);
+  b[16 + 512] = 2; b[16 + 513] = 2 | 64; b[16 + 514] = 2 | 8;
+  const result = program(b); assert.equal(result.length, 1032);
+  assert.equal(result[8 + 512], 1); assert.equal(result.subarray(8).reduce((a: number, b: number) => a + b, 0), 1);
+  b.fill(0); assert.equal(result[8 + 512], 1);
+  const empty = request(6, 0, 0, 0, 0); assert.equal(program(empty).length, 8);
+  for (const at of [0, 2, 3, 4, 5, 6, 7, 8, 12]) { const bad = empty.slice(); bad[at] = 255; assert.throws(() => program(bad)); }
+  assert.throws(() => program(new Uint8Array([...empty, 0])));
+});
@@ -1935,6 +1935,8 @@ pub const DesignTokens = struct {
     widget_reconcile_policy: ?*const fn ([]const u8, []u8) usize = null,
     /// Portable retained scroll extents, moving subtrees and selected-tab reveals.
     scroll_tree_policy: ?*const fn ([]const u8, []u8) usize = null,
+    /// Portable scroll mutation, retained state and publication sequencing.
+    scroll_mutation_policy: ?*const fn ([]const u8, []u8) usize = null,
     widget_continuity_policy: ?*const fn ([]const u8, []u8) usize = null,
     staged_rebuild_policy: ?*const fn ([]const u8, []u8) usize = null,
     /// Portable retained damage geometry; native supplies font measurements.
 
@@ -1336,6 +1336,8 @@ const testingBuiltinBridgeErrorCode = builtinBridgeErrorCode;
 const testingBuiltinBridgeErrorMessage = builtinBridgeErrorMessage;
 
 pub const testing = struct {
+    pub const scroll_mutation_methods = @import("view_widget_scroll.zig");
+    pub const scroll_mutation_policy = @import("scroll_mutation_policy.zig");
     pub const virtual_window_policy = @import("virtual_window_policy.zig");
     pub const context_menu_policy = @import("context_menu_policy.zig");
     pub const web_pane_test_cases = @import("web_pane_test_cases.zig");
 
@@ -0,0 +1,130 @@
+//! Copied scroll capability programs. All state, identities, f32 numeric
+//! operations and geometry remain native-owned; compiled code orders them.
+const std = @import("std");
+const canvas = @import("canvas");
+const limits = @import("canvas_limits.zig");
+pub const Policy = *const fn ([]const u8, []u8) usize;
+pub const Mode = enum(u8) { axis, textarea, driver, keyboard, kinetic, finish };
+pub const Kind = enum(u8) {
+    viewport,
+    textarea_viewport,
+    region_state,
+    textarea_state,
+    delegate_textarea,
+    wheel,
+    wheel_clamped,
+    discrete,
+    zero_velocity,
+    store_axis,
+    compare_axis,
+    write_axis,
+    translate_axis,
+    event,
+    semantics,
+    revision,
+    dirty,
+    driver_y,
+    driver_x,
+    target_y,
+    target_x,
+    store_state,
+    write_both,
+    translate_both,
+    clear_velocities,
+    probe_y,
+    probe_x,
+    kinetic_y,
+    kinetic_x,
+    zero_y,
+    zero_x,
+    accumulate_dirty,
+};
+pub fn nodeFacts(node: canvas.WidgetLayoutNode) u8 {
+    var facts: u8 = 1;
+    if (node.widget.kind == .scroll_view) facts |= 2;
+    if (node.widget.kind == .textarea) facts |= 4;
+    if (node.widget.layout.virtualized and !canvas.widgetVirtualRuntimeScrolled(node.widget)) facts |= 8;
+    if (canvas.widgetScrollsAxis(node.widget, .vertical)) facts |= 16;
+    if (canvas.widgetScrollsAxis(node.widget, .horizontal)) facts |= 32;
+    if (node.widget.runtime_flags.native_scroll) facts |= 64;
+    return facts;
+}
+pub const Selection = struct {
+    include: [limits.max_canvas_widget_nodes_per_view]bool = undefined,
+};
+pub fn kineticSelection(policy: Policy, nodes: []const canvas.WidgetLayoutNode) Selection {
+    comptime {
+        if (limits.max_canvas_widget_nodes_per_view != 1024) @compileError("update kinetic selection wire budget");
+    }
+    if (nodes.len > limits.max_canvas_widget_nodes_per_view) @panic("kinetic selection exceeds node budget");
+    var input: [16 + limits.max_canvas_widget_nodes_per_view]u8 = @splat(0);
+    input[0] = 101;
+    input[1] = 6;
+    std.mem.writeInt(u32, input[8..12], @intCast(nodes.len), .little);
+    for (nodes, 0..) |node, i| input[16 + i] = nodeFacts(node);
+    var output: [8 + limits.max_canvas_widget_nodes_per_view]u8 = undefined;
+    if (policy(input[0 .. 16 + nodes.len], &output) != 8 + nodes.len or output[0] != 101 or output[1] != 6 or
+        output[2] != 0 or output[3] != 0 or std.mem.readInt(u32, output[4..8], .little) != nodes.len)
+        @panic("invalid kinetic selection header");
+    var result: Selection = undefined;
+    for (result.include[0..nodes.len], 0..) |*include, i| {
+        if (output[8 + i] > 1) @panic("invalid kinetic selection capability");
+        include.* = output[8 + i] == 1;
+    }
+    return result;
+}
+pub const Program = struct {
+    bytes: [24]u8,
+    count: usize,
+    next: u8,
+    pub fn instruction(self: *const Program, index: usize) Kind {
+        std.debug.assert(index < self.count);
+        return @enumFromInt(self.bytes[8 + index]);
+    }
+};
+pub fn plan(policy: Policy, mode: Mode, phase: u8, source: u8, vertical: bool, facts: u32) Program {
+    var input: [16]u8 = @splat(0);
+    input[0..5].* = .{ 101, @intFromEnum(mode), phase, source, @intFromBool(vertical) };
+    std.mem.writeInt(u32, input[8..12], facts, .little);
+    var result: Program = undefined;
+    const size = policy(&input, &result.bytes);
+    if (size < 8 or size > result.bytes.len or result.bytes[0] != 101 or result.bytes[1] != @intFromEnum(mode) or
+        std.mem.readInt(u32, result.bytes[4..8], .little) != 0)
+        @panic("invalid scroll mutation program header");
+    result.count = result.bytes[3];
+    result.next = result.bytes[2];
+    if (size != 8 + result.count or (result.next != 255 and (result.next != phase + 1 or result.next > (if (mode == .kinetic) @as(u8, 4) else 2))) or
+        (mode == .finish and result.next != 255)) @panic("invalid scroll mutation program progress");
+    if (mode != .finish and ((facts & 1 == 0 and result.count != 0) or
+        (phase > 1 and facts & 256 == 0 and result.count != 0))) @panic("invalid scroll mutation storage admission");
+    for (result.bytes[8..size]) |kind| {
+        if (kind > @intFromEnum(Kind.accumulate_dirty)) @panic("invalid scroll mutation capability");
+        const capability: Kind = @enumFromInt(kind);
+        // Capability admission, independent of the program's semantic choices.
+        const allowed = switch (capability) {
+            .viewport => phase == 0 and mode != .textarea and mode != .finish,
+            .textarea_viewport => phase == 0 and mode == .textarea,
+            .delegate_textarea => phase == 0 and mode == .axis,
+            .region_state => phase == 1 and mode != .textarea and mode != .finish,
+            .textarea_state, .compare_axis => phase == 1 and mode == .textarea,
+            .wheel, .wheel_clamped, .discrete => phase == 1 and (mode == .axis or mode == .textarea),
+            .zero_velocity, .store_axis => phase == 1 and mode == .axis,
+            .driver_y, .driver_x => phase == 1 and mode == .driver,
+            .target_y, .target_x => phase == 1 and mode == .keyboard,
+            .store_state => (phase == 1 and (mode == .driver or mode == .keyboard)) or (phase == 3 and mode == .kinetic),
+            .clear_velocities => phase == 1 and mode == .kinetic,
+            .probe_y => phase == 1 and mode == .kinetic,
+            .probe_x, .kinetic_y, .zero_y => phase == 2 and mode == .kinetic,
+            .kinetic_x, .zero_x => phase == 3 and mode == .kinetic,
+            .semantics, .revision => (phase == 2 and mode != .kinetic and mode != .finish) or (phase == 0 and mode == .finish),
+            .write_axis => phase == 2 and (mode == .axis or mode == .textarea),
+            .translate_axis => phase == 2 and mode == .axis,
+            .dirty => phase == 2 and mode != .kinetic and mode != .finish,
+            .event => (phase == 2 and (mode == .axis or mode == .driver or mode == .keyboard)) or (phase == 4 and mode == .kinetic),
+            .write_both, .translate_both => (phase == 2 and (mode == .driver or mode == .keyboard)) or (phase == 4 and mode == .kinetic),
+            .accumulate_dirty => phase == 4 and mode == .kinetic,
+        };
+        if (!allowed) @panic("invalid scroll mutation capability admission");
+    }
+    return result;
+}