@nodegx/mcp 0.2.3 → 0.2.4

package/dist/noodl-mcp.cjs

@@ -104563,6 +104563,52 @@ var require_src3 = __commonJS({
     .filter((x) => x.box > 0 && x.width > x.box + 1)
     .map((x) => ({ text: x.el.textContent.trim().slice(0, 80), width: round(x.width), parentWidth: round(x.box), cls: cls(x.el) }));
 
+  // P112-OWN020-OFFSYSTEM \u2014 the controls, measured against the project's type scale. A control nobody styled draws
+  // the runtime's own look (a Radio Button is a 32px circle with a 2px black ring; a native select or button keeps
+  // the browser's 13.33px text), and that is the "chunky" control beside a page on tokens. A radio or checkbox input
+  // is opacity 0, so its box is read on the first ancestor a person can see. The scale is the project's --text-*
+  // tokens, read off :root; the fake DOMs in the tests have no getPropertyValue, so it is guarded.
+  const pxOf = (value) => {
+    const s = String(value || '').trim();
+    if (!s) return NaN;
+    if (s.slice(-3) === 'rem') return parseFloat(s) * (parseFloat(styleOf(document.documentElement).fontSize) || 16);
+    return parseFloat(s);
+  };
+  const textScale = [];
+  const rootStyle = styleOf(document.documentElement);
+  if (rootStyle && typeof rootStyle.getPropertyValue === 'function') {
+    for (const step of ['xs', 'sm', 'base', 'lg', 'xl', '2xl', '3xl', '4xl', '5xl', '6xl']) {
+      const px = pxOf(rootStyle.getPropertyValue('--text-' + step));
+      if (px > 0) textScale.push(Math.round(px * 100) / 100);
+    }
+  }
+  const controlKind = (el) => {
+    const type = String(el.type || '').toLowerCase();
+    if (el.tagName === 'INPUT' && type === 'radio') return 'Radio Button';
+    if (el.tagName === 'INPUT' && type === 'checkbox') return 'Checkbox';
+    if (el.tagName === 'SELECT') return 'Dropdown';
+    if (el.tagName === 'TEXTAREA' || (el.tagName === 'INPUT' && ['', 'text', 'email', 'password', 'search', 'number', 'tel', 'url'].indexOf(type) !== -1)) return 'Text Input';
+    if (el.tagName === 'BUTTON') return 'Button';
+    return null;
+  };
+  const controls = [];
+  for (const el of all) {
+    const kind = controlKind(el);
+    if (!kind) continue;
+    if (kind === 'Radio Button' || kind === 'Checkbox') {
+      let shown = el;
+      for (let hops = 0; shown && hops < 3 && (parseFloat(styleOf(shown).opacity) < 0.05 || shown.getBoundingClientRect().width < 2); hops++) shown = shown.parentElement;
+      if (!shown || shown.offsetParent === null) continue;
+      const r = shown.getBoundingClientRect();
+      let label = null;
+      if (el.id && typeof document.querySelector === 'function') label = document.querySelector('label[for="' + el.id + '"]');
+      controls.push({ kind, box: round(Math.max(r.width, r.height)), textSize: label ? pxOf(styleOf(label).fontSize) : NaN });
+    } else {
+      if (visible.indexOf(el) === -1) continue;
+      controls.push({ kind, box: 0, textSize: pxOf(styleOf(el).fontSize) });
+    }
+  }
+
   // AWP-004 \u2014 what is on screen, as opposed to what is in the DOM. The page is
   // never scrolled when this runs, so a rect is already a document position.
   // Kimi K3's storefront was 83 texts in the DOM and about three on screen, and
@@ -105021,6 +105067,7 @@ var require_src3 = __commonJS({
     overflowingCount: overflowing.length,
     textsWiderThanBox: textsWiderThanBox.slice(0, 10),
     textsWiderThanBoxCount: textsWiderThanBox.length,
+    controls: { textScale, items: controls.slice(0, 60), count: controls.length },
     text: {
       elements: textEls.length,
       onScreen: textEls.filter(onScreen).length,
@@ -105110,6 +105157,13 @@ var require_src3 = __commonJS({
        * page-level finding stayed quiet because the page itself kept its width.
        */
       TextWiderThanItsBox: "text-wider-than-its-box",
+      /**
+       * P112-OWN020-OFFSYSTEM — a control drawn at the runtime's own size beside a page on its token scale: a radio or
+       * checkbox box much bigger than its label, or control text off the project's --text-* scale (a native select or
+       * button keeps the browser's 13.33px). Mistral (SP1) and DeepSeek (OpenTune) both shipped one — the "chunky"
+       * Sort-by circles — because a control placed in passing is the one an agent never styles.
+       */
+      ControlOffScale: "control-off-scale",
       SingleColumnGrid: "single-column-grid",
       MinimumLayoutWidth: "minimum-layout-width",
       HorizontalOverflow: "horizontal-overflow",
@@ -105178,9 +105232,30 @@ var require_src3 = __commonJS({
       const named = widest.cls ? `${widest.tag.toLowerCase()}.${widest.cls.split(/\s+/)[0]}` : widest.tag.toLowerCase();
       return `${named} at ${widest.width}px`;
     }
+    function controlsOffScale(controls) {
+      const scale = controls.textScale || [];
+      const onScale = (px3) => scale.length === 0 || !(px3 > 0) || scale.some((s) => Math.abs(s - px3) < 0.6);
+      const byKind = {};
+      for (const c of controls.items || []) {
+        const oversized = (c.kind === "Radio Button" || c.kind === "Checkbox") && c.box > Math.max(20, 1.5 * (c.textSize > 0 ? c.textSize : 0));
+        const offText = !onScale(c.textSize);
+        if (!oversized && !offText) continue;
+        const k = byKind[c.kind] || (byKind[c.kind] = { kind: c.kind, count: 0, box: c.box, textSize: c.textSize, oversized, offText });
+        k.count += 1;
+      }
+      const fmt = (n) => String(Math.round(n * 100) / 100);
+      return Object.keys(byKind).map((kind) => {
+        const k = byKind[kind];
+        const parts = [];
+        if (k.oversized) parts.push(fmt(k.box) + "px box" + (k.textSize > 0 ? " beside a " + fmt(k.textSize) + "px label" : ""));
+        if (k.offText) parts.push(fmt(k.textSize) + "px text, off the type scale (" + scale.map(fmt).join("/") + "px)");
+        return { kind, count: k.count, box: k.box, textSize: k.textSize, sentence: kind + " x" + k.count + ": " + parts.join(", ") };
+      });
+    }
     function summarise(viewports, diagnosis, overridden = {}) {
       const findings = [];
       const add = (f) => findings.push(f);
+      let controlsJudged = false;
       for (const [name, v] of Object.entries(viewports)) {
         if (!v || v.error) continue;
         const isDesktop = v.requested.width >= DESKTOP_WIDTH;
@@ -105329,6 +105404,19 @@ var require_src3 = __commonJS({
             evidence: v.textsWiderThanBox
           });
         }
+        if (!controlsJudged && v.controls && v.controls.count > 0) {
+          controlsJudged = true;
+          const off = controlsOffScale(v.controls);
+          if (off.length > 0) {
+            add({
+              code: RenderFinding.ControlOffScale,
+              severity: "warning",
+              viewport: name,
+              message: "Controls drawn at a size the rest of the page is not: " + off.map((o) => o.sentence).join("; ") + `. A control nobody styled keeps the runtime's own look. Give the type one look for the whole app with set_element_style (find_tools group "theme"), or set_style_preset to add on-system styles for every control; a node that sets the parameter itself keeps its own value.`,
+              evidence: off.map((o) => ({ kind: o.kind, count: o.count, box: o.box, textSize: o.textSize, textScale: v.controls.textScale }))
+            });
+          }
+        }
         if (v.text.elements >= 10) {
           const weights = Object.keys(v.text.fontWeights);
           if (weights.length <= 1 || v.text.distinctFontSizes <= 2) {
@@ -105499,6 +105587,8 @@ var require_src3 = __commonJS({
       plural: plural3,
       widestOffender,
       describeSites,
+      // P112-OWN020-OFFSYSTEM — exported so its spec grades the judgement on readings, not only through a fake DOM.
+      controlsOffScale,
       TEXT_BEARING_PORTS,
       placeholderStringsFromCatalog
     };
@@ -105510,7 +105600,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@nodegx/mcp",
-      version: "0.2.3",
+      version: "0.2.4",
       description: "Model Context Protocol server exposing NodeGX (OpenNoodl) v2 projects to external AI agents.",
       license: "GPL-3.0-only",
       homepage: "https://nodegx.io",
@@ -105546,17 +105636,15 @@ var require_package = __commonJS({
         test: "jest",
         typecheck: "tsc --noEmit"
       },
-      dependencies: {
-        "@modelcontextprotocol/sdk": "^1.29.0",
-        zod: "^3.25.76"
-      },
       devDependencies: {
+        "@modelcontextprotocol/sdk": "^1.29.0",
         "@nodegx/kit-catalog": "*",
         "@nodegx/kit-scaffold": "*",
         "@nodegx/module-inject": "*",
         "@types/jest": "^29.0.1",
         jest: "^29.7.0",
-        "ts-jest": "^29.4.1"
+        "ts-jest": "^29.4.1",
+        zod: "^3.25.76"
       },
       publishConfig: {
         access: "public"
@@ -121151,7 +121239,7 @@ var TOOL_GROUPS = Object.freeze([
     // looks — so the one instruction the design doctrine gives most often led to
     // an empty answer.
     keywords: ["theme", "colour", "color", "palette", "styling", "style guide", "branding", "appearance", "dark mode"],
-    tools: ["set_project_tokens", "set_style_preset"],
+    tools: ["set_project_tokens", "set_style_preset", "set_element_style"],
     resident: false
   }
 ]);
@@ -121237,6 +121325,8 @@ var WRITE_ONLY_TOOLS = /* @__PURE__ */ new Set([
   "set_project_settings",
   "set_project_tokens",
   "set_style_preset",
+  // P112-OWN020-OFFSYSTEM — writes nodegx.styles.json.
+  "set_element_style",
   // P109 ISL-005.
   "write_script_file",
   "edit_script_file",
@@ -225717,13 +225807,13 @@ var styles_schema_default = {
     },
     variant: {
       type: "object",
-      required: ["name", "typename"],
+      required: ["typename"],
       additionalProperties: true,
       properties: {
         name: {
           type: "string",
           minLength: 1,
-          description: "Variant name"
+          description: "Variant name. Absent: the element style, which dresses every node of this type that names no variant (the node's own parameters still win)"
         },
         typename: {
           type: "string",
@@ -226129,6 +226219,14 @@ var V2ProjectStore = class {
   readStyles() {
     return this.readJson(STYLES_FILE);
   }
+  /**
+   * P112-OWN020-OFFSYSTEM — the styles file had a reader and no writer, so the one layer that dresses every node of
+   * a type (a variant with no `name`) could not be written by anything that writes through the format. The whole
+   * file is replaced: a caller reads it, changes what it owns, and writes it back.
+   */
+  writeStyles(styles) {
+    this.writeJson(STYLES_FILE, styles);
+  }
   readRegistry() {
     const registry2 = this.readJson(REGISTRY_FILE);
     if (!registry2) throw new FormatRefusal("io-error", "missing-registry", "Missing components/_registry.json.");
@@ -231175,6 +231273,13 @@ Two things are settled BEFORE the first component exists, and in this order:
    choice into the project rather than carrying it in your head \u2014 \`set_style_preset\` adopts a whole
    coherent identity, \`set_project_tokens\` overrides individual values. Both sit in the deferred
    \`theme\` group: call \`find_tools({group:"theme"})\` and they arrive in your next tool list.
+   **Controls are styled once, for the whole app.** An ELEMENT STYLE is the look every node of a type
+   wears unless it sets the parameter itself (\`get_style_vocabulary\` \u2192 \`elementStyles\`). A control
+   type with none draws the runtime's own look, which matches no page. So before you place the first
+   Radio Button, Checkbox, Text Input, Dropdown, Slider or Button, call
+   \`set_element_style({ type, starter: true })\` for that type (also in \`theme\`), and change it there
+   to change every one. Style a single node only for what is particular to it: a control styled by
+   hand, one node at a time, is the one that drifts.
 2. **The screens.** Name every page the app has and say, in one sentence each, what a person does on
    it. That list is what the component tree is a decomposition OF.
 
@@ -243452,7 +243557,10 @@ var RUN_TASKS_CONTRACT = {
   failure: { parameter: "taskFailureOutput", default: "Failure" },
   error: { parameter: "taskErrorOutput", default: "Error" }
 };
+var SET_VARIABLE_CHAIN_OUTPUTS = ["done", "completed"];
 var OWN_CHAIN_OUTPUTS = {
+  // P18-S127-SETDONE (EXP-011 §95).
+  "Set Variable": SET_VARIABLE_CHAIN_OUTPUTS,
   [RUN_TASKS_TYPE]: RUN_TASKS_OUTPUTS,
   // EXP-011 §54. The boundary's Error is its listener, compiled by its own registration.
   [ON_APP_ERROR_TYPE]: ["error"],
@@ -243751,6 +243859,7 @@ var SESSION_READS = {
   username: { field: "username", maybeUndefined: true },
   email: { field: "email", maybeUndefined: true }
 };
+var INPUT_PULSE_TS_TYPE = "{ sent: number; taken: { current: number } }";
 function isDefer(value) {
   return typeof value === "object" && value !== null && "defer" in value;
 }
@@ -243840,9 +243949,11 @@ function planProject(ir, catalog2) {
       const child = byLegacyNow(pending.targetLegacy);
       const lifted6 = child?.liftedOutputProps.find((l) => l.port === pending.port);
       if (!lifted6) {
-        plan.notes.push(
-          `wire ${pending.connectionKey} dropped: instance output "${pending.port}" is not lifted by ${pending.targetLegacy} \u2014 its feed defers there`
-        );
+        const reason2 = `instance output "${pending.port}" is not lifted by ${pending.targetLegacy} \u2014 its feed defers there`;
+        plan.notes.push(`wire ${pending.connectionKey} dropped: ${reason2}`);
+        if (pending.intoInstance === true) {
+          plan.droppedWires.push({ key: pending.connectionKey, fromId: pending.instanceId, fromProperty: pending.port, toId: pending.toNodeId, toProperty: pending.toProperty, reason: reason2 });
+        }
         continue;
       }
       const varKey = `${pending.instanceId}:${pending.port}`;
@@ -243872,6 +243983,23 @@ function planProject(ir, catalog2) {
         kind: "computed",
         expr: { kind: "state-get", name, maybeUndefined: true }
       };
+      for (const pulse of plan.instancePulses) {
+        if (pulse.nodeId !== pending.toNodeId || pulse.delivered !== void 0) continue;
+        const taken = takenNamesOf(plan);
+        const base = `${pulse.stateName.replace(/Pulses$/, "")}Delivered`;
+        let delivered = base;
+        for (let n = 2; taken.has(delivered) || taken.has(setterNameOf(delivered)); n++) delivered = `${base}${n}`;
+        plan.stateVars.push({
+          name: delivered,
+          setterName: setterNameOf(delivered),
+          tsType: "number",
+          boot: 0,
+          originNodeId: pulse.nodeId,
+          origin: "counter",
+          comment: `"${pulse.port}" as the placed component is handed it: the count, one commit after it is sent, so the values lifted with it have landed (P18-S127-SIBLINGVALUE).`
+        });
+        pulse.delivered = { name: delivered, setterName: setterNameOf(delivered) };
+      }
     }
     plan.pendingLifted = [];
   };
@@ -243943,6 +244071,7 @@ function planProject(ir, catalog2) {
     kitDuplicates
   };
 }
+var UNCARRIED_PAGE_GROUP = "the page's own Group,";
 function undrawnReasonOf(plan, component, id) {
   const nodeById = new Map(component.nodes.map((n) => [n.id, n]));
   const labelOf = (nodeId) => {
@@ -243970,6 +244099,14 @@ function undrawnReasonOf(plan, component, id) {
   }
   return null;
 }
+function rowlessReasonOf(plan, repeaterId) {
+  const repeater = plan.repeaters[repeaterId];
+  if (repeater === void 0 || repeater.templatePath === null) return "it draws no rows in the export (it has no template component)";
+  const fed = plan.queries.some((q) => q.nodeId === repeater.itemsQueryId) || repeater.itemsCollectionName != null || repeater.itemsExpr !== void 0 || plan.staticData.some((sd) => sd.nodeId === repeater.itemsStaticId);
+  if (!fed) return "it draws no rows in the export (its items are not fed by a query, a named array, or a statically-known list)";
+  if (repeater.mapping === null) return "it draws no rows in the export (its rows are mapped by a script, which is not a static map)";
+  return null;
+}
 function unreachedTriggersOf(plan, component) {
   const found2 = { owners: /* @__PURE__ */ new Map(), mounts: /* @__PURE__ */ new Map(), rows: /* @__PURE__ */ new Map() };
   if (plan.file === null) return found2;
@@ -243982,25 +244119,22 @@ function unreachedTriggersOf(plan, component) {
   const owners = /* @__PURE__ */ new Set([...Object.keys(plan.handlers), ...Object.keys(plan.changeHandlers), ...plan.drags.map((d) => d.nodeId)]);
   for (const owner of owners) {
     if (plan.roleOf[owner] === void 0) continue;
-    const why = undrawnReasonOf(plan, component, owner);
+    const why = undrawnReasonOf(plan, component, owner) ?? (nodeById.get(owner)?.type === "For Each" ? rowlessReasonOf(plan, owner) : null);
     if (why === null) continue;
     whyUndrawn.set(owner, why);
     found2.owners.set(owner, `its trigger, ${labelOf(owner)}, is not drawn: ${why}`);
   }
   const whyUnmounted = /* @__PURE__ */ new Map();
   for (const [owner, byPort] of Object.entries(plan.handlers)) {
-    if (byPort["didMount"] === void 0 || whyUndrawn.has(owner)) continue;
-    for (let at = owner; at !== void 0; at = nodeById.get(at)?.parent) {
-      const bound = plan.bindings[at]?.["mounted"];
-      if (bound !== void 0 && !(bound.kind === "computed" && bound.expr.kind === "literal")) {
-        const whose = at === owner ? "it is" : `an element above it, ${labelOf(at)}, is`;
-        const why = `${whose} mounted by a value, so its Did Mount fires when that value says, and a mount effect runs when the component mounts`;
-        whyUnmounted.set(owner, why);
-        found2.mounts.set(owner, `its trigger, the Did Mount of ${labelOf(owner)}, is not run: ${why}`);
-        break;
-      }
-      if (at === plan.rootId) break;
-    }
+    if (byPort["didMount"] === void 0 || whyUndrawn.has(owner) || plan.collapsedGroupId === void 0) continue;
+    const bound = plan.bindings[plan.collapsedGroupId]?.["mounted"];
+    if (bound === void 0 || bound.kind === "computed" && bound.expr.kind === "literal") continue;
+    let inside = false;
+    for (let at = owner; at !== void 0; at = nodeById.get(at)?.parent) if (at === plan.collapsedGroupId) inside = true;
+    if (!inside) continue;
+    const why = `${UNCARRIED_PAGE_GROUP} ${labelOf(plan.collapsedGroupId)} is mounted by a value the export does not carry (it draws the page), so when it mounts is not known here`;
+    whyUnmounted.set(owner, why);
+    found2.mounts.set(owner, `its trigger, the Did Mount of ${labelOf(owner)}, is not run: ${why}`);
   }
   const writers = /* @__PURE__ */ new Map();
   const walk2 = (value, owner) => {
@@ -244081,6 +244215,8 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     handlers: {},
     changeHandlers: {},
     receivers: [],
+    inputPulses: [],
+    instancePulses: [],
     popups: [],
     closesPopup: false,
     queries: [],
@@ -244098,6 +244234,7 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     stateVars: [],
     syncEffects: [],
     pushEffects: [],
+    rowRelays: [],
     branchEffects: [],
     recordEffects: [],
     variableSeeds: [],
@@ -244303,6 +244440,7 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
   if (roots.length > 1) {
     notes.push(`component has ${roots.length} visual roots; only the first renders in step 4`);
   }
+  const routerMounted = (toNode, toProperty) => toProperty === "mounted" && toNode.id === plan.rootId && toNode.type === "Page";
   const root = roots[0];
   if (root !== void 0) {
     plan.rootId = root.id;
@@ -245279,7 +245417,17 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     }
   };
   const usedStateVarNames = /* @__PURE__ */ new Set();
-  const stateNameTaken = (name) => usedStateVarNames.has(name) || usedJsFnNames.has(name) || plan.props.some((p) => p.name === name) || plan.outputProps.some((o) => o.prop === name) || outputInterface.valueProps.some((v) => v.prop === name) || name === plan.file?.symbol || /**
+  let componentStoreNames;
+  const storeNameTaken = (name) => {
+    componentStoreNames ??= new Set(
+      component.nodes.filter((n) => n.type === "Variable2" || n.type === "Set Variable").map((n) => {
+        const variable = literalParam(n, "name");
+        return typeof variable === "string" ? registry2.variables.get(variable)?.exportName : void 0;
+      }).filter((n) => n !== void 0)
+    );
+    return componentStoreNames.has(name);
+  };
+  const stateNameTaken = (name) => usedStateVarNames.has(name) || storeNameTaken(name) || usedJsFnNames.has(name) || plan.props.some((p) => p.name === name) || plan.outputProps.some((o) => o.prop === name) || outputInterface.valueProps.some((v) => v.prop === name) || name === plan.file?.symbol || /**
    * `error` joined this list with EXP-011 Tier 1.2, and it is the only one here that is not
    * simply an identifier the file already prints.
    *
@@ -245358,6 +245506,9 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     return stateVar;
   };
   const httpChainScope = /* @__PURE__ */ new Map();
+  const rowChainScopes = [];
+  const relayTouches = [];
+  const relayTouchedKeys = /* @__PURE__ */ new Map();
   const httpNames = /* @__PURE__ */ new Map();
   const httpNamesOf = (node) => {
     let names2 = httpNames.get(node.id);
@@ -246312,7 +246463,8 @@ ${body}
   };
   const CONTROL_ACTION_PORTS = {
     checkbox: ["check", "uncheck"],
-    input: ["clear"]
+    // P18-S128-FIELDSET. A Set writes the field's text as a Clear does, so it earns the row too.
+    input: ["clear", "set"]
   };
   const LIST_PRODUCERS = /* @__PURE__ */ new Set(["Collection2", "Filter Collection", "Map Collection", "FilterDBModels"]);
   const collectionReadEligible = (node) => {
@@ -246846,8 +246998,52 @@ ${body}
     }
     return cases;
   };
+  const relayedInputOf = (forEach, output) => {
+    const repeater = plan.repeaters[forEach.id];
+    const templatePath = repeater?.templatePath ?? null;
+    const template = templatePath === null ? void 0 : ir.components.find((tc) => `/${tc.path}` === templatePath);
+    if (repeater === void 0 || templatePath === null || template === void 0) return { defer: `the repeater relaying "${output}" has no template component` };
+    if (repeater.mapping === null) return { defer: `the repeater relaying "${output}" maps its rows with a script, which is not a static map` };
+    const tById = new Map(template.nodes.map((n) => [n.id, n]));
+    const feeds = template.connections.filter((c) => c.toProperty === output && tById.get(c.toId)?.type === "Component Outputs");
+    if (feeds.length !== 1) {
+      return {
+        defer: feeds.length === 0 ? `nothing in ${templatePath} feeds the row output "${output}" that the repeater relays` : `${feeds.length} wires feed ${templatePath}'s row output "${output}" \u2014 last-writer-wins is not statically ordered`
+      };
+    }
+    const feeder = tById.get(feeds[0].fromId);
+    if (feeder?.type !== "Component Inputs") {
+      return {
+        defer: `${templatePath}'s row output "${output}" is computed inside the row (by ${feeder?.type ?? "a missing node"}.${feeds[0].fromProperty}) \u2014 only a row input passed straight through is relayed in this slice`
+      };
+    }
+    const input = feeds[0].fromProperty;
+    if (repeater.mapping !== "template-inputs" && !repeater.mapping.some((m) => m.input === input)) {
+      return { defer: `the repeater maps nothing into ${templatePath}'s input "${input}", which its row output "${output}" passes through` };
+    }
+    const declared = componentOutputInterface(template).valueProps.find((v) => v.port === output)?.tsType ?? "unknown";
+    return { input, templatePath, declared };
+  };
   const resolveExpr = (fromNode, fromProperty, ctx) => {
     if (!fromNode) return null;
+    if (fromNode.type === "For Each" && fromProperty.startsWith(ITEM_OUTPUT_VALUE)) {
+      const output = fromProperty.slice(ITEM_OUTPUT_VALUE.length);
+      relayTouches[relayTouches.length - 1]?.add(fromNode.id);
+      if (jsResolving.size > 0) {
+        ctx.defer = `it reads the repeater ${fromNode.id}'s relayed row value "${output}" as a standing input, read whenever the node runs \u2014 there it is the value of whichever row fired last, which the export does not hold; it reads that value only in a chain a row's relayed signal runs, as the firing row's own`;
+        return null;
+      }
+      if (rowChainScopes[rowChainScopes.length - 1] !== fromNode.id) {
+        ctx.defer = `it reads the repeater ${fromNode.id}'s relayed row value "${output}" in a chain no row's relayed signal of that repeater starts in the export \u2014 there it is the value of whichever row fired last, which the export does not hold (in a row's chain it is the firing row's own)`;
+        return null;
+      }
+      const relayed = relayedInputOf(fromNode, output);
+      if ("defer" in relayed) {
+        ctx.defer = relayed.defer;
+        return null;
+      }
+      return { kind: "row-relay", repeaterId: fromNode.id, output, input: relayed.input, tsType: relayed.declared };
+    }
     if (LIST_PRODUCERS.has(fromNode.type) && fromProperty === "items") return listReadOf(fromNode, ctx);
     if (LIST_PRODUCERS.has(fromNode.type) && fromProperty === "count") {
       const source = listReadOf(fromNode, ctx);
@@ -247719,6 +247915,9 @@ ${body}
         return expr.viaState !== void 0 && expr.seeded !== true;
       case "state-get":
         return expr.maybeUndefined === true;
+      // EXP-011 §100. The row's field: a row whose item lacks it is handed nothing. Must agree with component.ts maybeUndefined.
+      case "row-relay":
+        return true;
       // FLD-015. A hoisted Static Data constant is a frozen module-scope literal: it exists from
       // module load and nothing writes it, so it is never undefined for a stronger reason than
       // the named arrays below — there is no boot value to be before.
@@ -247862,7 +248061,7 @@ ${body}
           reason2 = `its ${w.fromProperty} feeds ${sink?.type ?? "a missing node"}.${w.toProperty} \u2014 a snapshot of the last Evaluate lands only in a Mounted or a Visible in this slice`;
         } else if (!sink || !rendered2.has(sink.id)) {
           reason2 = `its ${w.fromProperty} feeds an element that is not drawn \u2014 a snapshot lands only in a drawn element's Mounted or Visible in this slice`;
-        } else if (w.toProperty === "mounted" && sink.id === plan.rootId) {
+        } else if (routerMounted(sink, w.toProperty)) {
           reason2 = "a mounted wire into the component root is a router concern \u2014 not translated in this slice";
         }
         if (reason2 !== null) break;
@@ -248093,6 +248292,9 @@ ${body}
         return "unknown";
       case "state-get":
         return plan.stateVars.find((v) => v.name === expr.name)?.tsType.replace(" | undefined", "") ?? "unknown";
+      // EXP-011 §100. The row template's declared output type.
+      case "row-relay":
+        return expr.tsType;
       case "control-event":
         return expr.form === "checked" ? "boolean" : expr.form === "number" ? "number" : "string";
       case "logical":
@@ -248193,15 +248395,26 @@ ${body}
     "net.noodl.user.SetUserProperties": "store",
     "net.noodl.user.RequestMagicLink": "send"
   };
-  const isTriggerWire = (type, toProperty) => TRIGGER_PORTS[type] === toProperty || type === "NavigationShowPopup" && toProperty === "show" || type === "NavigationClosePopup" && (toProperty === "close" || toProperty.startsWith("closeAction-")) || jsNodeKindOf(type) !== null && toProperty === "run" || isLatchType(type) && (LATCH_TRIGGERS[type] ?? []).includes(toProperty) || (type === "net.noodl.controls.checkbox" || type === "Checkbox") && (toProperty === "check" || toProperty === "uncheck") || isTextInputType(type) && toProperty === "clear" || // EXP-011 §39. A Delay's Start/Restart/Stop — one node, three action ports.
+  const isTriggerWire = (type, toProperty) => TRIGGER_PORTS[type] === toProperty || type === "NavigationShowPopup" && toProperty === "show" || type === "NavigationClosePopup" && (toProperty === "close" || toProperty.startsWith("closeAction-")) || jsNodeKindOf(type) !== null && toProperty === "run" || isLatchType(type) && (LATCH_TRIGGERS[type] ?? []).includes(toProperty) || (type === "net.noodl.controls.checkbox" || type === "Checkbox") && (toProperty === "check" || toProperty === "uncheck") || // P18-S128-FIELDSET. A text field's four actions: Clear, Set, Focus, Blur.
+  isTextInputType(type) && (toProperty === "clear" || toProperty === "set" || toProperty === "focus" || toProperty === "blur") || // EXP-011 §39. A Delay's Start/Restart/Stop — one node, three action ports.
   type === TIMER_TYPE && isTimerTrigger(toProperty) || // EXP-011 §49. A States' Toggle and its `to-<state>` family.
   type === STATES_TYPE && isStatesTrigger(toProperty) || // EXP-011 §53. A Run Tasks' Do and Abort — one node, two action ports.
   type === RUN_TASKS_TYPE && (toProperty === "run" || toProperty === "abort") || // EXP-011 §58. The trio's action ports — Parse/Clear, Add/Flush/Clear, Add/Clear.
   STREAM_NODES[type] !== void 0 && STREAM_NODES[type].actions[toProperty] !== void 0 || // EXP-011 §63. A Drag's two snap Dos — one node, two action ports.
   type === DRAG_TYPE && DRAG_SNAP_TRIGGERS[toProperty] !== void 0 || // EXP-011 §61. The Pop's Navigate and its `backAction-<a>` family; the stack's Reset.
   type === STACK_POP_TYPE && (toProperty === "navigate" || toProperty.startsWith("backAction-")) || type === PAGE_STACK_TYPE && toProperty === "reset";
-  const isTriggerInto = (node, toProperty) => isTriggerWire(node.type, toProperty) || node.type === SCRIPT_TYPE && scriptPortsOf(node).signalInputs.includes(toProperty) || kitSignalInputOf(node, toProperty) !== void 0;
+  const isTriggerInto = (node, toProperty) => isTriggerWire(node.type, toProperty) || node.type === SCRIPT_TYPE && scriptPortsOf(node).signalInputs.includes(toProperty) || kitSignalInputOf(node, toProperty) !== void 0 || instanceSignalInputOf(node, toProperty);
   const kitSignalInputOf = (node, port5) => plan.roleOf[node.id] === "custom" ? plan.customNodes[node.id]?.def.inputs.find((input) => input.name === port5 && input.type === "signal") : void 0;
+  const instanceSignalInputOf = (node, port5) => {
+    if (plan.roleOf[node.id] !== "instance") return false;
+    const target = ir.components.find((c) => `/${c.path}` === node.type);
+    if (target === void 0 || !signalInputPortsOf(target).has(port5)) return false;
+    return target.nodes.some((n) => {
+      if (n.parent !== void 0) return false;
+      const role = renderRole(n, catalog2, kits);
+      return role !== null && role !== "unsupported" && role !== "radio";
+    });
+  };
   const popupTargetLegacies = /* @__PURE__ */ new Set();
   for (const comp of ir.components) {
     for (const n of comp.nodes) {
@@ -248456,6 +248669,7 @@ ${body}
     if ("defer" in ticked3) return { defer: ticked3.defer };
     for (const c of component.connections) {
       if (c.fromId !== node.id || c.fromProperty === "done" || isJsValueOutput(node, c.fromProperty)) continue;
+      if (node.type === JS_FUNCTION && c.fromProperty === "success") continue;
       if (node.type === JS_FUNCTION && !c.fromProperty.startsWith("out-")) {
         const builtIn = ["success", "failure", "unchanged", "completed", "error"].includes(c.fromProperty);
         if (!builtIn) continue;
@@ -248470,19 +248684,22 @@ ${body}
     }
     const done = doneChainOf(node);
     if ("defer" in done) return done;
+    const success = node.type === JS_FUNCTION ? doneChainOf(node, "success") : { then: [], consumes: [], collapses: [], subscribes: [] };
+    if ("defer" in success) return success;
     const pulsed = pulseChainsOf(node, record2.def);
     if ("defer" in pulsed) pulseRefusals.set(node.id, pulsed.defer);
     const pulses = "defer" in pulsed ? { then: [], consumes: [], collapses: [], subscribes: [] } : pulsed;
-    if (ticked3.watch.length > 0 && !actionsValidIn([{ kind: "jsfun-run", nodeId: node.id, then: pulses.then }], { kind: "render" })) {
+    const tickedThen = [...pulses.then, ...success.then];
+    if (ticked3.watch.length > 0 && !actionsValidIn([{ kind: "jsfun-run", nodeId: node.id, then: tickedThen }], { kind: "render" })) {
       return {
         defer: "a ticked input runs it again from no handler, and its signals' chains read values that exist only inside a handler"
       };
     }
     const chain = {
-      then: [...pulses.then, ...done.then],
-      consumes: [...pulses.consumes, ...done.consumes],
-      collapses: [...pulses.collapses, ...done.collapses],
-      subscribes: [...pulses.subscribes, ...done.subscribes]
+      then: [...pulses.then, ...success.then, ...done.then],
+      consumes: [...pulses.consumes, ...success.consumes, ...done.consumes],
+      collapses: [...pulses.collapses, ...success.collapses, ...done.collapses],
+      subscribes: [...pulses.subscribes, ...success.subscribes, ...done.subscribes]
     };
     const strays = component.connections.filter(
       (c) => c.fromId === node.id && isJsValueOutput(node, c.fromProperty) && !chain.consumes.includes(c.key)
@@ -248551,10 +248768,10 @@ ${body}
       return { defer: "its Run drives nothing this slice translates \u2014 no done-chain action consumes its work" };
     }
     if (pulses.then.length > 0 || materialize !== void 0 && record2.def.kind === "function") record2.def.pulsed = true;
-    if (ticked3.watch.length > 0 && (pulses.then.length > 0 || materialize !== void 0)) {
+    if (ticked3.watch.length > 0 && (tickedThen.length > 0 || materialize !== void 0)) {
       tickedRunPieces.set(node.id, {
         watch: ticked3.watch,
-        action: { kind: "jsfun-run", nodeId: node.id, then: pulses.then, ...materialize !== void 0 ? { materialize } : {}, ticked: true }
+        action: { kind: "jsfun-run", nodeId: node.id, then: tickedThen, ...materialize !== void 0 ? { materialize } : {}, ticked: true }
       });
     }
     return {
@@ -248596,6 +248813,31 @@ ${body}
     }
     return { action: { kind: "state-set", name: stateVar.name, op: "inc" }, consumes: [] };
   };
+  const instancePulseVars = /* @__PURE__ */ new Map();
+  const compileInstanceSignal = (node, port5) => {
+    const key2 = `${node.id}\0${port5}`;
+    let stateVar = instancePulseVars.get(key2);
+    if (stateVar === void 0) {
+      stateVar = allocStateVar(
+        `${node.authoredLabel ?? "instance"} ${port5} pulses`,
+        `${port5}Pulses`,
+        "number",
+        0,
+        node.id,
+        "counter",
+        `How many times "${port5}" on the placed ${node.type} ${node.id} has been signalled \u2014 the count it reads (P18-S126-INSIGNAL).`
+      );
+      instancePulseVars.set(key2, stateVar);
+      const base = `${stateVar.name.replace(/Pulses$/, "")}Taken`;
+      let takenLocal = base;
+      for (let n = 2; stateNameTaken(takenLocal); n++) takenLocal = `${base}${n}`;
+      usedStateVarNames.add(takenLocal);
+      plan.instancePulses.push({ nodeId: node.id, port: port5, stateName: stateVar.name, takenLocal });
+      plan.bindings[node.id] = plan.bindings[node.id] ?? {};
+      plan.bindings[node.id][port5] = { kind: "computed", expr: { kind: "state-get", name: stateVar.name } };
+    }
+    return { action: { kind: "state-set", name: stateVar.name, op: "inc" }, consumes: [] };
+  };
   const compileControlAction = (node, port5) => {
     const consumedOutcome = component.connections.find(
       (c) => c.fromId === node.id && (c.fromProperty === "done" || c.fromProperty === "unchanged")
@@ -248609,12 +248851,51 @@ ${body}
     if (stateVar === void 0) {
       return { defer: `its ${port5} action writes control state nothing else observes \u2014 no state row is minted` };
     }
+    if (port5 === "set") return compileFieldSet(node, stateVar);
     const action = port5 === "check" ? { kind: "state-set", name: stateVar.name, expr: { kind: "literal", value: true } } : port5 === "uncheck" ? { kind: "state-set", name: stateVar.name, expr: { kind: "literal", value: false } } : (
-      // clear → the field type's empty value, projected onto the DOM string (FB-026).
-      { kind: "state-set", name: stateVar.name, expr: { kind: "literal", value: "" } }
+      // clear → the field type's empty value, projected onto the DOM string (FB-026); P18-S127-CLEAROUT: then the
+      // field's change chain, with the empty text (the runtime's `clear()` calls `setText('')`).
+      { kind: "state-set", name: stateVar.name, expr: { kind: "literal", value: "" }, field: { inputId: node.id, port: "clear" } }
     );
     return { action, consumes: [] };
   };
+  const compileFieldSet = (node, stateVar) => {
+    const type = literalParam(node, "type");
+    if (wiredPorts.has(`${node.id}:type`) || type !== void 0 && typeof type !== "string") {
+      return { defer: "its Type is wired, so whether its Set writes text or a number is not known here" };
+    }
+    if (type === "number") {
+      return { defer: "a Number field's Set sends a number or null, and the exported field carries text (P18-S118-NUMBERFIELD)" };
+    }
+    const authored = literalParam(node, "startValue");
+    const start3 = authored === void 0 || authored === null ? "" : typeof authored === "object" ? void 0 : String(authored);
+    if (start3 === void 0) return { defer: "its typed-in Value is not text, a number or a boolean" };
+    const field2 = { inputId: node.id, port: "set", start: start3 };
+    const wires = component.connections.filter((c) => c.toId === node.id && c.toProperty === "startValue");
+    if (wires.length > 1) return { defer: "two wires feed its Value \u2014 which one its Set writes is not statically ordered" };
+    if (wires.length === 0) {
+      return { action: { kind: "state-set", name: stateVar.name, expr: { kind: "literal", value: start3 }, field: field2 }, consumes: [] };
+    }
+    const ctx = newCtx();
+    const expr = resolveExpr(nodeById.get(wires[0].fromId), wires[0].fromProperty, ctx);
+    if (expr === null) return { defer: ctx.defer ?? "its Value wire has no statically known source, and its Set writes that Value" };
+    if (isBooleanExpr(expr)) return { defer: "its Value wire carries a logic truth value, and its Set writes it as text" };
+    return {
+      action: { kind: "state-set", name: stateVar.name, expr, field: field2 },
+      consumes: [...ctx.consumes],
+      collapses: ctx.logicNodeIds,
+      subscribes: ctx.subscriberIds
+    };
+  };
+  const compileFieldFocus = (node, port5) => {
+    const consumedOutcome = component.connections.find(
+      (c) => c.fromId === node.id && (c.fromProperty === "done" || c.fromProperty === "unchanged")
+    );
+    if (consumedOutcome) {
+      return { defer: `its ${consumedOutcome.fromProperty} outcome is consumed \u2014 change-conditional pulses are not translated in this slice` };
+    }
+    return { action: { kind: "field-focus", inputId: node.id, focus: port5 === "focus" }, consumes: [] };
+  };
   const compileRecordOp = (node) => {
     const verb = RECORD_VERBS[node.type];
     const authoredOrWired = (name) => node.parameters.some((p) => p.name === name) || wiredPorts.has(`${node.id}:${name}`);
@@ -251450,9 +251731,11 @@ ${body}
     if (jsNodeKindOf(node.type) !== null && port5 === "run") return compileJsRun(node);
     if (isLatchType(node.type)) return compileLatch(node, port5);
     if (kitSignalInputOf(node, port5) !== void 0) return compileKitSignal(node, port5);
+    if (instanceSignalInputOf(node, port5)) return compileInstanceSignal(node, port5);
     if ((plan.roleOf[node.id] === "checkbox" || plan.roleOf[node.id] === "input") && (CONTROL_ACTION_PORTS[plan.roleOf[node.id]] ?? []).includes(port5)) {
       return compileControlAction(node, port5);
     }
+    if (plan.roleOf[node.id] === "input" && (port5 === "focus" || port5 === "blur")) return compileFieldFocus(node, port5);
     if (node.type === EXTERNAL_LINK_TYPE) return compileExternalLink(node);
     if (node.type === LOG_TYPE) return compileLog(node);
     if (node.type === TIMER_TYPE && isTimerTrigger(port5)) return compileDelay(node, port5);
@@ -251479,25 +251762,25 @@ ${body}
       if (propagation !== "global") {
         return { defer: `propagation "${String(propagation)}" scopes the event to the component tree` };
       }
-      const ctx2 = newCtx();
+      const ctx = newCtx();
       const payload = [];
       const consumes = [];
       for (const key2 of payloadKeysOf(node)) {
-        const wire2 = component.connections.find((c) => c.toId === node.id && c.toProperty === key2);
-        if (!wire2) continue;
-        const expr2 = resolveExpr(nodeById.get(wire2.fromId), wire2.fromProperty, ctx2);
-        if (expr2 === null) return { defer: ctx2.defer ?? `payload "${key2}" has no statically known source` };
-        if (isBooleanExpr(expr2)) {
+        const wire = component.connections.find((c) => c.toId === node.id && c.toProperty === key2);
+        if (!wire) continue;
+        const expr = resolveExpr(nodeById.get(wire.fromId), wire.fromProperty, ctx);
+        if (expr === null) return { defer: ctx.defer ?? `payload "${key2}" has no statically known source` };
+        if (isBooleanExpr(expr)) {
           return { defer: `payload "${key2}" is fed a logic truth value \u2014 only truthiness sinks take one in this slice` };
         }
-        payload.push({ key: key2, expr: expr2 });
-        consumes.push(wire2.key);
+        payload.push({ key: key2, expr });
+        consumes.push(wire.key);
       }
       return {
         action: { kind: "emit", channelName, payload },
-        consumes: [...consumes, ...ctx2.consumes],
-        collapses: ctx2.logicNodeIds,
-        subscribes: ctx2.subscriberIds
+        consumes: [...consumes, ...ctx.consumes],
+        collapses: ctx.logicNodeIds,
+        subscribes: ctx.subscriberIds
       };
     }
     if (node.type === GLOBAL_STORE_SET) {
@@ -251518,26 +251801,26 @@ ${body}
       if (keyType === "number" || keyType === "boolean") {
         return { defer: `key "${key2}" is ${keyType}-typed by the initial state; only string writes translate in this slice` };
       }
-      const wire2 = lastValueWireOf(node);
-      if (wire2 === void 0 && valueWiresInto(node).length > 1) {
+      const wire = lastValueWireOf(node);
+      if (wire === void 0 && valueWiresInto(node).length > 1) {
         return { defer: "two wires feed its Value input \u2014 last-writer-wins is not statically ordered" };
       }
-      if (!wire2) {
+      if (!wire) {
         const authored = literalParam(node, "value");
         if (authored === void 0) return { defer: "nothing is wired into value" };
         return { action: { kind: "globalstore-set", storeName: store2.name, key: key2, expr: { kind: "literal", value: authored } }, consumes: [], collapses: [], subscribes: [] };
       }
-      const ctx2 = newCtx();
-      const expr2 = resolveExpr(nodeById.get(wire2.fromId), wire2.fromProperty, ctx2);
-      if (expr2 === null) return { defer: ctx2.defer ?? "the value wire has no statically known source" };
-      if (isBooleanExpr(expr2)) {
+      const ctx = newCtx();
+      const expr = resolveExpr(nodeById.get(wire.fromId), wire.fromProperty, ctx);
+      if (expr === null) return { defer: ctx.defer ?? "the value wire has no statically known source" };
+      if (isBooleanExpr(expr)) {
         return { defer: "the value wire carries a logic truth value \u2014 only truthiness sinks take one in this slice" };
       }
       return {
-        action: { kind: "globalstore-set", storeName: store2.name, key: key2, expr: expr2, ...typedInUnderWire(node, "value", wire2, expr2) },
-        consumes: [wire2.key, ...ctx2.consumes],
-        collapses: ctx2.logicNodeIds,
-        subscribes: ctx2.subscriberIds
+        action: { kind: "globalstore-set", storeName: store2.name, key: key2, expr, ...typedInUnderWire(node, "value", wire, expr) },
+        consumes: [wire.key, ...ctx.consumes],
+        collapses: ctx.logicNodeIds,
+        subscribes: ctx.subscriberIds
       };
     }
     if (node.type === "NewModel") {
@@ -251545,16 +251828,16 @@ ${body}
       if (result === void 0) return { defer: "the created object is never inserted into a translated array" };
       if ("defer" in result) return { defer: result.defer };
       const chain = result.chain;
-      const ctx2 = newCtx();
+      const ctx = newCtx();
       const entries2 = [];
       for (const property of chain.properties) {
         if (property.wire) {
-          const expr2 = resolveExpr(nodeById.get(property.wire.fromId), property.wire.fromProperty, ctx2);
-          if (expr2 === null) return { defer: ctx2.defer ?? `property "${property.key}" has no statically known source` };
-          if (isBooleanExpr(expr2)) {
+          const expr = resolveExpr(nodeById.get(property.wire.fromId), property.wire.fromProperty, ctx);
+          if (expr === null) return { defer: ctx.defer ?? `property "${property.key}" has no statically known source` };
+          if (isBooleanExpr(expr)) {
             return { defer: `property "${property.key}" is fed a logic truth value \u2014 only truthiness sinks take one in this slice` };
           }
-          entries2.push({ key: property.key, expr: expr2 });
+          entries2.push({ key: property.key, expr });
         } else if (property.literal !== void 0) {
           entries2.push({ key: property.key, expr: { kind: "literal", value: property.literal } });
         }
@@ -251563,25 +251846,25 @@ ${body}
         const insertNode = nodeById.get(chain.insertId);
         const conflict = mintScopeConflict(node, "new", { kind: "minted", nodeId: chain.minted, wireKey: "" });
         if (conflict !== void 0) return { defer: conflict };
-        for (const wire2 of component.connections.filter((c) => c.fromId === insertNode.id)) {
-          if (wire2.fromProperty === "failure") continue;
-          return { defer: `the insert's ${wire2.fromProperty} output is consumed \u2014 into a minted array this slice translates the Failure chain only` };
+        for (const wire of component.connections.filter((c) => c.fromId === insertNode.id)) {
+          if (wire.fromProperty === "failure") continue;
+          return { defer: `the insert's ${wire.fromProperty} output is consumed \u2014 into a minted array this slice translates the Failure chain only` };
         }
         const fail2 = doneChainOf(insertNode, "failure");
         if ("defer" in fail2) return { defer: fail2.defer };
         const target = { kind: "minted", nodeId: chain.minted, wireKey: "" };
         return {
           action: { kind: "collection-add", collectionName: "", entries: entries2, minted: mintedTargetFor(target, chain.insertId, "insert", fail2.then) },
-          consumes: [...chain.consumes, ...ctx2.consumes, ...fail2.consumes],
-          collapses: [chain.insertId, ...ctx2.logicNodeIds, ...fail2.collapses],
-          subscribes: [...ctx2.subscriberIds, ...fail2.subscribes]
+          consumes: [...chain.consumes, ...ctx.consumes, ...fail2.consumes],
+          collapses: [chain.insertId, ...ctx.logicNodeIds, ...fail2.collapses],
+          subscribes: [...ctx.subscriberIds, ...fail2.subscribes]
         };
       }
       return {
         action: { kind: "collection-add", collectionName: chain.collectionName, entries: entries2 },
-        consumes: [...chain.consumes, ...ctx2.consumes],
-        collapses: [chain.insertId, ...ctx2.logicNodeIds],
-        subscribes: ctx2.subscriberIds
+        consumes: [...chain.consumes, ...ctx.consumes],
+        collapses: [chain.insertId, ...ctx.logicNodeIds],
+        subscribes: ctx.subscriberIds
       };
     }
     if (node.type === "CollectionClear") return compileCollectionClear(node);
@@ -251601,6 +251884,30 @@ ${body}
     if (node.type === "Condition") return compileCondition2(node);
     if (node.type === SET_OBJECT_PROPERTIES_TYPE) return compileSetObjectProperties(node);
     if (node.type === SET_COMPONENT_OBJECT_TYPE || node.type === SET_PARENT_COMPONENT_OBJECT_TYPE) return compileComponentObjectSet(node);
+    return withSetDone(node, compileSetVariableWrite(node));
+  };
+  const withSetDone = (node, write) => {
+    if ("defer" in write || write.action.kind !== "store-set") return write;
+    const then2 = [];
+    const consumes = [...write.consumes];
+    const collapses = [...write.collapses ?? []];
+    const subscribes = [...write.subscribes ?? []];
+    for (const port5 of SET_VARIABLE_CHAIN_OUTPUTS) {
+      if (!component.connections.some((c) => c.fromId === node.id && c.fromProperty === port5)) continue;
+      const chain = doneChainOf(node, port5);
+      if ("defer" in chain) {
+        setDoneRefusals.set(`${node.id}:${port5}`, chain.defer);
+        continue;
+      }
+      then2.push(...chain.then);
+      consumes.push(...chain.consumes);
+      collapses.push(...chain.collapses);
+      subscribes.push(...chain.subscribes);
+    }
+    if (then2.length === 0) return { ...write, consumes, collapses, subscribes };
+    return { action: { ...write.action, then: then2 }, consumes, collapses, subscribes };
+  };
+  const compileSetVariableWrite = (node) => {
     const variableName = variableNameOf(node);
     if (variableName === void 0) return { defer: "variable name is not a literal" };
     const setWith = literalParam(node, "setWith");
@@ -251882,12 +252189,28 @@ ${body}
     return { action: { kind: "branch", cond, whenTrue, whenFalse }, consumes, collapses, subscribes };
   };
   const compiledSinks = /* @__PURE__ */ new Map();
+  const setDoneRefusals = /* @__PURE__ */ new Map();
   const reactiveConditionDefers = /* @__PURE__ */ new Map();
   const recordEffectDefers = /* @__PURE__ */ new Map();
   const compiling = /* @__PURE__ */ new Set();
   const compiledOf = (node, port5) => {
     const valueWires = (node.type === "Set Variable" || node.type === GLOBAL_STORE_SET) && valueWiresInto(node).length > 1;
-    const plainKey = `${node.id}:${port5}${valueWires ? `@value:${lastValueWireOf(node)?.key ?? "none"}` : ""}`;
+    const basePlain = `${node.id}:${port5}${valueWires ? `@value:${lastValueWireOf(node)?.key ?? "none"}` : ""}`;
+    const rowScope = rowChainScopes[rowChainScopes.length - 1] ?? null;
+    const scopedKey = `${basePlain}@row:${rowScope ?? "none"}`;
+    const scopes = relayTouchedKeys.get(basePlain);
+    const key2 = scopes !== void 0 ? scopedKey : basePlain;
+    relayTouches.push(/* @__PURE__ */ new Set());
+    const result = compiledOfKeyed(node, port5, key2);
+    const touched = relayTouches.pop();
+    if (touched.size > 0) {
+      relayTouchedKeys.set(basePlain, /* @__PURE__ */ new Set([...scopes ?? [], rowScope]));
+      if (key2 === basePlain) compiledSinks.set(scopedKey, result);
+    }
+    if (touched.size > 0 || relayTouchedKeys.has(basePlain)) relayTouches[relayTouches.length - 1]?.add(rowScope ?? "none");
+    return result;
+  };
+  const compiledOfKeyed = (node, port5, plainKey) => {
     const scoped = [...verbChainScope].filter(([, s]) => s === "failure").map(([id]) => id);
     const scopeKey = scoped.length > 0 ? `${plainKey}@failure:${[...scoped].sort().join(",")}` : void 0;
     const readsScoped = (result2, form) => {
@@ -251962,6 +252285,9 @@ ${body}
         return exprValidIn(expr.source, context, invokedScope) && whereExprs(expr.where).every((e) => exprValidIn(e, context, invokedScope));
       case "input-text":
         return context.kind === "dom" && context.nodeId === expr.inputId;
+      // EXP-011 §100. Only in that repeater's row callbacks, which close over the firing row's item.
+      case "row-relay":
+        return context.kind === "dom" && context.nodeId === expr.repeaterId && (context.port?.startsWith(ITEM_OUTPUT_SIGNAL) ?? false);
       case "control-event":
         return context.kind === "dom" && context.nodeId === expr.controlId;
       case "payload":
@@ -252077,7 +252403,9 @@ ${body}
        */
       case "collection-remove":
         return context.kind === "dom" && context.nodeId === action.repeaterId && context.port !== void 0 && context.port.startsWith(ITEM_OUTPUT_SIGNAL) && actionsValidIn(action.then, context, invokedScope);
+      // P18-S127-SETDONE. The value, then the Done chain.
       case "store-set":
+        return exprValidIn(action.expr, context, invokedScope) && actionsValidIn(action.then ?? [], context, invokedScope);
       case "globalstore-set":
         return exprValidIn(action.expr, context, invokedScope);
       // EXP-011 §47. Every value in the patch, then the chain.
@@ -252210,6 +252538,9 @@ ${body}
       // EXP-011 §63. A call on the handle; the Done listener is validated where it compiles (the render context).
       case "drag-snap":
         return true;
+      // P18-S128-FIELDSET. A call on the field's element, reading nothing.
+      case "field-focus":
+        return true;
       // EXP-011 §52. A call on the handle; the node's listeners are validated where they compile.
       case "script-signal":
         return true;
@@ -252337,10 +252668,14 @@ ${body}
     const wires = component.connections.filter((c) => c.toId === node.id && c.toProperty === spec.statePort);
     if (wires.length === 0) continue;
     if (spec.coerce === "textinput" && literalParam(node, "runOnChange-startValue") === false) {
+      const viaSet = wiredPorts.has(`${node.id}:set`);
       for (const w of wires) {
         consumed.add(w.key);
         notes.push(
-          wireNote(w, `Value is unticked under Run On Value Change \u2014 arrivals wait for a Set pulse, which is not translated in this slice`)
+          wireNote(
+            w,
+            viaSet ? "Value is unticked under Run On Value Change \u2014 it reaches the field only when its Set is sent (P18-S128-FIELDSET)" : "Value is unticked under Run On Value Change \u2014 arrivals wait for a Set pulse, and nothing sends this field one"
+          )
         );
       }
       continue;
@@ -252410,6 +252745,37 @@ ${body}
       }
     }
   }
+  const rowRelays = /* @__PURE__ */ new Map();
+  const relayedSignalsOf = (forEach) => [
+    ...new Set(
+      component.connections.filter((c) => c.fromId === forEach.id && c.fromProperty.startsWith(ITEM_OUTPUT_SIGNAL)).map((c) => c.fromProperty.slice(ITEM_OUTPUT_SIGNAL.length))
+    )
+  ].join(", ") || "relayed signal";
+  const rowRelayOf = (forEach, fromProperty) => {
+    if (!fromProperty.startsWith(ITEM_OUTPUT_VALUE)) {
+      return { defer: `a repeater's "${fromProperty}" is not a row's relayed value \u2014 those register as "${ITEM_OUTPUT_VALUE}<name>"` };
+    }
+    const output = fromProperty.slice(ITEM_OUTPUT_VALUE.length);
+    const key2 = `${forEach.id}\0${output}`;
+    const known = rowRelays.get(key2);
+    if (known !== void 0) return { stateName: known.name };
+    const relayed = relayedInputOf(forEach, output);
+    if ("defer" in relayed) return relayed;
+    const { input, declared } = relayed;
+    const tsType = declared === "unknown" || declared === "any" ? declared : `${declared} | undefined`;
+    const stateVar = allocStateVar(
+      `relayed ${output}`,
+      "relayed",
+      tsType,
+      null,
+      forEach.id,
+      "relay",
+      `What the row whose "${relayedSignalsOf(forEach)}" fired last holds on its "${output}" \u2014 undefined until one fires (foreach.tsx itemOutputSignalTriggered, EXP-011 \xA799).`
+    );
+    rowRelays.set(key2, stateVar);
+    plan.rowRelays.push({ repeaterId: forEach.id, output, input, stateName: stateVar.name });
+    return { stateName: stateVar.name };
+  };
   {
     const valuePropByPort = new Map(outputInterface.valueProps.map((v) => [v.port, v]));
     const wiresByPort = /* @__PURE__ */ new Map();
@@ -252434,15 +252800,17 @@ ${body}
       }
       const wire = wires[0];
       const from = nodeById.get(wire.fromId);
+      let relayExpr;
       if (from?.type === "For Each") {
-        fail2(
-          wire.key,
-          `a repeater relays its rows' outputs into "${port5}" \u2014 which row fired is not statically expressible in this slice`
-        );
-        continue;
+        const relay = rowRelayOf(from, wire.fromProperty);
+        if ("defer" in relay) {
+          fail2(wire.key, relay.defer);
+          continue;
+        }
+        relayExpr = { kind: "state-get", name: relay.stateName };
       }
       const ctx = newCtx();
-      const expr = from === void 0 ? null : resolveExpr(from, wire.fromProperty, ctx);
+      const expr = relayExpr ?? (from === void 0 ? null : resolveExpr(from, wire.fromProperty, ctx));
       if (expr === null) {
         fail2(
           wire.key,
@@ -252477,6 +252845,11 @@ ${body}
       }
     }
   }
+  const siblingValueInputOf = (toNode, port5) => {
+    if (plan.roleOf[toNode.id] !== "instance") return false;
+    const target = ir.components.find((tc) => `/${tc.path}` === toNode.type);
+    return target !== void 0 && target.nodes.some((n) => n.type === "Component Inputs" && n.declaredPorts.some((p) => p.plug === "output" && p.name === port5 && p.kind !== "signal"));
+  };
   for (const c of component.connections) {
     if (consumed.has(c.key)) continue;
     const fromNode = nodeById.get(c.fromId);
@@ -252496,7 +252869,7 @@ ${body}
     const contentRole = (CONTENT_PARAMS[toNode.type] ?? {})[c.toProperty];
     const truthinessSink = c.toProperty === "visible" || c.toProperty === "mounted";
     const bindable = truthinessSink || contentRole === "children" || contentRole === "attr-not:disabled" || contentRole !== void 0 && contentRole.startsWith("attr:") || // EXP-011 §49. A wired style parameter the emitter prints inline.
-    styleSinkOf(toNode, c.toProperty) !== void 0;
+    styleSinkOf(toNode, c.toProperty) !== void 0 || siblingValueInputOf(toNode, c.toProperty);
     if (!bindable) {
       consumed.add(c.key);
       notes.push(
@@ -252504,7 +252877,7 @@ ${body}
       );
       continue;
     }
-    if (c.toProperty === "mounted" && toNode.id === plan.rootId) {
+    if (routerMounted(toNode, c.toProperty)) {
       consumed.add(c.key);
       notes.push(wireNote(c, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
@@ -252516,7 +252889,8 @@ ${body}
       targetLegacy: fromNode.type,
       port: c.fromProperty,
       toNodeId: toNode.id,
-      toProperty: c.toProperty
+      toProperty: c.toProperty,
+      ...siblingValueInputOf(toNode, c.toProperty) ? { intoInstance: true } : {}
     });
   }
   const customLiftedVarByKey = /* @__PURE__ */ new Map();
@@ -252549,7 +252923,7 @@ ${body}
       notes.push(wireNote(c, `custom node output "${c.fromProperty}" ${bindable}`));
       continue;
     }
-    if (c.toProperty === "mounted" && toNode.id === plan.rootId) {
+    if (routerMounted(toNode, c.toProperty)) {
       consumed.add(c.key);
       notes.push(wireNote(c, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
@@ -252785,13 +253159,22 @@ ${body}
         if (action.expr !== void 0) {
           const e = snapExpr(action.expr, snap2);
           if ("defer" in e) return e;
-          snap2.set(action.name, e);
+          snap2.set(action.name, action.field?.port === "set" ? "op" : e);
           return { ...action, expr: e };
         }
         snap2.set(action.name, "op");
         return action;
       }
-      case "store-set":
+      // P18-S127-SETDONE. The value is read where the handler is; the Done chain follows, one arm always taken, so it
+      // carries the map onward (an Object's Set's treatment).
+      case "store-set": {
+        const e = snapExpr(action.expr, snap2);
+        if ("defer" in e) return e;
+        if (action.then === void 0) return { ...action, expr: e };
+        const then2 = snapActionList(action.then, snap2);
+        if (!Array.isArray(then2)) return then2;
+        return { ...action, expr: e, then: then2 };
+      }
       case "globalstore-set": {
         const e = snapExpr(action.expr, snap2);
         if ("defer" in e) return e;
@@ -253409,6 +253792,7 @@ ${body}
     }
   }
   const receiverActions = /* @__PURE__ */ new Map();
+  const inputPulseActions = /* @__PURE__ */ new Map();
   const unreachedOwnerOf = (connection) => excluded.owners.get(connection.fromId) ?? (connection.fromProperty === "didMount" ? excluded.mounts.get(connection.fromId) : void 0);
   const refuseUnreached = (connection, toNode, compiled2, reason2, outputsSink) => {
     notes.push(wireNote(connection, reason2));
@@ -253419,6 +253803,11 @@ ${body}
       if (dispositions[id] === void 0) dispositions[id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
     }
   };
+  const instanceBeforeAttach = /* @__PURE__ */ new Map();
+  const isRunSuccessWire = (connection) => connection.fromProperty === "success" && nodeById.get(connection.fromId)?.type === JS_FUNCTION && wiredPorts.has(`${connection.fromId}:run`);
+  for (const node of component.nodes) {
+    if (plan.roleOf[node.id] === "instance" || plan.roleOf[node.id] === "input") instanceBeforeAttach.set(node.id, dispositions[node.id]);
+  }
   for (const connection of component.connections) {
     if (consumed.has(connection.key)) continue;
     const toNode = nodeById.get(connection.toId);
@@ -253438,6 +253827,7 @@ ${body}
     if (fromNode !== void 0 && jsNodeKindOf(fromNode.type) !== null && connection.fromProperty === "done") {
       continue;
     }
+    if (isRunSuccessWire(connection)) continue;
     consumed.add(connection.key);
     if (fromNode?.type === "For Each" && connection.fromProperty.startsWith(ITEM_OUTPUT_SIGNAL)) {
       const relayed = connection.fromProperty.slice(ITEM_OUTPUT_SIGNAL.length);
@@ -253462,7 +253852,13 @@ ${body}
       }
       compiled2 = sink;
     } else {
-      compiled2 = compiledOf(toNode, connection.toProperty);
+      const rowScope = fromNode?.type === "For Each" && connection.fromProperty.startsWith(ITEM_OUTPUT_SIGNAL) ? fromNode.id : void 0;
+      if (rowScope !== void 0) rowChainScopes.push(rowScope);
+      try {
+        compiled2 = compiledOf(toNode, connection.toProperty);
+      } finally {
+        if (rowScope !== void 0) rowChainScopes.pop();
+      }
     }
     if ("defer" in compiled2) {
       if (outputsSink) {
@@ -253555,6 +253951,40 @@ ${body}
       for (const id of compiled2.subscribes ?? []) boundSubscribers.add(id);
       continue;
     }
+    if (fromNode?.type === "Component Inputs" && signalInputPortsOf(component).has(connection.fromProperty)) {
+      const refuse = (reason2) => {
+        if (outputsSink) {
+          if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, reason2);
+        } else {
+          dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
+        }
+        notes.push(wireNote(connection, reason2));
+      };
+      if (!plan.file) {
+        refuse("the component emits no file to host the effect a signal input runs");
+        continue;
+      }
+      if (!actionsValidIn([compiled2.action], { kind: "render" })) {
+        refuse("the action reads values that only exist inside a handler");
+        continue;
+      }
+      const snappedIn = snapAction(compiled2.action, chainSnapshotFor(`input:${connection.fromProperty}`));
+      const lateInWrite = "defer" in snappedIn ? void 0 : lateQueryFetchWrite([...inputPulseActions.get(connection.fromProperty) ?? [], snappedIn]);
+      if (lateInWrite !== void 0) {
+        refuse(lateInWrite);
+        continue;
+      }
+      if ("defer" in snappedIn) {
+        refuse(snappedIn.defer);
+        continue;
+      }
+      inputPulseActions.set(connection.fromProperty, [...inputPulseActions.get(connection.fromProperty) ?? [], snappedIn]);
+      if (!outputsSink) dispositions[toNode.id] = { kind: "collapsed", into: fromNode.id };
+      for (const id of compiled2.collapses ?? []) dispositions[id] = { kind: "collapsed", into: fromNode.id };
+      for (const key2 of compiled2.consumes) consumed.add(key2);
+      for (const id of compiled2.subscribes ?? []) boundSubscribers.add(id);
+      continue;
+    }
     if (fromNode?.type === "Event Receiver" && connection.fromProperty === "eventReceived") {
       const eligible = receiverEligible(fromNode);
       if ("defer" in eligible) {
@@ -253605,6 +254035,79 @@ ${body}
     }
     notes.push(wireNote(connection, pulseRefusal ?? `the trigger is not a rendered element event or a receiver`));
   }
+  const inSenderRowScope = (senderId, port5, fn) => {
+    const scopes = [...relayTouchedKeys].find(([key2]) => key2 === `${senderId}:${port5}` || key2.startsWith(`${senderId}:${port5}@`))?.[1];
+    const scope = [...scopes ?? []].find((s) => s !== null) ?? null;
+    if (scope !== null) rowChainScopes.push(scope);
+    try {
+      return fn();
+    } finally {
+      if (scope !== null) rowChainScopes.pop();
+    }
+  };
+  for (const connection of component.connections) {
+    if (consumed.has(connection.key)) continue;
+    const fromNode = nodeById.get(connection.fromId);
+    if (fromNode?.type !== "Set Variable" || !SET_VARIABLE_CHAIN_OUTPUTS.includes(connection.fromProperty)) continue;
+    const toNode = nodeById.get(connection.toId);
+    if (!toNode) continue;
+    const outputsSink = toNode.type === "Component Outputs";
+    if (!outputsSink && !isTriggerInto(toNode, connection.toProperty)) continue;
+    consumed.add(connection.key);
+    const sink = outputsSink ? outputSinkOf(connection.toProperty, fromNode, connection.fromProperty) : inSenderRowScope(fromNode.id, "do", () => compiledOf(toNode, connection.toProperty));
+    if ("drop" in sink) {
+      notes.push(wireNote(connection, sink.drop));
+      continue;
+    }
+    if ("defer" in sink) {
+      if (outputsSink) {
+        if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, sink.defer);
+      } else if (dispositions[toNode.id]?.kind !== "collapsed" && dispositions[toNode.id]?.kind !== "static") {
+        dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: sink.defer };
+      }
+      notes.push(wireNote(connection, sink.defer));
+      continue;
+    }
+    const trigger = `trigger ${connection.fromId}.${connection.fromProperty}`;
+    const chainRefusal = setDoneRefusals.get(`${connection.fromId}:${connection.fromProperty}`);
+    const own2 = dispositions[fromNode.id];
+    const compiled2 = [...compiledSinks].find(([key2]) => key2 === `${fromNode.id}:do` || key2.startsWith(`${fromNode.id}:do@`))?.[1];
+    const reason2 = chainRefusal !== void 0 ? `${trigger}: the Set Variable's ${connection.fromProperty === "done" ? "Done" : "Completed"} chain is not exported \u2014 ${chainRefusal}` : own2?.kind === "deferred" ? `${trigger}: the Set Variable that sends it is not exported \u2014 ${own2.reason}` : compiled2 !== void 0 && "defer" in compiled2 ? `${trigger}: the Set Variable that sends it is not exported \u2014 ${compiled2.defer}` : `${trigger}: the Set Variable that sends it is never run by an exported trigger`;
+    if (outputsSink) {
+      if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, reason2);
+    } else if (dispositions[toNode.id] === void 0) {
+      dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
+    }
+    notes.push(wireNote(connection, reason2));
+  }
+  for (const connection of component.connections) {
+    if (consumed.has(connection.key) || !isRunSuccessWire(connection)) continue;
+    const fromNode = nodeById.get(connection.fromId);
+    const toNode = nodeById.get(connection.toId);
+    if (!toNode) continue;
+    const outputsSink = toNode.type === "Component Outputs";
+    if (!outputsSink && !isTriggerInto(toNode, connection.toProperty)) continue;
+    consumed.add(connection.key);
+    const sink = outputsSink ? outputSinkOf(connection.toProperty, fromNode, connection.fromProperty) : inSenderRowScope(fromNode.id, "run", () => compiledOf(toNode, connection.toProperty));
+    if ("drop" in sink) {
+      notes.push(wireNote(connection, sink.drop));
+      continue;
+    }
+    const run6 = compiledSinks.get(`${fromNode.id}:run`);
+    const trigger = `trigger ${connection.fromId}.success`;
+    const reason2 = "defer" in sink ? sink.defer : run6 !== void 0 && "defer" in run6 ? `${trigger}: the Function that sends it is not exported \u2014 ${run6.defer}` : `${trigger}: the Function that sends it is never run by an exported trigger`;
+    if (outputsSink) {
+      if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, reason2);
+    } else if (dispositions[toNode.id] === void 0 || "defer" in sink && dispositions[toNode.id]?.kind !== "collapsed" && dispositions[toNode.id]?.kind !== "static") {
+      dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
+    }
+    notes.push(wireNote(connection, reason2));
+  }
+  for (const [id, before] of instanceBeforeAttach) {
+    if (dispositions[id]?.kind !== "deferred" || before?.kind === "deferred") continue;
+    if (before === void 0) delete dispositions[id];
+    else dispositions[id] = before;
+  }
   for (const node of component.nodes) {
     if (node.type !== "Component Outputs" || dispositions[node.id] !== void 0) continue;
     const failure3 = failedOutputsNodes.get(node.id);
@@ -253639,6 +254142,7 @@ ${body}
     plan.receivers.push({ nodeId: node.id, channelName: channelNameOf(node), actions });
     dispositions[node.id] = { kind: "collapsed", into: `src/${plan.file.dir}/${plan.file.fileBase}.tsx` };
   }
+  for (const [port5, actions] of inputPulseActions) plan.inputPulses.push({ port: port5, actions });
   {
     const attachedSlotKeys = /* @__PURE__ */ new Set();
     const attachedMutations = attachedRecordVerbs;
@@ -253711,6 +254215,8 @@ ${body}
           scanActions(action.failThen);
         } else if (action.kind === "log") {
           scanActions(action.then);
+        } else if (action.kind === "store-set") {
+          scanActions(action.then ?? []);
         } else if (action.kind === "delay") {
           scanActions(action.then);
           scanActions(action.unchangedThen);
@@ -253742,6 +254248,7 @@ ${body}
     for (const byPort of Object.values(plan.handlers)) for (const actions of Object.values(byPort)) scanActions(actions);
     for (const actions of Object.values(plan.changeHandlers)) scanActions(actions);
     for (const receiver of plan.receivers) scanActions(receiver.actions);
+    for (const pulse of plan.inputPulses) scanActions(pulse.actions);
     for (const run6 of plan.runTasks) for (const chain of Object.values(run6.listeners)) if (chain !== void 0) scanActions(chain);
     if (plan.task !== void 0) scanActions(plan.task.actions);
     for (const item of plan.repeaterItems) scanActions(item.actions);
@@ -254097,7 +254604,7 @@ ${body}
       notes.push(wireNote(connection, VARIABLE_FROZEN));
       continue;
     }
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) {
+    if (routerMounted(toNode, connection.toProperty)) {
       notes.push(wireNote(connection, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
     }
@@ -254117,7 +254624,7 @@ ${body}
       notes.push(wireNote(connection, `${read2.defer}`));
       continue;
     }
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) {
+    if (routerMounted(toNode, connection.toProperty)) {
       notes.push(wireNote(connection, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
     }
@@ -254188,7 +254695,7 @@ ${body}
       );
       continue;
     }
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) {
+    if (routerMounted(toNode, connection.toProperty)) {
       notes.push(wireNote(connection, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
     }
@@ -254214,7 +254721,7 @@ ${body}
     const bindable = truthinessSink || contentRole === "children" || contentRole === "attr-not:disabled" || contentRole !== void 0 && contentRole.startsWith("attr:") || // EXP-011 §49. A wired style parameter the emitter prints inline.
     styleSinkOf(toNode, connection.toProperty) !== void 0;
     if (!bindable) continue;
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) continue;
+    if (routerMounted(toNode, connection.toProperty)) continue;
     const ctx = newCtx();
     const expr = resolveExpr(fromNode, connection.fromProperty, ctx);
     if (expr === null) continue;
@@ -254251,7 +254758,7 @@ ${body}
     const bindable = truthinessSink || contentRole === "children" || contentRole === "attr-not:disabled" || contentRole !== void 0 && contentRole.startsWith("attr:") || // EXP-011 §49. A wired style parameter the emitter prints inline.
     styleSinkOf(toNode, connection.toProperty) !== void 0;
     if (!bindable) continue;
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) continue;
+    if (routerMounted(toNode, connection.toProperty)) continue;
     const deadRow = excluded.rows.get(fromNode.id);
     if (deadRow !== void 0) {
       consumed.add(connection.key);
@@ -254325,7 +254832,7 @@ ${body}
       );
       continue;
     }
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) {
+    if (routerMounted(toNode, connection.toProperty)) {
       consumed.add(connection.key);
       notes.push(wireNote(connection, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
@@ -254364,7 +254871,7 @@ ${body}
     const bindable = truthinessSink || contentRole === "children" || contentRole === "attr-not:disabled" || contentRole !== void 0 && contentRole.startsWith("attr:") || // EXP-011 §49. A wired style parameter the emitter prints inline.
     styleSinkOf(toNode, connection.toProperty) !== void 0;
     if (!bindable) continue;
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) continue;
+    if (routerMounted(toNode, connection.toProperty)) continue;
     const objectStore = objectStoreNodes.get(fromNode.id);
     if (objectStore !== void 0) {
       consumed.add(connection.key);
@@ -254399,7 +254906,7 @@ ${body}
     const bindable = truthinessSink || contentRole === "children" || contentRole === "attr-not:disabled" || contentRole !== void 0 && contentRole.startsWith("attr:") || // EXP-011 §49. A wired style parameter the emitter prints inline.
     styleSinkOf(toNode, connection.toProperty) !== void 0;
     if (!bindable) continue;
-    if (connection.toProperty === "mounted" && toNode.id === plan.rootId) continue;
+    if (routerMounted(toNode, connection.toProperty)) continue;
     const ctx = newCtx();
     const expr = resolveExpr(fromNode, connection.fromProperty, ctx);
     if (expr === null) {
@@ -254453,7 +254960,7 @@ ${body}
       continue;
     }
     if (fromNode?.type === "Component Inputs" && toNode && rendered2.has(toNode.id)) {
-      if (connection.toProperty === "mounted" && toNode.id === plan.rootId) {
+      if (routerMounted(toNode, connection.toProperty)) {
         consumed.add(connection.key);
         notes.push(wireNote(connection, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
         continue;
@@ -254893,6 +255400,9 @@ ${body}
           // EXP-011 §63. Nothing to read; the options and listeners are walked off the plan below.
           case "drag-snap":
             break;
+          // P18-S128-FIELDSET. Nothing to read.
+          case "field-focus":
+            break;
           // EXP-011 §52. The same: the inputs and listeners are walked off the plan below.
           case "script-signal":
             break;
@@ -254933,6 +255443,10 @@ ${body}
           case "state-set":
             if (action.expr !== void 0) walkExpr(action.expr);
             break;
+          // P18-S127-SETDONE. A Set Variable's Done chain (its own value is not walked here, as before).
+          case "store-set":
+            walkActions(action.then ?? []);
+            break;
           default:
             break;
         }
@@ -254944,6 +255458,7 @@ ${body}
     for (const byPort of Object.values(plan.handlers)) for (const actions of Object.values(byPort)) walkActions(actions);
     for (const actions of Object.values(plan.changeHandlers)) walkActions(actions);
     for (const receiver of plan.receivers) walkActions(receiver.actions);
+    for (const pulse of plan.inputPulses) walkActions(pulse.actions);
     for (const effect of plan.branchEffects) walkActions([effect.action]);
     for (const effect of plan.valueChangedEffects) {
       walkExpr(effect.watch);
@@ -255007,6 +255522,23 @@ ${body}
     for (const id of wiring.collapses) dispositions[id] = { kind: "collapsed", into };
     for (const id of wiring.subscribes) boundSubscribers.add(id);
   }
+  for (const relay of [...plan.rowRelays]) {
+    const repeater = plan.repeaters[relay.repeaterId];
+    const fed = repeater !== void 0 && (plan.queries.some((q) => q.nodeId === repeater.itemsQueryId) || repeater.itemsCollectionName != null || repeater.itemsExpr !== void 0 || plan.staticData.some((sd) => sd.nodeId === repeater.itemsStaticId));
+    if (fed) continue;
+    const reason2 = `the repeater relaying "${relay.output}" draws no rows in the export (its items are not fed by a query, a named array, or a statically-known list), so no row ever relays it`;
+    plan.rowRelays.splice(plan.rowRelays.indexOf(relay), 1);
+    plan.stateVars = plan.stateVars.filter((v) => v.name !== relay.stateName);
+    plan.pushEffects = plan.pushEffects.filter((e) => !(e.expr.kind === "state-get" && e.expr.name === relay.stateName));
+    for (const wire of component.connections) {
+      if (wire.fromId !== relay.repeaterId || wire.fromProperty !== `${ITEM_OUTPUT_VALUE}${relay.output}`) continue;
+      const outputs2 = nodeById.get(wire.toId);
+      if (outputs2?.type !== "Component Outputs") continue;
+      plan.liftedOutputProps = plan.liftedOutputProps.filter((l) => l.port !== wire.toProperty);
+      notes.push(wireNote(wire, reason2));
+      if (dispositions[outputs2.id]?.kind !== "deferred") dispositions[outputs2.id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
+    }
+  }
   for (const connection of component.connections) {
     if (consumed.has(connection.key)) continue;
     const kitEndpoint = undeclaredKitPortOf(connection, nodeById, kits);
@@ -255046,17 +255578,19 @@ ${body}
       const label2 = node.authoredLabel ? `"${node.authoredLabel}"` : "The text input";
       const refuse = (why) => notes.push(`node ${node.id} (${node.type}): its Value at mount is not announced \u2014 ${why}; typing still runs its chain (P18-S116-FIELDMOUNT)`);
       let away;
+      const gates = [];
       for (let id = node.id; id !== void 0; id = parentOf.get(id)) {
         const bound = plan.bindings[id]?.["mounted"];
         if (bound !== void 0) {
           const literal2 = bound.kind === "computed" && (bound.expr.kind === "literal" || bound.expr.kind === "undefined");
-          if (!literal2) away = away ?? "later";
+          if (!literal2 && id === plan.collapsedGroupId) away = "uncarried";
+          else if (!literal2) gates.push(id);
           else if (bound.expr.kind === "undefined" || !bound.expr.value) away = "never";
         } else if (literalParam(nodeById.get(id), "mounted") === false) away = "never";
       }
       if (away === "never") continue;
-      if (away === "later") {
-        refuse("it or a group it sits in mounts from a wire, so it announces when that wire first says true, not as the component mounts");
+      if (away === "uncarried") {
+        refuse("it sits in the page's own Group, whose Mounted is wired and not carried (the page is drawn), so when it appears is not known here");
         continue;
       }
       const type = literalParam(node, "type");
@@ -255080,7 +255614,8 @@ ${body}
         inputId: node.id,
         start: raw === void 0 ? "" : String(raw),
         ...sync !== void 0 ? { source: sync.source } : {},
-        comment: `${label2} announces its Value as it mounts, and its chain runs with it (TextInput.tsx componentDidMount \u2192 setText(startValue)).`
+        ...gates.length > 0 ? { gates } : {},
+        comment: gates.length > 0 ? `${label2} announces its Value the first time it mounts, and its chain runs with it (TextInput.tsx componentDidMount \u2192 setText(startValue)); it mounts when a value says.` : `${label2} announces its Value as it mounts, and its chain runs with it (TextInput.tsx componentDidMount \u2192 setText(startValue)).`
       });
     }
   }
@@ -255340,6 +255875,8 @@ ${body}
           // EXP-011 §63. Nothing nested; the listeners are filled off the plan below.
           case "drag-snap":
             break;
+          case "field-focus":
+            break;
           case "script-signal":
             break;
           // EXP-011 §53. Nothing nested on the action; the listeners are filled off the plan below.
@@ -255467,6 +256004,10 @@ ${body}
             fillMaterialize(action.then);
             fillMaterialize(action.failThen);
             break;
+          // P18-S127-SETDONE. A Set Variable's Done chain.
+          case "store-set":
+            fillMaterialize(action.then ?? []);
+            break;
           default:
             break;
         }
@@ -255475,6 +256016,7 @@ ${body}
     for (const byPort of Object.values(plan.handlers)) for (const actions of Object.values(byPort)) fillMaterialize(actions);
     for (const actions of Object.values(plan.changeHandlers)) fillMaterialize(actions);
     for (const receiver of plan.receivers) fillMaterialize(receiver.actions);
+    for (const pulse of plan.inputPulses) fillMaterialize(pulse.actions);
     for (const effect of plan.branchEffects) fillMaterialize([effect.action]);
     for (const effect of plan.valueChangedEffects) fillMaterialize(effect.actions);
     for (const ticked3 of plan.tickedRuns) fillMaterialize([ticked3.action]);
@@ -255574,11 +256116,45 @@ ${body}
     if (node === void 0 || !component.connections.some((c) => c.toId === id && isTriggerInto(node, c.toProperty))) continue;
     dispositions[id] = { kind: "static" };
   }
+  if (instancePulseVars.size > 0) {
+    const pulsed = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (value) => {
+      if (value === null || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      if (Array.isArray(value)) return value.forEach(visit);
+      const v = value;
+      if (v.kind === "state-set" && v.op === "inc" && typeof v.name === "string") pulsed.add(v.name);
+      for (const child of Object.values(value)) visit(child);
+    };
+    for (const [key2, value] of Object.entries(plan)) if (key2 !== "stateVars" && key2 !== "bindings") visit(value);
+    for (const [key2, stateVar] of instancePulseVars) {
+      if (pulsed.has(stateVar.name)) continue;
+      const [nodeId, port5] = key2.split("\0");
+      plan.stateVars = plan.stateVars.filter((v) => v !== stateVar);
+      plan.instancePulses = plan.instancePulses.filter((p) => p.stateName !== stateVar.name);
+      if (plan.bindings[nodeId] !== void 0) delete plan.bindings[nodeId][port5];
+    }
+  }
   sweepRefusedScripts();
   sweepUnreportedDeferrals();
   collectRefusals();
   return plan;
 }
+var signalInputPortsCache = /* @__PURE__ */ new WeakMap();
+function signalInputPortsOf(component) {
+  if (component === void 0) return /* @__PURE__ */ new Set();
+  let ports = signalInputPortsCache.get(component);
+  if (ports === void 0) {
+    ports = /* @__PURE__ */ new Set();
+    for (const node of component.nodes) {
+      if (node.type !== "Component Inputs") continue;
+      for (const port5 of node.declaredPorts) if (port5.plug === "output" && port5.kind === "signal") ports.add(port5.name);
+    }
+    signalInputPortsCache.set(component, ports);
+  }
+  return ports;
+}
 function componentOutputInterface(component) {
   const takenProps = /* @__PURE__ */ new Set();
   for (const node of component.nodes) {
@@ -255979,7 +256555,7 @@ function indexPageStacks(ir, catalog2, kits) {
   return index;
 }
 function tsTypeOf(portType2, kind) {
-  if (kind === "signal") return "() => void";
+  if (kind === "signal") return INPUT_PULSE_TS_TYPE;
   switch (portType2) {
     case "boolean":
       return "boolean";
@@ -267978,6 +268554,23 @@ var GENERATED_TS3 = "// @nodegx:generated (visual \u2014 provenance markers comp
 var GENERATED_CSS2 = "/* @nodegx:generated (visual) */\n";
 var PRINT_WIDTH = 100;
 var SIMPLE_REF = /^[A-Za-z_$][A-Za-z0-9_$.]*(\(\))?$/;
+function negatedCode(cond) {
+  if (cond.startsWith("!!")) {
+    const rest = cond.slice(2);
+    if (SIMPLE_REF.test(rest)) return `!${rest}`;
+    if (rest.startsWith("(") && closingParenOf(rest) === rest.length - 1) return `!${rest}`;
+  }
+  if (SIMPLE_REF.test(cond) || cond.startsWith("(") && closingParenOf(cond) === cond.length - 1) return `!${cond}`;
+  return `!(${cond})`;
+}
+function closingParenOf(code) {
+  let depth = 0;
+  for (let i = 0; i < code.length; i++) {
+    if (code[i] === "(") depth++;
+    else if (code[i] === ")" && --depth === 0) return i;
+  }
+  return -1;
+}
 var FILE_OUT_OPTIONAL_FIELDS2 = /* @__PURE__ */ new Set(["upload.contentType", "upload.size", "sign.expiresAt", "sign.ttlSeconds"]);
 var SESSION_LOCAL = "session";
 var PAGE_PARAMS_LOCAL = "pageParams";
@@ -268223,25 +268816,27 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
   const mountRefusals = /* @__PURE__ */ new Map();
   {
     const mountGateOf = (id) => {
+      const gates = [];
       for (let at = id; at !== void 0; at = nodeById.get(at)?.parent) {
         const bound = plan.bindings[at]?.["mounted"];
         const literal2 = nodeById.get(at)?.parameters.find((p) => p.name === "mounted")?.value;
         const never2 = bound !== void 0 && bound.kind === "computed" && (bound.expr.kind === "undefined" || bound.expr.kind === "literal" && !bound.expr.value) || bound === void 0 && literal2?.kind === "literal" && literal2.value === false;
         const whose = at === id ? "it is" : `an element above it (${at}) is`;
-        if (never2) return `${whose} never mounted, so its Did Mount never fires`;
-        if (bound !== void 0 && !(bound.kind === "computed" && bound.expr.kind === "literal")) {
-          return `${whose} mounted by a value, so its Did Mount fires when that value says, and a mount effect runs when the component mounts`;
+        if (never2) return { never: `${whose} never mounted, so its Did Mount never fires` };
+        if (bound !== void 0 && !(bound.kind === "computed" && bound.expr.kind === "literal") && at === plan.collapsedGroupId) {
+          return { never: `${UNCARRIED_PAGE_GROUP} ${at}, is mounted by a value the export does not carry (it draws the page), so when it mounts is not known here` };
         }
+        if (bound !== void 0 && !(bound.kind === "computed" && bound.expr.kind === "literal")) gates.push(at);
         if (at === plan.rootId) break;
       }
-      return null;
+      return { gates };
     };
     const consider = (id) => {
       const actions = plan.handlers[id]?.["didMount"];
       if (actions === void 0) return;
-      const why = mountGateOf(id);
-      if (why === null) mountChains.push({ nodeId: id, actions });
-      else mountRefusals.set(id, why);
+      const gate = mountGateOf(id);
+      if ("gates" in gate) mountChains.push({ nodeId: id, actions, gates: gate.gates });
+      else mountRefusals.set(id, gate.never);
     };
     const visit = (id) => {
       for (const child of plan.childrenOf[id] ?? []) visit(child);
@@ -268333,6 +268928,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     if (action.kind === "store-set") {
       usedVariableNames.add(action.variableName);
       collectExprUse(action.expr);
+      (action.then ?? []).forEach(collectActionUse);
     }
     if (action.kind === "globalstore-set") {
       usedStoreNames.add(action.storeName);
@@ -268492,6 +269088,8 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     ...Object.values(plan.handlers).flatMap((byPort) => Object.values(byPort).flat()),
     ...Object.values(plan.changeHandlers).flat(),
     ...plan.receivers.flatMap((r) => r.actions),
+    // P18-S126-INSIGNAL. A signal input's chain earns imports and references exactly as a handler's does.
+    ...plan.inputPulses.flatMap((p) => p.actions),
     // A reactive Condition's branch earns imports, `navigate` and state references exactly as a
     // handler's does — it just runs from an effect instead of an event (LOGIC-TARGET §10).
     ...plan.branchEffects.map((e) => e.action),
@@ -268557,7 +269155,10 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
                       // two outcome arms and its minted Failure arm, an Insert's minted Failure arm, a Remove's Done.
                       a8.kind === "collection-clear" ? [a8, ...deepActions(a8.then), ...deepActions(a8.unchangedThen), ...deepActions(a8.minted?.failThen ?? [])] : a8.kind === "collection-add" ? [a8, ...deepActions(a8.minted?.failThen ?? [])] : a8.kind === "log" || a8.kind === "popup-show" || a8.kind === "popup-close" || a8.kind === "jsfun-run" || // EXP-011 §86. The pulse loop and each signal's arm.
                       a8.kind === "jsfun-pulses" || a8.kind === "jsfun-pulse" || a8.kind === "date-now-read" || a8.kind === "collection-remove" || a8.kind === "array-new" || // EXP-011 §61. A Reset's one chain.
-                      a8.kind === "stack-reset" ? [a8, ...deepActions(a8.then)] : [a8]
+                      a8.kind === "stack-reset" ? [a8, ...deepActions(a8.then)] : (
+                        // P18-S127-SETDONE. A Set Variable's Done chain.
+                        a8.kind === "store-set" && a8.then !== void 0 ? [a8, ...deepActions(a8.then)] : [a8]
+                      )
                     )
                   )
                 )
@@ -268719,6 +269320,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
       if (stateVar) referencedStateNames.add(stateVar.name);
     }
   }
+  for (const pulse of plan.instancePulses) if (pulse.delivered !== void 0) referencedStateNames.add(pulse.delivered.name);
   const referencedStateVars = plan.stateVars.filter((v) => referencedStateNames.has(v.name));
   const liveRecordRows = plan.recordReads.flatMap((read2) => {
     const row = read2.live && !read2.binds ? referencedStateVars.find((v) => v.originNodeId === read2.nodeId && v.origin === "record-row") : void 0;
@@ -268928,6 +269530,9 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
       case "payload":
         return true;
       // payload keys are optional-typed
+      case "row-relay":
+        return true;
+      // EXP-011 §100: the row's field, which a row's item may lack. Must agree with plan.ts maybeUndefinedExpr.
       case "undefined":
         return true;
       // a Component Object property's boot value (COMPONENT-OBJECT-TARGET §3)
@@ -269120,12 +269725,15 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     return `${local}.${node === "hash" ? "digest" : "value"}`;
   };
   let announcedCode;
+  let rowRelayCode;
   const exprCode = (expr, mode) => {
     switch (expr.kind) {
       case "prop":
         return propName(expr.name);
       case "input-text":
         return announcedCode?.inputId === expr.inputId ? announcedCode.code : "event.target.value";
+      case "row-relay":
+        return rowRelayCode?.repeaterId === expr.repeaterId ? rowRelayCode.read(expr.input) : "undefined";
       /**
        * A url parameter (EXP-011 Tier 2.5) — the query first, the path segment behind it.
        *
@@ -269596,18 +270204,23 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
       // on read, so the runtime's no-object Failure is unreachable — and `store.set()` is
       // synchronous, so its Done chain is following statements too.
       (a8.kind === "popup-show" || a8.kind === "collection-remove" || a8.kind === "log" || a8.kind === "object-set" || a8.kind === "delay" && a8.verb === "restart") && a8.then.length > 0 ? [{ ...a8, then: [] }, ...expandActions(a8.then)] : (
-        // EXP-011 §60. The self variant cannot miss and `set` is synchronous: Done then Completed are following
-        // statements, in the order reportOutcome sends them. The parent form prints its own two arms.
-        a8.kind === "component-object-set" && !a8.parent && (a8.then.length > 0 || a8.completedThen.length > 0) ? [{ ...a8, then: [], completedThen: [] }, ...expandActions(a8.then), ...expandActions(a8.completedThen)] : (
-          // A jsfun-run is only its done-chain (EXP-003 §4 A2h): output reads inline the call
-          // at their sinks, so the run itself needs no statement — unless it materializes its
-          // output record (CONTROLLED-STATE §4f), which is one setter statement before the chain.
-          a8.kind === "jsfun-run" ? a8.materialize !== void 0 || runIsPulsed(a8) ? [{ ...a8, then: [] }, ...expandActions(a8.then)] : expandActions(a8.then) : (
-            // P18-S116-QUERYFETCH. A Fetch into a query the export does not keep (nothing it renders reads the rows) asks
-            // for nothing anyone sees; the query's own row in the report says why it is not kept.
-            a8.kind === "query-fetch" && !plan.queries.some((q) => q.nodeId === a8.nodeId) ? [] : (
-              // EXP-011 §87. A literal Condition's one side is following statements.
-              a8.kind === "branch" && a8.flat === true ? expandActions(a8.whenTrue) : [a8]
+        // P18-S127-SETDONE. A Set Variable with a literal Name cannot fail and its write is synchronous: Done, then
+        // Completed, are following statements (`withSetDone` put them in `then` in that order).
+        a8.kind === "store-set" && a8.then !== void 0 ? [{ ...a8, then: void 0 }, ...expandActions(a8.then)] : (
+          // EXP-011 §60. The self variant cannot miss and `set` is synchronous: Done then Completed are following
+          // statements, in the order reportOutcome sends them. The parent form prints its own two arms.
+          a8.kind === "component-object-set" && !a8.parent && (a8.then.length > 0 || a8.completedThen.length > 0) ? [{ ...a8, then: [], completedThen: [] }, ...expandActions(a8.then), ...expandActions(a8.completedThen)] : (
+            // A jsfun-run is only its done-chain (EXP-003 §4 A2h): output reads inline the call
+            // at their sinks, so the run itself needs no statement — unless it materializes its
+            // output record (CONTROLLED-STATE §4f), which is one setter statement before the chain.
+            // P18-S129-FNSUCCESS: or a Run of a Function a ticked input also runs, which records what it read first.
+            a8.kind === "jsfun-run" ? a8.materialize !== void 0 || runIsPulsed(a8) || a8.ticked !== true && tickedRunIds.has(a8.nodeId) ? [{ ...a8, then: [] }, ...expandActions(a8.then)] : expandActions(a8.then) : (
+              // P18-S116-QUERYFETCH. A Fetch into a query the export does not keep (nothing it renders reads the rows) asks
+              // for nothing anyone sees; the query's own row in the report says why it is not kept.
+              a8.kind === "query-fetch" && !plan.queries.some((q) => q.nodeId === a8.nodeId) ? [] : (
+                // EXP-011 §87. A literal Condition's one side is following statements.
+                a8.kind === "branch" && a8.flat === true ? expandActions(a8.whenTrue) : [a8]
+              )
             )
           )
         )
@@ -269644,7 +270257,9 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     };
     const inAction = (a8) => {
       switch (a8.kind) {
+        // P18-S127-SETDONE. The value, or anything in the Done chain.
         case "store-set":
+          return reads(a8.expr) || (a8.then ?? []).some(inAction);
         case "globalstore-set":
           return reads(a8.expr);
         // EXP-011 §47. Any of the patch's values, or anything in the chain after it.
@@ -270101,6 +270716,7 @@ ${pad(indent)}${stateSetterOf(action.materialize)}({ ...${names2.run}.outputs })
         if (action.materialize !== void 0) {
           return `${record2}${stateSetterOf(action.materialize)}(${def.fnName}(${jsArgsObject(def, "handler")}))`;
         }
+        if (record2 !== "" && action.then.length === 0) return `tickedArrival(${tickedRecordArgs(action.nodeId)})`;
         return expandActions(action.then).map(actionCode).join("; ");
       }
       /**
@@ -270129,6 +270745,7 @@ ${pad(indent)}${stateSetterOf(action.materialize)}({ ...${names2.run}.outputs })
       // The functional updates are §3.3's closure-staleness-immune forms.
       case "state-set": {
         const setter = stateSetterOf(action.name);
+        if (action.field !== void 0 && fieldWriteIsRun(action)) return fieldWriteCode(action, action.field, indent);
         if (action.op === "toggle") return `${setter}((v) => !v)`;
         if (action.op === "inc") return `${setter}((v) => v + 1)`;
         if (action.op === "dec") return `${setter}((v) => v - 1)`;
@@ -270538,6 +271155,9 @@ ${at}`) : "new Date()";
       // EXP-011 §63. One call on the handle; Done is the node's listener, passed once to the hook.
       case "drag-snap":
         return `${action.local}.snapTo(${tsLiteral(action.axis)})`;
+      // P18-S128-FIELDSET. A call on the field's element; nothing when it is not on the page.
+      case "field-focus":
+        return `${fieldRefs.get(action.inputId)}.current?.${action.focus ? "focus" : "blur"}()`;
       /**
        * EXP-011 §61. A push, printed as the runtime's own call (`navigate.ts` `navigate()`): the target, the
        * parameters by the target's own prop identifiers, the back callback (the results row written FIRST, then
@@ -270806,7 +271426,64 @@ ${pad(indent)}}`;
     a8.kind === "id-new" && (idNewIsBlock(a8) || a8.materialize !== void 0 || a8.then.length > 0 || chainReadsIdLocal(a8.then, a8.nodeId)) || // EXP-011 §59. Always the block form — the Failure arm always raises.
     a8.kind === "crypto-call" || // EXP-011 §60. The parent write is the block form (the miss arm raises); the own write is one expression.
     a8.kind === "component-object-set" && a8.parent || // EXP-011 §61. A push is a multi-line call; a pop is always the block form; a Reset with a chain is a run of statements.
-    a8.kind === "stack-push" || a8.kind === "stack-pop" || a8.kind === "stack-reset" && a8.then.length > 0;
+    a8.kind === "stack-push" || a8.kind === "stack-pop" || a8.kind === "stack-reset" && a8.then.length > 0 || // P18-S128-FIELDSET. A field's Set is an `if`; a Clear with a chain to run after it is a run of statements.
+    a8.kind === "state-set" && fieldWriteIsRun(a8);
+  }
+  const fieldChainOf = (inputId) => [
+    ...plan.changeHandlers[inputId] ?? [],
+    ...(plan.handlers[inputId] ?? {})["onChange"] ?? []
+  ];
+  const printingFieldChains = /* @__PURE__ */ new Set();
+  function fieldWriteIsRun(a8) {
+    if (a8.kind !== "state-set" || a8.field === void 0) return false;
+    if (a8.field.port === "set") return true;
+    return fieldClearedLocals.has(a8.field.inputId) || !printingFieldChains.has(a8.field.inputId) && fieldChainOf(a8.field.inputId).length > 0;
+  }
+  function fieldWriteCode(action, field2, indent) {
+    const setter = stateSetterOf(action.name);
+    const at = pad(indent);
+    const cleared = fieldClearedLocals.get(field2.inputId);
+    const chainLines = (code2, depth) => {
+      if (printingFieldChains.has(field2.inputId)) return [];
+      const chain = fieldChainOf(field2.inputId);
+      if (chain.length === 0) return [];
+      const outer = announcedCode;
+      announcedCode = { inputId: field2.inputId, code: code2 };
+      printingFieldChains.add(field2.inputId);
+      const lines = effectBody(chain, depth);
+      printingFieldChains.delete(field2.inputId);
+      announcedCode = outer;
+      return lines;
+    };
+    if (field2.port === "clear") {
+      const lines = [`${at}${setter}('');`, ...cleared !== void 0 ? [`${at}${cleared}.current = true;`] : [], ...chainLines("''", indent)];
+      return lines.join("\n").slice(at.length);
+    }
+    const ref = fieldRefs.get(field2.inputId);
+    const inner = pad(indent + 2);
+    const start3 = tsLiteral(field2.start ?? "");
+    const body2 = [];
+    let code;
+    if (action.expr === void 0 || action.expr.kind === "literal") {
+      const literal2 = tsLiteral(action.expr?.kind === "literal" ? String(action.expr.value) : field2.start ?? "");
+      code = cleared !== void 0 ? `(${cleared}.current ? '' : ${literal2})` : literal2;
+    } else {
+      const blockLocal = (base) => {
+        let candidate = base;
+        for (let n = 2; reserved.has(candidate); n++) candidate = `${base}${n}`;
+        return candidate;
+      };
+      const value = blockLocal(`${action.name}Value`);
+      code = blockLocal(`${action.name}Text`);
+      const asText2 = `String(${value} ?? '')`;
+      const coerced = field2.start === void 0 || field2.start === "" ? asText2 : `${value} === undefined ? ${start3} : ${asText2}`;
+      body2.push(
+        `${inner}const ${value} = ${exprCode(action.expr, "handler")};`,
+        `${inner}const ${code} = ${cleared !== void 0 ? `${cleared}.current ? '' : ${coerced}` : coerced};`
+      );
+    }
+    body2.push(`${inner}${setter}(${code});`, ...chainLines(code, indent + 2));
+    return [`if (${ref}.current !== document.activeElement) {`, ...body2, `${at}}`].join("\n");
   }
   function actionTakesNoTerminator(a8) {
     if ("detached" in a8 && a8.detached === true) return false;
@@ -270822,7 +271499,8 @@ ${pad(indent)}}`;
       a8.kind === "id-new" && idNewIsBlock(a8) || // EXP-011 §59. The block form ends in `}` too.
       a8.kind === "crypto-call" || // EXP-011 §60. The parent write's `if` ends in `}` and takes no terminator.
       a8.kind === "component-object-set" && a8.parent || // EXP-011 §61. The pop's block form ends in `}`; the push ends in `)` and takes its `;`, as does a Reset.
-      a8.kind === "stack-pop"
+      a8.kind === "stack-pop" || // P18-S128-FIELDSET. Each line of a field write ends its own statement.
+      a8.kind === "state-set" && fieldWriteIsRun(a8)
     );
   }
   function actionsAwait(actions) {
@@ -270834,7 +271512,10 @@ ${pad(indent)}}`;
   }
   function blockBody(expanded, indent) {
     return expanded.map(
-      (a8) => actionTakesNoTerminator(a8) ? `${pad(indent)}${actionCode(a8, indent)}` : `${pad(indent)}${actionCode(a8, "detached" in a8 && a8.detached === true || a8.kind === "date-now-read" || a8.kind === "id-new" || a8.kind === "crypto-call" || a8.kind === "branch" || a8.kind === "array-new" || a8.kind === "component-object-set" || a8.kind === "stack-push" || a8.kind === "stack-reset" || a8.kind === "jsfun-run" ? indent : 0)};`
+      (a8) => (
+        // P18-S128-FIELDSET. A field write's lines take the column (`actionTakesNoTerminator` holds for it).
+        actionTakesNoTerminator(a8) ? `${pad(indent)}${actionCode(a8, indent)}` : `${pad(indent)}${actionCode(a8, "detached" in a8 && a8.detached === true || a8.kind === "date-now-read" || a8.kind === "id-new" || a8.kind === "crypto-call" || a8.kind === "branch" || a8.kind === "array-new" || a8.kind === "component-object-set" || a8.kind === "stack-push" || a8.kind === "stack-reset" || a8.kind === "jsfun-run" ? indent : 0)};`
+      )
     );
   }
   function effectBody(actions, indent) {
@@ -270854,10 +271535,37 @@ ${pad(indent)}}`;
     }
     return statements.length === 1 ? `${head} => ${statements[0]}` : `${head} => { ${statements.join("; ")}; }`;
   };
+  const prependStatements = (arrow, statements, indent) => {
+    if (statements.length === 0) return arrow;
+    const head = arrow.slice(0, arrow.indexOf("=> ") + 3);
+    const body2 = arrow.slice(head.length);
+    if (body2.startsWith("{\n")) return `${head}{
+${statements.map((st) => `${pad(indent + 2)}${st};`).join("\n")}
+${body2.slice(2)}`;
+    if (body2.startsWith("{ ")) return `${head}{ ${statements.join("; ")}; ${body2.slice(2)}`;
+    return `${head}{ ${statements.join("; ")}; ${body2}; }`;
+  };
   const delayRefs = /* @__PURE__ */ new Map();
   for (const a8 of deepActions(allActions)) {
     if (a8.kind === "delay") delayRefs.set(a8.nodeId, a8.ref);
   }
+  const fieldRefs = /* @__PURE__ */ new Map();
+  const fieldSetSources = /* @__PURE__ */ new Map();
+  const fieldCleared = /* @__PURE__ */ new Set();
+  for (const a8 of deepActions(allActions)) {
+    const inputId = a8.kind === "field-focus" ? a8.inputId : a8.kind === "state-set" && a8.field?.port === "set" ? a8.field.inputId : void 0;
+    if (inputId !== void 0 && !fieldRefs.has(inputId)) {
+      const named = lowerFirst(pascalCase2(nodeById.get(inputId)?.authoredLabel ?? "")) || "field";
+      fieldRefs.set(inputId, dedupeLocal(/^[A-Za-z_$]/.test(named) ? `${named}Field` : "field"));
+    }
+    if (a8.kind === "state-set" && a8.field?.port === "set" && a8.expr !== void 0) fieldSetSources.set(a8.field.inputId, a8.expr);
+    if (a8.kind === "state-set" && a8.field?.port === "clear") fieldCleared.add(a8.field.inputId);
+  }
+  const fieldClearedLocals = /* @__PURE__ */ new Map();
+  for (const inputId of fieldCleared) {
+    if (!fieldSetSources.has(inputId)) continue;
+    fieldClearedLocals.set(inputId, dedupeLocal(`${fieldRefs.get(inputId).replace(/Field$/, "")}Cleared`));
+  }
   const relRoot = "..";
   const externalImports = [];
   const coreHooks = [];
@@ -270880,7 +271588,9 @@ ${pad(indent)}}`;
   if (referencedStateVars.length > 0 && !reactImports.includes("useState")) reactImports.push("useState");
   if ((plan.syncEffects.length > 0 || plan.pushEffects.length > 0 || plan.branchEffects.length > 0 || // EXP-011 §39. A Value Changed is an effect; a Delay owes the unmount cleanup effect.
   plan.valueChangedEffects.length > 0 || // P18-S119-TICKEDRUN. A ticked input's run is an effect.
-  plan.tickedRuns.length > 0 || // EXP-011 §43, P18-S113-IDBINDREAD. A Record with Fetch unwired is a bind keyed on its Id.
+  plan.tickedRuns.length > 0 || // P18-S126-INSIGNAL. A signal input's chain is an effect on its count.
+  plan.inputPulses.length > 0 || // P18-S127-SIBLINGVALUE. A delivered count follows the count sent from an effect.
+  plan.instancePulses.some((p) => p.delivered !== void 0) || // EXP-011 §43, P18-S113-IDBINDREAD. A Record with Fetch unwired is a bind keyed on its Id.
   recordBinds.length > 0 || // P18-S111-RECORDLIVE. A live Record's row subscribes to the client's copy of its record.
   liveRecordRows.length > 0 || // EXP-011 §67. A Variable's authored Value is a mount effect.
   plan.variableSeeds.length > 0 || // EXP-011 §71. An Object's own authored property values are a mount effect.
@@ -270891,7 +271601,8 @@ ${pad(indent)}}`;
     reactImports.push("useEffect");
   }
   if (radioNameLocals.size > 0) reactImports.push("useId");
-  if (delayRefs.size > 0 || plan.valueChangedEffects.length > 0 || usedKeptLocals.size > 0 || pulsedRunIds.size > 0 || plan.tickedRuns.length > 0) reactImports.push("useRef");
+  if (delayRefs.size > 0 || plan.valueChangedEffects.length > 0 || usedKeptLocals.size > 0 || pulsedRunIds.size > 0 || plan.tickedRuns.length > 0 || plan.instancePulses.length > 0 || fieldRefs.size > 0) reactImports.push("useRef");
+  if ([...fieldClearedLocals.keys()].some((id) => fieldSetSources.get(id)?.kind !== "literal") && !reactImports.includes("useEffect")) reactImports.push("useEffect");
   if (plan.task !== void 0 || plan.repeaterItems.length > 0 || plan.fieldMounts.length > 0 || mountChains.length > 0) {
     if (!reactImports.includes("useEffect")) reactImports.push("useEffect");
     if (!reactImports.includes("useRef")) reactImports.push("useRef");
@@ -271414,6 +272125,16 @@ ${pad(indent)}}`;
         defer(node.id, 'the "didMount" signal', mountRefusals.get(node.id));
         continue;
       }
+      if (port5 === "onEnter" && plan.roleOf[node.id] === "input") {
+        const expanded = expandActions(actions);
+        attrs.push(
+          `onKeyDown={${actionsAwait(expanded) ? "async " : ""}(event) => {
+${pad(attrIndent + 2)}if (event.key !== 'Enter') return;
+${blockBody(expanded, attrIndent + 2).join("\n")}
+${pad(attrIndent)}}}`
+        );
+        continue;
+      }
       const eventAttr = roleEvents[port5] ?? EVENT_ATTRS[port5];
       if (!eventAttr) {
         notes.push(`${plan.path}: signal ${node.id}.${port5} has no DOM event equivalent \u2014 dropped, reported`);
@@ -271459,6 +272180,19 @@ ${pad(indent)}}`;
     if (boolTypedSource(source)) return base;
     return SIMPLE_REF.test(base) ? `!!${base}` : `!!(${base})`;
   };
+  const mountedCondOf = (id, source) => {
+    const cond = truthinessCode(source);
+    if (cond === null) return null;
+    const node = nodeById.get(id);
+    const authored = node?.parameters.find((p) => p.name === "mounted")?.value;
+    if (authored?.kind === "literal" && authored.value === false) return cond;
+    const isExpressionAnswer = source.kind === "computed" && source.expr.kind === "jsfun-out" && source.expr.viaState === void 0 && nodeById.get(source.expr.nodeId)?.type === "Expression";
+    const undefinedAtFirst = source.kind === "prop" || source.kind === "store" || source.kind === "store-key" || source.kind === "computed" && !isExpressionAnswer && maybeUndefined(source.expr);
+    if (!undefinedAtFirst) return cond;
+    const base = rawBindingExpr(source);
+    if (base === null || !SIMPLE_REF.test(base) || base.endsWith("()")) return cond;
+    return boolTypedSource(source) ? `(${base} === undefined || ${base})` : `(${base} === undefined || !!${base})`;
+  };
   const negatedVisibleCode = (source) => {
     const base = bindingExpr(source, "truthy");
     if (base === null) return null;
@@ -271565,6 +272299,7 @@ ${pad(indent)}}`;
     return typeof def === "string" || typeof def === "number" || typeof def === "boolean" ? def : void 0;
   };
   const fontIconSetsNoted = /* @__PURE__ */ new Set();
+  let rootMountedCond = null;
   const render2 = (id, indent, radioCtx) => {
     const node = nodeById.get(id);
     const mountedBound = plan.bindings[id]?.["mounted"];
@@ -271579,8 +272314,12 @@ ${pad(indent)}}`;
       }
       const staticallyTrue = mountedBound.kind === "computed" && mountedBound.expr.kind === "literal";
       if (!staticallyTrue) {
-        const cond = truthinessCode(mountedBound);
+        const cond = mountedCondOf(id, mountedBound);
         if (cond !== null) {
+          if (id === plan.rootId) {
+            rootMountedCond = cond;
+            return renderCore(id, indent, radioCtx);
+          }
           const inner = renderCore(id, indent + 2, radioCtx);
           return [`${pad(indent)}{${cond} && (`, ...inner, `${pad(indent)})}`];
         }
@@ -271651,6 +272390,7 @@ ${pad(indent)}}`;
     if (controlVar !== void 0) {
       attrs.push(`${role === "checkbox" ? "checked" : "value"}={${controlVar.name}}`);
     }
+    if (role === "input" && fieldRefs.has(id)) attrs.push(`ref={${fieldRefs.get(id)}}`);
     if (role === "input" || isControl) attrs.push(...changeAttrs(node, indent + 2));
     attrs.push(...handlerAttrs(node, indent + 2));
     if (role === "stack") return renderStack(node, attrs, indent);
@@ -271796,10 +272536,14 @@ ${pad(indent)}}`;
       }
       return out;
     };
-    const rowSignalAttrs = (attrIndent) => {
+    const rowSignalAttrs = (attrIndent, itemRef, entries2) => {
       const handlers = plan.handlers[node.id];
       if (handlers === void 0) return [];
       const propByPort = new Map((templatePlan?.outputProps ?? []).map((o) => [o.port, o.prop]));
+      const relayWrites = plan.rowRelays.filter((r) => r.repeaterId === node.id).map((r) => {
+        const entry = entries2.find((e) => e.input === r.input);
+        return `${stateSetterOf(r.stateName)}(${entry === void 0 ? "undefined" : memberExpr(itemRef, entry.field)})`;
+      });
       const out = [];
       for (const [port5, actions] of Object.entries(handlers)) {
         if (!port5.startsWith(ITEM_OUTPUT_SIGNAL)) {
@@ -271822,7 +272566,16 @@ ${pad(indent)}}`;
           defer(node.id, `the relayed row signal "${templatePort}"`, `has no callback prop on ${templateLegacy}`);
           continue;
         }
-        out.push(`${prop}={${handlerArrow(actions, "()", attrIndent)}}`);
+        const outer = rowRelayCode;
+        rowRelayCode = { repeaterId: node.id, read: (input) => {
+          const entry = entries2.find((e) => e.input === input);
+          return entry === void 0 ? "undefined" : memberExpr(itemRef, entry.field);
+        } };
+        try {
+          out.push(`${prop}={${prependStatements(handlerArrow(actions, "()", attrIndent), relayWrites, attrIndent)}}`);
+        } finally {
+          rowRelayCode = outer;
+        }
       }
       return out;
     };
@@ -271851,7 +272604,7 @@ ${pad(indent)}}`;
         );
       }
       const keyAttr = staticData.keyField ? `key={${itemLocal}.${staticData.keyField}}` : `key={${indexLocal}}`;
-      const attrs2 = [keyAttr, ...rowAttrs(keptStatic, itemLocal), ...rowSignalAttrs(indent + 2)];
+      const attrs2 = [keyAttr, ...rowAttrs(keptStatic, itemLocal), ...rowSignalAttrs(indent + 2, itemLocal, keptStatic)];
       const lines2 = element(target.symbol, attrs2, null, indent + 2, false);
       const params = staticData.keyField ? itemLocal : `${itemLocal}, ${indexLocal}`;
       return [`${pad(indent)}{${staticData.constName}.map((${params}) => (`, ...lines2, `${pad(indent)}))}`];
@@ -271870,7 +272623,7 @@ ${pad(indent)}}`;
           );
         }
       }
-      const attrs2 = [`key={${indexLocal}}`, ...rowAttrs(keptExpr, itemLocal), ...rowSignalAttrs(indent + 2)];
+      const attrs2 = [`key={${indexLocal}}`, ...rowAttrs(keptExpr, itemLocal), ...rowSignalAttrs(indent + 2, itemLocal, keptExpr)];
       const lines2 = element(target.symbol, attrs2, null, indent + 2, false);
       const srcCode = exprCode(itemsExpr, "render");
       const source = itemsExpr.kind === "minted-array-get" || itemsExpr.kind === "record-filter" ? srcCode : SIMPLE_REF.test(srcCode) ? `(${srcCode} ?? [])` : `((${srcCode}) ?? [])`;
@@ -271890,13 +272643,13 @@ ${pad(indent)}}`;
       );
     }
     if (collection) {
-      const attrs2 = [`key={${indexLocal}}`, ...rowAttrs(kept, itemLocal), ...rowSignalAttrs(indent + 2)];
+      const attrs2 = [`key={${indexLocal}}`, ...rowAttrs(kept, itemLocal), ...rowSignalAttrs(indent + 2, itemLocal, kept)];
       const lines2 = element(target.symbol, attrs2, null, indent + 2, false);
       const local = collectionLocals.get(collection.name);
       return [`${pad(indent)}{${local}.map((${itemLocal}, ${indexLocal}) => (`, ...lines2, `${pad(indent)}))}`];
     }
     const item = query2.itemName;
-    const attrs = [`key={${item}.id}`, ...rowAttrs(kept, item), ...rowSignalAttrs(indent + 2)];
+    const attrs = [`key={${item}.id}`, ...rowAttrs(kept, item), ...rowSignalAttrs(indent + 2, item, kept)];
     const lines = element(target.symbol, attrs, null, indent + 2, false);
     return [`${pad(indent)}{${query2.stateName}.map((${item}) => (`, ...lines, `${pad(indent)}))}`];
   };
@@ -272106,6 +272859,14 @@ ${pad(indent)}}`;
     for (const [toProperty, source] of Object.entries(plan.bindings[node.id] ?? {})) {
       claimBinding(node.id, toProperty);
       if (toProperty === "mounted") continue;
+      const pulse = plan.instancePulses.find((p) => p.nodeId === node.id && p.port === toProperty);
+      if (pulse !== void 0) {
+        const pulseAttr = targetPropName(node.type, toProperty);
+        if (pulseAttr !== null) {
+          attrs.push(`${pulseAttr}={{ sent: ${pulse.delivered?.name ?? pulse.stateName}, taken: ${pulse.takenLocal} }}`);
+          continue;
+        }
+      }
       if (toProperty === "visible") {
         notes.push(
           `${plan.path}: wire into instance ${node.id}.visible dropped \u2014 an instance has no element class to toggle in this slice`
@@ -272550,7 +273311,28 @@ ${pad(indent)}}`;
     body.push(`  const ${mintedLocals.get(nodeId)} = useCollection${rowType === "any" ? "" : `<${rowType}>`}(${mintStateName(nodeId)} ?? ${NO_ARRAY2});`);
   }
   for (const [, ref] of delayRefs) body.push(`  const ${ref} = useRef<DelayHandle | null>(null);`);
+  for (const [, ref] of fieldRefs) body.push(`  const ${ref} = useRef<HTMLInputElement>(null);`);
+  for (const [inputId, local] of fieldClearedLocals) {
+    const source = fieldSetSources.get(inputId);
+    body.push(`  const ${local} = useRef(false);`);
+    if (source.kind === "literal") continue;
+    const read2 = exprCode(source, "handler");
+    const store2 = /^([A-Za-z_$][A-Za-z0-9_$]*)\.get\(\)$/.exec(read2);
+    body.push(
+      ...store2 !== null ? [`  useEffect(() => ${store2[1]}.subscribe(() => { ${local}.current = false; }), []);`] : ["  useEffect(() => {", `    ${local}.current = false;`, `  }, [${exprCode(source, "render")}]);`]
+    );
+  }
   for (const effect of plan.valueChangedEffects) body.push(`  const ${effect.lastLocal} = useRef<unknown>(undefined);`);
+  for (const pulse of plan.instancePulses) body.push(`  const ${pulse.takenLocal} = useRef(0);`);
+  for (const pulse of plan.instancePulses) {
+    if (pulse.delivered === void 0) continue;
+    body.push(
+      `  // "${pulse.port}" is handed on one commit after it is sent: the values lifted with it arrive first, as the running app delivers them.`,
+      "  useEffect(() => {",
+      `    ${pulse.delivered.setterName}(${pulse.stateName});`,
+      `  }, [${pulse.stateName}]);`
+    );
+  }
   for (const id of pulsedRunIds) {
     const def = jsFunByNode[id];
     body.push(`  const ${pulseNamesOf(def).node} = useRef(functionNode<NonNullable<Parameters<typeof ${def.fnName}>[1]>>([${def.signals.map(tsLiteral).join(", ")}])).current;`);
@@ -272825,16 +273607,19 @@ ${pad(indent)}}`;
     announcedCode = { inputId: mount2.inputId, code };
     const chainLines = effectBody(chain, 4);
     announcedCode = void 0;
+    const gate = (mount2.gates ?? []).map((id) => mountedCondOf(id, plan.bindings[id]["mounted"])).filter((c) => c !== null);
+    const when = gate.length === 0 ? null : gate.length === 1 ? gate[0] : gate.map((c) => SIMPLE_REF.test(c) ? c : `(${c})`).join(" && ");
     body.push(
       `  // ${mount2.comment}`,
       `  const ${once} = useRef(false);`,
       "  useEffect(() => {",
       `    if (${once}.current) return;`,
+      ...when !== null ? [`    if (${negatedCode(when)}) return;`] : [],
       `    ${once}.current = true;`,
       ...lines,
       ...chainLines,
-      "    // eslint-disable-next-line react-hooks/exhaustive-deps -- once, as the field mounts",
-      "  }, []);",
+      when !== null ? "    // eslint-disable-next-line react-hooks/exhaustive-deps -- once, the first time the field mounts" : "    // eslint-disable-next-line react-hooks/exhaustive-deps -- once, as the field mounts",
+      `  }, [${gate.join(", ")}]);`,
       ""
     );
   }
@@ -272917,6 +273702,18 @@ ${pad(indent)}}`;
       ""
     );
   }
+  for (const pulse of plan.inputPulses) {
+    const pair = exprCode({ kind: "prop", name: pulse.port }, "render");
+    body.push(
+      `  // "${commentSafe(pulse.port)}", a signal the parent sends in: its chain runs once for each pulse sent, never twice.`,
+      "  useEffect(() => {",
+      `    if (${pair} === undefined || ${pair}.taken.current === ${pair}.sent) return;`,
+      `    ${pair}.taken.current = ${pair}.sent;`,
+      ...effectBody(pulse.actions, 4),
+      `  }, [${pair}?.sent]);`,
+      ""
+    );
+  }
   for (const ticked3 of plan.tickedRuns) {
     const deps = [...new Set(ticked3.watch.flatMap(effectDeps))].join(", ");
     body.push(
@@ -272931,6 +273728,26 @@ ${pad(indent)}}`;
   for (const mount2 of mountChains) {
     const node = nodeById.get(mount2.nodeId);
     const mounted = dedupeLocal("mounted");
+    const gate = mount2.gates.map((id) => mountedCondOf(id, plan.bindings[id]["mounted"])).filter((c) => c !== null);
+    if (gate.length > 0) {
+      const when = gate.length === 1 ? gate[0] : gate.map((c) => SIMPLE_REF.test(c) ? c : `(${c})`).join(" && ");
+      body.push(
+        `  // ${node.authoredLabel ?? node.type} \u2014 Did Mount: each time it mounts, as the running app sends it: when ${commentSafe(when)}.`,
+        `  const ${mounted} = useRef(false);`,
+        "  useEffect(() => {",
+        `    if (${negatedCode(when)}) {`,
+        `      ${mounted}.current = false;`,
+        "      return;",
+        "    }",
+        `    if (${mounted}.current) return;`,
+        `    ${mounted}.current = true;`,
+        ...effectBody(mount2.actions, 4),
+        "    // eslint-disable-next-line react-hooks/exhaustive-deps -- once per mount, like the element's own Did Mount",
+        `  }, [${gate.join(", ")}]);`,
+        ""
+      );
+      continue;
+    }
     body.push(
       `  // ${node.authoredLabel ?? node.type} \u2014 Did Mount: once, when it mounts, as the running app sends it.`,
       `  const ${mounted} = useRef(false);`,
@@ -272947,7 +273764,9 @@ ${pad(indent)}}`;
     switch (a8.kind) {
       case "emit":
         return a8.payload.map((p) => p.expr);
+      // P18-S127-SETDONE. The value, then the Done chain.
       case "store-set":
+        return [a8.expr, ...(a8.then ?? []).flatMap(actionExprsOf)];
       case "globalstore-set":
         return [a8.expr];
       // EXP-011 §47. The patch's values, then the chain.
@@ -273061,6 +273880,9 @@ ${pad(indent)}}`;
       // EXP-011 §63. The same.
       case "drag-snap":
         return [];
+      // P18-S128-FIELDSET. The same.
+      case "field-focus":
+        return [];
       // EXP-011 Tier 2.5. The link, the wired Open In New Tab, and both chains — `usesPayload`
       // walks this list, so a link built from a received event's payload is found here or the
       // emitted callback takes no argument and its body reads one.
@@ -273122,7 +273944,18 @@ ${pad(indent)}}`;
   ] : jsxLines;
   if (jsxLines.length === 1 && jsxLines[0] === "    null") body.push(...preReturnComment, "  return null;", "}");
   else if (removedRoot !== null) body.push(...preReturnComment, `  // ${removedRoot[1]}`, "  return null;", "}");
-  else body.push(...preReturnComment, "  return (", ...providedJsx, "  );", "}");
+  else if (rootMountedCond !== null) {
+    const guard = negatedCode(rootMountedCond);
+    body.push(
+      ...preReturnComment,
+      `  // Its root is mounted when ${commentSafe(rootMountedCond)}; while it is not, the running app draws nothing for this instance.`,
+      `  if (${guard}) return null;`,
+      "  return (",
+      ...providedJsx,
+      "  );",
+      "}"
+    );
+  } else body.push(...preReturnComment, "  return (", ...providedJsx, "  );", "}");
   if (usesRowField) {
     body.push(
       "",
@@ -278721,6 +279554,10 @@ var ProjectStore = class {
   readStyles() {
     return this.viaFormat(() => this.format.readStyles());
   }
+  /** P112-OWN020-OFFSYSTEM — element styles (nameless variants) are written here; see `tools/elementStyles.ts`. */
+  writeStyles(styles) {
+    this.viaFormat(() => this.format.writeStyles(styles));
+  }
   get componentsDir() {
     return path11.join(this.projectDir, "components");
   }
@@ -279719,6 +280556,83 @@ function honestySection(h) {
   ].filter(Boolean).join("\n");
 }
 
+// src/tools/unknownArguments.ts
+function declaredKeys(schema) {
+  const def = schema?._def;
+  if (!def || def.typeName !== "ZodObject") return void 0;
+  if (def.unknownKeys !== "strip" && def.unknownKeys !== "strict") return void 0;
+  if (def.catchall && def.catchall._def?.typeName !== "ZodNever") return void 0;
+  return Object.keys(schema.shape);
+}
+var fold = (key2) => key2.toLowerCase().replace(/[_\-\s]/g, "");
+function distance2(a8, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a8.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cur = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a8[i - 1] === b[j - 1] ? 0 : 1));
+      prev = cur;
+    }
+  }
+  return row[b.length];
+}
+var ARGUMENT_SYNONYMS = {
+  description: ["summary", "intent", "request"],
+  desc: ["summary", "intent"],
+  title: ["name"],
+  folder: ["directory", "path"],
+  dir: ["directory", "path"]
+};
+function closestArgument(key2, declared) {
+  const same = declared.find((d) => fold(d) === fold(key2));
+  if (same) return same;
+  const synonym = (ARGUMENT_SYNONYMS[fold(key2)] ?? []).find((s) => declared.includes(s));
+  if (synonym) return synonym;
+  let best;
+  let bestDistance = 3;
+  for (const d of declared) {
+    const n = distance2(fold(key2), fold(d));
+    if (n < bestDistance) {
+      best = d;
+      bestDistance = n;
+    }
+  }
+  return best;
+}
+function unknownArgumentKeys(schema, args) {
+  const declared = declaredKeys(schema);
+  if (!declared || !args || typeof args !== "object" || Array.isArray(args)) return [];
+  return Object.keys(args).filter((key2) => !declared.includes(key2));
+}
+function unknownArgumentsRefusal(tool, schema, unknown3) {
+  const declared = declaredKeys(schema) ?? [];
+  const named = unknown3.map((key2) => {
+    const meant = closestArgument(key2, declared);
+    return meant ? `"${key2}" (did you mean "${meant}"?)` : `"${key2}"`;
+  });
+  return {
+    error: {
+      code: "invalid-argument",
+      message: `${tool} has no argument ${named.join(", ")}. Nothing was done: an argument a tool does not have would be dropped without a word. Its arguments are: ${declared.join(", ")}.`,
+      details: {
+        unknownArguments: [...unknown3],
+        didYouMean: Object.fromEntries(unknown3.map((key2) => [key2, closestArgument(key2, declared) ?? null]))
+      }
+    }
+  };
+}
+function refuseUnknownArguments(server) {
+  const s = server;
+  const original = s.validateToolInput.bind(server);
+  s.validateToolInput = async (tool, args, toolName) => {
+    const unknown3 = unknownArgumentKeys(tool.inputSchema, args);
+    if (unknown3.length > 0) throw new Error(JSON.stringify(unknownArgumentsRefusal(toolName, tool.inputSchema, unknown3), null, 2));
+    return original(tool, args, toolName);
+  };
+}
+
 // src/tools/util.ts
 function jsonResult(payload) {
   return { content: [{ type: "text", text: JSON.stringify(payload) }] };
@@ -280069,6 +280983,11 @@ function registerCallTool(server, disclosure) {
         }
         let parsed2 = void 0;
         if (schema) {
+          const unknown3 = unknownArgumentKeys(schema, args.arguments ?? {});
+          if (unknown3.length > 0) {
+            const { error: error2 } = unknownArgumentsRefusal(args.name, schema, unknown3);
+            throw new ToolError(error2.code, error2.message, error2.details);
+          }
           const result2 = await safeParseAsync3(schema, args.arguments ?? {});
           if (!result2.success) {
             throw new ToolError(
@@ -289504,6 +290423,248 @@ function renderImagery(report3) {
   return lines.join("\n");
 }
 
+// src/tools/elementStyles.ts
+var STYLES_SCHEMA = "https://opennoodl.dev/schemas/styles-v2.json";
+var ELEMENT_STATES = ["hover", "pressed", "focused", "disabled"];
+var LABEL = {
+  labelfontSize: "var(--text-sm)",
+  labelfontWeight: "var(--font-normal)",
+  labelcolor: "var(--foreground)",
+  labelSpacing: "var(--space-2)"
+};
+var FIELD_BORDER = {
+  borderStyle: "solid",
+  borderWidth: "var(--border-1)",
+  borderColor: "var(--border-control)"
+};
+var ELEMENT_STYLE_STARTERS = {
+  "net.noodl.controls.button": {
+    parameters: {
+      backgroundColor: "var(--primary)",
+      color: "var(--primary-foreground)",
+      fontFamily: "var(--font-sans)",
+      fontSize: "var(--text-sm)",
+      fontWeight: "var(--font-medium)",
+      borderRadius: "var(--radius-md)",
+      paddingTop: "var(--space-2)",
+      paddingBottom: "var(--space-2)",
+      paddingLeft: "var(--space-4)",
+      paddingRight: "var(--space-4)"
+    },
+    stateParameters: { hover: { backgroundColor: "var(--primary-hover)" }, disabled: { opacity: 0.5 } }
+  },
+  "net.noodl.controls.checkbox": {
+    parameters: {
+      width: "var(--space-4)",
+      height: "var(--space-4)",
+      backgroundColor: "var(--background)",
+      ...FIELD_BORDER,
+      borderRadius: "var(--radius-sm)",
+      ...LABEL
+    },
+    stateParameters: { hover: { borderColor: "var(--primary)" }, disabled: { opacity: 0.5 } }
+  },
+  "net.noodl.controls.radiobutton": {
+    parameters: {
+      width: "var(--space-4)",
+      height: "var(--space-4)",
+      backgroundColor: "var(--background)",
+      ...FIELD_BORDER,
+      borderRadius: "var(--radius-full)",
+      fillColor: "var(--primary)",
+      fillSpacing: "var(--space-0-5)",
+      ...LABEL
+    },
+    stateParameters: { hover: { borderColor: "var(--primary)" }, disabled: { opacity: 0.5 } }
+  },
+  "net.noodl.controls.textinput": {
+    parameters: {
+      backgroundColor: "var(--background)",
+      color: "var(--foreground)",
+      fontFamily: "var(--font-sans)",
+      fontSize: "var(--text-base)",
+      ...FIELD_BORDER,
+      borderRadius: "var(--radius-md)",
+      paddingTop: "var(--space-2)",
+      paddingBottom: "var(--space-2)",
+      paddingLeft: "var(--space-3)",
+      paddingRight: "var(--space-3)",
+      ...LABEL
+    },
+    stateParameters: { hover: { borderColor: "var(--border-strong)" }, disabled: { opacity: 0.5 } }
+  },
+  "net.noodl.controls.options": {
+    parameters: {
+      backgroundColor: "var(--background)",
+      color: "var(--foreground)",
+      fontFamily: "var(--font-sans)",
+      fontSize: "var(--text-base)",
+      ...FIELD_BORDER,
+      borderRadius: "var(--radius-md)",
+      paddingTop: "var(--space-2)",
+      paddingBottom: "var(--space-2)",
+      paddingLeft: "var(--space-3)",
+      paddingRight: "var(--space-3)",
+      ...LABEL
+    },
+    stateParameters: { hover: { borderColor: "var(--border-strong)" }, disabled: { opacity: 0.5 } }
+  },
+  "net.noodl.controls.range": {
+    parameters: {
+      thumbColor: "var(--primary)",
+      thumbWidth: "var(--space-4)",
+      thumbHeight: "var(--space-4)",
+      thumbBorderRadius: "var(--radius-full)",
+      trackColor: "var(--muted)",
+      trackActiveColor: "var(--primary)",
+      trackHeight: "var(--space-1)",
+      trackBorderRadius: "var(--radius-full)"
+    }
+  }
+};
+var isElementStyle = (v) => !!v && typeof v.typename === "string" && (v.name === void 0 || v.name === null || v.name === "");
+function readElementStyles(store2) {
+  const out = {};
+  for (const v of store2.readStyles()?.variants ?? []) {
+    if (!isElementStyle(v)) continue;
+    const states = v.stateParameters ?? v.stateParamaters;
+    out[v.typename] = {
+      parameters: v.parameters ?? {},
+      ...states && Object.keys(states).length > 0 ? { stateParameters: states } : {}
+    };
+  }
+  return out;
+}
+function stylesOrNew(store2) {
+  return store2.readStyles() ?? { $schema: STYLES_SCHEMA };
+}
+function upsert2(styles, typename, style) {
+  const variants = (styles.variants ?? []).filter((v) => !(isElementStyle(v) && v.typename === typename));
+  if (style) {
+    variants.push({
+      typename,
+      parameters: style.parameters,
+      ...style.stateParameters && Object.keys(style.stateParameters).length > 0 ? { stateParameters: style.stateParameters } : {}
+    });
+  }
+  styles.variants = variants;
+}
+function resolveElementType(name) {
+  const direct = getNodeTypeDetail(name);
+  if (!("error" in direct) && !direct.deprecated) return direct.typeName;
+  const wanted = name.trim().toLowerCase();
+  const rows = listNodeTypes({ includeHidden: true }).filter(
+    (r) => r.displayName.toLowerCase() === wanted || r.typeName.toLowerCase() === wanted
+  );
+  const live = rows.find((r) => !r.deprecated);
+  if (live) return live.typeName;
+  if (!("error" in direct)) return direct.replacedBy ?? direct.typeName;
+  throw new ToolError("not-found", direct.error, direct.suggestion ? { suggestion: direct.suggestion } : void 0);
+}
+function assertPorts(typename, names2, where) {
+  const detail = getNodeTypeDetail(typename);
+  if ("error" in detail) throw new ToolError("not-found", detail.error);
+  const ports = new Set(detail.inputs.map((p) => p.name));
+  const unknown3 = names2.filter((n) => !ports.has(n));
+  if (unknown3.length === 0) return;
+  const lower = new Map([...ports].map((p) => [p.toLowerCase(), p]));
+  const suggestions = Object.fromEntries(
+    unknown3.map((u) => [u, lower.get(u.toLowerCase()) ?? [...ports].find((p) => p.toLowerCase().includes(u.toLowerCase()))])
+  );
+  throw new ToolError(
+    "invalid-argument",
+    `${detail.displayName} has no ${unknown3.map((u) => `"${u}"`).join(", ")} ${where}. get_node_type lists its ports; an element style sets the same parameters a node does.`,
+    { unknownParameters: unknown3, suggestions }
+  );
+}
+function nodesOverriding(store2, typename, names2) {
+  let nodes = 0;
+  const overriding = [];
+  for (const row of store2.listComponents()) {
+    const key2 = row.path;
+    let stored;
+    try {
+      stored = store2.readComponent(key2);
+    } catch {
+      continue;
+    }
+    for (const n of stored.files.nodes.nodes ?? []) {
+      if (n.type !== typename || n.variant) continue;
+      nodes += 1;
+      const own2 = names2.filter((p) => n.parameters && Object.prototype.hasOwnProperty.call(n.parameters, p));
+      if (own2.length > 0) overriding.push({ component: key2, nodeId: n.id, parameters: own2 });
+    }
+  }
+  return { nodes, overriding };
+}
+function registerElementStyleTools(server, binding) {
+  server.registerTool(
+    "set_element_style",
+    {
+      title: "Set an element style",
+      description: `Set the look of every node of one type at once \u2014 every Radio Button, Checkbox, Text Input, Dropdown, Slider, Button or Text \u2014 so whichever control you place matches the page. starter: true writes the on-system look for a control type; parameters are the node's own (get_node_type lists them), as "var(--token)" values. A node that sets a parameter itself keeps its own value. Read them with get_style_vocabulary (elementStyles). Set merges into the current style; remove: true clears it.`,
+      inputSchema: {
+        type: external_exports.string().describe('Node type or its display name, e.g. "Radio Button" or "net.noodl.controls.radiobutton"'),
+        starter: external_exports.boolean().optional().describe("true = start from the on-system look for this control type (parameters still apply on top)"),
+        parameters: external_exports.record(external_exports.unknown()).optional().describe('e.g. { "width": "var(--space-4)", "labelFontSize": "var(--text-sm)" }'),
+        states: external_exports.record(external_exports.record(external_exports.unknown())).optional().describe(`Per visual state (${ELEMENT_STATES.join(", ")}), the parameters that change`),
+        unset: external_exports.array(external_exports.string()).optional().describe("Parameter names to drop from the style"),
+        remove: external_exports.boolean().optional().describe("true = delete this element style")
+      }
+    },
+    guarded(
+      (args) => {
+        const store2 = binding.require();
+        const typename = resolveElementType(args.type);
+        const styles = stylesOrNew(store2);
+        const current2 = readElementStyles(store2)[typename];
+        if (args.remove) {
+          upsert2(styles, typename, null);
+          store2.writeStyles(styles);
+          return jsonResult({ ok: true, type: typename, removed: !!current2 });
+        }
+        if (!args.starter && !args.parameters && !args.states && !args.unset) {
+          throw new ToolError("invalid-argument", "Pass starter: true, parameters, states, unset or remove: true.");
+        }
+        const starter = args.starter ? ELEMENT_STYLE_STARTERS[typename] : void 0;
+        if (args.starter && !starter) {
+          throw new ToolError(
+            "invalid-argument",
+            `There is no starter look for ${typename}. Starters exist for: ${Object.keys(ELEMENT_STYLE_STARTERS).join(", ")}. Pass parameters instead.`
+          );
+        }
+        const parameters = { ...current2?.parameters ?? {}, ...starter?.parameters ?? {}, ...args.parameters ?? {} };
+        for (const u of args.unset ?? []) delete parameters[u];
+        const stateParameters = { ...current2?.stateParameters ?? {} };
+        for (const [state, params] of Object.entries(starter?.stateParameters ?? {})) {
+          stateParameters[state] = { ...stateParameters[state] ?? {}, ...params };
+        }
+        for (const [state, params] of Object.entries(args.states ?? {})) {
+          if (!ELEMENT_STATES.includes(state)) {
+            throw new ToolError("invalid-argument", `Unknown visual state "${state}". Use one of: ${ELEMENT_STATES.join(", ")}.`);
+          }
+          stateParameters[state] = { ...stateParameters[state] ?? {}, ...params };
+        }
+        assertPorts(typename, Object.keys(parameters), "parameter");
+        for (const [state, params] of Object.entries(stateParameters)) assertPorts(typename, Object.keys(params), `parameter (state "${state}")`);
+        upsert2(styles, typename, { parameters, stateParameters });
+        store2.writeStyles(styles);
+        const reach2 = nodesOverriding(store2, typename, Object.keys(parameters));
+        return jsonResult({
+          ok: true,
+          type: typename,
+          style: { parameters, ...Object.keys(stateParameters).length ? { states: stateParameters } : {} },
+          nodesOfType: reach2.nodes,
+          ...reach2.overriding.length ? {
+            overriding: reach2.overriding.slice(0, 20),
+            note: `${reach2.overriding.length} of ${reach2.nodes} set some of these parameters themselves and keep their own value. Remove them from those nodes (update_node unset_parameters) to let the element style through.`
+          } : {}
+        });
+      }
+    )
+  );
+}
+
 // src/presetFontFiles.ts
 var fs28 = __toESM(require("fs"));
 var path28 = __toESM(require("path"));
@@ -289644,10 +290805,13 @@ function registerStyleReadTools(server, binding) {
       const vocab = buildStyleVocabulary(store2.designTokenMetaSource(), readProjectLooks(store2));
       const icons = readIconSets(store2.projectDir);
       const imagery = readImagery(store2.projectDir);
+      const elementStyles = readElementStyles(store2);
       if (args.detail === "prompt") {
         return jsonResult({
           vocabulary: `${renderStyleVocabulary(vocab)}
 
+${renderElementStyles(elementStyles)}
+
 ${renderIconSets(icons)}
 
 ${renderImagery(imagery)}
@@ -289655,7 +290819,7 @@ ${renderImagery(imagery)}
 LAYOUT: ${LAYOUT_RULES_SHORT}`
         });
       }
-      return jsonResult({ ...vocab, icons, imagery, layout: LAYOUT_RULES });
+      return jsonResult({ ...vocab, elementStyles, elementStylesNote: ELEMENT_STYLES_NOTE, icons, imagery, layout: LAYOUT_RULES });
     })
   );
 }
@@ -289675,6 +290839,20 @@ function readProjectLooks(store2) {
     };
   });
 }
+var ELEMENT_STYLES_NOTE = `Element styles dress every node of a type that does not set the parameter itself, so leave a control's look to its element style and set only what is particular to one node. Change a type's look for the whole app with set_element_style (find_tools({ group: "theme" })).`;
+function renderElementStyles(styles) {
+  const types = Object.keys(styles);
+  if (types.length === 0) {
+    return "ELEMENT STYLES: none \u2014 every control you place draws the runtime's own look until its type has one: call set_element_style for each control type you use.";
+  }
+  const lines = types.map((t) => {
+    const params = Object.entries(styles[t].parameters).map(([k, v]) => `${k} ${String(v)}`).join(", ");
+    return `  ${t.replace("net.noodl.controls.", "")}: ${params}`;
+  });
+  return `ELEMENT STYLES (every node of the type wears these unless it sets the parameter itself):
+${lines.join("\n")}
+${ELEMENT_STYLES_NOTE}`;
+}
 function registerStyleWriteTools(server, binding) {
   server.registerTool(
     "set_project_tokens",
@@ -293295,87 +294473,10 @@ function registerLessonTools(server) {
   );
 }
 
-// src/tools/unknownArguments.ts
-function declaredKeys(schema) {
-  const def = schema?._def;
-  if (!def || def.typeName !== "ZodObject") return void 0;
-  if (def.unknownKeys !== "strip" && def.unknownKeys !== "strict") return void 0;
-  if (def.catchall && def.catchall._def?.typeName !== "ZodNever") return void 0;
-  return Object.keys(schema.shape);
-}
-var fold = (key2) => key2.toLowerCase().replace(/[_\-\s]/g, "");
-function distance2(a8, b) {
-  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a8.length; i++) {
-    let prev = row[0];
-    row[0] = i;
-    for (let j = 1; j <= b.length; j++) {
-      const cur = row[j];
-      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a8[i - 1] === b[j - 1] ? 0 : 1));
-      prev = cur;
-    }
-  }
-  return row[b.length];
-}
-var ARGUMENT_SYNONYMS = {
-  description: ["summary", "intent", "request"],
-  desc: ["summary", "intent"],
-  title: ["name"],
-  folder: ["directory", "path"],
-  dir: ["directory", "path"]
-};
-function closestArgument(key2, declared) {
-  const same = declared.find((d) => fold(d) === fold(key2));
-  if (same) return same;
-  const synonym = (ARGUMENT_SYNONYMS[fold(key2)] ?? []).find((s) => declared.includes(s));
-  if (synonym) return synonym;
-  let best;
-  let bestDistance = 3;
-  for (const d of declared) {
-    const n = distance2(fold(key2), fold(d));
-    if (n < bestDistance) {
-      best = d;
-      bestDistance = n;
-    }
-  }
-  return best;
-}
-function unknownArgumentKeys(schema, args) {
-  const declared = declaredKeys(schema);
-  if (!declared || !args || typeof args !== "object" || Array.isArray(args)) return [];
-  return Object.keys(args).filter((key2) => !declared.includes(key2));
-}
-function unknownArgumentsRefusal(tool, schema, unknown3) {
-  const declared = declaredKeys(schema) ?? [];
-  const named = unknown3.map((key2) => {
-    const meant = closestArgument(key2, declared);
-    return meant ? `"${key2}" (did you mean "${meant}"?)` : `"${key2}"`;
-  });
-  return {
-    error: {
-      code: "invalid-argument",
-      message: `${tool} has no argument ${named.join(", ")}. Nothing was done: an argument a tool does not have would be dropped without a word. Its arguments are: ${declared.join(", ")}.`,
-      details: {
-        unknownArguments: [...unknown3],
-        didYouMean: Object.fromEntries(unknown3.map((key2) => [key2, closestArgument(key2, declared) ?? null]))
-      }
-    }
-  };
-}
-function refuseUnknownArguments(server) {
-  const s = server;
-  const original = s.validateToolInput.bind(server);
-  s.validateToolInput = async (tool, args, toolName) => {
-    const unknown3 = unknownArgumentKeys(tool.inputSchema, args);
-    if (unknown3.length > 0) throw new Error(JSON.stringify(unknownArgumentsRefusal(toolName, tool.inputSchema, unknown3), null, 2));
-    return original(tool, args, toolName);
-  };
-}
-
 // src/server.ts
 var PKG_VERSION3 = (
   // eslint-disable-next-line @typescript-eslint/no-var-requires
-  true ? "0.4.2" : null.version
+  true ? "0.4.3" : null.version
 );
 function createServer2(options) {
   setClientProfile(options.profile);
@@ -293426,6 +294527,7 @@ function createServer2(options) {
     registerAuthorTools(rec, binding, planRegistry, exampleBudget, renderLedger, disclosure);
     registerPlanTools(rec, binding, planRegistry, exampleBudget, renderLedger, disclosure);
     registerStyleWriteTools(rec, binding);
+    registerElementStyleTools(rec, binding);
     registerDocsWriteTools(rec, binding);
     registerScriptWriteTools(rec, binding);
     registerBackendWriteTools(rec, binding);