diff --git a/build.zig b/build.zig
index 19fde3dc9..06ac7f0cd 100644
--- a/build.zig
+++ b/build.zig
@@ -1582,6 +1582,7 @@ pub fn build(b: *std.Build) void {
         b.step("test-ts-static-markup-values", "Compare static markup dynamic values, exact payloads, keys and complete failure effects").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-static-markup-value-tests", &.{ "static markup values", "compiled markup values" })).step);
         b.step("test-ts-static-markup-collections", "Compare static virtual windows, row consumption, exact keys, stepper indices and complete failure effects").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-static-markup-collection-tests", &.{ "static markup collections", "compiled markup numeric", "compiled markup specialized" })).step);
         b.step("test-ts-static-markup-expansion", "Compare static branches, item sequencing, lexical captures, exact inherited keys and complete failure effects").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-static-markup-expansion-tests", &.{ "static markup expansion", "static markup collections" })).step);
+        b.step("test-ts-static-markup-specialized", "Compare static specialized metadata, forwarded handlers, tab triggers and complete failure effects").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-static-markup-specialized-tests", &.{ "static markup", "compiled markup values", "compiled markup metadata", "compiled markup options", "compiled markup postprocessing", "compiled markup numeric", "compiled markup admission", "compiled markup literals" })).step);
         b.step("test-ts-markup-postprocessing", "Compare forwarded handlers, provenance, tabs and borrowed binding paths").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-markup-postprocessing-tests", &.{ "compiled markup postprocessing", "compiled markup literals", "compiled markup admission", "compiled markup construction" })).step);
         b.step("test-ts-markup-literals", "Compare exact literal inference, template defaults and lexical capture ownership").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-markup-literal-tests", &.{ "compiled markup literals", "compiled markup admission", "compiled markup construction" })).step);
         b.step("test-ts-markup-admission", "Compare specialized attribute forms, raw flags and complete eager failure effects").dependOn(&b.addRunArtifact(filteredTestArtifact(b, ts_core_artifacts.surface_layout.root_module, "ts-markup-admission-tests", &.{ "compiled markup admission", "compiled markup specialized", "compiled markup options", "compiled markup metadata" })).step);
diff --git a/packages/core/src/markup_values.ts b/packages/core/src/markup_values.ts
index 41835a9a7..317a7aaa0 100644
--- a/packages/core/src/markup_values.ts
+++ b/packages/core/src/markup_values.ts
@@ -316,10 +316,13 @@ function nscmValues(r: NscElementReader, out: number[], mode: number): void {
     const path = r.blob(), dot = nscmDot(path);
     // Return borrowed byte offsets; a trailing dot has a present empty tail.
     nsceEmit(out, 93, 0, dot < 0 ? path.length : dot, dot < 0 ? 0 : dot + 1);
+  } else if (mode === 36) {
+    // A use-site handler replaces the local timeline handler before construction.
+    nsceEmit(out, r.flag() ? 1 : 0);
   } else throw new Error("invalid markup value mode");
 }
 function nscvMarkupValues(input: Uint8Array): Uint8Array {
-  if (input.length < 4 || input[0] !== 113 || input[1] !== 1 || input[2]! > 35 || input[3]! > 1) throw new Error("invalid markup value header");
+  if (input.length < 4 || input[0] !== 113 || input[1] !== 1 || input[2]! > 36 || input[3]! > 1) throw new Error("invalid markup value header");
   const r = new NscElementReader(input), out: number[] = [];
   nscmValues(r, out, input[2]!);
   if (r.at !== input.length) throw new Error("trailing markup value facts");
diff --git a/packages/core/test/markup_values.test.ts b/packages/core/test/markup_values.test.ts
index 924a908c0..35190eeec 100644
--- a/packages/core/test/markup_values.test.ts
+++ b/packages/core/test/markup_values.test.ts
@@ -302,3 +302,12 @@ test("binding paths retain byte offsets including empty, trailing and malformed
     assert.deepEqual(row!.fields, [dot < 0 ? path.length : dot, dot < 0 ? 0 : dot + 1, 0, 0, 0]);
   }
 });
+
+test("timeline forwarding selects use-site handlers and rejects malformed facts", () => {
+  assert.deepEqual(actions(new Packet(36).word(0)), [0]);
+  assert.deepEqual(actions(new Packet(36).word(1)), [1]);
+  const valid = new Packet(36).word(1).bytes();
+  for (let end = 0; end < valid.length; end++) assert.throws(() => run(valid.slice(0, end)));
+  assert.throws(() => run(new Packet(36).word(2).bytes()));
+  assert.throws(() => run(new Packet(36).word(0, 1).bytes()));
+});
diff --git a/src/primitives/canvas/ui_markup_compiled.zig b/src/primitives/canvas/ui_markup_compiled.zig
index dff244cdf..8de2b3474 100644
--- a/src/primitives/canvas/ui_markup_compiled.zig
+++ b/src/primitives/canvas/ui_markup_compiled.zig
@@ -35,6 +35,7 @@ const reflect = @import("ui_markup_reflect.zig");
 const runtime_values = @import("ui_markup_compiled_values.zig");
 const specialized = @import("ui_markup_specialized.zig");
 const construction = @import("ui_markup_construction.zig");
+const value_programs = @import("ui_markup_values.zig");
 
 const Value = interpreter.Value;
 
@@ -273,6 +274,34 @@ fn CompiledMarkupEngine(comptime ModelT: type, comptime MsgT: type, comptime res
         }
 
         fn buildElementWithForwardedPress(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT) Ui.Node {
+            if (ui.expression_policy) |owner| return buildElementWithForwardedPressOwned(node, entries, ui, model, scope, forwarded_press, owner);
+            return buildElementWithForwardedPressReference(node, entries, ui, model, scope, forwarded_press);
+        }
+
+        fn buildElementWithForwardedPressOwned(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT, owner: markup.expr.Policy) Ui.Node {
+            var request = value_programs.Request.init(33);
+            defer request.deinit();
+            // Static views do not attach interpreter provenance.
+            request.words(&.{ @intFromBool(forwarded_press != null), 0 });
+            var program = request.program(owner) catch return runtimeFail(Ui.Node, ui);
+            defer program.deinit();
+            var built: ?Ui.Node = null;
+            while (program.next()) |step| switch (step.action) {
+                88 => built = buildElementInner(node, entries, ui, model, scope, forwarded_press),
+                89 => {
+                    built.?.on_press = forwarded_press.?;
+                    built.?.widget.semantics.focusable = true;
+                },
+                91 => {
+                    if (program.next() != null) @panic("trailing static element publication capability");
+                    return built orelse @panic("static element publication did not build a node");
+                },
+                else => @panic("invalid static element publication capability"),
+            };
+            @panic("incomplete static element publication program");
+        }
+
+        fn buildElementWithForwardedPressReference(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT) Ui.Node {
             var built = buildElementInner(node, entries, ui, model, scope, forwarded_press);
             if (forwarded_press) |msg| {
                 // A press declared on <use> belongs to the expanded root.
@@ -284,6 +313,23 @@ fn CompiledMarkupEngine(comptime ModelT: type, comptime MsgT: type, comptime res
             return built;
         }
 
+        fn lowerTabsTriggers(ui: *Ui, children: []Ui.Node) void {
+            const owner = ui.expression_policy orelse return interpreter.lowerTabsTriggers(children);
+            var request = value_programs.Request.init(34);
+            defer request.deinit();
+            request.word(children.len);
+            for (children) |child| request.blob(@tagName(child.widget.kind));
+            var program = request.program(owner) catch {
+                ui.failed = true;
+                return;
+            };
+            defer program.deinit();
+            while (program.next()) |step| switch (step.action) {
+                92 => children[step.fields[0]].widget.kind = .segmented_control,
+                else => @panic("invalid static tab trigger capability"),
+            };
+        }
+
         fn buildElementInner(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT) Ui.Node {
             if (comptime std.mem.eql(u8, node.name, "virtual-window")) return buildVirtualWindow(node, entries, ui, model, scope);
             if (comptime std.mem.eql(u8, node.name, "virtual-list")) return buildVirtualList(node, entries, ui, model, scope);
@@ -559,7 +605,7 @@ fn CompiledMarkupEngine(comptime ModelT: type, comptime MsgT: type, comptime res
             // `<button>` children of a `<tabs>` strip lower to the
             // widget kind tab strips are built on (see
             // `interpreter.lowerTabsTriggers`).
-            if (comptime (kind == .tabs)) interpreter.lowerTabsTriggers(children.items);
+            if (comptime (kind == .tabs)) lowerTabsTriggers(ui, children.items);
             var built = ui.el(kind, options, @as([]const Ui.Node, children.items));
             // Interpreter parity: the extracted reactions run lands on
             // the bubble widget's chrome-text channel — the render pass
@@ -1150,6 +1196,71 @@ fn CompiledMarkupEngine(comptime ModelT: type, comptime MsgT: type, comptime res
         /// runtime. Misuse fails compilation with the interpreter's
         /// message.
         fn buildMarkdown(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype) Ui.Node {
+            if (ui.expression_policy) |owner| return buildMarkdownOwned(node, entries, ui, model, scope, owner);
+            return buildMarkdownReference(node, entries, ui, model, scope);
+        }
+
+        fn buildMarkdownOwned(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, owner: markup.expr.Policy) Ui.Node {
+            comptime {
+                if (node.children.len != 0) fail(node.children[0], markup.markdown_children_message);
+                for (node.attrs) |attribute| {
+                    if (std.mem.eql(u8, attribute.name, "kind")) continue;
+                    if (std.mem.eql(u8, attribute.name, "source")) continue;
+                    if (std.mem.eql(u8, attribute.name, "on-link")) continue;
+                    if (std.mem.eql(u8, attribute.name, "on-details")) continue;
+                    if (std.mem.eql(u8, attribute.name, "details-expanded")) continue;
+                    if (std.mem.eql(u8, attribute.name, "issue-link-base")) continue;
+                    if (std.mem.eql(u8, attribute.name, "images")) continue;
+                    fail(node, markup.markdown_attr_message);
+                }
+            }
+            const source_path = comptime blk: {
+                const raw = node.attr("source") orelse fail(node, markup.markdown_source_message);
+                const expression = markup.parseAttrExpression(raw) orelse fail(node, markup.markdown_source_message);
+                if (expression != .binding) fail(node, markup.markdown_source_message);
+                break :blk expression.binding;
+            };
+            comptime requireVariant(pathVariant(node, entries, source_path, true), &.{.string}, node, markup.markdown_source_message);
+            const source_text = switch (bindingValue(node, entries, source_path, ui, model, scope, true)) {
+                .string => |text| text,
+                else => runtimeFail([]const u8, ui),
+            };
+
+            var options: Md.Options = .{};
+            if (comptime (node.attr("on-link") != null)) {
+                options.on_link = comptime markdownLinkConstructor(node, node.attr("on-link").?);
+            }
+            if (comptime (node.attr("on-details") != null)) {
+                options.on_details = comptime markdownDetailsConstructor(node, node.attr("on-details").?);
+            }
+            if (comptime (node.attr("details-expanded") != null)) {
+                options.details_expanded = detailsExpandedItems(node, entries, comptime node.attr("details-expanded").?, ui, model, scope);
+            }
+            if (comptime (node.attr("images") != null)) {
+                options.images = markdownImageItems(node, entries, comptime node.attr("images").?, ui, model, scope);
+            }
+            if (comptime (node.attr("issue-link-base") != null)) {
+                const raw = comptime node.attr("issue-link-base").?;
+                comptime {
+                    const expression = markup.parseAttrExpression(raw) orelse fail(node, markup.markdown_issue_link_base_message);
+                    if (expression == .equals) fail(node, markup.markdown_issue_link_base_message);
+                }
+                comptime requireVariant(attrExprVariant(node, entries, "issue-link-base", raw), &.{.string}, node, markup.markdown_issue_link_base_message);
+                const base = switch (attrExprValue(node, entries, "issue-link-base", raw, ui, model, scope)) {
+                    .string => |text| text,
+                    else => runtimeFail([]const u8, ui),
+                };
+                const admission = value_programs.specializedValue(owner, 2, .{ .string = base });
+                switch (admission.action) {
+                    0 => {},
+                    1 => options.issue_link_base = base,
+                    else => @panic("invalid static issue link publication capability"),
+                }
+            }
+            return Md.view(ui, source_text, options);
+        }
+
+        fn buildMarkdownReference(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype) Ui.Node {
             comptime {
                 if (node.children.len != 0) fail(node.children[0], markup.markdown_children_message);
                 for (node.attrs) |attribute| {
@@ -1207,6 +1318,111 @@ fn CompiledMarkupEngine(comptime ModelT: type, comptime MsgT: type, comptime res
         // ----------------------------------------------------------- code
 
         fn buildCode(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype) Ui.Node {
+            if (ui.expression_policy) |owner| return buildCodeOwned(node, entries, ui, model, scope, owner);
+            return buildCodeReference(node, entries, ui, model, scope);
+        }
+
+        fn buildCodeOwned(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, owner: markup.expr.Policy) Ui.Node {
+            comptime {
+                if (node.children.len != 0) fail(node.children[0], markup.code_children_message);
+                for (node.attrs) |attribute| {
+                    if (std.mem.eql(u8, attribute.name, "kind")) continue;
+                    const known = std.mem.eql(u8, attribute.name, "source") or
+                        std.mem.eql(u8, attribute.name, "language") or
+                        std.mem.eql(u8, attribute.name, "editable") or
+                        std.mem.eql(u8, attribute.name, "on-input") or
+                        std.mem.eql(u8, attribute.name, "line-numbers") or
+                        std.mem.eql(u8, attribute.name, "added-lines") or
+                        std.mem.eql(u8, attribute.name, "removed-lines") or
+                        std.mem.eql(u8, attribute.name, "wrap") or
+                        std.mem.eql(u8, attribute.name, "width") or
+                        std.mem.eql(u8, attribute.name, "height") or
+                        std.mem.eql(u8, attribute.name, "min-width") or
+                        std.mem.eql(u8, attribute.name, "grow") or
+                        std.mem.eql(u8, attribute.name, "label") or
+                        std.mem.eql(u8, attribute.name, "key") or
+                        std.mem.eql(u8, attribute.name, "global-key");
+                    if (!known) fail(node, markup.code_attr_message);
+                }
+            }
+            const source_path = comptime blk: {
+                const raw = node.attr("source") orelse fail(node, markup.code_source_message);
+                const expression = markup.parseAttrExpression(raw) orelse fail(node, markup.code_source_message);
+                if (expression != .binding) fail(node, markup.code_source_message);
+                break :blk expression.binding;
+            };
+            comptime requireVariant(pathVariant(node, entries, source_path, true), &.{.string}, node, markup.code_source_message);
+            const source = switch (bindingValue(node, entries, source_path, ui, model, scope, true)) {
+                .string => |text| text,
+                else => runtimeFail([]const u8, ui),
+            };
+
+            var options: Ui.CodeOptions = .{};
+            var added_lines_storage: [canvas.code.max_diff_lines]usize = undefined;
+            var removed_lines_storage: [canvas.code.max_diff_lines]usize = undefined;
+            if (comptime (node.attr("language") != null)) {
+                const name = comptime blk: {
+                    const expression = markup.parseAttrExpression(node.attr("language").?) orelse fail(node, markup.code_language_message);
+                    if (expression != .literal) fail(node, markup.code_language_message);
+                    if (!canvas.code.isLanguageName(expression.literal)) fail(node, markup.code_language_message);
+                    break :blk expression.literal;
+                };
+                options.language = canvas.code.languageFromName(name);
+            }
+            if (comptime (node.attr("line-numbers") != null)) {
+                options.line_numbers = videoFlagValue(node, entries, comptime node.attr("line-numbers").?, ui, model, scope);
+            }
+            if (comptime (node.attr("added-lines") != null)) {
+                const spec = codeLineSpecAttr(node, entries, comptime node.attr("added-lines").?, ui, model, scope);
+                options.added_lines = value_programs.lineNumbers(owner, spec, &added_lines_storage) orelse blk: {
+                    ui.failed = true;
+                    break :blk added_lines_storage[0..0];
+                };
+            }
+            if (comptime (node.attr("removed-lines") != null)) {
+                const spec = codeLineSpecAttr(node, entries, comptime node.attr("removed-lines").?, ui, model, scope);
+                options.removed_lines = value_programs.lineNumbers(owner, spec, &removed_lines_storage) orelse blk: {
+                    ui.failed = true;
+                    break :blk removed_lines_storage[0..0];
+                };
+            }
+            if (comptime (node.attr("editable") != null)) {
+                options.editable = videoFlagValue(node, entries, comptime node.attr("editable").?, ui, model, scope);
+            }
+            if (comptime (node.attr("on-input") != null)) {
+                const expression = comptime (markup.parseMessageExpression(node.attr("on-input").?) orelse
+                    fail(node, "invalid message expression: on-* takes a Msg tag (\"add\") or tag with one binding payload (\"toggle:{item.id}\")"));
+                options.on_input = comptime (inputConstructor(expression.tag) orelse
+                    fail(node, "on-input tag must carry a TextInputEvent payload"));
+            }
+            if (comptime (node.attr("wrap") != null)) {
+                options.wrap = videoFlagValue(node, entries, comptime node.attr("wrap").?, ui, model, scope);
+            }
+            if (comptime (node.attr("width") != null)) {
+                options.width = floatAttr(node, entries, comptime node.attr("width").?, ui, model, scope);
+            }
+            if (comptime (node.attr("height") != null)) {
+                options.height = floatAttr(node, entries, comptime node.attr("height").?, ui, model, scope);
+            }
+            if (comptime (node.attr("min-width") != null)) {
+                options.min_width = floatAttr(node, entries, comptime node.attr("min-width").?, ui, model, scope);
+            }
+            if (comptime (node.attr("grow") != null)) {
+                options.grow = floatAttr(node, entries, comptime node.attr("grow").?, ui, model, scope);
+            }
+            if (comptime (node.attr("label") != null)) {
+                options.semantics.label = stringAttr(node, entries, "label", comptime node.attr("label").?, ui, model, scope, "label expects text");
+            }
+            if (comptime (node.attr("key") != null)) {
+                options.key = attrKey(node, entries, comptime node.attr("key").?, ui, model, scope, "keys must be integers or strings");
+            }
+            if (comptime (node.attr("global-key") != null)) {
+                options.global_key = attrKey(node, entries, comptime node.attr("global-key").?, ui, model, scope, "keys must be integers or strings");
+            }
+            return ui.code(options, source);
+        }
+
+        fn buildCodeReference(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype) Ui.Node {
             comptime {
                 if (node.children.len != 0) fail(node.children[0], markup.code_children_message);
                 for (node.attrs) |attribute| {
@@ -1682,6 +1898,95 @@ fn CompiledMarkupEngine(comptime ModelT: type, comptime MsgT: type, comptime res
 
         /// Comptime mirror of the interpreter's `buildTimelineItem`.
         fn buildTimelineItem(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT) Ui.Node {
+            if (ui.expression_policy) |owner| return buildTimelineItemOwned(node, entries, ui, model, scope, forwarded_press, owner);
+            return buildTimelineItemReference(node, entries, ui, model, scope, forwarded_press);
+        }
+
+        fn buildTimelineItemOwned(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT, owner: markup.expr.Policy) Ui.Node {
+            comptime {
+                if (node.children.len != 0) fail(node.children[0], markup.timeline_item_children_message);
+                if (node.attr("title") == null) fail(node, markup.timeline_item_title_message);
+                for (node.attrs) |attribute| {
+                    if (std.mem.eql(u8, attribute.name, "kind")) continue;
+                    if (std.mem.eql(u8, attribute.name, "title")) continue;
+                    if (std.mem.eql(u8, attribute.name, "description")) continue;
+                    if (std.mem.eql(u8, attribute.name, "meta")) continue;
+                    if (std.mem.eql(u8, attribute.name, "indicator")) continue;
+                    if (std.mem.eql(u8, attribute.name, "icon")) continue;
+                    if (std.mem.eql(u8, attribute.name, "variant")) continue;
+                    if (std.mem.eql(u8, attribute.name, "connector")) continue;
+                    if (std.mem.eql(u8, attribute.name, "selected")) continue;
+                    if (std.mem.eql(u8, attribute.name, "on-press")) continue;
+                    if (std.mem.startsWith(u8, attribute.name, "on-")) fail(node, markup.timeline_item_press_only_message);
+                    if (std.mem.eql(u8, attribute.name, "key")) continue;
+                    if (std.mem.eql(u8, attribute.name, "global-key")) continue;
+                    fail(node, markup.timeline_item_attr_message);
+                }
+            }
+            var options: Ui.TimelineItemOptions = .{ .title = "" };
+            options.title = stringAttr(node, entries, "title", comptime node.attr("title").?, ui, model, scope, markup.timeline_item_text_attr_message);
+            if (comptime (node.attr("description") != null)) {
+                options.description = stringAttr(node, entries, "description", comptime node.attr("description").?, ui, model, scope, markup.timeline_item_text_attr_message);
+            }
+            if (comptime (node.attr("meta") != null)) {
+                options.meta = stringAttr(node, entries, "meta", comptime node.attr("meta").?, ui, model, scope, markup.timeline_item_text_attr_message);
+            }
+            if (comptime (node.attr("indicator") != null)) {
+                options.indicator = stringAttr(node, entries, "indicator", comptime node.attr("indicator").?, ui, model, scope, markup.timeline_item_text_attr_message);
+            }
+            if (comptime (node.attr("icon") != null)) {
+                // Vector icon indicator: the shared icon value grammar,
+                // resolved at comptime like every icon attribute.
+                switch (comptime iconValueChecked(node, node.attr("icon").?, markup.button_icon_message)) {
+                    .builtin, .app => |name| options.icon = name,
+                    .binding => options.icon = stringAttr(node, entries, "icon", comptime node.attr("icon").?, ui, model, scope, markup.button_icon_message),
+                    .invalid => unreachable,
+                }
+            }
+            if (comptime (node.attr("variant") != null)) {
+                const raw = comptime node.attr("variant").?;
+                comptime requireVariant(exprVariant(node, entries, raw), &.{.string}, node, "expected an option name");
+                const expression = comptime markup.parseAttrExpression(raw).?;
+                if (comptime (expression == .literal)) {
+                    options.variant = comptime (std.meta.stringToEnum(canvas.WidgetVariant, expression.literal) orelse fail(node, "unknown option value"));
+                } else {
+                    const text = switch (evalExpr(node, entries, raw, ui, model, scope)) {
+                        .string => |text| text,
+                        else => runtimeFail([]const u8, ui),
+                    };
+                    options.variant = runtimeEnum(canvas.WidgetVariant, ui, text);
+                }
+            }
+            if (comptime (node.attr("connector") != null)) {
+                options.connector = markup.expr.truthyWithPolicy(ui.expression_policy, evalExpr(node, entries, comptime node.attr("connector").?, ui, model, scope));
+            }
+            if (comptime (node.attr("selected") != null)) {
+                options.selected = markup.expr.truthyWithPolicy(ui.expression_policy, evalExpr(node, entries, comptime node.attr("selected").?, ui, model, scope));
+            }
+            if (comptime (node.attr("on-press") != null)) {
+                // Reuse the full message-attr machinery (payload bindings
+                // included) through a scratch options value.
+                const press_index = comptime blk: {
+                    for (node.attrs, 0..) |attribute, index| {
+                        if (std.mem.eql(u8, attribute.name, "on-press")) break :blk index;
+                    }
+                    unreachable;
+                };
+                var scratch: Ui.ElementOptions = .{};
+                applyMessageAttr(node, comptime node.attrs[press_index], entries, ui, model, scope, &scratch);
+                options.on_press = scratch.on_press;
+            }
+            if (comptime (node.attr("key") != null)) {
+                options.key = attrKey(node, entries, comptime node.attr("key").?, ui, model, scope, "keys must be integers or strings");
+            }
+            if (comptime (node.attr("global-key") != null)) {
+                options.global_key = attrKey(node, entries, comptime node.attr("global-key").?, ui, model, scope, "keys must be integers or strings");
+            }
+            if (value_programs.forwardedPress(owner, forwarded_press != null)) options.on_press = forwarded_press.?;
+            return ui.timelineItem(options);
+        }
+
+        fn buildTimelineItemReference(comptime node: markup.MarkupNode, comptime entries: []const ScopeEntry, ui: *Ui, model: *const ModelT, scope: anytype, forwarded_press: ?MsgT) Ui.Node {
             comptime {
                 if (node.children.len != 0) fail(node.children[0], markup.timeline_item_children_message);
                 if (node.attr("title") == null) fail(node, markup.timeline_item_title_message);
diff --git a/src/primitives/canvas/ui_markup_values.zig b/src/primitives/canvas/ui_markup_values.zig
index 6f4978410..a1f988704 100644
--- a/src/primitives/canvas/ui_markup_values.zig
+++ b/src/primitives/canvas/ui_markup_values.zig
@@ -356,3 +356,13 @@ pub fn message(code: u8) []const u8 {
         else => @panic("invalid markup value diagnostic"),
     };
 }
+
+/// The compiled program selects whether a forwarded root handler replaces the local handler.
+pub fn forwardedPress(owner: markup.expr.Policy, present: bool) bool {
+    const row = decide(owner, 36, &.{@intFromBool(present)});
+    return switch (row.action) {
+        0 => false,
+        1 => true,
+        else => @panic("invalid forwarded press capability"),
+    };
+}
diff --git a/src/primitives/canvas/ui_markup_view.zig b/src/primitives/canvas/ui_markup_view.zig
index e5658448f..65da9e6f6 100644
--- a/src/primitives/canvas/ui_markup_view.zig
+++ b/src/primitives/canvas/ui_markup_view.zig
@@ -2076,7 +2076,7 @@ pub fn MarkupView(comptime ModelT: type, comptime MsgT: type) type {
                     options.global_key = try self.attrKey(scope, node, attribute);
                 },
                 200 => {
-                    if (forwarded_press) |msg| options.on_press = msg;
+                    if (value_programs.forwardedPress(owner, forwarded_press != null)) options.on_press = forwarded_press.?;
                     return ui.timelineItem(options);
                 },
                 255 => return self.failNode(if (step.fields[0] == 0) node else node.children[step.fields[0] - 1], specialized.message(step.code)),
diff --git a/tests/ts-core/markup_admission_e2e_tests.zig b/tests/ts-core/markup_admission_e2e_tests.zig
index cb00c395f..bfba8a51b 100644
--- a/tests/ts-core/markup_admission_e2e_tests.zig
+++ b/tests/ts-core/markup_admission_e2e_tests.zig
@@ -26,7 +26,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
     }
 }
 
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 var forms: [14]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) {
diff --git a/tests/ts-core/markup_literals_e2e_tests.zig b/tests/ts-core/markup_literals_e2e_tests.zig
index bab1598fc..6c6b061f5 100644
--- a/tests/ts-core/markup_literals_e2e_tests.zig
+++ b/tests/ts-core/markup_literals_e2e_tests.zig
@@ -26,7 +26,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
     }
 }
 
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) {
         operations[input[2]] += 1;
diff --git a/tests/ts-core/markup_metadata_e2e_tests.zig b/tests/ts-core/markup_metadata_e2e_tests.zig
index 758154d1a..8bb3affbd 100644
--- a/tests/ts-core/markup_metadata_e2e_tests.zig
+++ b/tests/ts-core/markup_metadata_e2e_tests.zig
@@ -25,7 +25,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
         else => try @import("surface_layout_e2e_tests.zig").expectComplete(a, b),
     }
 }
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) operations[input[2]] += 1;
     const n = core.nativeWindowPolicy(input, output);
diff --git a/tests/ts-core/markup_numeric_e2e_tests.zig b/tests/ts-core/markup_numeric_e2e_tests.zig
index ede665936..ddb06944d 100644
--- a/tests/ts-core/markup_numeric_e2e_tests.zig
+++ b/tests/ts-core/markup_numeric_e2e_tests.zig
@@ -26,7 +26,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
     }
 }
 
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 var channels: [3]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) {
diff --git a/tests/ts-core/markup_options_e2e_tests.zig b/tests/ts-core/markup_options_e2e_tests.zig
index 113dc113a..ce6fed090 100644
--- a/tests/ts-core/markup_options_e2e_tests.zig
+++ b/tests/ts-core/markup_options_e2e_tests.zig
@@ -25,7 +25,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
         else => try @import("surface_layout_e2e_tests.zig").expectComplete(a, b),
     }
 }
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) operations[input[2]] += 1;
     const n = core.nativeWindowPolicy(input, output);
diff --git a/tests/ts-core/markup_values_e2e_tests.zig b/tests/ts-core/markup_values_e2e_tests.zig
index 0bb1a8760..41a1f836d 100644
--- a/tests/ts-core/markup_values_e2e_tests.zig
+++ b/tests/ts-core/markup_values_e2e_tests.zig
@@ -25,7 +25,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
         else => try @import("surface_layout_e2e_tests.zig").expectComplete(a, b),
     }
 }
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) operations[input[2]] += 1;
     const n = core.nativeWindowPolicy(input, output);
diff --git a/tests/ts-core/static_markup_collections_e2e_tests.zig b/tests/ts-core/static_markup_collections_e2e_tests.zig
index c15ee706d..399cdb010 100644
--- a/tests/ts-core/static_markup_collections_e2e_tests.zig
+++ b/tests/ts-core/static_markup_collections_e2e_tests.zig
@@ -25,7 +25,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
     }
 }
 
-var values: [36]usize = @splat(0);
+var values: [256]usize = @splat(0);
 var specialized: [21]usize = @splat(0);
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) values[input[2]] += 1;
diff --git a/tests/ts-core/static_markup_specialized_e2e_tests.zig b/tests/ts-core/static_markup_specialized_e2e_tests.zig
new file mode 100644
index 000000000..c02a27171
--- /dev/null
+++ b/tests/ts-core/static_markup_specialized_e2e_tests.zig
@@ -0,0 +1,160 @@
+const std = @import("std");
+const sdk = @import("native_sdk");
+const core = @import("surface_fixture_core");
+const c = sdk.canvas;
+fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
+    const T = @TypeOf(a);
+    switch (@typeInfo(T)) {
+        .@"struct" => |info| inline for (info.fields) |field| try exact(@field(a, field.name), @field(b, field.name)),
+        .optional => {
+            try std.testing.expectEqual(a != null, b != null);
+            if (a) |value| try exact(value, b.?);
+        },
+        .pointer => |info| if (info.size == .slice) {
+            try std.testing.expectEqual(a.len, b.len);
+            for (a, b) |l, r| try exact(l, r);
+        } else if (info.size == .one and (@typeInfo(info.child) == .@"struct" or @typeInfo(info.child) == .@"union" or info.child == bool)) try exact(a.*, b.*) else try std.testing.expectEqual(a, b),
+        .array => for (a, b) |l, r| try exact(l, r),
+        .@"union" => {
+            try std.testing.expectEqual(std.meta.activeTag(a), std.meta.activeTag(b));
+            switch (a) {
+                inline else => |value, tag| try exact(value, @field(b, @tagName(tag))),
+            }
+        },
+        else => try @import("surface_layout_e2e_tests.zig").expectComplete(a, b),
+    }
+}
+
+var calls: [4096]u64 = undefined;
+var call_count: usize = 0;
+var modes: [256]usize = @splat(0);
+fn observed(input: []const u8, output: []u8) usize {
+    if (input[0] == 113) modes[input[2]] += 1;
+    const count = core.nativeWindowPolicy(input, output);
+    core.rt.frameReset();
+    return count;
+}
+fn event(value: u64) void {
+    calls[call_count] = value;
+    call_count += 1;
+}
+const Model = struct {
+    lines: []const u8 = "2-3,1,2",
+    removed: []const u8 = "3",
+    prefix: []const u8 = "https://example.invalid/issues/",
+    chosen: i64 = -9007199254740993,
+    pub fn code(_: *const Model) []const u8 {
+        event(1);
+        return "const x = 1;\nreturn x;\n// Done";
+    }
+    pub fn added(self: *const Model) []const u8 {
+        event(2);
+        return self.lines;
+    }
+    pub fn deleted(self: *const Model) []const u8 {
+        event(3);
+        return self.removed;
+    }
+    pub fn body(_: *const Model) []const u8 {
+        event(4);
+        return "# Document\nIssue #12\n<details><summary>More</summary>Body</details>";
+    }
+    pub fn base(self: *const Model) []const u8 {
+        event(5);
+        return self.prefix;
+    }
+    pub fn title(_: *const Model) []const u8 {
+        event(6);
+        return "Borrowed title";
+    }
+};
+const Msg = union(enum) { tick, local, selected: i64, link: []const u8, details: usize };
+const Ui = c.Ui(Msg);
+const unlimited = std.math.maxInt(usize);
+const Outcome = struct { allocations: usize, resizes: usize, calls: usize };
+fn aliases(a: Ui.Node, b: Ui.Node) anyerror!void {
+    if (a.on_press) |message| if (message == .selected) try std.testing.expectEqual(message.selected, b.on_press.?.selected);
+    for (a.nodes, b.nodes) |left, right| try aliases(left, right);
+}
+fn compare(comptime source: []const u8, model: Model, failure: usize, resize: usize) !Outcome {
+    const View = c.CompiledMarkupView(Model, Msg, source);
+    var aa = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer aa.deinit();
+    var ab = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer ab.deinit();
+    var fa = std.testing.FailingAllocator.init(aa.allocator(), .{ .fail_index = failure, .resize_fail_index = resize });
+    var fb = std.testing.FailingAllocator.init(ab.allocator(), .{ .fail_index = failure, .resize_fail_index = resize });
+    var left = Ui.init(fa.allocator());
+    var right = Ui.init(fb.allocator());
+    right.expression_policy = observed;
+    call_count = 0;
+    const a = View.build(&left, &model);
+    const before = calls;
+    const count = call_count;
+    call_count = 0;
+    const b = View.build(&right, &model);
+    errdefer std.debug.print("static specialized source={s} failure={d} resize={d}\n", .{ source, failure, resize });
+    try exact(before[0..count], calls[0..call_count]);
+    try exact(a, b);
+    try aliases(a, b);
+    const at = left.finalize(a);
+    const bt = right.finalize(b);
+    if (at) |tree| try exact(tree, try bt) else |err| try std.testing.expectError(err, bt);
+    try exact(left.failed, right.failed);
+    try exact(left.virtualWindows(), right.virtualWindows());
+    try exact(fa.alloc_index, fb.alloc_index);
+    try exact(fa.resize_index, fb.resize_index);
+    return .{ .allocations = fa.alloc_index, .resizes = fa.resize_index, .calls = count };
+}
+fn check(comptime source: []const u8, model: Model, faults: bool) !void {
+    const result = try compare(source, model, unlimited, unlimited);
+    if (faults) {
+        for (0..result.allocations + 1) |index| _ = try compare(source, model, index, unlimited);
+        for (0..result.resizes + 1) |index| _ = try compare(source, model, unlimited, index);
+    }
+}
+test "static markup specialized code retains all line grammar boundaries and complete failure effects" {
+    _ = core.initialModel();
+    modes = @splat(0);
+    const source = "<column><code source=\"{code}\" added-lines=\"{added}\" removed-lines=\"{deleted}\" language=\"zig\" label=\"Source\"/><text>{title}</text></column>";
+    for ([_][]const u8{ "", " \t\r\n", "1", "128", "1-128", "128,1,128,2-4", "+1 - 0__2,2", "1_2", "1,", ",1", "1,,2", "0", "129", "2-1", "-1", "1-2-3", "1-", "1 - \n2", "18446744073709551616", "1,2,x", "1,2,3-0", "\xff", "1\x00" }) |lines| {
+        try check(source, .{ .lines = lines }, false);
+        try check(source, .{ .removed = lines }, false);
+    }
+    try check(source, .{}, true);
+    try check(source, .{ .lines = "1,2,x", .removed = "3-1" }, true);
+    try std.testing.expect(modes[17] > 0 and modes[18] > 0);
+}
+test "static markup specialized literal and template code preserve callback order after invalid metadata" {
+    _ = core.initialModel();
+    const source = "<template name=\"code-card\" args=\"lines removed\"><code source=\"{code}\" added-lines=\"{lines}\" removed-lines=\"{removed}\"/></template><column><use template=\"code-card\" lines=\"{added}\" removed=\"{deleted}\"/><code source=\"{code}\" added-lines=\"1-3,1\" removed-lines=\"2\"/></column>";
+    try check(source, .{}, true);
+    try check(source, .{ .lines = "0" }, true);
+}
+test "static markup specialized markdown preserves nonempty issue bases and borrowed callbacks" {
+    _ = core.initialModel();
+    modes = @splat(0);
+    const source = "<column><markdown source=\"{body}\" issue-link-base=\"{base}\" on-link=\"link\" on-details=\"details\"/><text>{title}</text></column>";
+    for ([_][]const u8{ "", " ", "https://example.invalid/issues/", "ghissue://", "\x00\xff" }) |prefix| try check(source, .{ .prefix = prefix }, true);
+    try std.testing.expect(modes[28] > 0);
+}
+test "static markup specialized markdown template captures retain source and issue callback order" {
+    _ = core.initialModel();
+    const source = "<template name=\"document\" args=\"base\"><markdown source=\"{body}\" issue-link-base=\"{base}\" on-link=\"link\"/></template><column><use template=\"document\" base=\"{base}\"/><markdown source=\"{body}\" issue-link-base=\"https://example.invalid/\"/></column>";
+    try check(source, .{}, true);
+    try check(source, .{ .prefix = "" }, true);
+}
+test "static markup specialized root press publication preserves timeline affordances and exact payloads" {
+    _ = core.initialModel();
+    modes = @splat(0);
+    const source = "<template name=\"item\"><timeline-item title=\"{title}\" on-press=\"local\"/></template><template name=\"button-card\"><button on-press=\"local\">{title}</button></template><column><timeline><use template=\"item\" on-press=\"selected:{chosen}\"/><use template=\"item\"/><timeline-item title=\"{title}\"/></timeline><use template=\"button-card\" on-press=\"selected:{chosen}\"/><use template=\"button-card\"/></column>";
+    for ([_]i64{ std.math.minInt(i64), -9007199254740993, 0, 9007199254740993, std.math.maxInt(i64) }) |chosen| try check(source, .{ .chosen = chosen }, true);
+    try std.testing.expect(modes[33] > 0 and modes[36] > 0);
+}
+test "static markup specialized tab conversion preserves toggle contracts nested children and handlers" {
+    _ = core.initialModel();
+    modes = @splat(0);
+    const source = "<template name=\"trigger\"><button on-press=\"local\">{title}</button></template><column><tabs><button on-press=\"tick\">First</button><toggle-button on-toggle=\"tick\">Toggle</toggle-button><text>Caption</text><use template=\"trigger\" on-press=\"selected:{chosen}\"/><column><button on-press=\"local\">Nested</button></column></tabs><tabs/></column>";
+    try check(source, .{}, true);
+    try std.testing.expect(modes[34] > 0);
+}
diff --git a/tests/ts-core/static_markup_values_e2e_tests.zig b/tests/ts-core/static_markup_values_e2e_tests.zig
index b02d7a89b..c3f5a9373 100644
--- a/tests/ts-core/static_markup_values_e2e_tests.zig
+++ b/tests/ts-core/static_markup_values_e2e_tests.zig
@@ -25,7 +25,7 @@ fn exact(a: anytype, b: @TypeOf(a)) anyerror!void {
     }
 }
 
-var operations: [36]usize = @splat(0);
+var operations: [256]usize = @splat(0);
 var keys: usize = 0;
 fn observed(input: []const u8, output: []u8) usize {
     if (input[0] == 113) operations[input[2]] += 1;
diff --git a/tests/ts-core/surface_layout_e2e_tests.zig b/tests/ts-core/surface_layout_e2e_tests.zig
index ebeabe1f8..548b695eb 100644
--- a/tests/ts-core/surface_layout_e2e_tests.zig
+++ b/tests/ts-core/surface_layout_e2e_tests.zig
@@ -1012,4 +1012,5 @@ test {
 test {
     _ = @import("static_markup_collections_e2e_tests.zig");
     _ = @import("static_markup_expansion_e2e_tests.zig");
+    _ = @import("static_markup_specialized_e2e_tests.zig");
 }