@nodegx/mcp 0.2.2 → 0.2.3

package/dist/noodl-mcp.cjs

@@ -47137,6 +47137,18 @@ var require_node_catalog_enriched = __commonJS({
               isSignal: false,
               description: "Object path inside the bucket, such as avatars/me.png. Supabase only. Leave blank to use the file's own name"
             },
+            {
+              name: "photoQuality",
+              displayName: "Photo Quality",
+              group: "Shrink Photos",
+              plug: "input",
+              type: {
+                name: "number"
+              },
+              isSignal: false,
+              default: 80,
+              description: "How much detail a shrunk JPEG or WebP keeps, from 1 to 100; PNG keeps every pixel and its transparency, GIF and SVG are never shrunk"
+            },
             {
               name: "private",
               displayName: "Private",
@@ -47149,6 +47161,17 @@ var require_node_catalog_enriched = __commonJS({
               default: false,
               description: "Restricts the stored file to whoever uploaded it, so reading it later needs a Sign File URL node"
             },
+            {
+              name: "readers",
+              displayName: "Readers",
+              group: "General",
+              plug: "input",
+              type: {
+                name: "string"
+              },
+              isSignal: false,
+              description: "Roles that may read the file as well as whoever uploaded it, such as role:member, separated by commas; setting it makes the file private. NodeGX backends only"
+            },
             {
               name: "recordId",
               displayName: "Record ID (PocketBase)",
@@ -47160,6 +47183,18 @@ var require_node_catalog_enriched = __commonJS({
               isSignal: false,
               description: "Existing record to attach the file to. PocketBase only. Leave blank to create a new record as part of the upload"
             },
+            {
+              name: "shrinkTo",
+              displayName: "Shrink To",
+              group: "Shrink Photos",
+              plug: "input",
+              type: {
+                name: "number"
+              },
+              isSignal: false,
+              default: 0,
+              description: "Makes a photo smaller in the browser before sending it, so its longer side is at most this many pixels; 0 sends every file as picked"
+            },
             {
               name: "upload",
               displayName: "Upload",
@@ -47302,6 +47337,15 @@ var require_node_catalog_enriched = __commonJS({
             private: [
               "always: held as handed; read when the next Upload goes"
             ],
+            readers: [
+              "always: held as handed; read when the next Upload goes \u2014 set, those roles may read the file as well as whoever uploaded it, and the file is private"
+            ],
+            shrinkTo: [
+              "always: held as handed; read when the next Upload goes \u2014 above 0, a photo (not a GIF or an SVG) is drawn smaller in the browser first, its longer side at most this many pixels, and the smaller file is what goes; it goes as picked when it is already that small, when the smaller one would weigh more, or when the browser cannot read it"
+            ],
+            photoQuality: [
+              "always: held as handed; read when the next Upload goes, and only when a photo is shrunk \u2014 1 to 100 for a JPEG or WebP, anything else is 80; a PNG keeps every pixel"
+            ],
             bucket: [
               "always: held as handed; read when the next Upload goes \u2014 set, the file goes to this bucket at Path (or under the file's own name)"
             ],
@@ -47318,7 +47362,7 @@ var require_node_catalog_enriched = __commonJS({
               "always: held as handed; read when the next Upload goes, and only with Collection \u2014 a half-filled group is no location at all"
             ],
             upload: [
-              "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure"
+              "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private, Readers and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure"
             ]
           },
           enrichment: {
@@ -105466,7 +105510,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@nodegx/mcp",
-      version: "0.2.2",
+      version: "0.2.3",
       description: "Model Context Protocol server exposing NodeGX (OpenNoodl) v2 projects to external AI agents.",
       license: "GPL-3.0-only",
       homepage: "https://nodegx.io",
@@ -156645,6 +156689,18 @@ var node_catalog_default = {
           isSignal: false,
           description: "Object path inside the bucket, such as avatars/me.png. Supabase only. Leave blank to use the file's own name"
         },
+        {
+          name: "photoQuality",
+          displayName: "Photo Quality",
+          group: "Shrink Photos",
+          plug: "input",
+          type: {
+            name: "number"
+          },
+          isSignal: false,
+          default: 80,
+          description: "How much detail a shrunk JPEG or WebP keeps, from 1 to 100; PNG keeps every pixel and its transparency, GIF and SVG are never shrunk"
+        },
         {
           name: "private",
           displayName: "Private",
@@ -156657,6 +156713,17 @@ var node_catalog_default = {
           default: false,
           description: "Restricts the stored file to whoever uploaded it, so reading it later needs a Sign File URL node"
         },
+        {
+          name: "readers",
+          displayName: "Readers",
+          group: "General",
+          plug: "input",
+          type: {
+            name: "string"
+          },
+          isSignal: false,
+          description: "Roles that may read the file as well as whoever uploaded it, such as role:member, separated by commas; setting it makes the file private. NodeGX backends only"
+        },
         {
           name: "recordId",
           displayName: "Record ID (PocketBase)",
@@ -156668,6 +156735,18 @@ var node_catalog_default = {
           isSignal: false,
           description: "Existing record to attach the file to. PocketBase only. Leave blank to create a new record as part of the upload"
         },
+        {
+          name: "shrinkTo",
+          displayName: "Shrink To",
+          group: "Shrink Photos",
+          plug: "input",
+          type: {
+            name: "number"
+          },
+          isSignal: false,
+          default: 0,
+          description: "Makes a photo smaller in the browser before sending it, so its longer side is at most this many pixels; 0 sends every file as picked"
+        },
         {
           name: "upload",
           displayName: "Upload",
@@ -156810,6 +156889,15 @@ var node_catalog_default = {
         private: [
           "always: held as handed; read when the next Upload goes"
         ],
+        readers: [
+          "always: held as handed; read when the next Upload goes \u2014 set, those roles may read the file as well as whoever uploaded it, and the file is private"
+        ],
+        shrinkTo: [
+          "always: held as handed; read when the next Upload goes \u2014 above 0, a photo (not a GIF or an SVG) is drawn smaller in the browser first, its longer side at most this many pixels, and the smaller file is what goes; it goes as picked when it is already that small, when the smaller one would weigh more, or when the browser cannot read it"
+        ],
+        photoQuality: [
+          "always: held as handed; read when the next Upload goes, and only when a photo is shrunk \u2014 1 to 100 for a JPEG or WebP, anything else is 80; a PNG keeps every pixel"
+        ],
         bucket: [
           "always: held as handed; read when the next Upload goes \u2014 set, the file goes to this bucket at Path (or under the file's own name)"
         ],
@@ -156826,7 +156914,7 @@ var node_catalog_default = {
           "always: held as handed; read when the next Upload goes, and only with Collection \u2014 a half-filled group is no location at all"
         ],
         upload: [
-          "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure"
+          "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private, Readers and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure"
         ]
       }
     },
@@ -200422,8 +200510,8 @@ var nodegxDescriptor = {
     // The header works. What it cannot do is make a file private on behalf of
     // nobody, and an author reading "supported" would not expect that.
     "files.private": degraded(
-      "A private upload is locked to the person who made it, so a file uploaded by anything other than a signed-in user \u2014 an admin tool, a cloud function \u2014 ends up private with no owner, and stays readable by everyone.",
-      "BCN-007 live, security enforced: uploaded as a signed-in user, the plain URL is 403 for anonymous AND for a second signed-in user. Uploaded with the master key, the identical request with X-NodeGX-File-Private: true serves 200 to anonymous \u2014 files.ts::upload sets owner=null for a non-user principal"
+      "A private upload is locked to the person who made it, so a file uploaded by anything other than a signed-in user \u2014 an admin tool, a cloud function \u2014 ends up private with no owner, and stays readable by everyone. Upload File's Readers names roles that may read it too, such as role:member; a file with Readers is never readable by everyone.",
+      "BCN-007 live, security enforced: uploaded as a signed-in user, the plain URL is 403 for anonymous AND for a second signed-in user. Uploaded with the master key, the identical request with X-NodeGX-File-Private: true serves 200 to anonymous \u2014 files.ts::upload sets owner=null for a non-user principal. P121-TWO001-MEMBERSPHOTO: X-NodeGX-File-Readers adds read-only role entries to the file's ACL; uploaded with the master key and role:crew, anonymous and a user without the role are 403 (files-http.test.ts)"
     ),
     "files.progress": supported("XHR upload path reports progress"),
     "auth.password": supported("nodegx-backend/src/server/users.ts"),
@@ -219762,13 +219850,25 @@ var UploadFile = defineNode({
   // Error always a sentence; v1 read `code || status || 0` and put a message-less envelope on Error.
   // v3 (P109 ISL-030, row C52 ruled "Keep the real name"): the Cloud File keeps the name it was uploaded as (the backend's
   // `filename`, else the sent file's name); v2's dropped `filename` and knew only the stored name.
-  version: 3,
+  // v4 (P121 TWO-001 / TWO-008): three inputs, Readers (roles that may read a private file), Shrink To and Photo Quality.
+  version: 4,
+  changes: [
+    {
+      version: 4,
+      says: "Three new inputs: Readers names the roles that may read a private file as well as whoever uploaded it, and Shrink To and Photo Quality make a photo smaller in the browser before it is sent. Left empty, each sends the file as v3 did",
+      row: "P121-TWO001-MEMBERSPHOTO, P121-TWO008-UPLOADSHRINK",
+      migration: { none: "Each new input is empty in an app built on v3, and an empty one changes nothing: the upload is the same request" }
+    }
+  ],
   source: "packages/noodl-viewer-react/src/nodes/std-library/uploadfile.ts; noodl-runtime api/cloudstore.js, api/cloudfile.ts",
   needs: ["backend"],
   worldPool: { backends: [...pool2("uploadFile", FILE_REFS[0]), ...pool2("uploadFile", FILE_REFS[1]).slice(0, 1), ...pool2("uploadFile", FILE_REFS[2]).slice(2, 3)] },
   state: {
     file: void 0,
     private: void 0,
+    readers: void 0,
+    shrinkTo: void 0,
+    photoQuality: void 0,
     bucket: void 0,
     path: void 0,
     collection: void 0,
@@ -219800,6 +219900,35 @@ var UploadFile = defineNode({
       description: "Restricts the stored file to whoever uploaded it, so reading it later needs a Sign File URL node",
       examples: [true, false]
     },
+    // P121-TWO001-MEMBERSPHOTO — handed to the store with Private; the backend reads it (files.ts)
+    readers: {
+      type: "string",
+      coerce: "none",
+      displayName: "Readers",
+      group: "General",
+      description: "Roles that may read the file as well as whoever uploaded it, such as role:member, separated by commas; setting it makes the file private. NodeGX backends only",
+      examples: ["role:member, role:admin", ""]
+    },
+    // P121-TWO008-UPLOADSHRINK — the Shrink Photos group. The canvas step (shrinkphoto.ts) is the browser's: this world
+    // has no decoder, so a photo goes as it was picked, which is what the runtime does when the browser cannot read it.
+    shrinkTo: {
+      type: "number",
+      coerce: "none",
+      default: 0,
+      displayName: "Shrink To",
+      group: "Shrink Photos",
+      description: "Makes a photo smaller in the browser before sending it, so its longer side is at most this many pixels; 0 sends every file as picked",
+      examples: [0, 1600]
+    },
+    photoQuality: {
+      type: "number",
+      coerce: "none",
+      default: 80,
+      displayName: "Photo Quality",
+      group: "Shrink Photos",
+      description: "How much detail a shrunk JPEG or WebP keeps, from 1 to 100; PNG keeps every pixel and its transparency, GIF and SVG are never shrunk",
+      examples: [80, 50]
+    },
     // :111-158
     bucket: {
       ...stringInput("Bucket (Supabase)", "Supabase Storage bucket to upload into. Supabase only; there is no default, and a bucket that does not exist fails with an error that does not say so", ["avatars", ""]),
@@ -219839,6 +219968,21 @@ var UploadFile = defineNode({
   {
     file: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes \u2014 an upload already running keeps the file it was sent with", set: { file: v }, send: [] }),
     private: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes", set: { private: v }, send: [] }),
+    readers: (_s, v) => ({
+      says: "always: held as handed; read when the next Upload goes \u2014 set, those roles may read the file as well as whoever uploaded it, and the file is private",
+      set: { readers: v },
+      send: []
+    }),
+    shrinkTo: (_s, v) => ({
+      says: "always: held as handed; read when the next Upload goes \u2014 above 0, a photo (not a GIF or an SVG) is drawn smaller in the browser first, its longer side at most this many pixels, and the smaller file is what goes; it goes as picked when it is already that small, when the smaller one would weigh more, or when the browser cannot read it",
+      set: { shrinkTo: v },
+      send: []
+    }),
+    photoQuality: (_s, v) => ({
+      says: "always: held as handed; read when the next Upload goes, and only when a photo is shrunk \u2014 1 to 100 for a JPEG or WebP, anything else is 80; a PNG keeps every pixel",
+      set: { photoQuality: v },
+      send: []
+    }),
     bucket: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes \u2014 set, the file goes to this bucket at Path (or under the file's own name)", set: { bucket: v }, send: [] }),
     path: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes, and only with a Bucket", set: { path: v }, send: [] }),
     collection: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes \u2014 with Field set and no Bucket, the file attaches to a record of this collection", set: { collection: v }, send: [] }),
@@ -219846,7 +219990,7 @@ var UploadFile = defineNode({
     field: (_s, v) => ({ says: "always: held as handed; read when the next Upload goes, and only with Collection \u2014 a half-filled group is no location at all", set: { field: v }, send: [] }),
     // :170-172 — a token now, the work at the frame end
     upload: (s) => ({
-      says: "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure",
+      says: "always: its own upload at the frame's end \u2014 two presses are two uploads \u2014 with File, Private, Readers and the File Location held then: no File, or a Backend the project does not have, is Error, Error Status Code 0 and Failure at once; otherwise the backend answers with Cloud File then Done, or Error, Error Status Code and Failure",
       set: { presses: s.presses + 1 },
       send: [],
       outcome: "pending"
@@ -219863,7 +220007,7 @@ var UploadFile = defineNode({
     },
     // :172-216
     afterInputs: (s, _i, w) => {
-      const r = frame(s, w, !!s.file, "uploadFile", () => ({ file: s.file, private: s.private, target: fileTarget(s) }), UPLOAD_ERROR_CODE, "upload");
+      const r = frame(s, w, !!s.file, "uploadFile", () => ({ file: s.file, private: s.private, readers: s.readers, target: fileTarget(s) }), UPLOAD_ERROR_CODE, "upload");
       if (!("backend" in r) || !r.backend) return r;
       const f = s.file;
       const sent2 = f && typeof f.name === "string" ? f.name : void 0;
@@ -224468,6 +224612,113 @@ function settingsDiagnostics(spec, params, wired = []) {
   return [...shown].map(([key2, message2]) => ({ key: key2, says: spec.diagnostics[key2].says, message: message2 }));
 }
 
+// ../nodegx-node-spec/src/honesty.ts
+var SCRIPT_TYPES = Object.freeze(["Expression", "JavaScriptFunction", "Javascript2", "Logic Builder"]);
+var EXEMPT_TYPES = Object.freeze(["CSS Definition", "Component Children"]);
+var GRAPH_GRADED_TYPES = Object.freeze([
+  "Component Inputs",
+  "Component Outputs",
+  "Event Receiver",
+  "Event Sender",
+  "For Each Actions",
+  "On App Error",
+  "RunTasks",
+  "net.noodl.ActionDispatcher",
+  "net.noodl.ActionHandler",
+  "net.noodl.ComponentObject",
+  "net.noodl.GlobalStore",
+  "net.noodl.GlobalStore.Set",
+  "net.noodl.GlobalStore.Subscribe",
+  "net.noodl.OptimisticUpdate",
+  "net.noodl.ParentComponentObject",
+  "net.noodl.SetComponentObjectProperties",
+  "net.noodl.SetParentComponentObjectProperties",
+  "net.noodl.StateHistory",
+  "net.noodl.StateHistory.Undo",
+  "net.noodl.StateSnapshot"
+]);
+var SCRIPT_TEXT_PARAMETER = Object.freeze({
+  JavaScriptFunction: "functionScript",
+  Expression: "expression",
+  Javascript2: "code",
+  "Logic Builder": "generatedCode"
+});
+function honestyClassifier(options) {
+  const core = new Set(options.coreTypes);
+  const components = new Set(options.components ?? []);
+  const exempt = new Set(EXEMPT_TYPES);
+  const scriptTypes = new Set(SCRIPT_TYPES);
+  const specs2 = options.specs ?? specs;
+  const graph = new Set(options.graphGraded ?? GRAPH_GRADED_TYPES);
+  const known = (t) => {
+    const spec = Object.prototype.hasOwnProperty.call(specs2, t) ? specs2[t] : void 0;
+    const contract = spec && typeof spec.contract === "string" && spec.contract.length > 0;
+    return !!spec && !contract || graph.has(t);
+  };
+  return (type) => {
+    if (typeof type !== "string") return "unspecced";
+    if (type.startsWith("/") || type.startsWith("#") || components.has(type)) return "instance";
+    if (exempt.has(type)) return "exempt";
+    if (scriptTypes.has(type)) return "script";
+    if (known(type)) return "known";
+    if (!core.has(type)) return "script";
+    return "unspecced";
+  };
+}
+function scriptLinesOf(node) {
+  const param = SCRIPT_TEXT_PARAMETER[node.type];
+  const text2 = param && node.parameters ? node.parameters[param] : void 0;
+  return typeof text2 === "string" && text2.length > 0 ? text2.split("\n").length : 0;
+}
+var percentOf2 = (n, d) => d > 0 ? Math.round(1e3 * n / d) / 10 : null;
+function tally(nodes, classify) {
+  const h = { known: 0, script: 0, unspecced: 0, instances: 0, exempt: 0, percent: null, scriptLines: 0, percentByLines: null, scriptParts: [], unspeccedTypes: {} };
+  let weight = 0;
+  for (const node of nodes) {
+    const cls = classify(node.type);
+    if (cls === "known") h.known++;
+    else if (cls === "instance") h.instances++;
+    else if (cls === "exempt") h.exempt++;
+    else if (cls === "unspecced") {
+      h.unspecced++;
+      h.unspeccedTypes[node.type] = (h.unspeccedTypes[node.type] ?? 0) + 1;
+    } else {
+      h.script++;
+      const lines = scriptLinesOf(node);
+      h.scriptLines += lines;
+      weight += Math.max(1, lines);
+      h.scriptParts.push({ id: node.id, type: node.type, ...node.label ? { label: node.label } : {}, lines, kit: !SCRIPT_TYPES.includes(node.type) });
+    }
+  }
+  h.percent = percentOf2(h.known, h.known + h.script);
+  h.percentByLines = percentOf2(h.known, h.known + weight);
+  return h;
+}
+function componentHonesty(component, options, classify = honestyClassifier(options)) {
+  return { component: component.name, ...tally(component.nodes, classify) };
+}
+function projectHonesty(components, options) {
+  const classify = honestyClassifier({ ...options, components: [...options.components ?? [], ...components.map((c) => c.name)] });
+  const rows = components.map((c) => componentHonesty(c, options, classify));
+  const all = tally(
+    components.flatMap((c) => c.nodes),
+    classify
+  );
+  return { ...all, components: rows };
+}
+function scriptPartName(part) {
+  return part.label ? part.label : `${part.type} ${part.id}`;
+}
+function honestyLine(h, maxNames = 5) {
+  const head = h.percent === null ? `no known or script nodes (${h.unspecced} unspecced)` : `${h.percent}% known (${h.known} known, ${h.script} script${h.unspecced ? `, ${h.unspecced} unspecced` : ""})`;
+  if (!h.scriptParts.length || maxNames <= 0) return head;
+  const parts = [...h.scriptParts].sort((a8, b) => b.lines - a8.lines);
+  const names2 = parts.slice(0, maxNames).map((p) => "`" + scriptPartName(p) + "`");
+  const more = parts.length > maxNames ? ` +${parts.length - maxNames} more` : "";
+  return `${head}; script: ${names2.join(", ")}${more}`;
+}
+var HONESTY_SENTENCE = "The honesty number is the share of an app's nodes whose behaviour is specced and graded (known) against the nodes that hold code nobody has checked: Function, Script, Expression and Visual Function nodes, and kit nodes with no spec (script). It is known \xF7 (known + script), counted by node instance; component instances are counted inside their component, and a shipped node still waiting for its spec is reported apart as unspecced. It is not a quality score: a Function written on purpose is still script. It says how much of the app can be explained without reading code, and the script list says which parts cannot.";
+
 // ../nodegx-project-contract/port-context.ts
 function portProjectFromStore(store2) {
   const registry2 = store2.readRegistry().components;
@@ -226067,6 +226318,234 @@ var V2ProjectStore = class {
   }
 };
 
+// ../nodegx-project-contract/run-on-value-change-migration.ts
+var RUN_ON_CHANGE_PREFIX2 = "runOnChange-";
+var RUN_ON_CHANGE_FAMILIES = {
+  // variables/variablebase.ts — `Set` is the control signal on all four types.
+  String: { controlSignal: "saveValue", declared: ["value"] },
+  Number: { controlSignal: "saveValue", declared: ["value"] },
+  Boolean: { controlSignal: "saveValue", declared: ["value"] },
+  Color: { controlSignal: "saveValue", declared: ["value"] },
+  // std-library/condition.ts
+  Condition: { controlSignal: "eval", declared: ["condition"] },
+  // std-library/data/collectionnode2.ts — `array` is a subscription, not a port.
+  Collection2: { controlSignal: "fetch", declared: ["collectionId", "array"] },
+  // std-library/data/modelnode2.ts
+  Model2: { controlSignal: "fetch", declared: ["modelId", "object"] },
+  // std-library/data/dbmodelnode2.ts
+  DbModel2: { controlSignal: "fetch", declared: ["modelId", "record"] },
+  // std-library/data/variablenode2.ts
+  Variable2: { controlSignal: "fetch", declared: ["name", "variable"] },
+  // std-library/data/filtercollectionnode.ts
+  "Filter Collection": {
+    controlSignal: "filter",
+    declared: ["items", "enabled", "array", "filterSettings"]
+  },
+  // std-library/data/filterdbmodelsnode.ts — plus one `fp-<name>` port per visual filter input.
+  FilterDBModels: {
+    controlSignal: "filter",
+    declared: ["items", "enabled", "records", "filterSettings"],
+    discoveredPrefixes: ["fp-"]
+  },
+  // std-library/data/dbcollectionnode2.ts — every governed name is registered at runtime
+  // (`initialize` and `registerInputIfNeeded`), so none of them reaches the catalog; plus one
+  // `qp-<name>` port per visual query input.
+  DbCollection2: {
+    controlSignal: "storageFetch",
+    declared: ["records", "querySettings", "collectionName", "search"],
+    discoveredPrefixes: ["qp-"]
+  },
+  // std-library/componentutils/componentobject.ts
+  "net.noodl.ComponentObject": { controlSignal: "fetch", declared: ["object"] },
+  // noodl-viewer-react/nodes/std-library/componentutils/parentcomponentobject.ts
+  "net.noodl.ParentComponentObject": { controlSignal: "fetch", declared: ["object"] },
+  // std-library/user/user.ts
+  "net.noodl.user.User": { controlSignal: "fetch", declared: ["user"] },
+  // noodl-viewer-react/nodes/controls/text-input.ts — `Set` is the control signal and `Text` the
+  // one value input it silenced.
+  //
+  // ✅ P88 GAM-019 (2026-09-14): this family's checkbox port is now declared. Until then
+  // `createNodeFromReactComponent` built its definition field by field and never copied
+  // `runOnValueChange`, so `defineNode` synthesised nothing and the catalog and the panel carried
+  // no `runOnChange-startValue`, though a saved parameter still reached `registerInputIfNeeded`,
+  // where `defineNode`'s wrapper claimed it and the untick landed. The field is forwarded now, so
+  // the port is in the catalog and the panel, and the validator's parameter check accepts it.
+  "net.noodl.controls.textinput": { controlSignal: "set", declared: ["startValue"] },
+  // std-library/simplejavascript.ts — script inputs are registered as `in-<name>`, so the
+  // checkbox is `runOnChange-in-<name>`. `functionScript` is the definition port and keeps the
+  // old guard deliberately; it is not governed.
+  JavaScriptFunction: { controlSignal: "run", declared: [], discoveredPrefixes: ["in-"] },
+  // std-library/expression.ts — every free identifier in `expression` becomes an input.
+  // `expression` is the definition port and keeps the old guard deliberately.
+  //
+  // 🔴 `staticInputs` must list EVERY declared input: anything else observed on a saved instance
+  // reads as a free variable. P88 GAM-002 (`89e533625`) declared `evaluateAtLoad`, and until it
+  // was listed here a saved `evaluateAtLoad: false` on an Expression whose `run` is wired was
+  // handed `runOnChange-evaluateAtLoad: false`, a checkbox for a port no expression feeds.
+  Expression: {
+    controlSignal: "run",
+    declared: [],
+    discoveredBareIdentifiers: true,
+    staticInputs: ["evaluateAtLoad", "expression", "run"]
+  }
+};
+function emptyPlan() {
+  return { writes: [], familyNodes: 0, signalDrivenNodes: 0, preserved: 0 };
+}
+function runOnChangePortName(inputName) {
+  return RUN_ON_CHANGE_PREFIX2 + inputName;
+}
+function governedInputsFor(node, family, incomingPorts) {
+  const governed = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (name.length === 0 || seen.has(name)) return;
+    seen.add(name);
+    governed.push(name);
+  };
+  for (const name of family.declared) add(name);
+  const wantsDiscovery = !!family.discoveredPrefixes || !!family.discoveredBareIdentifiers;
+  if (!wantsDiscovery) return governed;
+  const statics = new Set(family.staticInputs ?? []);
+  const observed = [...incomingPorts];
+  for (const name of Object.keys(node.parameters ?? {})) observed.push(name);
+  for (const port5 of node.ports ?? []) if (typeof port5?.name === "string") observed.push(port5.name);
+  for (const port5 of node.dynamicports ?? []) if (typeof port5?.name === "string") observed.push(port5.name);
+  for (const name of observed) {
+    if (name.indexOf(RUN_ON_CHANGE_PREFIX2) === 0) continue;
+    if (statics.has(name)) continue;
+    if (family.discoveredPrefixes) {
+      if (family.discoveredPrefixes.some((prefix) => name.indexOf(prefix) === 0)) add(name);
+      continue;
+    }
+    add(name);
+  }
+  return governed;
+}
+function eachNode2(roots, visit) {
+  for (const node of roots) {
+    if (!node || typeof node !== "object") continue;
+    visit(node);
+    if (Array.isArray(node.children)) eachNode2(node.children, visit);
+  }
+}
+function planRunOnValueChangeMigration(project2) {
+  const plan = emptyPlan();
+  if (!project2 || !Array.isArray(project2.components)) return plan;
+  for (const component of project2.components) {
+    const graph = component?.graph;
+    if (!graph || !Array.isArray(graph.roots)) continue;
+    const componentName = typeof component.name === "string" ? component.name : "";
+    const connections = Array.isArray(graph.connections) ? graph.connections : [];
+    const nodeIds = /* @__PURE__ */ new Set();
+    eachNode2(graph.roots, (node) => {
+      if (typeof node.id === "string") nodeIds.add(node.id);
+    });
+    const incomingByNode = /* @__PURE__ */ new Map();
+    for (const connection of connections) {
+      if (!connection || typeof connection.toId !== "string" || typeof connection.toProperty !== "string") continue;
+      if (!nodeIds.has(connection.fromId)) continue;
+      const ports = incomingByNode.get(connection.toId);
+      if (ports) ports.push(connection.toProperty);
+      else incomingByNode.set(connection.toId, [connection.toProperty]);
+    }
+    eachNode2(graph.roots, (node) => {
+      const family = RUN_ON_CHANGE_FAMILIES[node.type];
+      if (!family) return;
+      plan.familyNodes++;
+      const incomingPorts = incomingByNode.get(node.id) ?? [];
+      if (incomingPorts.indexOf(family.controlSignal) === -1) return;
+      plan.signalDrivenNodes++;
+      const parameters = node.parameters ?? {};
+      for (const input of governedInputsFor(node, family, incomingPorts)) {
+        const parameter = runOnChangePortName(input);
+        if (Object.prototype.hasOwnProperty.call(parameters, parameter)) {
+          plan.preserved++;
+          continue;
+        }
+        plan.writes.push({
+          component: componentName,
+          nodeId: node.id,
+          nodeType: node.type,
+          input,
+          parameter
+        });
+      }
+    });
+  }
+  return plan;
+}
+var RUN_ON_VALUE_CHANGE_FORMAT_VERSION = "5";
+function projectPredatesRunOnValueChange(version2) {
+  if (version2 === void 0 || version2 === null || version2 === "") return true;
+  const n = Number(version2);
+  return !Number.isFinite(n) || n < Number(RUN_ON_VALUE_CHANGE_FORMAT_VERSION);
+}
+function applyRunOnValueChangeMigration(project2) {
+  return writeGovernedCheckboxes(project2, false);
+}
+function writeGovernedCheckboxes(project2, value) {
+  const plan = planRunOnValueChangeMigration(project2);
+  if (plan.writes.length === 0) return plan;
+  const writesByNode = /* @__PURE__ */ new Map();
+  for (const write of plan.writes) {
+    const list5 = writesByNode.get(write.nodeId);
+    if (list5) list5.push(write);
+    else writesByNode.set(write.nodeId, [write]);
+  }
+  for (const component of project2.components ?? []) {
+    const roots = component?.graph?.roots;
+    if (!Array.isArray(roots)) continue;
+    eachNode2(roots, (node) => {
+      const writes = writesByNode.get(node.id);
+      if (!writes) return;
+      const existing = node.parameters ?? {};
+      const rebuilt = {};
+      for (const write of writes) rebuilt[write.parameter] = value;
+      for (const name of Object.keys(existing)) {
+        if (!Object.prototype.hasOwnProperty.call(rebuilt, name)) rebuilt[name] = existing[name];
+      }
+      node.parameters = rebuilt;
+    });
+  }
+  return plan;
+}
+
+// ../nodegx-project-contract/format/run-on-change-pins.ts
+var projectWillBeCleanedUp = (version2) => projectPredatesRunOnValueChange(version2);
+var incomingOf = (connections, id) => JSON.stringify(
+  (connections ?? []).filter((c) => c.toId === id).map((c) => `${c.fromId}.${c.fromProperty}>${c.toProperty}`).sort()
+);
+function pinAuthoredRunOnChange(key2, files, onDisk) {
+  const nodes = files.nodes.nodes ?? [];
+  const plan = planRunOnValueChangeMigration({
+    components: [{ name: key2, graph: { roots: nodes, connections: files.connections.connections } }]
+  });
+  if (plan.writes.length === 0) return [];
+  const before = /* @__PURE__ */ new Map();
+  for (const n of onDisk?.nodes.nodes ?? []) before.set(n.id, n);
+  const authored = (n) => {
+    const old = before.get(n.id);
+    if (!old) return true;
+    if (JSON.stringify(old) !== JSON.stringify(n)) return true;
+    return incomingOf(onDisk?.connections.connections, n.id) !== incomingOf(files.connections.connections, n.id);
+  };
+  const byNode = /* @__PURE__ */ new Map();
+  for (const w of plan.writes) byNode.set(w.nodeId, [...byNode.get(w.nodeId) ?? [], w.parameter]);
+  const written2 = [];
+  for (const node of nodes) {
+    const parameters = byNode.get(node.id);
+    if (!parameters || !authored(node)) continue;
+    const existing = node.parameters ?? {};
+    const rebuilt = {};
+    for (const p of parameters) rebuilt[p] = true;
+    for (const name of Object.keys(existing)) if (!(name in rebuilt)) rebuilt[name] = existing[name];
+    node.parameters = rebuilt;
+    for (const p of parameters) written2.push({ node: node.id, parameter: p });
+  }
+  return written2;
+}
+
 // ../noodl-editor/src/editor/src/models/AiAssistant/authoring/pageRegistration.ts
 var ROUTER_NODE_TYPES = /* @__PURE__ */ new Set(["Router", "Page Stack"]);
 function isSamePage(a8, b) {
@@ -236237,199 +236716,6 @@ function loadCatalog() {
 var fs6 = __toESM(require("fs"));
 var path5 = __toESM(require("path"));
 
-// ../nodegx-project-contract/run-on-value-change-migration.ts
-var RUN_ON_CHANGE_PREFIX2 = "runOnChange-";
-var RUN_ON_CHANGE_FAMILIES = {
-  // variables/variablebase.ts — `Set` is the control signal on all four types.
-  String: { controlSignal: "saveValue", declared: ["value"] },
-  Number: { controlSignal: "saveValue", declared: ["value"] },
-  Boolean: { controlSignal: "saveValue", declared: ["value"] },
-  Color: { controlSignal: "saveValue", declared: ["value"] },
-  // std-library/condition.ts
-  Condition: { controlSignal: "eval", declared: ["condition"] },
-  // std-library/data/collectionnode2.ts — `array` is a subscription, not a port.
-  Collection2: { controlSignal: "fetch", declared: ["collectionId", "array"] },
-  // std-library/data/modelnode2.ts
-  Model2: { controlSignal: "fetch", declared: ["modelId", "object"] },
-  // std-library/data/dbmodelnode2.ts
-  DbModel2: { controlSignal: "fetch", declared: ["modelId", "record"] },
-  // std-library/data/variablenode2.ts
-  Variable2: { controlSignal: "fetch", declared: ["name", "variable"] },
-  // std-library/data/filtercollectionnode.ts
-  "Filter Collection": {
-    controlSignal: "filter",
-    declared: ["items", "enabled", "array", "filterSettings"]
-  },
-  // std-library/data/filterdbmodelsnode.ts — plus one `fp-<name>` port per visual filter input.
-  FilterDBModels: {
-    controlSignal: "filter",
-    declared: ["items", "enabled", "records", "filterSettings"],
-    discoveredPrefixes: ["fp-"]
-  },
-  // std-library/data/dbcollectionnode2.ts — every governed name is registered at runtime
-  // (`initialize` and `registerInputIfNeeded`), so none of them reaches the catalog; plus one
-  // `qp-<name>` port per visual query input.
-  DbCollection2: {
-    controlSignal: "storageFetch",
-    declared: ["records", "querySettings", "collectionName", "search"],
-    discoveredPrefixes: ["qp-"]
-  },
-  // std-library/componentutils/componentobject.ts
-  "net.noodl.ComponentObject": { controlSignal: "fetch", declared: ["object"] },
-  // noodl-viewer-react/nodes/std-library/componentutils/parentcomponentobject.ts
-  "net.noodl.ParentComponentObject": { controlSignal: "fetch", declared: ["object"] },
-  // std-library/user/user.ts
-  "net.noodl.user.User": { controlSignal: "fetch", declared: ["user"] },
-  // noodl-viewer-react/nodes/controls/text-input.ts — `Set` is the control signal and `Text` the
-  // one value input it silenced.
-  //
-  // ✅ P88 GAM-019 (2026-09-14): this family's checkbox port is now declared. Until then
-  // `createNodeFromReactComponent` built its definition field by field and never copied
-  // `runOnValueChange`, so `defineNode` synthesised nothing and the catalog and the panel carried
-  // no `runOnChange-startValue`, though a saved parameter still reached `registerInputIfNeeded`,
-  // where `defineNode`'s wrapper claimed it and the untick landed. The field is forwarded now, so
-  // the port is in the catalog and the panel, and the validator's parameter check accepts it.
-  "net.noodl.controls.textinput": { controlSignal: "set", declared: ["startValue"] },
-  // std-library/simplejavascript.ts — script inputs are registered as `in-<name>`, so the
-  // checkbox is `runOnChange-in-<name>`. `functionScript` is the definition port and keeps the
-  // old guard deliberately; it is not governed.
-  JavaScriptFunction: { controlSignal: "run", declared: [], discoveredPrefixes: ["in-"] },
-  // std-library/expression.ts — every free identifier in `expression` becomes an input.
-  // `expression` is the definition port and keeps the old guard deliberately.
-  //
-  // 🔴 `staticInputs` must list EVERY declared input: anything else observed on a saved instance
-  // reads as a free variable. P88 GAM-002 (`89e533625`) declared `evaluateAtLoad`, and until it
-  // was listed here a saved `evaluateAtLoad: false` on an Expression whose `run` is wired was
-  // handed `runOnChange-evaluateAtLoad: false`, a checkbox for a port no expression feeds.
-  Expression: {
-    controlSignal: "run",
-    declared: [],
-    discoveredBareIdentifiers: true,
-    staticInputs: ["evaluateAtLoad", "expression", "run"]
-  }
-};
-function emptyPlan() {
-  return { writes: [], familyNodes: 0, signalDrivenNodes: 0, preserved: 0 };
-}
-function runOnChangePortName(inputName) {
-  return RUN_ON_CHANGE_PREFIX2 + inputName;
-}
-function governedInputsFor(node, family, incomingPorts) {
-  const governed = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (name) => {
-    if (name.length === 0 || seen.has(name)) return;
-    seen.add(name);
-    governed.push(name);
-  };
-  for (const name of family.declared) add(name);
-  const wantsDiscovery = !!family.discoveredPrefixes || !!family.discoveredBareIdentifiers;
-  if (!wantsDiscovery) return governed;
-  const statics = new Set(family.staticInputs ?? []);
-  const observed = [...incomingPorts];
-  for (const name of Object.keys(node.parameters ?? {})) observed.push(name);
-  for (const port5 of node.ports ?? []) if (typeof port5?.name === "string") observed.push(port5.name);
-  for (const port5 of node.dynamicports ?? []) if (typeof port5?.name === "string") observed.push(port5.name);
-  for (const name of observed) {
-    if (name.indexOf(RUN_ON_CHANGE_PREFIX2) === 0) continue;
-    if (statics.has(name)) continue;
-    if (family.discoveredPrefixes) {
-      if (family.discoveredPrefixes.some((prefix) => name.indexOf(prefix) === 0)) add(name);
-      continue;
-    }
-    add(name);
-  }
-  return governed;
-}
-function eachNode2(roots, visit) {
-  for (const node of roots) {
-    if (!node || typeof node !== "object") continue;
-    visit(node);
-    if (Array.isArray(node.children)) eachNode2(node.children, visit);
-  }
-}
-function planRunOnValueChangeMigration(project2) {
-  const plan = emptyPlan();
-  if (!project2 || !Array.isArray(project2.components)) return plan;
-  for (const component of project2.components) {
-    const graph = component?.graph;
-    if (!graph || !Array.isArray(graph.roots)) continue;
-    const componentName = typeof component.name === "string" ? component.name : "";
-    const connections = Array.isArray(graph.connections) ? graph.connections : [];
-    const nodeIds = /* @__PURE__ */ new Set();
-    eachNode2(graph.roots, (node) => {
-      if (typeof node.id === "string") nodeIds.add(node.id);
-    });
-    const incomingByNode = /* @__PURE__ */ new Map();
-    for (const connection of connections) {
-      if (!connection || typeof connection.toId !== "string" || typeof connection.toProperty !== "string") continue;
-      if (!nodeIds.has(connection.fromId)) continue;
-      const ports = incomingByNode.get(connection.toId);
-      if (ports) ports.push(connection.toProperty);
-      else incomingByNode.set(connection.toId, [connection.toProperty]);
-    }
-    eachNode2(graph.roots, (node) => {
-      const family = RUN_ON_CHANGE_FAMILIES[node.type];
-      if (!family) return;
-      plan.familyNodes++;
-      const incomingPorts = incomingByNode.get(node.id) ?? [];
-      if (incomingPorts.indexOf(family.controlSignal) === -1) return;
-      plan.signalDrivenNodes++;
-      const parameters = node.parameters ?? {};
-      for (const input of governedInputsFor(node, family, incomingPorts)) {
-        const parameter = runOnChangePortName(input);
-        if (Object.prototype.hasOwnProperty.call(parameters, parameter)) {
-          plan.preserved++;
-          continue;
-        }
-        plan.writes.push({
-          component: componentName,
-          nodeId: node.id,
-          nodeType: node.type,
-          input,
-          parameter
-        });
-      }
-    });
-  }
-  return plan;
-}
-var RUN_ON_VALUE_CHANGE_FORMAT_VERSION = "5";
-function projectPredatesRunOnValueChange(version2) {
-  if (version2 === void 0 || version2 === null || version2 === "") return true;
-  const n = Number(version2);
-  return !Number.isFinite(n) || n < Number(RUN_ON_VALUE_CHANGE_FORMAT_VERSION);
-}
-function applyRunOnValueChangeMigration(project2) {
-  return writeGovernedCheckboxes(project2, false);
-}
-function writeGovernedCheckboxes(project2, value) {
-  const plan = planRunOnValueChangeMigration(project2);
-  if (plan.writes.length === 0) return plan;
-  const writesByNode = /* @__PURE__ */ new Map();
-  for (const write of plan.writes) {
-    const list5 = writesByNode.get(write.nodeId);
-    if (list5) list5.push(write);
-    else writesByNode.set(write.nodeId, [write]);
-  }
-  for (const component of project2.components ?? []) {
-    const roots = component?.graph?.roots;
-    if (!Array.isArray(roots)) continue;
-    eachNode2(roots, (node) => {
-      const writes = writesByNode.get(node.id);
-      if (!writes) return;
-      const existing = node.parameters ?? {};
-      const rebuilt = {};
-      for (const write of writes) rebuilt[write.parameter] = value;
-      for (const name of Object.keys(existing)) {
-        if (!Object.prototype.hasOwnProperty.call(rebuilt, name)) rebuilt[name] = existing[name];
-      }
-      node.parameters = rebuilt;
-    });
-  }
-  return plan;
-}
-
 // ../nodegx-export/src/scriptFiles.ts
 function normalizeScriptPath2(path43) {
   if (typeof path43 !== "string") return void 0;
@@ -237114,6 +237400,7 @@ function emitScaffold(ir, shell) {
 function routedPages(ir) {
   const router = ir.project.routers[0];
   if (!router) return [];
+  const prefix = routerPrefix(ir, router);
   const byLegacyPath = /* @__PURE__ */ new Map();
   for (const component of ir.components) byLegacyPath.set(`/${component.path}`, component);
   const usedNames = /* @__PURE__ */ new Set();
@@ -237122,7 +237409,7 @@ function routedPages(ir) {
     const component = byLegacyPath.get(legacyPath);
     if (!component) continue;
     const fileBase = dedupe2(pascalCase(lastSegment(component.path)), usedNames);
-    const urlPath = `/${trimUrlPart2(pageUrlPath(component))}`;
+    const urlPath = `/${prefix}${trimUrlPart2(pageUrlPath(component))}`;
     pages.push({
       componentPath: component.path,
       fileBase,
@@ -237135,6 +237422,59 @@ function routedPages(ir) {
   }
   return pages;
 }
+function routerNodeOf(ir, router) {
+  const component = ir.components.find((c) => c.path === router.componentPath);
+  const node = component?.nodes.find((n) => n.id === router.nodeId);
+  return component && node ? { component, node } : void 0;
+}
+function routerPrefix(ir, router) {
+  const value = routerNodeOf(ir, router)?.node.parameters.find((p) => p.name === "urlPath")?.value;
+  if (value?.kind !== "literal" || typeof value.value !== "string") return "";
+  const trimmed = trimUrlPart2(value.value);
+  return trimmed === "" ? "" : `${trimmed}/`;
+}
+var ROUTER_OWN_STYLE = [
+  { port: "backgroundColor", label: "Background Color", paints: (t) => t.trim() !== "" && t.trim() !== "transparent" },
+  { port: "clip", label: "Clip Behavior", paints: (t) => t === "scroll" || t === "clip" },
+  { port: "cssClassName", label: "CSS Class", paints: (t) => t.trim() !== "" },
+  // The port's default is a comment, `/* background-color: red; */`: it declares nothing.
+  { port: "styleCss", label: "CSS Style", paints: (t) => t.replace(/\/\*[\s\S]*?\*\//g, "").trim() !== "" }
+];
+var paramText = (value) => value === void 0 ? void 0 : value.kind === "literal" ? String(value.value) : value.kind === "script" || value.kind === "expression" ? value.source : value.kind === "json" ? JSON.stringify(value.value) : `${value.value}${value.unit}`;
+function routerNotes(ir) {
+  const lines = [];
+  for (const router of ir.project.routers) {
+    const found2 = routerNodeOf(ir, router);
+    if (!found2) continue;
+    const { component, node } = found2;
+    const wired = (port5) => component.connections.some((c) => c.toId === node.id && c.toProperty === port5);
+    const value = (port5) => node.parameters.find((p) => p.name === port5)?.value;
+    const at = `${router.componentPath}: node ${router.nodeId} (Router "${router.name}")`;
+    if (wired("mounted")) {
+      lines.push(`${at}: its Mounted is wired \u2014 the running app shows no page while the value is false; this export always routes`);
+    } else {
+      const mounted = value("mounted");
+      if (mounted?.kind === "literal" && mounted.value === false) {
+        lines.push(`${at}: its Mounted is unticked \u2014 the running app renders no Router, so it shows no page at all; this export routes every page`);
+      }
+    }
+    if (wired("urlPath")) {
+      lines.push(`${at}: its Url Path is wired \u2014 the running app puts the value in front of every page's path; the exported routes carry none`);
+    }
+    const own2 = ROUTER_OWN_STYLE.filter(({ port: port5, paints: paints2 }) => {
+      if (wired(port5)) return true;
+      const text2 = paramText(value(port5));
+      return text2 !== void 0 && paints2(text2);
+    }).map((s) => s.label);
+    if (own2.length > 0) {
+      const names2 = own2.length === 1 ? own2[0] : `${own2.slice(0, -1).join(", ")} and ${own2[own2.length - 1]}`;
+      lines.push(
+        `${at}: its own ${names2} ${own2.length === 1 ? "is" : "are"} not carried \u2014 the export renders the pages with no Router element to put ${own2.length === 1 ? "it" : "them"} on`
+      );
+    }
+  }
+  return lines;
+}
 function pageUrlPath(component) {
   const pageNode = component.nodes.find((n) => n.type === "Page");
   const urlPath = pageNode?.parameters.find((p) => p.name === "urlPath")?.value;
@@ -237459,8 +237799,10 @@ var RESERVED_WORDS = /* @__PURE__ */ new Set([
   "with",
   "yield"
 ]);
+var REACT_WITHHELD_PROPS = /* @__PURE__ */ new Set(["key"]);
 var isReservedWord = (name) => RESERVED_WORDS.has(name);
 function propIdentifier(name) {
+  if (REACT_WITHHELD_PROPS.has(name)) return `${name}Prop`;
   if (TS_IDENTIFIER.test(name) && !RESERVED_WORDS.has(name)) return name;
   const words3 = name.split(/[^A-Za-z0-9_$]+/).filter((w) => w.length > 0);
   const joined = words3.map((w, i) => i === 0 ? w : w.charAt(0).toUpperCase() + w.slice(1)).join("");
@@ -239187,6 +239529,10 @@ var PROPERTY_ORDER = [
   "letter-spacing",
   "text-transform",
   "text-align",
+  // P18-S110-NOWRAP. Text's three white-space arms, together, after the text block they shape.
+  "white-space",
+  "overflow-wrap",
+  "text-overflow",
   "color",
   "opacity",
   "user-select"
@@ -239416,6 +239762,20 @@ function computeNodeStyle(node, role, catalog2, styles) {
   }
   consumed.add("backdropBlur");
   if (role !== "stack" && literal2("clip") === true) decls.push({ prop: "overflow", value: "hidden" });
+  if (node.type === "Text") {
+    const textOverflow = String(literal2("textOverflow") ?? catalogDefault("textOverflow") ?? "wrap");
+    if (textOverflow === "ellipsis" || textOverflow === "clip") {
+      decls.push({ prop: "white-space", value: "nowrap" });
+      decls.push({ prop: "text-overflow", value: textOverflow });
+      if (!decls.some((d) => d.prop === "overflow")) decls.push({ prop: "overflow", value: "hidden" });
+    } else if (sizeMode === "contentSize" || sizeMode === "contentWidth") {
+      decls.push({ prop: "white-space", value: "pre" });
+    } else {
+      decls.push({ prop: "white-space", value: "pre-wrap" });
+      decls.push({ prop: "overflow-wrap", value: "anywhere" });
+    }
+    consumed.add("textOverflow");
+  }
   boxShorthand("padding", params, decls);
   boxShorthand("margin", params, decls);
   for (const side of ["Top", "Right", "Bottom", "Left"]) {
@@ -239569,6 +239929,25 @@ function computeRoleCss(node, role, catalog2, styles) {
       };
     }
   }
+  if (role === "select") {
+    const placeholder = literal2("placeholder");
+    if (typeof placeholder === "string" && placeholder.length > 0) {
+      const raw = params.get("placeholderOpacity");
+      if (raw !== void 0 && raw.kind !== "literal") {
+        result.notes.push(`node ${node.id}'s Placeholder opacity is not a literal; the placeholder is drawn at full opacity`);
+      } else {
+        const authored = Number((raw?.kind === "literal" ? raw.value : void 0) ?? catalogDefault("placeholderOpacity") ?? 0.5);
+        const opacity = Number.isFinite(authored) ? Math.min(1, Math.max(0, authored)) : 1;
+        if (opacity < 1) {
+          const color = cssParam("color") ?? "FieldText";
+          const percent2 = `${Number((opacity * 100).toFixed(4))}%`;
+          const checked = ":has(> option[hidden]:checked)";
+          result.blocks.push({ suffix: checked, decls: [{ prop: "color", value: `color-mix(in srgb, ${color} ${percent2}, transparent)` }] });
+          result.blocks.push({ suffix: `${checked} > option`, decls: [{ prop: "color", value: color }] });
+        }
+      }
+    }
+  }
   if (role === "columns") {
     const minWidth = cssParam("minWidth");
     const pairs = [
@@ -241540,6 +241919,195 @@ ${source}`);
   return scriptFileMarkerDefer(source);
 }
 
+// ../nodegx-export/src/analyze/querySettings.ts
+var WIRED_VALUE = "@nodegx/wired-value";
+var MAX_WIRED_PARAMS = 3;
+var paramOf = (node, name) => node.parameters.find((p) => p.name === name)?.value;
+var valueOf = (value) => value === void 0 ? void 0 : value.kind === "literal" || value.kind === "json" ? value.value : void 0;
+function hasRelatedTo(filter) {
+  if (filter === null || typeof filter !== "object") return false;
+  const record2 = filter;
+  if (Array.isArray(record2.and)) return record2.and.some(hasRelatedTo);
+  if (Array.isArray(record2.or)) return record2.or.some(hasRelatedTo);
+  return "relatedTo" in record2;
+}
+function relatedToNeedsALoadedRecord(filter) {
+  if (filter === null || typeof filter !== "object") return false;
+  const record2 = filter;
+  if (Array.isArray(record2.and)) return record2.and.some(relatedToNeedsALoadedRecord);
+  if (Array.isArray(record2.or)) return record2.or.some(relatedToNeedsALoadedRecord);
+  const relatedTo = record2.relatedTo;
+  return relatedTo !== void 0 && (relatedTo.className === void 0 || relatedTo.className === "");
+}
+function hasPointsTo(filter) {
+  if (filter === null || typeof filter !== "object") return false;
+  const record2 = filter;
+  if (Array.isArray(record2.and)) return record2.and.some(hasPointsTo);
+  if (Array.isArray(record2.or)) return record2.or.some(hasPointsTo);
+  return Object.values(record2).some((condition) => condition !== null && typeof condition === "object" && "pointsTo" in condition);
+}
+function schemaOf(collectionName4, collections) {
+  const collection = collections.find((c) => c.name === collectionName4);
+  if (collection === void 0) return void 0;
+  const properties = {};
+  for (const column of collection.columns) properties[column.name] = { type: column.type };
+  return { collection: collectionName4, properties };
+}
+function querySettingsOf(node, component, collections) {
+  const wired = (port5) => component.connections.some((c) => c.toId === node.id && c.toProperty === port5);
+  const collectionName4 = String(valueOf(paramOf(node, "collectionName")) ?? "");
+  for (const port5 of ["storageFilterType", "visualFilter", "visualSort", "storageEnableLimit", "storageLimit", "storageSkip"]) {
+    if (wired(port5)) return { refuse: `its ${port5} input is wired \u2014 which records it asks for must be readable off the graph in this slice` };
+  }
+  if (valueOf(paramOf(node, "storageFilterType")) === "json") {
+    return { refuse: "its Filter is a Javascript filter, a script the runtime runs on every fetch \u2014 the export translates the Visual filter only" };
+  }
+  const search = valueOf(paramOf(node, "search"));
+  if (wired("search") || search !== void 0 && search !== "" && search !== null) {
+    return { refuse: "it searches (the Search input), which is the backend's full-text path \u2014 not exported in this slice" };
+  }
+  const params = {};
+  const visualFilter = valueOf(paramOf(node, "visualFilter"));
+  if (visualFilter !== void 0) {
+    const typedIn = {};
+    for (const p of node.parameters) if (p.name.startsWith("qp-")) typedIn[p.name.slice("qp-".length)] = valueOf(p.value);
+    const schema = schemaOf(collectionName4, collections);
+    const translate = (queryParameters, asked2) => {
+      const read2 = (name) => {
+        asked2.add(name);
+        return queryParameters[name];
+      };
+      let neutral;
+      if (isVisualQueryFormat(visualFilter)) {
+        const parameters = new Proxy(queryParameters, { get: (_target, key2) => typeof key2 === "string" ? read2(key2) : void 0 });
+        neutral = visualQueryToNeutral(visualFilter, parameters);
+      } else {
+        const bare2 = (portName) => portName.startsWith("qp-") ? portName.slice("qp-".length) : portName;
+        neutral = savedFilterToNeutral(visualFilter, (portName) => read2(bare2(portName)), {
+          dropUnresolvedConnected: true
+        });
+      }
+      if (neutral === null || neutral === void 0) return {};
+      if (hasRelatedTo(neutral) && relatedToNeedsALoadedRecord(neutral)) {
+        return { refuse: "its Filter asks a relation question whose class the runtime reads off a loaded record \u2014 not exported in this slice" };
+      }
+      if (hasPointsTo(neutral)) {
+        return { refuse: `its Filter has a "points to" condition, whose target class the export's schema snapshot does not carry` };
+      }
+      let where;
+      try {
+        where = toParseWhere(neutral, { backend: "nodegx", schema });
+      } catch (error2) {
+        if (error2 instanceof FilterTranslationError) {
+          return { refuse: `the runtime cannot translate its Filter either ("${error2.message}"), so it answers Failure and never queries` };
+        }
+        throw error2;
+      }
+      return Object.keys(where).length > 0 ? { where } : {};
+    };
+    const asked = /* @__PURE__ */ new Set();
+    const typedInReading = translate(typedIn, asked);
+    const wiredParams = [...asked].filter((name) => wired(`qp-${name}`));
+    if (wiredParams.length === 0) {
+      if ("refuse" in typedInReading) return typedInReading;
+      if (typedInReading.where !== void 0) params.where = typedInReading.where;
+    } else {
+      const reading = wiredWhereOf(node, component, wiredParams, typedIn, schema, translate);
+      if ("refuse" in reading) return reading;
+      params.wired = reading;
+    }
+  }
+  const visualSort = valueOf(paramOf(node, "visualSort"));
+  if (Array.isArray(visualSort)) {
+    params.sort = visualSort.map((s) => (s?.order === "descending" ? "-" : "") + String(s?.property));
+  }
+  if (valueOf(paramOf(node, "storageEnableLimit"))) {
+    const limit = Number(valueOf(paramOf(node, "storageLimit")) || 10);
+    const skip = Number(valueOf(paramOf(node, "storageSkip")) || 0);
+    params.limit = limit;
+    params.skip = skip;
+  }
+  return { params };
+}
+var markerOf2 = (name) => `\0nodegx-qp:${name}\0`;
+var PLAIN_COMPARISONS = /* @__PURE__ */ new Set(["$eq", "$ne", "$lt", "$gt", "$lte", "$gte"]);
+function wiredWhereOf(node, component, params, typedIn, schema, translate) {
+  const quoted = params.map((n) => `"${n}"`).join(", ");
+  const wiresInto = (port5) => component.connections.filter((c) => c.toId === node.id && c.toProperty === port5);
+  const fetchWired = wiresInto("storageFetch").length > 0;
+  if (fetchWired && new Set(params.map((name) => valueOf(paramOf(node, `runOnChange-qp-${name}`)) === false)).size > 1) {
+    return { refuse: `its Fetch is wired and the Run On Value Change boxes of ${quoted} disagree \u2014 a value that asks beside one that waits is not exported in this slice` };
+  }
+  if (params.length > MAX_WIRED_PARAMS) {
+    return { refuse: `its Filter reads ${params.length} values from wired inputs; the export builds a \`where\` from at most ${MAX_WIRED_PARAMS}` };
+  }
+  for (const name of params) {
+    if (wiresInto(`qp-${name}`).length > 1) {
+      return { refuse: `two wires feed its "${name}" input \u2014 last-writer-wins is not statically ordered` };
+    }
+    if (paramOf(node, `qp-${name}`) !== void 0) {
+      return { refuse: `its "${name}" input is wired and holds a typed-in value too \u2014 which one the first fetch reads is not exported in this slice` };
+    }
+    if (!fetchWired && valueOf(paramOf(node, `runOnChange-qp-${name}`)) === false) {
+      return {
+        refuse: `its Run On Value Change box for "${name}" is unticked, so a new value waits for a fetch something else starts \u2014 not exported in this slice`
+      };
+    }
+  }
+  const cases = [];
+  for (let mask = 0; mask < 1 << params.length; mask++) {
+    const values = { ...typedIn };
+    params.forEach((name, i) => {
+      values[name] = mask & 1 << i ? markerOf2(name) : void 0;
+    });
+    const reading = translate(values, /* @__PURE__ */ new Set());
+    if ("refuse" in reading) return reading;
+    if (reading.where === void 0) {
+      cases.push(void 0);
+      continue;
+    }
+    const placed2 = placeMarkers(reading.where, params, schema);
+    if ("refuse" in placed2) return placed2;
+    cases.push(placed2.where);
+  }
+  return { params, cases };
+}
+function placeMarkers(where, params, schema) {
+  let refusal2;
+  const nameIn = (text2) => params.find((name) => text2.includes(markerOf2(name)));
+  const walk2 = (value, key2, field2) => {
+    if (typeof value === "string") {
+      const name = nameIn(value);
+      if (name === void 0) return value;
+      if (value !== markerOf2(name) || key2 === void 0 || !PLAIN_COMPARISONS.has(key2) || field2 === void 0) {
+        refusal2 ??= `its Filter puts the value of "${name}" somewhere other than a plain comparison (${key2 ?? "the top"}${field2 === void 0 || field2 === key2 ? "" : ` on "${field2}"`}), which the runtime reshapes per value \u2014 not exported in this slice`;
+        return value;
+      }
+      const mark = { [WIRED_VALUE]: name, date: schema?.properties?.[field2]?.type === "Date" };
+      return mark;
+    }
+    if (Array.isArray(value)) return value.map((item) => walk2(item, key2, field2));
+    if (value !== null && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) out[k] = walk2(v, k, k.startsWith("$") ? field2 : k);
+      return out;
+    }
+    return value;
+  };
+  const placed2 = walk2(where, void 0, void 0);
+  return refusal2 === void 0 ? { where: placed2 } : { refuse: refusal2 };
+}
+var isWiredValueMark = (value) => value !== null && typeof value === "object" && WIRED_VALUE in value;
+function wiredWhereCode(where, valueCode) {
+  const codes = [];
+  const json3 = JSON.stringify(where, (_key, value) => {
+    if (!isWiredValueMark(value)) return value;
+    codes.push(valueCode(value[WIRED_VALUE], value.date));
+    return `\0${codes.length - 1}\0`;
+  });
+  return json3.replace(/"\\u0000(\d+)\\u0000"/g, (_m, index) => codes[Number(index)]);
+}
+
 // ../nodegx-export/src/analyze/appState.ts
 var GLOBAL_STORE = "net.noodl.GlobalStore";
 var GLOBAL_STORE_SET = "net.noodl.GlobalStore.Set";
@@ -241802,7 +242370,7 @@ function collectAppState(ir) {
           if (literalBool(node, "persist") === true || wiredPortsOf(component).has(`${node.id}:persist`)) {
             plan.deferred = plan.deferred ?? "a declarer authors persist \u2014 browser-storage rehydration is not translatable";
           } else if (node.parameters.some((p) => p.name === "storageKey")) {
-            plan.notes.push(`declarer \`${node.id}\` sets storageKey without persist \u2014 inert, ignored`);
+            plan.notes.push({ componentPath: component.path, nodeId: node.id, text: "sets storageKey without persist \u2014 inert, ignored" });
           }
           const initial = initialStateOf(node, wiredPortsOf(component));
           if (initial.kind === "object") {
@@ -241812,13 +242380,15 @@ function collectAppState(ir) {
                 entry.required = true;
                 entry.initial = value;
               } else if (JSON.stringify(entry.initial) !== JSON.stringify(value)) {
-                plan.notes.push(
-                  `two declarers give key "${key2}" different initial values \u2014 first-seen wins (declarer \`${node.id}\` loses)`
-                );
+                plan.notes.push({
+                  componentPath: component.path,
+                  nodeId: node.id,
+                  text: `gives key "${key2}" a different initial value from an earlier declarer \u2014 first-seen wins, so this one is ignored`
+                });
               }
             }
           } else if (initial.kind === "bad") {
-            plan.notes.push(`declarer \`${node.id}\` has a non-literal or non-object initialState \u2014 contributes nothing`);
+            plan.notes.push({ componentPath: component.path, nodeId: node.id, text: "has a non-literal or non-object initialState \u2014 contributes nothing" });
           }
         }
         if (node.type === GLOBAL_STORE_SET) {
@@ -242373,6 +242943,7 @@ var STACK_COMPLETED_REASON = "its Completed output is consumed \u2014 it fires a
 var CLOUD_FUNCTION_TYPE2 = "CloudFunction2";
 var CLOUD_FUNCTION_OUTPUTS = ["done", "failure", "completed", "error"];
 var RECORD_TYPE = "DbModel2";
+var VARIABLE_FROZEN = "its Variable changes box is unticked under Run On Value Change \u2014 it keeps the value it read until a Fetch, and the exported variable is read live";
 var RECORD_OUTPUTS = ["done", "failure", "completed", "error", "id"];
 var FILE_PICKER_TYPE = "Open File Picker";
 var UPLOAD_FILE_TYPE = "Upload File";
@@ -243169,6 +243740,11 @@ var USER_VERBS = {
     clearsErrorOnDone: true
   }
 };
+function isAwaitedAction(value) {
+  if (value === null || typeof value !== "object") return false;
+  const kind = value.kind;
+  return kind === "api-call" || kind === "http-call" || kind === "cloud-call" || kind === "record-fetch" || kind === "file-pick" || kind === "file-upload" || kind === "file-sign" || kind === "crypto-call" && value.async === true;
+}
 var SESSION_READS = {
   authenticated: "authenticated",
   id: { field: "id", maybeUndefined: true },
@@ -243227,32 +243803,41 @@ function planProject(ir, catalog2) {
   };
   for (const component of ir.components) visit(`/${component.path}`, []);
   const plannedByLegacy = /* @__PURE__ */ new Map();
-  for (const legacy of order) {
+  const exclusionsOf = /* @__PURE__ */ new Map();
+  const namesTakenBy = /* @__PURE__ */ new Map();
+  const nameSets = [usedPageNames, usedComponentNames, usedHttpNames];
+  const planOne = (legacy) => {
+    for (const taken of namesTakenBy.get(legacy) ?? []) for (const name of taken.names) taken.set.delete(name);
+    const before = nameSets.map((set2) => new Set(set2));
     const component = ir.components.find((c) => `/${c.path}` === legacy);
-    plannedByLegacy.set(
+    const planned = planComponent(
+      component,
+      ir,
+      catalog2,
+      registry2,
+      pageByLegacy,
+      pageFileByPath,
+      usedPageNames,
+      usedComponentNames,
+      kits,
+      usedHttpNames,
+      plannedByLegacy,
+      templateCycle,
+      exclusionsOf.get(legacy)
+    );
+    namesTakenBy.set(
       legacy,
-      planComponent(
-        component,
-        ir,
-        catalog2,
-        registry2,
-        pageByLegacy,
-        pageFileByPath,
-        usedPageNames,
-        usedComponentNames,
-        kits,
-        usedHttpNames,
-        plannedByLegacy,
-        templateCycle
-      )
+      nameSets.map((set2, i) => ({ set: set2, names: [...set2].filter((name) => !before[i].has(name)) }))
     );
-  }
-  const plans = ir.components.map((component) => plannedByLegacy.get(`/${component.path}`));
-  const byLegacyPath = new Map(plans.map((p) => [p.legacyPath, p]));
-  for (const plan of plans) {
+    plannedByLegacy.set(legacy, planned);
+    return planned;
+  };
+  for (const legacy of order) planOne(legacy);
+  const byLegacyNow = (legacy) => plannedByLegacy.get(legacy);
+  const liftInto = (plan) => {
     const liftedVarByKey = /* @__PURE__ */ new Map();
     for (const pending of plan.pendingLifted) {
-      const child = byLegacyPath.get(pending.targetLegacy);
+      const child = byLegacyNow(pending.targetLegacy);
       const lifted6 = child?.liftedOutputProps.find((l) => l.port === pending.port);
       if (!lifted6) {
         plan.notes.push(
@@ -243289,7 +243874,56 @@ function planProject(ir, catalog2) {
       };
     }
     plan.pendingLifted = [];
+  };
+  for (const legacy of order) liftInto(plannedByLegacy.get(legacy));
+  for (let round = 0; round < 8; round++) {
+    const again = [];
+    for (const legacy of order) {
+      const planned = plannedByLegacy.get(legacy);
+      const component = ir.components.find((c) => `/${c.path}` === legacy);
+      const found2 = unreachedTriggersOf(planned, component);
+      const known = exclusionsOf.get(legacy) ?? { owners: /* @__PURE__ */ new Map(), mounts: /* @__PURE__ */ new Map(), rows: /* @__PURE__ */ new Map() };
+      let fresh = false;
+      for (const key2 of ["owners", "mounts", "rows"]) {
+        for (const [id, reason2] of found2[key2]) {
+          if (known[key2].has(id)) continue;
+          known[key2].set(id, reason2);
+          fresh = true;
+        }
+      }
+      if (!fresh) continue;
+      exclusionsOf.set(legacy, known);
+      again.push(legacy);
+    }
+    if (again.length === 0) break;
+    for (const legacy of [...again]) {
+      for (const [host, templates] of templatesOf) if (templates.includes(legacy) && !again.includes(host)) again.push(host);
+    }
+    const liftedBefore = new Map(again.map((legacy) => [legacy, JSON.stringify(plannedByLegacy.get(legacy).liftedOutputProps)]));
+    for (const legacy of order) if (again.includes(legacy)) planOne(legacy);
+    for (const [legacy, before] of liftedBefore) {
+      if (JSON.stringify(plannedByLegacy.get(legacy).liftedOutputProps) === before) continue;
+      for (const component of ir.components) {
+        const parent = `/${component.path}`;
+        if (again.includes(parent) || !component.nodes.some((n) => n.type === legacy)) continue;
+        again.push(parent);
+        planOne(parent);
+      }
+    }
+    for (const legacy of again) liftInto(plannedByLegacy.get(legacy));
+  }
+  for (const [legacy, known] of exclusionsOf) {
+    const planned = plannedByLegacy.get(legacy);
+    for (const [fnId, reason2] of known.rows) {
+      const row = planned.stateVars.find((v) => v.origin === "jsfun" && v.originNodeId === fnId);
+      if (row === void 0) continue;
+      const text2 = JSON.stringify({ ...planned, stateVars: void 0, dispositions: void 0, notes: void 0 });
+      if (!text2.includes(`"viaState":"${row.name}"`)) continue;
+      planned.notes.push(`node ${fnId}: a handler or a node that is not drawn still reads its outputs, and reads nothing \u2014 ${reason2.replace(/^it reads /, "")}`);
+    }
   }
+  const plans = ir.components.map((component) => plannedByLegacy.get(`/${component.path}`));
+  const byLegacyPath = new Map(plans.map((p) => [p.legacyPath, p]));
   const stubCollections = [];
   for (const plan of plans) {
     for (const query2 of plan.queries) {
@@ -243309,7 +243943,108 @@ function planProject(ir, catalog2) {
     kitDuplicates
   };
 }
-function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFileByPath, usedPageNames, usedComponentNames, kits, usedHttpNames, plannedByLegacy, templateCycle) {
+function undrawnReasonOf(plan, component, id) {
+  const nodeById = new Map(component.nodes.map((n) => [n.id, n]));
+  const labelOf = (nodeId) => {
+    const node = nodeById.get(nodeId);
+    return node?.authoredLabel ? `"${node.authoredLabel}" (${nodeId})` : `${node?.type ?? "a node"} ${nodeId}`;
+  };
+  for (let at = id; at !== void 0; at = nodeById.get(at)?.parent) {
+    const whose = at === id ? "it is" : `an element above it, ${labelOf(at)}, is`;
+    const bound = plan.bindings[at]?.["mounted"];
+    if (bound !== void 0) {
+      if (bound.kind === "computed" && (bound.expr.kind === "undefined" || bound.expr.kind === "literal" && !bound.expr.value)) {
+        return `${whose} mounted from a statically false source`;
+      }
+    } else if (nodeById.get(at)?.parameters.find((p) => p.name === "mounted")?.value.kind === "literal" && nodeById.get(at).parameters.find((p) => p.name === "mounted").value.value === false) {
+      const wire = component.connections.find((c) => c.toId === at && c.toProperty === "mounted");
+      if (wire === void 0) return `${whose} authored Mounted false, and nothing mounts it`;
+      const prefix = `wire ${wire.key} dropped: `;
+      const dropped = plan.droppedWires.find((w) => w.key === wire.key)?.reason ?? plan.notes.find((n) => n.startsWith(prefix))?.slice(prefix.length);
+      const from = nodeById.get(wire.fromId);
+      const fromRefused = plan.dispositions[wire.fromId];
+      const because = dropped !== void 0 ? ` (${dropped})` : fromRefused?.kind === "deferred" ? ` (the node it comes from is not exported: ${fromRefused.reason})` : "";
+      return `${whose} authored Mounted false, and the wire into its Mounted from ${from?.authoredLabel ? `"${from.authoredLabel}"` : from?.type ?? wire.fromId}.${wire.fromProperty} is not exported${because}`;
+    }
+    if (at === plan.rootId) break;
+  }
+  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;
+  const nodeById = new Map(component.nodes.map((n) => [n.id, n]));
+  const labelOf = (nodeId) => {
+    const node = nodeById.get(nodeId);
+    return node?.authoredLabel ? `"${node.authoredLabel}" (${nodeId})` : `${node?.type ?? "a node"} ${nodeId}`;
+  };
+  const whyUndrawn = /* @__PURE__ */ new Map();
+  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);
+    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;
+    }
+  }
+  const writers = /* @__PURE__ */ new Map();
+  const walk2 = (value, owner) => {
+    if (Array.isArray(value)) {
+      for (const item of value) walk2(item, owner);
+      return;
+    }
+    if (value === null || typeof value !== "object") return;
+    const record2 = value;
+    if (record2.kind === "jsfun-run" && typeof record2.materialize === "string") {
+      const list5 = writers.get(record2.materialize) ?? [];
+      list5.push(owner ?? "");
+      writers.set(record2.materialize, list5);
+    }
+    for (const child of Object.values(record2)) walk2(child, owner);
+  };
+  for (const [key2, value] of Object.entries(plan)) {
+    if (key2 === "handlers") {
+      for (const [owner, byPort] of Object.entries(plan.handlers)) {
+        for (const [port5, actions] of Object.entries(byPort)) {
+          walk2(actions, whyUndrawn.has(owner) || port5 === "didMount" && whyUnmounted.has(owner) ? owner : void 0);
+        }
+      }
+    } else if (key2 === "changeHandlers") {
+      for (const [owner, actions] of Object.entries(plan.changeHandlers)) walk2(actions, whyUndrawn.has(owner) ? owner : void 0);
+    } else if (key2 !== "stateVars" && key2 !== "dispositions" && key2 !== "notes") {
+      walk2(value, void 0);
+    }
+  }
+  const planText = JSON.stringify({ ...plan, stateVars: void 0, dispositions: void 0, notes: void 0 });
+  for (const row of plan.stateVars) {
+    if (row.origin !== "jsfun") continue;
+    const fnId = row.originNodeId;
+    const written2 = writers.get(row.name) ?? [];
+    if (written2.some((owner2) => owner2 === "")) continue;
+    if (!planText.includes(`"viaState":"${row.name}"`)) continue;
+    const disposition = plan.dispositions[fnId];
+    const owner = written2[0];
+    const why = owner === void 0 ? disposition?.kind === "deferred" ? disposition.reason : "nothing the export runs sends its Run" : whyUndrawn.has(owner) ? `its Run is sent only from ${labelOf(owner)}, which is not drawn: ${whyUndrawn.get(owner)}` : `its Run is sent only from the Did Mount of ${labelOf(owner)}, which is not run: ${whyUnmounted.get(owner)}`;
+    found2.rows.set(fnId, `it reads ${labelOf(fnId)}, which the export never runs, so its outputs are never written: ${why}`);
+  }
+  return found2;
+}
+function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFileByPath, usedPageNames, usedComponentNames, kits, usedHttpNames, plannedByLegacy, templateCycle, excluded = { owners: /* @__PURE__ */ new Map(), mounts: /* @__PURE__ */ new Map(), rows: /* @__PURE__ */ new Map() }) {
   const nodeById = new Map(component.nodes.map((n) => [n.id, n]));
   const dispositions = {};
   const notes = [];
@@ -243367,7 +244102,9 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     recordEffects: [],
     variableSeeds: [],
     objectSeeds: [],
+    fieldMounts: [],
     valueChangedEffects: [],
+    tickedRuns: [],
     styleSheets: [],
     statesMachines: [],
     animations: [],
@@ -243491,6 +244228,10 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
   const renderedStackIds = [];
   const roleOf = (node) => {
     const role = renderRole(node, catalog2, kits);
+    if (role === "repeater" && (literalParam(node, "templateType") === "dynamic" || wiredIn.has(`${node.id}:templateType`))) {
+      deferReasons.set(node.id, "its Template Type is dynamic \u2014 each row's component is chosen by the Template Script at run time, and this slice renders one static template");
+      return "unsupported";
+    }
     if (role === null || role === "unsupported" || role === "instance" || role === "repeater" || role === "slot") return role;
     if (role === "custom") return role;
     if (role === "drag") {
@@ -243801,6 +244542,12 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     return plan2 !== void 0 && plan2.origin === "object" ? plan2 : void 0;
   };
   const objectNodeGate = (node, store2) => {
+    if (literalParam(node, "runOnChange-modelId") === false) {
+      return "Id is unticked under Run On Value Change \u2014 its properties read nothing until a Fetch, and the exported store is read at once";
+    }
+    if (literalParam(node, "runOnChange-object") === false) {
+      return "Object properties is unticked under Run On Value Change \u2014 its outputs freeze between Fetch pulses, and the exported store is read live";
+    }
     const propInput2 = component.connections.find((c) => c.toId === node.id && c.toProperty.startsWith("prop-"));
     if (propInput2 !== void 0) {
       return `its "${propInput2.toProperty.slice("prop-".length)}" property input is wired \u2014 a write through the Object node itself is not translated in this slice; a Set Object Properties naming "${store2.name}" is`;
@@ -244336,6 +245083,8 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
       const logicNodeIds = [];
       const subscriberIds = [];
       let anyDelivery = false;
+      let anyLiteral = false;
+      const wireFed = [];
       jsResolving.add(node.id);
       try {
         for (const name of inputNames) {
@@ -244345,6 +245094,7 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
             return { defer: `two wires feed input "${name}" \u2014 last-writer-wins is not statically ordered` };
           }
           const runChangeParam = kind === "function" ? `runOnChange-in-${name}` : `runOnChange-${name}`;
+          if (literalParam(node, port5) !== void 0) anyLiteral = true;
           if (wires.length === 1) {
             const wire = wires[0];
             if (mode === "reactive" && literalParam(node, runChangeParam) === false) {
@@ -244364,6 +245114,7 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
               return { defer: `input "${name}" is fed a logic truth value \u2014 only truthiness sinks take one in this slice` };
             }
             anyDelivery = true;
+            wireFed.push(name);
             const tsType = exprTsType(expr);
             inputs.push({
               name,
@@ -244386,8 +245137,12 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
       } finally {
         jsResolving.delete(node.id);
       }
-      if (kind === "expression" && mode === "reactive" && exprIds.ports.length > 0 && !anyDelivery) {
-        return { defer: "none of its inputs is ever delivered \u2014 the expression never evaluates (its outputs abstain null)" };
+      const evaluateAtLoad = literalParam(node, "evaluateAtLoad") !== false;
+      const loadGate = kind === "expression" && mode === "reactive" && exprIds.ports.length > 0 && !anyLiteral ? { unset: wireFed, atLoad: evaluateAtLoad ? "evaluate" : "wait" } : void 0;
+      if (loadGate?.atLoad === "wait" && !anyDelivery) {
+        return {
+          defer: "Evaluate At Load is unticked and none of its inputs is ever delivered \u2014 the expression never evaluates (its outputs abstain null)"
+        };
       }
       const outputs2 = [];
       const signals = [];
@@ -244437,6 +245192,7 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
         signals,
         mathAliases: exprIds.mathAliases,
         mode,
+        ...loadGate !== void 0 ? { loadGate } : {},
         ...scriptUses3.length > 0 ? { scripts: scriptUses3 } : {},
         ...kind === "visual" ? {
           variables: [
@@ -244472,8 +245228,13 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
       return null;
     }
     if (jsResolving.size > 0) {
-      ctx.defer = "it is fed by another Function/Expression node \u2014 JS-node chains are not translated in this slice";
-      return null;
+      const runKey = `${fromNode.id}:run`;
+      const materialized = kind === "function" && wiredPorts.has(runKey) && !jsResolving.has(fromNode.id) && jsMaterializedVars.has(fromNode.id);
+      if (!materialized) {
+        const compiled2 = kind === "function" ? compiledSinks.get(runKey) : void 0;
+        ctx.defer = compiled2 !== void 0 && "defer" in compiled2 ? `the Function that feeds it is not exported: ${compiled2.defer}` : "it is fed by another Function/Expression node \u2014 JS-node chains are not translated in this slice";
+        return null;
+      }
     }
     const record2 = jsFunDefOf(fromNode);
     if ("defer" in record2) {
@@ -244502,8 +245263,9 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     switch (output) {
       case "result":
         return base;
-      // The abstain-null pre-first-evaluation state is unreachable in the emitted world —
-      // every vocabulary source has a boot value (§4, noted not modeled).
+      // The abstain-null pre-first-evaluation state: Result is `null` there (a `loadGate`,
+      // P18-S110-EVALATLOAD), but the four folds below still compute from it where the runtime's
+      // getters abstain (§4, noted not modeled) — `isTrue` reads false, not "nothing yet".
       case "isTrue":
         return truthyExpr(base);
       case "isFalse":
@@ -244546,6 +245308,19 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
     return stateVar;
   };
   const verbErrorVars = /* @__PURE__ */ new Map();
+  const verbChainScope = /* @__PURE__ */ new Map();
+  const chainSenders = [];
+  const valueWiresInto = (node) => component.connections.filter((c) => c.toId === node.id && c.toProperty === "value" && c.kind !== "signal");
+  const lastValueWireOf = (node) => {
+    const wires = valueWiresInto(node);
+    if (wires.length < 2) return wires[0] ?? component.connections.find((c) => c.toId === node.id && c.toProperty === "value");
+    for (const sender of [...chainSenders].reverse()) {
+      const own2 = wires.filter((c) => c.fromId === sender);
+      if (own2.length === 1) return own2[0];
+      if (own2.length > 1) return void 0;
+    }
+    return void 0;
+  };
   const attachedRecordVerbs = /* @__PURE__ */ new Set();
   const sessionReadGate = (node) => {
     if (wiredPorts.has(`${node.id}:fetch`)) {
@@ -244763,7 +245538,8 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
         null,
         node.id,
         "record-row-error",
-        `The Error output of ${node.authoredLabel ? `"${node.authoredLabel}"` : "the Record"} \u2014 why the last read failed, and never cleared by a later success (dbmodelnode2.ts).`
+        // P18-S113-IDBINDREAD. With Fetch unwired the node is the Id bind, which reads nothing and so reports nothing.
+        wiredPorts.has(`${node.id}:fetch`) ? `The Error output of ${node.authoredLabel ? `"${node.authoredLabel}"` : "the Record"} \u2014 why the last read failed, and never cleared by a later success (dbmodelnode2.ts).` : `The Error output of ${node.authoredLabel ? `"${node.authoredLabel}"` : "the Record"} \u2014 its Fetch is unwired and only a Fetch reports one, so it stays empty (dbmodelnode2.ts).`
       );
       recordErrorVars.set(node.id, stateVar);
     }
@@ -244781,16 +245557,27 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
         null,
         node.id,
         "record-row",
-        `The record the last ${names2.fnName} read \u2014 undefined until the first read, as the node's property outputs read before one has been made.`
+        wiredPorts.has(`${node.id}:fetch`) ? `The record the last ${names2.fnName} read \u2014 undefined until the first read, as the node's property outputs read before one has been made.` : `The app's copy of the record ${node.authoredLabel ? `"${node.authoredLabel}"` : "the Record"}'s Id names \u2014 undefined until the app holds it, as the node's property outputs read before anything has filled the record (dbmodelnode2.ts setModelID).`
       );
       recordAnswerVars.set(node.id, stateVar);
     }
     return stateVar;
   };
   const attachedRecordNodes = /* @__PURE__ */ new Set();
+  const recordBindRefusal = (node) => {
+    if (literalParam(node, "runOnChange-modelId") === false) {
+      return "its Id is unticked under Run On Value Change and its Fetch is unwired \u2014 the runtime never reads the row";
+    }
+    const pulse = component.connections.find((c) => c.fromId === node.id && (c.fromProperty === "done" || c.fromProperty === "failure"));
+    if (pulse !== void 0) {
+      return `its ${pulse.fromProperty === "done" ? "Done" : "Failure"} output is consumed and its Fetch is unwired \u2014 both fire only after a Fetch, and an Id only binds the record it names (dbmodelnode2.ts setModelID)`;
+    }
+    return void 0;
+  };
   const recordWillFire = (node) => {
     if (wiredPorts.has(`${node.id}:fetch`)) return false;
     if (!plan.file) return false;
+    if (recordBindRefusal(node) !== void 0) return false;
     const compiled2 = compiledOf(node, "fetch");
     return !("defer" in compiled2) && actionsValidIn([compiled2.action], { kind: "render" });
   };
@@ -245077,9 +245864,53 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
   const usedQueryStateNames = /* @__PURE__ */ new Set();
   const queryReaders = /* @__PURE__ */ new Set();
   const staticRowsReadIds = /* @__PURE__ */ new Set();
+  const querySettingsCache = /* @__PURE__ */ new Map();
+  const queryWirings = /* @__PURE__ */ new Map();
+  const querySettingsFor = (node) => {
+    let settings = querySettingsCache.get(node.id);
+    if (settings === void 0) {
+      querySettingsCache.set(node.id, { refuse: "its Filter reads a value that depends on the query itself" });
+      settings = querySettingsOf(node, component, ir.project.collections);
+      if ("params" in settings && settings.params.wired !== void 0) settings = wireQueryValues(node, settings.params.wired.params) ?? settings;
+      querySettingsCache.set(node.id, settings);
+    }
+    return settings;
+  };
+  const wireQueryValues = (node, names2) => {
+    const wiring = { values: [], consumes: [], collapses: [], subscribes: [] };
+    for (const name of names2) {
+      const wire = component.connections.find((c) => c.toId === node.id && c.toProperty === `qp-${name}`);
+      if (wire === void 0) return { refuse: `its "${name}" input has no wire` };
+      const ctx = newCtx();
+      const expr = resolveExpr(nodeById.get(wire.fromId), wire.fromProperty, ctx);
+      if (expr === null) return { refuse: `its Filter reads "${name}" from a wire the export cannot read: ${ctx.defer ?? "no statically known source"}` };
+      if (!exprValidIn(expr, { kind: "render" })) return { refuse: `its Filter reads "${name}" from a value that only exists inside a handler` };
+      wiring.values.push({ name, expr });
+      wiring.consumes.push(wire.key, ...ctx.consumes);
+      wiring.collapses.push(...ctx.logicNodeIds);
+      wiring.subscribes.push(...ctx.subscriberIds);
+    }
+    queryWirings.set(node.id, wiring);
+    return void 0;
+  };
+  const queryLands = (node) => Object.values(plan.repeaters).some((r) => r.itemsQueryId === node.id) || queryReaders.has(node.id) && component.connections.some((c) => c.fromId === node.id && c.fromProperty === "items" && consumed.has(c.key));
+  const pageMountFetch = (wire) => wire.toProperty === "storageFetch" && wire.fromProperty === "didMount" && nodeById.get(wire.fromId)?.type === "Page" && nodeById.get(wire.toId)?.type === "DbCollection2";
+  const fetchWiredOf = (node) => {
+    const fetches2 = component.connections.filter((c) => c.toId === node.id && c.toProperty === "storageFetch");
+    if (fetches2.length === 0) return void 0;
+    const ticked3 = (input) => literalParam(node, `runOnChange-${input}`) !== false;
+    const NOT_QUERY_SETTINGS = /* @__PURE__ */ new Set(["collectionName", "search", "realtime"]);
+    const setting4 = node.parameters.some((p) => !NOT_QUERY_SETTINGS.has(p.name) && !p.name.startsWith("qp-") && !p.name.startsWith("runOnChange-"));
+    const wired = queryWirings.get(node.id)?.values ?? [];
+    return {
+      mount: ticked3("collectionName") || setting4 && ticked3("querySettings") || fetches2.some(pageMountFetch),
+      onValues: wired.length > 0 && wired.every((v) => ticked3(`qp-${v.name}`))
+    };
+  };
   const queryPlanOf = (node) => {
     const existing = plan.queries.find((q) => q.nodeId === node.id);
     if (existing !== void 0) return existing;
+    const settings = querySettingsFor(node);
     const collectionName4 = String(literalParam(node, "collectionName") ?? "Record");
     const { typeName: typeName3, plural: plural3, moduleBase, fetchName } = collectionModuleNames(collectionName4);
     const stateName = dedupe4(plural3, usedQueryStateNames);
@@ -245091,7 +245922,10 @@ function planComponent(component, ir, catalog2, registry2, pageByLegacy, pageFil
       itemName: typeName3.charAt(0).toLowerCase() + typeName3.slice(1),
       fetchName,
       typeName: typeName3,
-      moduleBase
+      moduleBase,
+      ..."params" in settings && Object.keys(settings.params).length > 0 ? { params: settings.params } : {},
+      ...queryWirings.has(node.id) ? { wiredValues: queryWirings.get(node.id).values, wiredClient: ir.project.cloudservices !== void 0 } : {},
+      ...fetchWiredOf(node) !== void 0 ? { fetchWired: fetchWiredOf(node) } : {}
     };
     plan.queries.push(query2);
     return query2;
@@ -245774,6 +246608,12 @@ ${body}
       ctx.defer = `its ${wiredSetting.slice(node.id.length + 1)} setting is wired \u2014 the filter is not statically known`;
       return null;
     }
+    for (const box of ["items", "array"]) {
+      if (literalParam(node, `runOnChange-${box}`) === false) {
+        ctx.defer = `its Run On Value Change box for "${box === "items" ? "Items" : "Array changes"}" is unticked \u2014 it would re-filter only on its Filter signal, which this slice does not translate`;
+        return null;
+      }
+    }
     if (literalParam(node, "enabled") === false) {
       ctx.logicNodeIds.push(node.id);
       return source;
@@ -246018,6 +246858,11 @@ ${body}
         ctx.defer = "the Query Records it reads names no Class statically";
         return null;
       }
+      const settings = querySettingsFor(fromNode);
+      if ("refuse" in settings) {
+        ctx.defer = `the Query Records it reads is not exported: ${settings.refuse}`;
+        return null;
+      }
       const query2 = queryPlanOf(fromNode);
       queryReaders.add(fromNode.id);
       return { kind: "query-get", nodeId: fromNode.id, stateName: query2.stateName, typeName: query2.typeName, collectionName: query2.collectionName };
@@ -246243,6 +247088,10 @@ ${body}
     }
     if (fromNode.type === "Variable2" && fromProperty === "value") {
       const name = variableNameOf(fromNode);
+      if (name !== void 0 && literalParam(fromNode, "runOnChange-variable") === false) {
+        ctx.defer = VARIABLE_FROZEN;
+        return null;
+      }
       return name !== void 0 ? { kind: "store-get", variableName: name } : null;
     }
     if (fromNode.type === GLOBAL_STORE_SUBSCRIBE && fromProperty === "value") {
@@ -246296,6 +247145,9 @@ ${body}
       }
     }
     if ((RECORD_VERBS[fromNode.type] !== void 0 || RELATION_VERBS[fromNode.type] !== void 0 || USER_VERBS[fromNode.type] !== void 0) && fromProperty === "error") {
+      if (verbChainScope.get(fromNode.id) === "failure") {
+        return { kind: "outcome-error", nodeId: fromNode.id, local: `${verbErrorStateOf(fromNode).name}Message` };
+      }
       if (!attachedRecordVerbs.has(fromNode.id)) {
         const trigger = USER_VERBS[fromNode.type]?.trigger ?? "store";
         const compiled2 = compiledOf(fromNode, trigger);
@@ -246992,6 +247844,72 @@ ${body}
     ctx.logicNodeIds.push(node.id);
     return output === "result" ? truthyExpr(cond) : notExpr(cond);
   };
+  const SNAPSHOT_SINK_PORTS = /* @__PURE__ */ new Set(["mounted", "visible"]);
+  const snapshotWiresOf = (node) => component.connections.filter((c) => c.fromId === node.id && (c.fromProperty === "result" || c.fromProperty === "isfalse"));
+  let snapshotVerdictMemo;
+  const snapshotVerdicts = () => {
+    if (snapshotVerdictMemo !== void 0) return snapshotVerdictMemo;
+    const verdicts = /* @__PURE__ */ new Map();
+    for (const node of component.nodes) {
+      if (node.type !== "Condition" || literalParam(node, "runOnChange-condition") !== false) continue;
+      if (!wiredPorts.has(`${node.id}:eval`)) continue;
+      const wires = snapshotWiresOf(node);
+      if (wires.length === 0) continue;
+      let reason2 = null;
+      for (const w of wires) {
+        const sink = nodeById.get(w.toId);
+        if (!SNAPSHOT_SINK_PORTS.has(w.toProperty)) {
+          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) {
+          reason2 = "a mounted wire into the component root is a router concern \u2014 not translated in this slice";
+        }
+        if (reason2 !== null) break;
+      }
+      verdicts.set(node.id, reason2);
+    }
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const [id, verdict] of verdicts) {
+        if (verdict !== null) continue;
+        for (const w of snapshotWiresOf(nodeById.get(id))) {
+          const feeders = component.connections.filter((c) => c.toId === w.toId && c.toProperty === w.toProperty);
+          const isSnapshot = (c) => (c.fromProperty === "result" || c.fromProperty === "isfalse") && verdicts.has(c.fromId);
+          const outsider = feeders.find((c) => !isSnapshot(c));
+          const peer = feeders.find((c) => isSnapshot(c) && verdicts.get(c.fromId) !== null);
+          if (outsider === void 0 && peer === void 0) continue;
+          verdicts.set(
+            id,
+            outsider !== void 0 ? `${w.toId}.${w.toProperty} is also fed by ${nodeById.get(outsider.fromId)?.type ?? "a missing node"}.${outsider.fromProperty}, which is not an Evaluate snapshot this slice carries \u2014 the runtime shows whichever wrote last` : `${w.toId}.${w.toProperty} is also written by Condition ${peer.fromId}, which does not translate here \u2014 the runtime shows whichever wrote last`
+          );
+          changed = true;
+          break;
+        }
+      }
+    }
+    snapshotVerdictMemo = verdicts;
+    return verdicts;
+  };
+  const snapshotCells = /* @__PURE__ */ new Map();
+  const snapshotCellOf = (toId, toProperty) => {
+    const key2 = `${toId}\0${toProperty}`;
+    let cell = snapshotCells.get(key2);
+    if (cell === void 0) {
+      const sink = nodeById.get(toId);
+      cell = allocStateVar(
+        sink?.authoredLabel === void 0 ? void 0 : `${sink.authoredLabel} ${toProperty}`,
+        toProperty === "mounted" ? "shown" : "visible",
+        "boolean",
+        false,
+        toId,
+        "condition",
+        `${toProperty === "mounted" ? "Mounted" : "Visible"} of ${sink?.authoredLabel ? `"${sink.authoredLabel}"` : toId}, written by the Evaluate of the Condition${component.connections.filter((c) => c.toId === toId && c.toProperty === toProperty).length > 1 ? "s" : ""} wired into it \u2014 false until the first one (EXP-011 \xA787).`
+      );
+      snapshotCells.set(key2, cell);
+    }
+    return cell;
+  };
   const formatExprOf = (node, ctx) => {
     if (wiredPorts.has(`${node.id}:format`)) {
       ctx.defer = "the format string is wired, not literal";
@@ -247234,6 +248152,8 @@ ${body}
     [CLOUD_FUNCTION_TYPE2]: "call",
     // EXP-011 §43. `Record`'s only action port; with it unwired the node is an effect (§43.2).
     [RECORD_TYPE]: "fetch",
+    // P18-S116-QUERYFETCH. `Query Records`' only action port (display name "Do"); with it unwired the node is an effect.
+    DbCollection2: "storageFetch",
     // EXP-011 §45. The three files nodes' only action ports (`Cloud File` has none — it is a read).
     [FILE_PICKER_TYPE]: "open",
     [UPLOAD_FILE_TYPE]: "upload",
@@ -247309,6 +248229,14 @@ ${body}
     return taken.has("onClose") ? 'a declared port already claims the reserved prop "onClose" \u2014 rename the port (POPUPS-TARGET \xA74)' : void 0;
   })();
   const doneChainOf = (node, port5 = "done") => {
+    chainSenders.push(node.id);
+    try {
+      return doneChainOfSender(node, port5);
+    } finally {
+      chainSenders.pop();
+    }
+  };
+  const doneChainOfSender = (node, port5) => {
     const then2 = [];
     const consumes = [];
     const collapses = [];
@@ -247340,6 +248268,18 @@ ${body}
     }
     return { then: then2, consumes, collapses, subscribes };
   };
+  const verbFailChainOf = (node) => {
+    const outer = verbChainScope.get(node.id);
+    verbChainScope.set(node.id, "failure");
+    let chain;
+    try {
+      chain = doneChainOf(node, "failure");
+    } finally {
+      if (outer === void 0) verbChainScope.delete(node.id);
+      else verbChainScope.set(node.id, outer);
+    }
+    return chain;
+  };
   const compileShowPopup = (node) => {
     if (wiredPorts.has(`${node.id}:target`)) {
       return { defer: "target is wired \u2014 which component opens is not statically knowable" };
@@ -247455,9 +248395,65 @@ ${body}
       if (from?.type === "NewModel" && !chainByNewModel.has(from.id)) chainByNewModel.set(from.id, result);
     }
   }
+  const pulseRefusals = /* @__PURE__ */ new Map();
+  const pulseChainsOf = (node, def) => {
+    const none = { then: [], consumes: [], collapses: [], subscribes: [] };
+    if (def.kind !== "function") return none;
+    const sentWires = component.connections.filter((c) => c.fromId === node.id && def.signals.includes(c.fromProperty.slice("out-".length)));
+    if (sentWires.length === 0) return none;
+    const signalsByPort = /* @__PURE__ */ new Map();
+    for (const c of sentWires) {
+      const port5 = `${c.toId}:${c.toProperty}`;
+      const signals = signalsByPort.get(port5) ?? /* @__PURE__ */ new Set();
+      signals.add(c.fromProperty.slice("out-".length));
+      signalsByPort.set(port5, signals);
+    }
+    for (const [port5, signals] of signalsByPort) {
+      if (signals.size < 2) continue;
+      const target = nodeById.get(port5.slice(0, port5.indexOf(":")));
+      return {
+        defer: `two of its signals (${[...signals].map((s) => `"${s}"`).join(", ")}) drive ${target?.type ?? "a missing node"}.${port5.slice(port5.indexOf(":") + 1)} \u2014 which value each pulse reads there is not translated`
+      };
+    }
+    const arms = [];
+    const result = { then: [], consumes: [], collapses: [], subscribes: [] };
+    for (const signal2 of def.signals) {
+      if (!sentWires.some((c) => c.fromProperty === `out-${signal2}`)) continue;
+      const arm = doneChainOf(node, `out-${signal2}`);
+      if ("defer" in arm) {
+        pulseRefusals.set(`${node.id}:out-${signal2}`, arm.defer.replace(`its out-${signal2} output`, `its "${signal2}" signal`));
+        continue;
+      }
+      arms.push({ kind: "jsfun-pulse", nodeId: node.id, signal: signal2, then: arm.then });
+      result.consumes.push(...arm.consumes);
+      result.collapses.push(...arm.collapses);
+      result.subscribes.push(...arm.subscribes);
+    }
+    if (arms.length > 0) result.then.push({ kind: "jsfun-pulses", nodeId: node.id, then: arms });
+    return result;
+  };
+  const tickedWatchOf = (node, def) => {
+    if (def.kind === "visual") return { watch: [] };
+    const watch = [];
+    for (const input of def.inputs) {
+      if (input.expr === void 0) continue;
+      if (literalParam(node, def.kind === "function" ? `runOnChange-in-${input.name}` : `runOnChange-${input.name}`) === false) continue;
+      if (!exprValidIn(input.expr, { kind: "render" })) {
+        return {
+          defer: `its "${input.name}" input is ticked under Run On Value Change, so a new value runs it again, and that value exists only inside a handler \u2014 the export cannot watch it`
+        };
+      }
+      watch.push(input.expr);
+    }
+    return { watch };
+  };
+  const isRowReader = (reader, port5) => reader.type === JS_FUNCTION && port5.startsWith("in-") || reader.type === "Set Variable" && port5 === "value" || reader.type === "DbModel2" && port5 === "modelId" || reader.type === "SetDbModelProperties" && (port5 === "modelId" || port5.startsWith("prop-")) || reader.type === "NewDbModelProperties" && port5.startsWith("prop-") || reader.type === "DeleteDbModelProperties" && port5 === "modelId" || reader.type === CLOUD_FUNCTION_TYPE2 && port5.startsWith("in-") || reader.type === "DbCollection2" && port5.startsWith("qp-");
+  const tickedRunPieces = /* @__PURE__ */ new Map();
   const compileJsRun = (node) => {
     const record2 = jsFunDefOf(node);
     if ("defer" in record2) return { defer: record2.defer };
+    const ticked3 = tickedWatchOf(node, record2.def);
+    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.startsWith("out-")) {
@@ -247472,19 +248468,68 @@ ${body}
       }
       return { defer: `its ${c.fromProperty} output is consumed \u2014 only done continues a Run chain in this slice` };
     }
-    const chain = doneChainOf(node);
-    if ("defer" in chain) return chain;
-    const strayRead = component.connections.find(
+    const done = doneChainOf(node);
+    if ("defer" in done) return done;
+    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" })) {
+      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]
+    };
+    const strays = component.connections.filter(
       (c) => c.fromId === node.id && isJsValueOutput(node, c.fromProperty) && !chain.consumes.includes(c.key)
     );
-    let materialize;
-    if (strayRead) {
-      const strayRendered = nodeById.get(strayRead.toId);
-      if (!strayRendered || !rendered2.has(strayRead.toId)) {
+    const signalTargetOf = (toId) => record2.def.kind !== "function" ? void 0 : component.connections.find((c) => c.fromId === node.id && c.toId === toId && record2.def.signals.includes(c.fromProperty.slice("out-".length)));
+    const missingSink = strays.find((c) => nodeById.get(c.toId) === void 0);
+    if (missingSink) {
+      return { defer: `its ${missingSink.fromProperty} output is consumed outside the Run chain by a missing node` };
+    }
+    const ownSignalStray = (c) => {
+      if (rendered2.has(c.toId)) return false;
+      const signalWire = signalTargetOf(c.toId);
+      return signalWire !== void 0 && (pulseRefusals.has(`${node.id}:${signalWire.fromProperty}`) || pulseRefusals.has(node.id));
+    };
+    const headMaterialized = strays.length > 0 && rendered2.has(strays[0].toId);
+    const unreadable = headMaterialized ? void 0 : strays.find(
+      (c) => !rendered2.has(c.toId) && !ownSignalStray(c) && (record2.def.kind !== "function" || !isRowReader(nodeById.get(c.toId), c.toProperty))
+    );
+    if (unreadable) {
+      return {
+        defer: `its ${unreadable.fromProperty} output is consumed outside the Run chain by an unrendered sink \u2014 the last run's value is not statically expressible there`
+      };
+    }
+    const readers = headMaterialized ? strays : strays.filter((c) => !ownSignalStray(c));
+    const runWires = component.connections.filter((c) => c.toId === node.id && c.toProperty === "run");
+    for (const reader of readers) {
+      if (rendered2.has(reader.toId)) continue;
+      const early = component.connections.find(
+        (w, i) => w.toId === reader.toId && runWires.some((r) => r.fromId === w.fromId && r.fromProperty === w.fromProperty && i < component.connections.indexOf(r))
+      );
+      if (early) {
         return {
-          defer: `its ${strayRead.fromProperty} output is consumed outside the Run chain by an unrendered sink \u2014 the last run's value is not statically expressible there`
+          defer: `its ${reader.fromProperty} output is read by ${nodeById.get(reader.toId).type}.${reader.toProperty}, whose ${early.toProperty} the same ${early.fromProperty} sends before it runs this \u2014 the runtime's reader waits for the run's value, the export's would read the one before`
         };
       }
+    }
+    if (readers.length === 0 && strays.length > 0 && chain.then.length === 0) {
+      const stray = strays[0];
+      const signalWire = signalTargetOf(stray.toId);
+      const refused = pulseRefusals.get(`${node.id}:${signalWire.fromProperty}`) ?? pulseRefusals.get(node.id);
+      return {
+        defer: refused !== void 0 ? `its ${stray.fromProperty} output feeds ${nodeById.get(stray.toId).type}.${stray.toProperty}, which its "${signalWire.fromProperty.slice("out-".length)}" signal runs, and that chain is not exported: ${refused}` : `its ${stray.fromProperty} output is consumed outside the Run chain by an unrendered sink \u2014 the last run's value is not statically expressible there`
+      };
+    }
+    const strayRead = readers[0];
+    let materialize;
+    if (strayRead) {
       const def = record2.def;
       const fields = def.outputs.map(
         (o) => `${/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(o.name) ? o.name : JSON.stringify(o.name)}?: ${o.tsType}`
@@ -247505,6 +248550,13 @@ ${body}
     if (chain.then.length === 0 && materialize === void 0) {
       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)) {
+      tickedRunPieces.set(node.id, {
+        watch: ticked3.watch,
+        action: { kind: "jsfun-run", nodeId: node.id, then: pulses.then, ...materialize !== void 0 ? { materialize } : {}, ticked: true }
+      });
+    }
     return {
       action: {
         kind: "jsfun-run",
@@ -247576,6 +248628,18 @@ ${body}
     if (literalParam(node, "idSource") === "foreach" || authoredOrWired("repeaterComponent")) {
       return { defer: "its Id Source is the enclosing repeater's row \u2014 row identity is not statically knowable in this slice" };
     }
+    const namesProperties = (name) => {
+      const value = literalParam(node, name);
+      if (wiredPorts.has(`${node.id}:${name}`)) return true;
+      if (typeof value !== "string") return false;
+      return name === "upsertOn" ? value.trim() !== "" : value.split(",").some((n) => n.trim() !== "");
+    };
+    if (verb === "create" && namesProperties("upsertOn")) {
+      return { defer: "its Upsert On names a unique property \u2014 a clash would update the existing row in the runtime, and the exported create always creates" };
+    }
+    if (verb === "update" && namesProperties("onlyIfUnchanged")) {
+      return { defer: "its Only If Unchanged names properties \u2014 the runtime writes only if they still hold what the record was read with, and the exported update writes unconditionally" };
+    }
     if (verb === "update") {
       if (literalParam(node, "storeType") === "local" || wiredPorts.has(`${node.id}:storeType`)) {
         return { defer: "Store to is Local only \u2014 an in-memory-only write, and the export holds no record to write into" };
@@ -247591,8 +248655,8 @@ ${body}
       };
     }
     for (const wire of component.connections.filter((c) => c.fromId === node.id)) {
-      if (wire.fromProperty === "failure" || wire.fromProperty === "completed") {
-        return { defer: `its ${wire.fromProperty} output is consumed \u2014 only the done chain and the Error value are translated in this slice` };
+      if (wire.fromProperty === "completed") {
+        return { defer: `its ${wire.fromProperty} output is consumed \u2014 only the done and failure chains and the Error value are translated in this slice` };
       }
       if (wire.fromProperty === "id") {
         return { defer: "its Id output is consumed \u2014 the record it names exists only inside the invoking chain, which the relation verbs would need" };
@@ -247649,6 +248713,8 @@ ${body}
     }
     const chain = doneChainOf(node);
     if ("defer" in chain) return { defer: chain.defer };
+    const failChain = verbFailChainOf(node);
+    if ("defer" in failChain) return { defer: failChain.defer };
     const { typeName: typeName3, moduleBase } = collectionModuleNames(collectionName4);
     const fnName = `${verb}${typeName3}`;
     plan.mutations.push({
@@ -247678,11 +248744,12 @@ ${body}
         // EXP-011 §72. An `unknown` id (an untyped Variable, a store key nothing types) into a `string` parameter.
         ...idExpr !== void 0 && idExpr.kind !== "literal" && exprTsType(idExpr) === "unknown" ? { coerceId: "string" } : {},
         errorState: verbErrorStateOf(node).name,
-        then: chain.then
+        then: chain.then,
+        failThen: failChain.then
       },
-      consumes: [...consumes, ...chain.consumes, ...ctx.consumes],
-      collapses: [...ctx.logicNodeIds, ...chain.collapses],
-      subscribes: [...ctx.subscriberIds, ...chain.subscribes]
+      consumes: [...consumes, ...chain.consumes, ...failChain.consumes, ...ctx.consumes],
+      collapses: [...ctx.logicNodeIds, ...chain.collapses, ...failChain.collapses],
+      subscribes: [...ctx.subscriberIds, ...chain.subscribes, ...failChain.subscribes]
     };
   };
   const compileRelationOp = (node) => {
@@ -247701,8 +248768,8 @@ ${body}
       return { defer: "its Id Source is the enclosing repeater's row \u2014 row identity is not statically knowable in this slice" };
     }
     for (const wire of component.connections.filter((c) => c.fromId === node.id)) {
-      if (wire.fromProperty === "failure" || wire.fromProperty === "completed") {
-        return { defer: `its ${wire.fromProperty} output is consumed \u2014 only the done chain and the Error value are translated in this slice` };
+      if (wire.fromProperty === "completed") {
+        return { defer: `its ${wire.fromProperty} output is consumed \u2014 only the done and failure chains and the Error value are translated in this slice` };
       }
       if (wire.fromProperty === "id") {
         return { defer: "its Id output is consumed \u2014 it republishes the Id it was given, and that read is not translated in this slice" };
@@ -247752,6 +248819,8 @@ ${body}
     consumes.push(targetWires[0].key);
     const chain = doneChainOf(node);
     if ("defer" in chain) return { defer: chain.defer };
+    const failChain = verbFailChainOf(node);
+    if ("defer" in failChain) return { defer: failChain.defer };
     const { typeName: typeName3, moduleBase } = collectionModuleNames(collectionName4);
     const fnName = `${spec.fnPrefix}${typeName3}Relation`;
     plan.mutations.push({ nodeId: node.id, verb: spec.verb, collectionName: collectionName4, fnName, typeName: typeName3, moduleBase, writes: [] });
@@ -247776,11 +248845,12 @@ ${body}
         guardId: false,
         ...guards.length > 0 ? { guards } : {},
         errorState: verbErrorStateOf(node).name,
-        then: chain.then
+        then: chain.then,
+        failThen: failChain.then
       },
-      consumes: [...consumes, ...chain.consumes, ...ctx.consumes],
-      collapses: [...ctx.logicNodeIds, ...chain.collapses],
-      subscribes: [...ctx.subscriberIds, ...chain.subscribes]
+      consumes: [...consumes, ...chain.consumes, ...failChain.consumes, ...ctx.consumes],
+      collapses: [...ctx.logicNodeIds, ...chain.collapses, ...failChain.collapses],
+      subscribes: [...ctx.subscriberIds, ...chain.subscribes, ...failChain.subscribes]
     };
   };
   const compileUserOp = (node) => {
@@ -247788,9 +248858,9 @@ ${body}
     const ctx = newCtx();
     const consumes = [];
     for (const wire of component.connections.filter((c) => c.fromId === node.id)) {
-      if (wire.fromProperty === "failure" || wire.fromProperty === "completed") {
+      if (wire.fromProperty === "completed") {
         return {
-          defer: `its ${wire.fromProperty} output is consumed \u2014 only the done chain and the Error value are translated in this slice`
+          defer: `its ${wire.fromProperty} output is consumed \u2014 only the done and failure chains and the Error value are translated in this slice`
         };
       }
     }
@@ -247850,6 +248920,8 @@ ${body}
     }
     const chain = doneChainOf(node);
     if ("defer" in chain) return { defer: chain.defer };
+    const failChain = verbFailChainOf(node);
+    if ("defer" in failChain) return { defer: failChain.defer };
     const call5 = { nodeId: node.id, verb: spec.verb, fnName: spec.fnName };
     if (spec.columns === true) {
       call5.writes = columns.map(({ key: key2, expr }) => {
@@ -247874,11 +248946,12 @@ ${body}
         guardId: false,
         errorState: verbErrorStateOf(node).name,
         ...spec.clearsErrorOnDone === true ? { clearErrorOnDone: true } : {},
-        then: chain.then
+        then: chain.then,
+        failThen: failChain.then
       },
-      consumes: [...consumes, ...chain.consumes, ...ctx.consumes],
-      collapses: [...ctx.logicNodeIds, ...chain.collapses],
-      subscribes: [...ctx.subscriberIds, ...chain.subscribes]
+      consumes: [...consumes, ...chain.consumes, ...failChain.consumes, ...ctx.consumes],
+      collapses: [...ctx.logicNodeIds, ...chain.collapses, ...failChain.collapses],
+      subscribes: [...ctx.subscriberIds, ...chain.subscribes, ...failChain.subscribes]
     };
   };
   const compileHttpFetch = (node) => {
@@ -247930,7 +249003,7 @@ ${body}
     const ctx = newCtx();
     const args = [];
     const takenParams = /* @__PURE__ */ new Set();
-    const valueOf = (port5, name, paramBase) => {
+    const valueOf2 = (port5, name, paramBase) => {
       const wires = component.connections.filter((c) => c.toId === node.id && c.toProperty === port5);
       if (wires.length > 1) {
         return { defer: `two wires feed ${port5} \u2014 last-writer-wins is not statically ordered` };
@@ -247957,7 +249030,7 @@ ${body}
     const stringList = (param) => String(literalParam(node, param) ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
     const collect3 = (names3, portPrefix, paramPrefix, into) => {
       for (const name of names3) {
-        const value = valueOf(`${portPrefix}${name}`, name, `${paramPrefix}${pascalCase2(name.replace(/[^A-Za-z0-9]+/g, " "))}`);
+        const value = valueOf2(`${portPrefix}${name}`, name, `${paramPrefix}${pascalCase2(name.replace(/[^A-Za-z0-9]+/g, " "))}`);
         if (isDefer(value)) return value;
         if (value !== null) into.push(value);
       }
@@ -247979,7 +249052,7 @@ ${body}
     if (["POST", "PUT", "PATCH"].includes(method)) {
       const bodyType = String(literalParam(node, "bodyType") ?? "json");
       if (bodyType === "raw") {
-        const raw = valueOf("body-raw", "raw", "bodyRaw");
+        const raw = valueOf2("body-raw", "raw", "bodyRaw");
         if (isDefer(raw)) return raw;
         if (raw !== null) body = { type: "raw", raw };
       } else if (bodyType === "json" || bodyType === "form" || bodyType === "urlencoded") {
@@ -247994,19 +249067,19 @@ ${body}
     let auth = null;
     const authType = String(literalParam(node, "authType") ?? "none");
     if (authType === "bearer") {
-      const token = valueOf("auth-authToken", "authToken", "authToken");
+      const token = valueOf2("auth-authToken", "authToken", "authToken");
       if (isDefer(token)) return token;
       if (token !== null) auth = { kind: "bearer", token };
     } else if (authType === "basic") {
-      const username = valueOf("auth-authUsername", "authUsername", "authUsername");
+      const username = valueOf2("auth-authUsername", "authUsername", "authUsername");
       if (isDefer(username)) return username;
-      const password = valueOf("auth-authPassword", "authPassword", "authPassword");
+      const password = valueOf2("auth-authPassword", "authPassword", "authPassword");
       if (isDefer(password)) return password;
       if (username !== null && password !== null) auth = { kind: "basic", username, password };
     } else if (authType === "apiKey") {
-      const name = valueOf("auth-authApiKeyName", "authApiKeyName", "authKeyName");
+      const name = valueOf2("auth-authApiKeyName", "authApiKeyName", "authKeyName");
       if (isDefer(name)) return name;
-      const value = valueOf("auth-authApiKeyValue", "authApiKeyValue", "authKeyValue");
+      const value = valueOf2("auth-authApiKeyValue", "authApiKeyValue", "authKeyValue");
       if (isDefer(value)) return value;
       if (name !== null && value !== null) {
         auth = {
@@ -248408,7 +249481,9 @@ ${body}
       answerLocal: names2.answerLocal,
       messageLocal: names2.messageLocal,
       idLocal: names2.idLocal,
-      reads
+      reads,
+      // With no backend the read is a stub that throws, the row is never set, and there is no client to hold a copy.
+      live: ir.project.cloudservices !== void 0 && literalParam(node, "runOnChange-record") !== false
     });
     return {
       action: {
@@ -248428,6 +249503,16 @@ ${body}
       subscribes: [...ctx.subscriberIds, ...chain.subscribes, ...failChain.subscribes]
     };
   };
+  const compileQueryFetch = (node) => {
+    const settings = querySettingsFor(node);
+    if ("refuse" in settings) return { defer: `the Query Records it fetches is not exported: ${settings.refuse}` };
+    return {
+      action: { kind: "query-fetch", nodeId: node.id, values: queryWirings.get(node.id)?.values ?? [] },
+      consumes: [],
+      collapses: [],
+      subscribes: []
+    };
+  };
   const fileOutputsRefusal = (node, valueOutputs, unchanged) => {
     for (const wire of component.connections.filter((c) => c.fromId === node.id)) {
       const p = wire.fromProperty;
@@ -249088,6 +250173,10 @@ ${body}
   const compileRouterNavigate = (node, page) => {
     const ctx = newCtx();
     const consumes = [];
+    if (wiredPorts.has(`${node.id}:openInNewTab`)) {
+      return { defer: "its Open In New Tab port is wired \u2014 whether it opens a tab or navigates in place is a runtime value" };
+    }
+    const newTab = literalParam(node, "openInNewTab") === true;
     const values = /* @__PURE__ */ new Map();
     for (const param of node.parameters) {
       if (!param.name.startsWith("pm-")) continue;
@@ -249117,7 +250206,7 @@ ${body}
     }
     const query2 = Array.from(values, ([name, expr]) => ({ name, expr }));
     return {
-      action: { kind: "navigate", to: page.urlPath, pathParams, query: query2 },
+      action: { kind: "navigate", to: page.urlPath, pathParams, query: query2, ...newTab ? { newTab: true } : {} },
       consumes: [...consumes, ...ctx.consumes],
       collapses: ctx.logicNodeIds,
       subscribes: ctx.subscriberIds
@@ -249216,7 +250305,7 @@ ${body}
     const level = LOG_LEVELS.includes(String(authoredLevel)) ? authoredLevel : "info";
     const ctx = newCtx();
     const consumes = [];
-    const valueOf = (port5) => {
+    const valueOf2 = (port5) => {
       const wires = component.connections.filter((c) => c.toId === node.id && c.toProperty === port5);
       if (wires.length > 1) return { defer: `two wires feed its ${port5} input \u2014 last-writer-wins is not statically ordered` };
       if (wires.length === 1) {
@@ -249231,9 +250320,9 @@ ${body}
       const literal2 = literalParam(node, port5);
       return literal2 === void 0 ? void 0 : { kind: "literal", value: literal2 };
     };
-    const message2 = valueOf("message");
+    const message2 = valueOf2("message");
     if (isDefer(message2)) return message2;
-    const data = valueOf("data");
+    const data = valueOf2("data");
     if (isDefer(data)) return data;
     const done = doneChainOf(node, "done");
     if ("defer" in done) return { defer: done.defer };
@@ -249822,6 +250911,10 @@ ${body}
     for (const key2 of consumes) consumed.add(key2);
     for (const id of collapses) dispositions[id] = { kind: "collapsed", into };
     for (const id of subscribes) boundSubscribers.add(id);
+    const errorPort = outputPorts.find((p) => p.name === contract.error);
+    if (errorPort !== void 0) {
+      notes.push(`node ${node.id} (${RUN_TASKS_TYPE}): a failed task is reported without its Template's "${contract.error}" output \u2014 the runtime puts that value in the run-tasks/task-failed error, and the exported host has no value channel from a task`);
+    }
     return core;
   };
   const compileRunTasks = (node, port5) => {
@@ -250204,12 +251297,14 @@ ${body}
       if (!Array.isArray(snapped)) return refuse(snapped.defer);
       arrive2 = snapped;
     }
+    const castToNumber = ["duration", "delay"].filter((input) => exprTsType(input === "duration" ? duration3 : delay) !== "number");
     const registered = {
       nodeId: node.id,
       local: mintLocal(animateLocals, node, "Animated", ""),
       target,
       duration: duration3,
       delay,
+      ...castToNumber.length > 0 ? { castToNumber: [...castToNumber] } : {},
       ease: easeParam,
       ...arrive2 !== void 0 ? { arrive: arrive2 } : {},
       comment: `${node.authoredLabel ?? "Animate To Value"} \u2014 moves towards its Target Value over Duration after Delay (animate-to-value.ts); the first target is adopted outright.`
@@ -250270,7 +251365,7 @@ ${body}
         consumes.push(wire.key);
       }
     }
-    const valueOf = (port5) => {
+    const valueOf2 = (port5) => {
       let expr;
       const authored = node.parameters.find((param) => param.name === port5);
       if (authored?.value.kind === "literal") expr = { kind: "literal", value: authored.value.value };
@@ -250295,7 +251390,7 @@ ${body}
       }
       let expr = resolvedParams.get(name);
       if (expr === void 0) {
-        const resolved = valueOf(`p-${name}`);
+        const resolved = valueOf2(`p-${name}`);
         if (isDefer(resolved)) return { defer: resolved.defer };
         expr = resolved ?? { kind: "literal", value: "" };
         resolvedParams.set(name, expr);
@@ -250306,7 +251401,7 @@ ${body}
     const query2 = [];
     if (typeof authoredQueryNames === "string" && authoredQueryNames !== "") {
       for (const name of authoredQueryNames.split(",")) {
-        const resolved = valueOf(`q-${name}`);
+        const resolved = valueOf2(`q-${name}`);
         if (isDefer(resolved)) return { defer: resolved.defer };
         if (resolved === void 0) continue;
         query2.push({ name, expr: resolved, omittable: maybeUndefinedExpr(resolved) });
@@ -250423,7 +251518,10 @@ ${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 = component.connections.find((c) => c.toId === node.id && c.toProperty === "value");
+      const wire2 = lastValueWireOf(node);
+      if (wire2 === void 0 && valueWiresInto(node).length > 1) {
+        return { defer: "two wires feed its Value input \u2014 last-writer-wins is not statically ordered" };
+      }
       if (!wire2) {
         const authored = literalParam(node, "value");
         if (authored === void 0) return { defer: "nothing is wired into value" };
@@ -250492,6 +251590,7 @@ ${body}
     if (node.type === HTTP_TYPE) return compileHttpFetch(node);
     if (node.type === CLOUD_FUNCTION_TYPE2) return compileCloudCall(node);
     if (node.type === RECORD_TYPE) return compileRecordFetch(node);
+    if (node.type === "DbCollection2") return compileQueryFetch(node);
     if (node.type === FILE_PICKER_TYPE) return compileFilePick(node);
     if (node.type === UPLOAD_FILE_TYPE) return compileFileUpload(node);
     if (node.type === SIGN_FILE_URL_TYPE) return compileFileSign(node);
@@ -250505,13 +251604,16 @@ ${body}
     const variableName = variableNameOf(node);
     if (variableName === void 0) return { defer: "variable name is not a literal" };
     const setWith = literalParam(node, "setWith");
-    const wire = component.connections.find((c) => c.toId === node.id && c.toProperty === "value");
+    const wire = lastValueWireOf(node);
     if (setWith === "object" || setWith === "array") {
       return { defer: `setWith "${String(setWith)}" conversion is not translated in step 5` };
     }
     if (setWith === "emptyString") {
       return { action: { kind: "store-set", variableName, expr: { kind: "literal", value: "" } }, consumes: wire ? [wire.key] : [], collapses: [], subscribes: [] };
     }
+    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 (setWith === "boolean" && wire) {
       return { defer: `setWith "boolean" conversion is not translated in step 5` };
     }
@@ -250694,10 +251796,17 @@ ${body}
     return compileConditionBranch(node);
   };
   const compileConditionBranch = (node) => {
+    const snapshotVerdict = snapshotVerdicts().get(node.id);
+    const snapshotWires = snapshotVerdict === null ? snapshotWiresOf(node) : [];
     const stray = component.connections.find(
-      (c) => c.fromId === node.id && c.fromProperty !== "ontrue" && c.fromProperty !== "onfalse"
+      (c) => c.fromId === node.id && c.fromProperty !== "ontrue" && c.fromProperty !== "onfalse" && !snapshotWires.includes(c)
     );
-    if (stray) return { defer: `its ${stray.fromProperty} output drives logic this slice does not translate` };
+    if (stray) {
+      const valueOut = stray.fromProperty === "result" || stray.fromProperty === "isfalse";
+      return {
+        defer: valueOut && typeof snapshotVerdict === "string" ? snapshotVerdict : `its ${stray.fromProperty} output drives logic this slice does not translate`
+      };
+    }
     const ctx = newCtx();
     let cond;
     const condWire = component.connections.find((c) => c.toId === node.id && c.toProperty === "condition");
@@ -250748,6 +251857,25 @@ ${body}
     if ("defer" in whenTrue) return whenTrue;
     const whenFalse = arm("onfalse");
     if ("defer" in whenFalse) return whenFalse;
+    if (snapshotWires.length > 0) {
+      const writes = (answer3) => snapshotWires.map((w) => ({
+        kind: "state-set",
+        name: snapshotCellOf(w.toId, w.toProperty).name,
+        expr: { kind: "literal", value: w.fromProperty === "result" ? answer3 : !answer3 }
+      }));
+      const truth = truthyExpr(cond);
+      if (truth.kind === "literal") {
+        const side = [...writes(truth.value === true), ...truth.value === true ? whenTrue : whenFalse];
+        const action = side.length === 1 ? side[0] : { kind: "branch", cond: { kind: "literal", value: true }, whenTrue: side, whenFalse: [], flat: true };
+        return { action, consumes, collapses, subscribes };
+      }
+      return {
+        action: { kind: "branch", cond, whenTrue: [...writes(true), ...whenTrue], whenFalse: [...writes(false), ...whenFalse] },
+        consumes,
+        collapses,
+        subscribes
+      };
+    }
     if (whenTrue.length === 0 && whenFalse.length === 0) {
       return { defer: "neither branch drives a translatable action" };
     }
@@ -250758,14 +251886,35 @@ ${body}
   const recordEffectDefers = /* @__PURE__ */ new Map();
   const compiling = /* @__PURE__ */ new Set();
   const compiledOf = (node, port5) => {
-    const key2 = `${node.id}:${port5}`;
-    const cached3 = compiledSinks.get(key2);
-    if (cached3 !== void 0) return cached3;
+    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 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) => {
+      if ("defer" in result2 || scoped.length === 0) return false;
+      const rows = form === "row" ? new Set(scoped.map((id) => verbErrorVars.get(id)?.name).filter((n) => n !== void 0)) : void 0;
+      let found2 = false;
+      const visit = (value) => {
+        if (found2 || value === null || typeof value !== "object") return;
+        if (Array.isArray(value)) return value.forEach(visit);
+        const v = value;
+        if (form === "local" && v.kind === "outcome-error" && v.viaState === void 0 && scoped.includes(v.nodeId)) found2 = true;
+        if (form === "row" && v.kind === "state-get" && rows.has(v.name)) found2 = true;
+        for (const child of Object.values(value)) visit(child);
+      };
+      visit(result2.action);
+      return found2;
+    };
+    const cachedScoped = scopeKey !== void 0 ? compiledSinks.get(scopeKey) : void 0;
+    if (cachedScoped !== void 0) return cachedScoped;
+    const cached3 = compiledSinks.get(plainKey);
+    if (cached3 !== void 0 && !readsScoped(cached3, "row")) return cached3;
+    const key2 = scopeKey !== void 0 && (cached3 !== void 0 || compiling.has(plainKey)) ? scopeKey : plainKey;
     if (compiling.has(key2)) return { defer: "its trigger chain is cyclic" };
     compiling.add(key2);
     const result = compileSink(node, port5);
     compiling.delete(key2);
-    compiledSinks.set(key2, result);
+    compiledSinks.set(key2 === plainKey && readsScoped(result, "local") ? scopeKey : key2, result);
     return result;
   };
   const exprValidIn = (expr, context, invokedScope) => {
@@ -250947,7 +252096,7 @@ ${body}
       case "api-call":
         return action.args.every(
           (arg) => arg.kind === "expr" ? exprValidIn(arg.expr, context, invokedScope) : arg.props.every((p) => exprValidIn(p.expr, context, invokedScope))
-        ) && actionsValidIn(action.then, context, invokedScope);
+        ) && actionsValidIn(action.then, context, invokedScope) && actionsValidIn(action.failThen, context, invokedScope);
       case "jsfun-run": {
         const def = plan.jsFunctions[action.nodeId];
         if (def === void 0) return false;
@@ -251069,6 +252218,13 @@ ${body}
         return exprValidIn(action.items, context, invokedScope);
       case "runtasks-abort":
         return true;
+      // P18-S116-QUERYFETCH. The wired filter values are read at the pulse, in the handler that pulses.
+      case "query-fetch":
+        return action.values.every((v) => exprValidIn(v.expr, context, invokedScope));
+      // EXP-011 §86. A run's pulse loop and its arms sit inside the run's own `then`, so its scope already holds the node.
+      case "jsfun-pulses":
+      case "jsfun-pulse":
+        return actionsValidIn(action.then, context, invokedScope);
       // EXP-011 §58. The data is read at the pulse, in the handler that pulses; the listeners are validated where they compile.
       case "stream-action":
         return action.value === void 0 || exprValidIn(action.value, context, invokedScope);
@@ -251150,6 +252306,9 @@ ${body}
         );
         return !firedByOwnChange;
       }
+      if (sink.type === JS_FUNCTION && c.toProperty.startsWith("in-")) {
+        return component.connections.some((w) => w.toId === sink.id && w.toProperty === "run" && w.fromId !== node.id);
+      }
       return rendered2.has(sink.id) && !isTriggerInto(sink, c.toProperty);
     });
     if (!stateWired && !actionWired && !outputRead) continue;
@@ -251301,7 +252460,8 @@ ${body}
       }
       consumed.add(wire.key);
       stateLandedKeys.add(wire.key);
-      plan.pushEffects.push({ prop: vp.prop, expr });
+      const pushedType = exprTsType(expr);
+      plan.pushEffects.push({ prop: vp.prop, expr, ...vp.tsType !== "any" && pushedType !== vp.tsType ? { castTo: vp.tsType } : {} });
       plan.liftedOutputProps.push({ port: port5, prop: vp.prop, tsType: vp.tsType });
       for (const k of ctx.consumes) consumed.add(k);
       for (const s of ctx.subscriberIds) boundSubscribers.add(s);
@@ -251565,8 +252725,60 @@ ${body}
       if ("defer" in r) return r;
       out.push(r);
     }
+    const late2 = lateQueryFetchWrite(out);
+    if (late2 !== void 0) return { defer: late2 };
     return out;
   }
+  function lateQueryFetchWrite(actions) {
+    const writes = (a8) => a8.kind === "store-set" ? `store:${a8.variableName}` : a8.kind === "globalstore-set" ? `key:${a8.storeName}:${a8.key}` : a8.kind === "state-set" ? `state:${a8.name}` : void 0;
+    const reads = (e, into) => {
+      if (e.kind === "store-get") into.add(`store:${e.variableName}`);
+      else if (e.kind === "store-key-get") into.add(`key:${e.storeName}:${e.key}`);
+      else if (e.kind === "state-get") into.add(`state:${e.name}`);
+      else if (e.kind === "format") e.parts.forEach((p) => typeof p !== "string" && reads(p, into));
+      else if (e.kind === "logical") e.operands.forEach((o) => reads(o, into));
+      else if (e.kind === "not" || e.kind === "truthy") reads(e.operand, into);
+      return into;
+    };
+    for (const [i, a8] of actions.entries()) {
+      if (a8.kind !== "query-fetch") continue;
+      for (const v of a8.values) {
+        const read2 = reads(v.expr, /* @__PURE__ */ new Set());
+        if (actions.slice(i + 1).some((b) => read2.has(writes(b) ?? ""))) {
+          return `its Fetch is sent before the chain writes "${v.name}", which its Filter reads \u2014 the runtime fetches after the pulse's writes (scheduleFetch), and that order is not exported in this slice`;
+        }
+      }
+    }
+    for (const [i, a8] of actions.entries()) {
+      if (!isAwaitedAction(a8)) continue;
+      const sent2 = /* @__PURE__ */ new Set();
+      const collect3 = (value, top) => {
+        if (value === null || typeof value !== "object") return;
+        if (Array.isArray(value)) return value.forEach((v) => collect3(v, false));
+        const kind = value.kind;
+        if (!top && typeof kind === "string" && (kind === "store-get" || kind === "store-key-get" || kind === "state-get")) {
+          reads(value, sent2);
+          return;
+        }
+        for (const [key2, child] of Object.entries(value)) if (!/Then$|^then$/.test(key2)) collect3(child, false);
+      };
+      collect3(a8, true);
+      const laterWrites = /* @__PURE__ */ new Map();
+      const writtenIn = (b) => {
+        if (b === null || typeof b !== "object") return;
+        if (Array.isArray(b)) return b.forEach(writtenIn);
+        const key2 = writes(b);
+        if (key2 !== void 0 && !laterWrites.has(key2)) laterWrites.set(key2, key2.split(":").pop() ?? key2);
+        for (const child of Object.values(b)) writtenIn(child);
+      };
+      writtenIn(actions.slice(i + 1));
+      const clash = [...sent2].find((k) => laterWrites.has(k));
+      if (clash !== void 0) {
+        return `its node sends "${laterWrites.get(clash)}" after the click's later wires have written it \u2014 the runtime reads what it sends after the update, the export where the call starts, and that order is not exported in this slice`;
+      }
+    }
+    return void 0;
+  }
   function snapAction(action, snap2) {
     switch (action.kind) {
       case "state-set": {
@@ -251719,7 +252931,9 @@ ${body}
         }
         const then2 = snapActionList(action.then, snap2);
         if (!Array.isArray(then2)) return then2;
-        return { ...action, args, then: then2 };
+        const failThen = snapActionList(action.failThen, snap2);
+        if (!Array.isArray(failThen)) return failThen;
+        return { ...action, args, then: then2, failThen };
       }
       // Same rule for a request (EXP-011 Tier 1.2): the values it sends are read where the
       // handler is, before the await, so a `Set Variable` earlier in the chain must reach them —
@@ -251795,6 +253009,16 @@ ${body}
       }
       case "runtasks-abort":
         return action;
+      // P18-S116-QUERYFETCH. A value the chain wrote a statement earlier is read as written, as `stream-action`'s.
+      case "query-fetch": {
+        const values = [];
+        for (const v of action.values) {
+          const expr = snapExpr(v.expr, snap2);
+          if ("defer" in expr) return expr;
+          values.push({ name: v.name, expr });
+        }
+        return { ...action, values };
+      }
       case "jsfun-run": {
         if ((plan.jsFunctions[action.nodeId]?.inputs ?? []).some((i) => i.expr !== void 0 && exprTouchesSnap(i.expr, snap2))) {
           return { defer: "a Function argument reads state written earlier in this chain \u2014 not translated in this slice" };
@@ -251803,6 +253027,13 @@ ${body}
         if (!Array.isArray(then2)) return then2;
         return { ...action, then: then2 };
       }
+      // EXP-011 §86. The arms run in the run's closure, after the body: a write earlier in the chain reaches them.
+      case "jsfun-pulses":
+      case "jsfun-pulse": {
+        const then2 = snapActionList(action.then, snap2);
+        if (!Array.isArray(then2)) return then2;
+        return { ...action, then: then2 };
+      }
       /**
        * EXP-011 Tier 2.5. Same rule as a request: the link is read where the handler is, before
        * the browser is touched, so a `Set Variable` earlier in the chain must reach it — and both
@@ -251942,7 +253173,22 @@ ${body}
         return action;
     }
   }
+  const feedersCompiled = /* @__PURE__ */ new Set();
+  const compileFunctionFeedersOf = (node) => {
+    if (feedersCompiled.has(node.id)) return;
+    feedersCompiled.add(node.id);
+    for (const c of component.connections) {
+      if (c.toId !== node.id || !c.fromProperty.startsWith("out-")) continue;
+      const from = nodeById.get(c.fromId);
+      if (!from || jsNodeKindOf(from.type) !== "function" || !wiredPorts.has(`${from.id}:run`)) continue;
+      const runs = component.connections.filter((w) => w.toId === from.id && w.toProperty === "run");
+      if (!runs.every((w) => w.fromProperty === "didMount" || rendered2.has(w.fromId))) continue;
+      compileFunctionFeedersOf(from);
+      compiledOf(from, "run");
+    }
+  };
   for (const node of component.nodes) {
+    compileFunctionFeedersOf(node);
     if (TRIGGER_PORTS[node.type] !== void 0) compiledOf(node, TRIGGER_PORTS[node.type]);
     else if (node.type === "NavigationShowPopup") compiledOf(node, "show");
     else if (node.type === "NavigationClosePopup") {
@@ -252163,6 +253409,16 @@ ${body}
     }
   }
   const receiverActions = /* @__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));
+    for (const key2 of compiled2.consumes) consumed.add(key2);
+    if (outputsSink) return;
+    if (dispositions[toNode.id] === void 0) dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
+    for (const id of compiled2.collapses ?? []) {
+      if (dispositions[id] === void 0) dispositions[id] = { kind: "deferred", to: "EXP-003", reason: reason2 };
+    }
+  };
   for (const connection of component.connections) {
     if (consumed.has(connection.key)) continue;
     const toNode = nodeById.get(connection.toId);
@@ -252173,6 +253429,7 @@ ${body}
     if (fromNode?.type === "Condition" && (connection.fromProperty === "ontrue" || connection.fromProperty === "onfalse")) {
       continue;
     }
+    if (pageMountFetch(connection)) continue;
     if ((fromNode?.type === "NavigationShowPopup" || fromNode?.type === "NavigationClosePopup") && connection.fromProperty === "done") {
       continue;
     }
@@ -252217,6 +253474,11 @@ ${body}
       continue;
     }
     if (fromNode && rendered2.has(fromNode.id) && isTextInputType(fromNode.type) && connection.fromProperty === "textChanged") {
+      const unreached = unreachedOwnerOf(connection);
+      if (unreached !== void 0) {
+        refuseUnreached(connection, toNode, compiled2, unreached, outputsSink);
+        continue;
+      }
       if (!actionsValidIn([compiled2.action], { kind: "dom", nodeId: fromNode.id, port: "textChanged" })) {
         const reason2 = "the action reads values that only exist in another handler";
         if (outputsSink) {
@@ -252249,6 +253511,11 @@ ${body}
     const customSignal = fromNode !== void 0 && plan.roleOf[fromNode.id] === "custom" && customSignalOutputs(fromNode).has(connection.fromProperty);
     const repeaterRowSignal = fromNode !== void 0 && fromNode.type === "For Each" && connection.fromProperty.startsWith(ITEM_OUTPUT_SIGNAL);
     if (fromNode && rendered2.has(fromNode.id) && (connection.kind === "signal" || instanceSignal || customSignal || repeaterRowSignal)) {
+      const unreached = unreachedOwnerOf(connection);
+      if (unreached !== void 0) {
+        refuseUnreached(connection, toNode, compiled2, unreached, outputsSink);
+        continue;
+      }
       if (!actionsValidIn([compiled2.action], { kind: "dom", nodeId: fromNode.id, port: connection.fromProperty })) {
         const reason2 = "the action reads values that only exist in another handler";
         if (outputsSink) {
@@ -252264,6 +253531,12 @@ ${body}
         compiled2.action,
         chainSnapshotFor(`dom:${fromNode.id}:${connection.fromProperty}`, seedId)
       );
+      const lateWrite = "defer" in snapped ? void 0 : lateQueryFetchWrite([...plan.handlers[fromNode.id]?.[connection.fromProperty] ?? [], snapped]);
+      if (lateWrite !== void 0) {
+        dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: lateWrite };
+        notes.push(wireNote(connection, lateWrite));
+        continue;
+      }
       if ("defer" in snapped) {
         if (outputsSink) {
           if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, snapped.defer);
@@ -252300,6 +253573,12 @@ ${body}
         continue;
       }
       const snappedRecv = snapAction(compiled2.action, chainSnapshotFor(`recv:${fromNode.id}`));
+      const lateRecvWrite = "defer" in snappedRecv ? void 0 : lateQueryFetchWrite([...receiverActions.get(fromNode.id) ?? [], snappedRecv]);
+      if (lateRecvWrite !== void 0) {
+        dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: lateRecvWrite };
+        notes.push(wireNote(connection, lateRecvWrite));
+        continue;
+      }
       if ("defer" in snappedRecv) {
         if (outputsSink) {
           if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, snappedRecv.defer);
@@ -252316,13 +253595,15 @@ ${body}
       for (const id of compiled2.subscribes ?? []) boundSubscribers.add(id);
       continue;
     }
-    const untranslatable = `trigger ${connection.fromId}.${connection.fromProperty} is not a rendered element event or a receiver`;
+    const sendingRun = fromNode !== void 0 && wiredPorts.has(`${fromNode.id}:run`) ? compiledSinks.get(`${fromNode.id}:run`) : void 0;
+    const pulseRefusal = fromNode !== void 0 && jsNodeKindOf(fromNode.type) === "function" ? pulseRefusals.get(`${fromNode.id}:${connection.fromProperty}`) ?? pulseRefusals.get(fromNode.id) ?? (sendingRun !== void 0 && "defer" in sendingRun && connection.fromProperty.startsWith("out-") ? `the Function that sends its "${connection.fromProperty.slice("out-".length)}" signal is not exported: ${sendingRun.defer}` : void 0) : void 0;
+    const untranslatable = pulseRefusal ?? `trigger ${connection.fromId}.${connection.fromProperty} is not a rendered element event or a receiver`;
     if (outputsSink) {
       if (!failedOutputsNodes.has(toNode.id)) failedOutputsNodes.set(toNode.id, untranslatable);
     } else {
       dispositions[toNode.id] = { kind: "deferred", to: "EXP-003", reason: untranslatable };
     }
-    notes.push(wireNote(connection, `the trigger is not a rendered element event or a receiver`));
+    notes.push(wireNote(connection, pulseRefusal ?? `the trigger is not a rendered element event or a receiver`));
   }
   for (const node of component.nodes) {
     if (node.type !== "Component Outputs" || dispositions[node.id] !== void 0) continue;
@@ -252378,6 +253659,7 @@ ${body}
         } else if (action.kind === "api-call") {
           attachedMutations.add(action.nodeId);
           scanActions(action.then);
+          scanActions(action.failThen);
         } else if (action.kind === "http-call") {
           attachedHttpNodes.add(action.nodeId);
           scanActions(action.then);
@@ -252452,6 +253734,8 @@ ${body}
           scanActions(action.minted?.failThen ?? []);
         } else if (action.kind === "array-new") {
           scanActions(action.then);
+        } else if (action.kind === "jsfun-run" || action.kind === "jsfun-pulses" || action.kind === "jsfun-pulse") {
+          scanActions(action.then);
         }
       }
     };
@@ -252605,6 +253889,22 @@ ${body}
       for (const key2 of [inputs[0].key, ...ctx.consumes, ...chain.consumes]) consumed.add(key2);
       for (const id of [...ctx.subscriberIds, ...chain.subscribes]) boundSubscribers.add(id);
     }
+    for (const node of component.nodes) {
+      const pieces = tickedRunPieces.get(node.id);
+      if (pieces === void 0 || dispositions[node.id]?.kind !== "collapsed" || !plan.file) continue;
+      const snapped = snapAction(pieces.action, chainSnapshotFor(`ticked:${node.id}`));
+      if ("defer" in snapped) {
+        dispositions[node.id] = { kind: "deferred", to: "EXP-003", reason: `the run a ticked input starts: ${snapped.defer}` };
+        notes.push(`node ${node.id} (${node.type}) deferred: the run a ticked input starts: ${snapped.defer}`);
+        continue;
+      }
+      plan.tickedRuns.push({
+        nodeId: node.id,
+        watch: pieces.watch,
+        action: snapped,
+        comment: `${node.authoredLabel ?? node.type} \u2014 also runs when a ticked input gets a new value, sending its signals and never Done (NDA-017 \xA72).`
+      });
+    }
     for (const node of component.nodes) {
       if (node.type !== "Condition" || dispositions[node.id] !== void 0) continue;
       if (literalParam(node, "runOnChange-condition") === false) continue;
@@ -252645,6 +253945,11 @@ ${body}
     for (const node of component.nodes) {
       if (node.type !== RECORD_TYPE || dispositions[node.id] !== void 0) continue;
       if (wiredPorts.has(`${node.id}:fetch`)) continue;
+      const refusal2 = recordBindRefusal(node);
+      if (refusal2 !== void 0) {
+        recordEffectDefers.set(node.id, refusal2);
+        continue;
+      }
       if (!plan.file) {
         recordEffectDefers.set(node.id, "component emits no file to host the effect");
         continue;
@@ -252666,9 +253971,13 @@ ${body}
       const into = `src/${plan.file.dir}/${plan.file.fileBase}.tsx`;
       plan.recordEffects.push({
         nodeId: node.id,
-        action: snapped.kind === "record-fetch" ? { ...snapped, viaEffect: true } : snapped,
-        comment: `${node.authoredLabel ?? "Record"} \u2014 read again whenever its Id changes (dbmodelnode2.ts runOnValueChange).`
+        action: snapped,
+        comment: `${node.authoredLabel ?? "Record"} \u2014 bound to the app's copy of the record its Id names, whenever the Id changes; binding reads nothing (dbmodelnode2.ts setModelID).`,
+        held: ir.project.cloudservices !== void 0,
+        follows: literalParam(node, "runOnChange-record") !== false
       });
+      const read2 = plan.recordReads.find((r) => r.nodeId === node.id);
+      if (read2 !== void 0) read2.binds = true;
       dispositions[node.id] = { kind: "collapsed", into };
       for (const id of compiled2.collapses ?? []) dispositions[id] = { kind: "collapsed", into };
       for (const key2 of compiled2.consumes) consumed.add(key2);
@@ -252676,6 +253985,7 @@ ${body}
     }
     for (const effect of plan.branchEffects) scanActions([effect.action]);
     for (const effect of plan.valueChangedEffects) scanActions(effect.actions);
+    for (const ticked3 of plan.tickedRuns) scanActions([ticked3.action]);
     for (const effect of plan.recordEffects) scanActions([effect.action]);
     for (const machine of plan.statesMachines) for (const chain of statesListenerChains(machine)) scanActions(chain);
     for (const drag of plan.drags) for (const chain of dragListenerChains(drag)) scanActions(chain);
@@ -252783,6 +254093,10 @@ ${body}
       notes.push(wireNote(connection, `variable name is not a literal`));
       continue;
     }
+    if (literalParam(fromNode, "runOnChange-variable") === false) {
+      notes.push(wireNote(connection, VARIABLE_FROZEN));
+      continue;
+    }
     if (connection.toProperty === "mounted" && toNode.id === plan.rootId) {
       notes.push(wireNote(connection, `a mounted wire into the component root is a router concern \u2014 not translated in this slice`));
       continue;
@@ -252842,6 +254156,19 @@ ${body}
     const toNode = nodeById.get(connection.toId);
     if (!toNode || !rendered2.has(toNode.id)) continue;
     consumed.add(connection.key);
+    const snapshotVerdict = fromNode.type === "Condition" ? snapshotVerdicts().get(fromNode.id) : void 0;
+    if (snapshotVerdict === null) {
+      plan.bindings[toNode.id] = plan.bindings[toNode.id] ?? {};
+      plan.bindings[toNode.id][connection.toProperty] = {
+        kind: "computed",
+        expr: { kind: "state-get", name: snapshotCellOf(toNode.id, connection.toProperty).name }
+      };
+      continue;
+    }
+    if (snapshotVerdict !== void 0) {
+      notes.push(wireNote(connection, snapshotVerdict));
+      continue;
+    }
     const ctx = newCtx();
     const expr = resolveExpr(fromNode, connection.fromProperty, ctx);
     if (expr === null) {
@@ -252925,6 +254252,12 @@ ${body}
     styleSinkOf(toNode, connection.toProperty) !== void 0;
     if (!bindable) continue;
     if (connection.toProperty === "mounted" && toNode.id === plan.rootId) continue;
+    const deadRow = excluded.rows.get(fromNode.id);
+    if (deadRow !== void 0) {
+      consumed.add(connection.key);
+      notes.push(wireNote(connection, deadRow));
+      continue;
+    }
     const ctx = newCtx();
     const expr = resolveExpr(fromNode, connection.fromProperty, ctx);
     if (expr === null) continue;
@@ -253136,6 +254469,12 @@ ${body}
       continue;
     }
     if (toNode?.type === "For Each" && connection.toProperty === "items" && fromNode?.type === "DbCollection2" && plan.repeaters[toNode.id]) {
+      const settings = querySettingsFor(fromNode);
+      if ("refuse" in settings) {
+        consumed.add(connection.key);
+        notes.push(wireNote(connection, `the Query Records it reads is not exported: ${settings.refuse}`));
+        continue;
+      }
       plan.repeaters[toNode.id].itemsQueryId = fromNode.id;
       consumed.add(connection.key);
       continue;
@@ -253454,6 +254793,7 @@ ${body}
               else for (const p of arg.props) walkExpr(p.expr);
             }
             walkActions(action.then);
+            walkActions(action.failThen);
             break;
           // A session read is at its most ordinary inside a request — the signed-in user's id in
           // a path parameter, their token in a header. Missing it here would leave the page
@@ -253562,6 +254902,10 @@ ${body}
             break;
           case "runtasks-abort":
             break;
+          // P18-S116-QUERYFETCH. The wired filter values, read at the pulse.
+          case "query-fetch":
+            for (const v of action.values) walkExpr(v.expr);
+            break;
           // EXP-011 §58. The data read at the pulse; the config and listeners are walked off the plan below.
           case "stream-action":
             if (action.value !== void 0) walkExpr(action.value);
@@ -253574,6 +254918,8 @@ ${body}
           case "popup-show":
           case "popup-close":
           case "jsfun-run":
+          case "jsfun-pulses":
+          case "jsfun-pulse":
           // EXP-011 §30, and the same omission the sibling walker had: a session read inside an
           // array mutator's Done chain is as ordinary as one inside a request's, and missing it
           // here leaves the page importing a `useSession` the module never exported.
@@ -253603,6 +254949,11 @@ ${body}
       walkExpr(effect.watch);
       walkActions(effect.actions);
     }
+    for (const ticked3 of plan.tickedRuns) {
+      ticked3.watch.forEach(walkExpr);
+      walkActions([ticked3.action]);
+    }
+    for (const query2 of plan.queries) for (const value of query2.wiredValues ?? []) walkExpr(value.expr);
     for (const machine of plan.statesMachines) {
       if (machine.follow !== void 0) walkExpr(machine.follow);
       for (const chain of statesListenerChains(machine)) walkActions(chain);
@@ -253646,6 +254997,16 @@ ${body}
       if (dispositions[node.id]?.kind === "collapsed") delete dispositions[node.id];
     }
   }
+  for (const node of component.nodes) {
+    if (node.type !== "DbCollection2" || !queryLands(node)) continue;
+    for (const wire of component.connections) if (wire.toId === node.id && pageMountFetch(wire)) consumed.add(wire.key);
+    const wiring = queryWirings.get(node.id);
+    if (wiring === void 0) continue;
+    const into = plan.file ? `src/${plan.file.dir}/${plan.file.fileBase}.tsx` : plan.path;
+    for (const key2 of wiring.consumes) consumed.add(key2);
+    for (const id of wiring.collapses) dispositions[id] = { kind: "collapsed", into };
+    for (const id of wiring.subscribes) boundSubscribers.add(id);
+  }
   for (const connection of component.connections) {
     if (consumed.has(connection.key)) continue;
     const kitEndpoint = undeclaredKitPortOf(connection, nodeById, kits);
@@ -253675,6 +255036,54 @@ ${body}
       comment: `${label2} \u2014 its authored Value is stored on every mount of this component (variablenode2.ts: the value setter runs at node creation).`
     });
   }
+  {
+    const parentOf = parentMapOf(component);
+    for (const node of component.nodes) {
+      if (!isTextInputType(node.type) || !rendered2.has(node.id)) continue;
+      const stateVar = controlStateVars.get(node.id);
+      const chain = plan.changeHandlers[node.id] ?? [];
+      if (chain.length === 0) continue;
+      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;
+      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";
+          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");
+        continue;
+      }
+      const type = literalParam(node, "type");
+      if (wiredPorts.has(`${node.id}:type`) || type !== void 0 && typeof type !== "string") {
+        refuse("its Type is wired, so whether it announces text or a number is not known here");
+        continue;
+      }
+      if (type === "number") {
+        refuse("a Number field announces a number or null, and the exported field carries text (P18-S118-NUMBERFIELD)");
+        continue;
+      }
+      const sync = stateVar === void 0 ? void 0 : plan.syncEffects.find((e) => e.stateName === stateVar.name);
+      if (sync === void 0 && wiredPorts.has(`${node.id}:startValue`) && literalParam(node, "runOnChange-startValue") !== false) {
+        refuse("its Value is wired and the export does not carry that wire");
+        continue;
+      }
+      const authored = literalParam(node, "startValue");
+      const catalogDefault = node.catalogRef ? catalog2.inputDefault(node.catalogRef, "startValue") : void 0;
+      const raw = authored !== void 0 ? authored : typeof catalogDefault === "string" || typeof catalogDefault === "number" ? catalogDefault : void 0;
+      plan.fieldMounts.push({
+        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)).`
+      });
+    }
+  }
   for (const node of component.nodes) {
     if (node.type !== "Variable2" || dispositions[node.id] !== void 0) continue;
     if (variableNameOf(node) !== void 0) {
@@ -253747,9 +255156,13 @@ ${body}
   }
   for (const node of component.nodes) {
     if (node.type !== "DbCollection2") continue;
-    const consumedByRepeater = Object.values(plan.repeaters).some((r) => r.itemsQueryId === node.id);
-    const readByLandedTransform = queryReaders.has(node.id) && component.connections.some((c) => c.fromId === node.id && c.fromProperty === "items" && consumed.has(c.key));
-    if (!consumedByRepeater && !readByLandedTransform) {
+    const settings = querySettingsFor(node);
+    if ("refuse" in settings) {
+      plan.queries = plan.queries.filter((q) => q.nodeId !== node.id);
+      dispositions[node.id] = { kind: "deferred", to: "EXP-003", reason: settings.refuse };
+      continue;
+    }
+    if (!queryLands(node)) {
       plan.queries = plan.queries.filter((q) => q.nodeId !== node.id);
       dispositions[node.id] = {
         kind: "deferred",
@@ -253932,6 +255345,7 @@ ${body}
           // EXP-011 §53. Nothing nested on the action; the listeners are filled off the plan below.
           case "runtasks-run":
           case "runtasks-abort":
+          case "query-fetch":
             break;
           // EXP-011 §58. Nothing nested on the action; the listeners are filled off the plan below.
           case "stream-action":
@@ -254044,8 +255458,14 @@ ${body}
           case "popup-show":
           case "popup-close":
           case "jsfun-run":
+          case "jsfun-pulses":
+          case "jsfun-pulse":
+            fillMaterialize(action.then);
+            break;
+          // EXP-011 §90. Both chains.
           case "api-call":
             fillMaterialize(action.then);
+            fillMaterialize(action.failThen);
             break;
           default:
             break;
@@ -254057,6 +255477,7 @@ ${body}
     for (const receiver of plan.receivers) fillMaterialize(receiver.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]);
     for (const effect of plan.recordEffects) fillMaterialize([effect.action]);
     for (const machine of plan.statesMachines) for (const chain of statesListenerChains(machine)) fillMaterialize(chain);
     for (const drag of plan.drags) for (const chain of dragListenerChains(drag)) fillMaterialize(chain);
@@ -254069,6 +255490,22 @@ ${body}
     for (const stream of plan.streams) for (const chain of Object.values(stream.listeners)) fillMaterialize(chain);
     plan.screenResolutions = plan.screenResolutions.filter((s) => dispositions[s.nodeId]?.kind === "collapsed");
   }
+  {
+    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)) {
+        value.forEach((item, i) => {
+          if (i < value.length - 1 && isAwaitedAction(item)) item.detached = true;
+          visit(item);
+        });
+        return;
+      }
+      for (const child of Object.values(value)) visit(child);
+    };
+    visit(plan);
+  }
   for (const node of component.nodes) {
     if (node.type !== RUN_TASKS_TYPE || dispositions[node.id] !== void 0) continue;
     const dangling = component.connections.find((c) => c.fromId === node.id && RUN_TASKS_OUTPUTS.includes(c.fromProperty));
@@ -254712,7 +256149,7 @@ function kitFile(module2, bindings) {
       const prop = binding.propOf.get(input.name);
       if (prop === void 0) continue;
       if (input.displayName !== void 0) lines.push(`  /** ${escapeComment(input.displayName)} */`);
-      lines.push(`  ${prop}?: ${tsTypeOf2(input)};`);
+      lines.push(`  ${prop}?: ${inputTsTypeOf(input)};`);
     }
     for (const [port5, prop] of binding.signalPropOf) {
       lines.push(`  /** Signal output "${escapeComment(port5)}". */`);
@@ -254800,6 +256237,10 @@ function tsTypeOf2(port5) {
       return "unknown";
   }
 }
+function inputTsTypeOf(port5) {
+  const type = tsTypeOf2(port5);
+  return type === "Record<string, unknown>" ? "Record<string, unknown> | readonly unknown[]" : type;
+}
 function runtimeFile() {
   return GENERATED_TS2 + `/*
  * The custom-node bridge (EXP-010, Route B).
@@ -265371,6 +266812,108 @@ function signInLibSource() {
   ].join("\n");
 }
 
+// ../nodegx-export/src/emit/functionRunLib.ts
+var FUNCTION_RUN_LIB_PATH = "src/lib/functionRun.ts";
+function functionRunLibSource() {
+  return `/**
+ * A Function node's run, as the running app's Function node publishes it.
+ *
+ * The body writes \`Outputs.x = \u2026\` and sends \`Outputs.go()\`. A write is published only when the value changes, and a
+ * write of the value already held is published with the next signal. Each signal is a pulse its chain acts on after the
+ * body, reading the outputs in step with the pulse: the k-th pulse reads the k-th value published since the run began,
+ * or the last one when there are fewer, or what the output last sent when this run published nothing.
+ */
+
+/** One Function node's state, kept across runs as the running app's node keeps it. */
+export interface FunctionNode<O> {
+  /** The signal names its body may send. */
+  signals: readonly string[];
+  /** What each output holds: the last value written to it, in any run. */
+  outputs: Partial<O>;
+  /** What each output last sent down its wire. \`undefined\` is never sent, so a reader keeps the value before it. */
+  delivered: Partial<O>;
+}
+
+/** One signal the body sent, and the outputs as that pulse's chain reads them. */
+export interface FunctionPulse<O> {
+  signal: string;
+  values: Partial<O>;
+}
+
+export interface FunctionRun<O> {
+  /** The node's outputs after the run. */
+  outputs: Partial<O>;
+  /** Every signal the body sent, in the order it sent them. */
+  pulses: Array<FunctionPulse<O>>;
+}
+
+export function functionNode<O>(signals: readonly string[]): FunctionNode<O> {
+  return { signals, outputs: {}, delivered: {} };
+}
+
+export function runFunction<I, O>(body: (inputs: I, outputs: O) => unknown, inputs: I, node: FunctionNode<O>): FunctionRun<O> {
+  const current = node.outputs as Record<string, unknown>;
+  const delivered = node.delivered as Record<string, unknown>;
+  const before: Record<string, unknown> = { ...delivered };
+  const published: Record<string, unknown[]> = {};
+  const held = new Set<string>();
+  const sent: string[] = [];
+  const publish = (name: string, value: unknown) => {
+    if (value === undefined) return;
+    (published[name] = published[name] ?? []).push(value);
+    delivered[name] = value;
+  };
+  const signals: Record<string, unknown> = {};
+  for (const signal of node.signals) {
+    const send = () => {
+      held.forEach((name) => publish(name, current[name]));
+      held.clear();
+      sent.push(signal);
+    };
+    signals[signal] = Object.assign(send, { send });
+  }
+  const outputs = new Proxy(signals, {
+    get: (target, name) => (typeof name === 'string' && name in target ? target[name] : current[name as string]),
+    set: (_target, name, value) => {
+      const key = String(name);
+      if (value !== current[key]) {
+        current[key] = value;
+        held.delete(key);
+        publish(key, value);
+      } else {
+        held.add(key);
+      }
+      return true;
+    }
+  });
+  body(inputs, outputs as unknown as O);
+  const count: Record<string, number> = {};
+  const pulses = sent.map((signal) => {
+    const k = (count[signal] = (count[signal] ?? 0) + 1);
+    const values: Record<string, unknown> = { ...before };
+    for (const name of Object.keys(published)) values[name] = published[name][Math.min(k, published[name].length) - 1];
+    return { signal, values: values as Partial<O> };
+  });
+  return { outputs: node.outputs, pulses };
+}
+
+/**
+ * Whether the values on a node's ticked inputs (those whose Run On Value Change box is ticked) are an arrival that runs it:
+ * one of them is not \`undefined\`, which is never delivered, and is not the value that input already holds. Records each
+ * one that arrived. A Run records what it read the same way, so a value set and a Run sent in one event make one run.
+ */
+export function tickedArrival(held: unknown[], values: readonly unknown[]): boolean {
+  let arrived = false;
+  values.forEach((value, i) => {
+    if (value === undefined || Object.is(value, held[i])) return;
+    held[i] = value;
+    arrived = true;
+  });
+  return arrived;
+}
+`;
+}
+
 // ../nodegx-export/src/emit/cryptoLib.ts
 var CRYPTO_LIB_PATH = "src/lib/crypto.ts";
 function cryptoLibSource() {
@@ -266404,6 +267947,33 @@ function popupDialogLibSource() {
 }
 
 // ../nodegx-export/src/emit/component.ts
+function queryHasEffect(query2) {
+  const fetched = query2.fetchWired;
+  return fetched === void 0 || fetched.mount || fetched.onValues && query2.params?.wired !== void 0;
+}
+function queryParamsLiteral(params, whereLocal) {
+  const parts = [];
+  if (whereLocal !== void 0) parts.push(whereLocal === "where" ? "where" : `where: ${whereLocal}`);
+  else if (params.where !== void 0) parts.push(`where: ${JSON.stringify(params.where)}`);
+  if (params.sort !== void 0) parts.push(`sort: [${params.sort.map((s) => tsLiteral(s)).join(", ")}]`);
+  if (params.limit !== void 0) parts.push(`limit: ${params.limit}`);
+  if (params.skip !== void 0) parts.push(`skip: ${params.skip}`);
+  return `{ ${parts.join(", ")} }`;
+}
+function wiredWhereExpr(wired, locals, valueCode) {
+  const at = (index, mask) => {
+    if (index === wired.params.length) {
+      const where = wired.cases[mask];
+      return where === void 0 ? "undefined" : wiredWhereCode(where, valueCode);
+    }
+    const unset = at(index + 1, mask);
+    const set2 = at(index + 1, mask | 1 << index);
+    if (unset === set2) return set2;
+    const arm = (code) => code.includes(" ? ") ? `(${code})` : code;
+    return `${locals[index]} === undefined ? ${arm(unset)} : ${arm(set2)}`;
+  };
+  return at(0, 0);
+}
 var GENERATED_TS3 = "// @nodegx:generated (visual \u2014 provenance markers complete in EXP-007)\n";
 var GENERATED_CSS2 = "/* @nodegx:generated (visual) */\n";
 var PRINT_WIDTH = 100;
@@ -266643,6 +268213,45 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
   const usedTimerHelpers = /* @__PURE__ */ new Set();
   const jsFunByNode = plan.jsFunctions;
   const referencedJsIds = /* @__PURE__ */ new Set();
+  const pulsedRunIds = /* @__PURE__ */ new Set();
+  const tickedRunIds = new Set(plan.tickedRuns.map((t) => t.nodeId));
+  const tickedRecordArgs = (nodeId) => {
+    const ticked3 = plan.tickedRuns.find((t) => t.nodeId === nodeId);
+    return `${pulseNamesOf(jsFunByNode[nodeId]).held}, [${ticked3.watch.map((e) => exprCode(e, "handler")).join(", ")}]`;
+  };
+  const mountChains = [];
+  const mountRefusals = /* @__PURE__ */ new Map();
+  {
+    const mountGateOf = (id) => {
+      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 (at === plan.rootId) break;
+      }
+      return null;
+    };
+    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 visit = (id) => {
+      for (const child of plan.childrenOf[id] ?? []) visit(child);
+      if (id === plan.rootId && plan.collapsedGroupId) consider(plan.collapsedGroupId);
+      consider(id);
+    };
+    if (plan.rootId !== null) visit(plan.rootId);
+  }
+  const mountHandled = new Set(mountChains.map((m) => m.nodeId));
+  const activePulses = /* @__PURE__ */ new Map();
   const referencedStateNames = /* @__PURE__ */ new Set();
   const stateVarByName = new Map(plan.stateVars.map((v) => [v.name, v]));
   const stateSetterOf = (name) => stateVarByName.get(name)?.setterName ?? `set${name}`;
@@ -266685,6 +268294,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
       if (expr.field === "name") usedFileHelpers.add("cloudFileName");
     }
     if (expr.kind === "id-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
+    if (expr.kind === "record-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
     if (expr.kind === "crypto-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
     if (expr.kind === "screen-out") usedScreenNodeIds.add(expr.nodeId);
     if (expr.kind === "component-object-out" && expr.parent) usedParentObject = true;
@@ -266708,6 +268318,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
   const collectActionUse = (action) => {
     if (action.kind === "runtasks-run") collectExprUse(action.items);
     if (action.kind === "stream-action" && action.value !== void 0) collectExprUse(action.value);
+    if (action.kind === "query-fetch") for (const v of action.values) collectExprUse(v.expr);
     if (action.kind === "state-set") {
       referencedStateNames.add(action.name);
       if (action.expr !== void 0) collectExprUse(action.expr);
@@ -266774,6 +268385,9 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     if (action.kind === "popup-show" || action.kind === "popup-close") {
       action.then.forEach(collectActionUse);
     }
+    if (action.kind === "jsfun-pulses" || action.kind === "jsfun-pulse") {
+      action.then.forEach(collectActionUse);
+    }
     if (action.kind === "api-call") {
       for (const arg of action.args) {
         if (arg.kind === "expr") collectExprUse(arg.expr);
@@ -266783,6 +268397,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
         }
       }
       action.then.forEach(collectActionUse);
+      action.failThen.forEach(collectActionUse);
     }
     if (action.kind === "http-call" || action.kind === "cloud-call") {
       action.args.forEach((a8) => collectExprUse(a8.expr));
@@ -266867,6 +268482,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
       referencedJsIds.add(action.nodeId);
       jsArgExprs(action.nodeId).forEach(collectExprUse);
       action.then.forEach(collectActionUse);
+      if (runIsPulsed(action) || action.materialize !== void 0 && jsFunByNode[action.nodeId]?.pulsed === true) pulsedRunIds.add(action.nodeId);
       for (const name of jsFunByNode[action.nodeId]?.variables ?? []) {
         if (variableByName.has(name)) usedVariableNames.add(name);
       }
@@ -266881,14 +268497,15 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     ...plan.branchEffects.map((e) => e.action),
     // EXP-011 §39. A Value Changed's chain earns imports and references exactly as a handler's does.
     ...plan.valueChangedEffects.flatMap((e) => e.actions),
+    // P18-S119-TICKEDRUN. The run a ticked input starts is a chain like any other.
+    ...plan.tickedRuns.map((t) => t.action),
     // EXP-011 §49. The listeners and the arrive chain are chains like any other: a store write
     // inside one earns its import here, a state setter its row.
     ...plan.statesMachines.flatMap(
       (m) => [m.listeners.stateChanged, m.listeners.done, m.listeners.unchanged, m.listeners.failure, ...Object.values(m.listeners.reached)].flatMap((chain) => chain ?? [])
     ),
     ...plan.animations.flatMap((a8) => a8.arrive ?? []),
-    // EXP-011 §43. A Record's Id effect is a read chain run from an effect.
-    ...plan.recordEffects.map((e) => e.action),
+    // P18-S113-IDBINDREAD. A Record's Id bind runs no chain and reads nothing: it earns only its own lines (`recordBinds`).
     // EXP-011 §67. A Variable's authored Value is a store write run from a mount effect — it earns its import here.
     ...plan.variableSeeds.map(variableSeedAction),
     // EXP-011 §71. An Object's own authored property values are a store write run from a mount effect — it earns its import here.
@@ -266908,36 +268525,40 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
   allActions.forEach(collectActionUse);
   for (const stream of plan.streams) if (stream.store !== void 0) usedStoreNames.add(stream.store);
   const deepActions = (actions) => actions.flatMap(
-    (a8) => a8.kind === "branch" ? [a8, ...deepActions(a8.whenTrue), ...deepActions(a8.whenFalse)] : a8.kind === "http-call" || a8.kind === "cloud-call" || a8.kind === "record-fetch" || a8.kind === "external-link" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : (
-      // EXP-011 §45. The two-arm files actions ride the line above's shape; the picker has a third arm.
-      a8.kind === "file-upload" || a8.kind === "file-sign" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : a8.kind === "file-pick" ? [a8, ...deepActions(a8.then), ...deepActions(a8.unchangedThen), ...deepActions(a8.failThen)] : (
-        // EXP-011 §15. `Navigate To Path` carries two chains and neither is `failThen`;
-        // without this line `usesNavigate` below cannot see a second navigation nested in
-        // the first one's Done, and the `useNavigate()` hook it needs goes undeclared.
-        a8.kind === "navigate-path" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen), ...deepActions(a8.completedThen)] : (
-          // EXP-011 §37. Two arms, so it cannot join the single-chain list below — a popup
-          // opened from a UUID's Failure chain is a popup nothing here knows is attached.
-          a8.kind === "id-new" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : (
-            // EXP-011 §76. Four arms: the extractor's two result chains print inside the Done arm.
-            a8.kind === "crypto-call" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen), ...deepActions(a8.foundThen), ...deepActions(a8.notFoundThen)] : (
-              // EXP-011 §60. Three chains — a popup opened from a record write's Done, or a raise in a parent write's
-              // Failure, is nowhere without this line.
-              a8.kind === "component-object-set" ? [a8, ...deepActions(a8.then), ...deepActions(a8.completedThen), ...deepActions(a8.failThen)] : (
-                // EXP-011 §61. The pusher's three callback families; the Pop's two arms.
-                a8.kind === "stack-push" ? [a8, ...deepActions(a8.then), ...deepActions(a8.unchangedThen), ...a8.backActions.flatMap((b) => deepActions(b.then))] : a8.kind === "stack-pop" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : (
-                  // EXP-011 §39. Four chains — a popup opened from a Delay's Finished is the shape
-                  // this node exists for, and it is nowhere without this line.
-                  a8.kind === "delay" ? [
-                    a8,
-                    ...deepActions(a8.then),
-                    ...deepActions(a8.unchangedThen),
-                    ...deepActions(a8.startedThen),
-                    ...deepActions(a8.finishedThen)
-                  ] : (
-                    // EXP-011 §55. The array mutators own chains too (§30.3's walker had the same hole): a Clear's
-                    // 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" || a8.kind === "api-call" || 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) => a8.kind === "branch" ? [a8, ...deepActions(a8.whenTrue), ...deepActions(a8.whenFalse)] : (
+      // EXP-011 §90. A record or user verb's Failure chain rides the same line.
+      a8.kind === "api-call" || a8.kind === "http-call" || a8.kind === "cloud-call" || a8.kind === "record-fetch" || a8.kind === "external-link" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : (
+        // EXP-011 §45. The two-arm files actions ride the line above's shape; the picker has a third arm.
+        a8.kind === "file-upload" || a8.kind === "file-sign" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : a8.kind === "file-pick" ? [a8, ...deepActions(a8.then), ...deepActions(a8.unchangedThen), ...deepActions(a8.failThen)] : (
+          // EXP-011 §15. `Navigate To Path` carries two chains and neither is `failThen`;
+          // without this line `usesNavigate` below cannot see a second navigation nested in
+          // the first one's Done, and the `useNavigate()` hook it needs goes undeclared.
+          a8.kind === "navigate-path" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen), ...deepActions(a8.completedThen)] : (
+            // EXP-011 §37. Two arms, so it cannot join the single-chain list below — a popup
+            // opened from a UUID's Failure chain is a popup nothing here knows is attached.
+            a8.kind === "id-new" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : (
+              // EXP-011 §76. Four arms: the extractor's two result chains print inside the Done arm.
+              a8.kind === "crypto-call" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen), ...deepActions(a8.foundThen), ...deepActions(a8.notFoundThen)] : (
+                // EXP-011 §60. Three chains — a popup opened from a record write's Done, or a raise in a parent write's
+                // Failure, is nowhere without this line.
+                a8.kind === "component-object-set" ? [a8, ...deepActions(a8.then), ...deepActions(a8.completedThen), ...deepActions(a8.failThen)] : (
+                  // EXP-011 §61. The pusher's three callback families; the Pop's two arms.
+                  a8.kind === "stack-push" ? [a8, ...deepActions(a8.then), ...deepActions(a8.unchangedThen), ...a8.backActions.flatMap((b) => deepActions(b.then))] : a8.kind === "stack-pop" ? [a8, ...deepActions(a8.then), ...deepActions(a8.failThen)] : (
+                    // EXP-011 §39. Four chains — a popup opened from a Delay's Finished is the shape
+                    // this node exists for, and it is nowhere without this line.
+                    a8.kind === "delay" ? [
+                      a8,
+                      ...deepActions(a8.then),
+                      ...deepActions(a8.unchangedThen),
+                      ...deepActions(a8.startedThen),
+                      ...deepActions(a8.finishedThen)
+                    ] : (
+                      // EXP-011 §55. The array mutators own chains too (§30.3's walker had the same hole): a Clear's
+                      // 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]
+                    )
                   )
                 )
               )
@@ -267005,6 +268626,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     }
     if (expr.kind === "now-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
     if (expr.kind === "id-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
+    if (expr.kind === "record-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
     if (expr.kind === "crypto-out" && expr.viaState !== void 0) referencedStateNames.add(expr.viaState);
     if (expr.kind === "screen-out") usedScreenNodeIds.add(expr.nodeId);
     if (expr.kind === "component-object-out" && expr.parent) usedParentObject = true;
@@ -267051,21 +268673,23 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     if (effect.action.kind === "branch") hookExprSources(effect.action.cond);
   }
   for (const effect of plan.valueChangedEffects) hookExprSources(effect.watch);
+  for (const ticked3 of plan.tickedRuns) ticked3.watch.forEach(hookExprSources);
   for (const animation of plan.animations) {
     hookExprSources(animation.target);
     hookExprSources(animation.duration);
     hookExprSources(animation.delay);
   }
   for (const machine of plan.statesMachines) if (machine.follow !== void 0) hookExprSources(machine.follow);
+  for (const query2 of plan.queries) {
+    if (!queryHasEffect(query2)) continue;
+    for (const value of query2.wiredValues ?? []) hookExprSources(value.expr);
+  }
   for (const drag of plan.drags) for (const option of drag.options) hookExprSources(option.expr);
   for (const stream of plan.streams) for (const entry of stream.config) hookExprSources(entry.expr);
   for (const run6 of plan.runTasks) {
     hookExprSources(run6.maxRunningTasks);
     hookExprSources(run6.stopOnFailure);
   }
-  for (const effect of plan.recordEffects) {
-    if (effect.action.kind === "record-fetch") hookExprSources(effect.action.id);
-  }
   for (const stateVar of plan.stateVars) {
     if (stateVar.origin === "control" && plan.roleOf[stateVar.originNodeId] !== void 0) {
       referencedStateNames.add(stateVar.name);
@@ -267096,7 +268720,19 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     }
   }
   const referencedStateVars = plan.stateVars.filter((v) => referencedStateNames.has(v.name));
-  const usesNavigate = deepActions(allActions).some((a8) => a8.kind === "navigate" || a8.kind === "navigate-path");
+  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;
+    return row === void 0 ? [] : [{ read: read2, row }];
+  });
+  const recordBinds = plan.recordEffects.flatMap((effect) => {
+    const action = effect.action;
+    if (action.kind !== "record-fetch" || !effect.held) return [];
+    const row = referencedStateVars.find((v) => v.originNodeId === effect.nodeId && v.origin === "record-row");
+    const read2 = plan.recordReads.find((r) => r.nodeId === effect.nodeId);
+    return row === void 0 || read2 === void 0 ? [] : [{ effect, action, read: read2, row }];
+  });
+  for (const { action } of recordBinds) hookExprSources(action.id);
+  const usesNavigate = deepActions(allActions).some((a8) => a8.kind === "navigate" && !a8.newTab || a8.kind === "navigate-path");
   const raisesAppErrors = deepActions(allActions).some((a8) => RAISING_ACTION_KINDS.has(a8.kind) || mintedGuards(a8) || a8.kind === "component-object-set" && a8.parent);
   const reserved = /* @__PURE__ */ new Set([
     "event",
@@ -267149,7 +268785,11 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     const deferrals = deferralsByNode.get(nodeId);
     if (deferrals === void 0) return [];
     flushed3.add(nodeId);
-    const out = [`TODO(export): node ${commentSafe(nodeId)} renders, and part of what the graph`, "asked of it did not survive:"];
+    const undrawn = plan.roleOf[nodeId] !== void 0 ? undrawnReasonOf(plan, component, nodeId) : null;
+    const out = [
+      undrawn === null ? `TODO(export): node ${commentSafe(nodeId)} renders, and part of what the graph` : `TODO(export): node ${commentSafe(nodeId)} is not drawn (${commentSafe(undrawn)}), and part of what the graph`,
+      "asked of it did not survive:"
+    ];
     for (const d of deferrals) {
       out.push(`  - ${commentSafe(d.subject)} ${commentSafe(d.reason)}.`);
       if (d.origin !== null) out.push(`    In the graph it is fed by ${commentSafe(d.origin)}.`);
@@ -267440,6 +269080,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     return SIMPLE_REF.test(code) || /^[A-Za-z_$][\w$.]*\(\)$/.test(code) || code.endsWith(")") ? code : `(${code})`;
   };
   const jsArgsObject = (def, mode) => {
+    if (def.kind === "expression" && def.inputs.length === 0) return "";
     const entries2 = def.inputs.filter((i) => i.expr !== void 0).map((i) => {
       const code = exprCode(i.expr, mode);
       const key3 = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(i.name) ? i.name : JSON.stringify(i.name);
@@ -267478,12 +269119,13 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     if (node === "pattern") return `${local}.${field2 ?? "match"}`;
     return `${local}.${node === "hash" ? "digest" : "value"}`;
   };
+  let announcedCode;
   const exprCode = (expr, mode) => {
     switch (expr.kind) {
       case "prop":
         return propName(expr.name);
       case "input-text":
-        return "event.target.value";
+        return announcedCode?.inputId === expr.inputId ? announcedCode.code : "event.target.value";
       /**
        * A url parameter (EXP-011 Tier 2.5) — the query first, the path segment behind it.
        *
@@ -267789,15 +269431,24 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
       // Expression's typed getters, verbatim semantics (expression.ts).
       case "jsfun-out": {
         const def = jsFunByNode[expr.nodeId];
-        if (expr.viaState !== void 0 && mode === "render") {
+        if (expr.viaState !== void 0 && mode === "handler" && def.kind === "function" && pulsedRunIds.has(expr.nodeId)) {
+          const delivered = memberExpr(`${pulseNamesOf(def).node}.delivered`, expr.output);
+          if (expr.fold === "string") return `String(${delivered} ?? '')`;
+          if (expr.fold === "number") return `(typeof ${delivered} === 'number' ? ${delivered} : Number(${delivered}) || 0)`;
+          if (expr.fold === "boolean") return `!!${delivered}`;
+          return delivered;
+        }
+        if (expr.viaState !== void 0) {
           const base2 = def.kind !== "expression" ? /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(expr.output) ? `${expr.viaState}?.${expr.output}` : `${expr.viaState}?.[${JSON.stringify(expr.output)}]` : expr.viaState;
           if (expr.fold === "string") return `String(${base2} ?? '')`;
           if (expr.fold === "number") return `(typeof ${base2} === 'number' ? ${base2} : Number(${base2}) || 0)`;
           if (expr.fold === "boolean") return `!!${base2}`;
           return base2;
         }
+        const pulse = mode === "handler" ? activePulses.get(expr.nodeId) : void 0;
+        const ran2 = mode === "handler" && pulse === void 0 && pulsedRunIds.has(expr.nodeId) ? `${pulseNamesOf(def).run}.outputs` : void 0;
         const local = mode === "render" ? jsLocals.get(expr.nodeId) : void 0;
-        const callee = local ?? `${def.fnName}(${jsArgsObject(def, mode)})`;
+        const callee = pulse !== void 0 ? `${pulse}.values` : ran2 ?? local ?? `${def.fnName}(${jsArgsObject(def, mode)})`;
         const base = def.kind === "function" ? memberExpr(callee, expr.output) : callee;
         if (expr.fold === "string") return `String(${base} ?? '')`;
         if (expr.fold === "number") return `(typeof ${base} === 'number' ? ${base} : Number(${base}) || 0)`;
@@ -267914,7 +269565,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
           break;
         case "jsfun-out": {
           if (e.viaState !== void 0) {
-            add(e.viaState);
+            add(exprCode({ ...e, fold: void 0 }, "render"));
             break;
           }
           const local = jsLocals.get(e.nodeId);
@@ -267951,7 +269602,14 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
           // 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 ? [{ ...a8, then: [] }, ...expandActions(a8.then)] : expandActions(a8.then) : [a8]
+          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]
+            )
+          )
         )
       )
     )
@@ -268011,7 +269669,7 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
         case "branch":
           return reads(a8.cond) || a8.whenTrue.some(inAction) || a8.whenFalse.some(inAction);
         case "api-call":
-          return a8.args.some((arg) => arg.kind === "expr" ? reads(arg.expr) : arg.props.some((p) => reads(p.expr))) || a8.then.some(inAction);
+          return a8.args.some((arg) => arg.kind === "expr" ? reads(arg.expr) : arg.props.some((p) => reads(p.expr))) || a8.then.some(inAction) || a8.failThen.some(inAction);
         case "http-call":
         // EXP-011 §41. The same, one node over.
         case "cloud-call":
@@ -268062,12 +269720,17 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
           return reads(a8.items);
         case "runtasks-abort":
           return false;
+        // P18-S116-QUERYFETCH. The wired filter values are read at the pulse.
+        case "query-fetch":
+          return a8.values.some((v) => reads(v.expr));
         // EXP-011 §58. The data is read at the pulse.
         case "stream-action":
           return a8.value !== void 0 && reads(a8.value);
         case "popup-show":
         case "popup-close":
         case "jsfun-run":
+        case "jsfun-pulses":
+        case "jsfun-pulse":
         case "date-now-read":
           return a8.then.some(inAction);
         // EXP-011 §37. Both arms, on the hazard the two notes above name: the Failure arm can
@@ -268120,6 +269783,11 @@ function emitComponent(plan, project2, ir, catalog2, kitBindings = /* @__PURE__
     return [`if (${m.stateName} === null) {`, ...guard, `${at}} else {`, ...elseLines.map((l) => `${inner}${l}`), `${at}}`].join("\n");
   };
   const actionCode = (action, indent = 0) => {
+    if ("detached" in action && action.detached === true) {
+      return `void (async () => {
+${pad(indent + 2)}${actionCode({ ...action, detached: void 0 }, indent + 2)}
+${pad(indent)}})()`;
+    }
     switch (action.kind) {
       /**
        * The url the runtime's `getRelativeURL` would build, built here instead.
@@ -268246,7 +269914,8 @@ ${at}`);
         );
         const query2 = action.query.map((param) => `${encodeURIComponent(param.name)}=\${${urlValue(param.expr)}}`).join("&");
         const url = query2 === "" ? filled : `${filled}?${query2}`;
-        return action.pathParams.length === 0 && action.query.length === 0 ? `navigate('${url}')` : `navigate(\`${url}\`)`;
+        const literal2 = action.pathParams.length === 0 && action.query.length === 0 ? `'${url}'` : `\`${url}\``;
+        return action.newTab ? `window.open(${literal2}, '_blank')` : `navigate(${literal2})`;
       }
       // The optional call is the runtime's hasOutput/unwired case: a parent that passes
       // nothing gets nothing (COMPONENT-OUTPUTS-TARGET §3).
@@ -268400,16 +270069,63 @@ ${at}`);
         return `${action.local}.run(${exprCode(action.items, "handler")})`;
       case "runtasks-abort":
         return `${action.local}.abort()`;
+      /**
+       * P18-S116-QUERYFETCH. A Query Records' Fetch: the query's own settings, a wired filter's `where` from the values as
+       * the handler reads them at the pulse (a store fresh, `.get()`). Not awaited: the runtime schedules its fetch.
+       */
+      case "query-fetch": {
+        const query2 = plan.queries.find((q) => q.nodeId === action.nodeId);
+        const wired = query2.params?.wired;
+        if (query2.params === void 0) return `void ${query2.fetchName}().then(${query2.setterName})`;
+        if (wired === void 0) return `void ${query2.fetchName}(${queryParamsLiteral(query2.params)}).then(${query2.setterName})`;
+        const codes = action.values.map((v) => exprCode(v.expr, "handler"));
+        const codeOf = (name) => codes[action.values.findIndex((v) => v.name === name)];
+        const tested = codes.map((code) => SIMPLE_REF.test(code) ? code : `(${code})`);
+        const valueCode = (name, date3) => query2.wiredClient ? `filterValue(${codeOf(name)}${date3 ? ", true" : ""})` : codeOf(name);
+        return `void ${query2.fetchName}(${queryParamsLiteral(query2.params, wiredWhereExpr(wired, tested, valueCode))}).then(${query2.setterName})`;
+      }
       /** A streaming node's action (EXP-011 §58) — one call on the handle, the data read at the pulse where the verb takes it. */
       case "stream-action":
         return `${action.local}.${action.verb}(${action.value !== void 0 ? exprCode(action.value, "handler") : ""})`;
       case "jsfun-run": {
+        const def = jsFunByNode[action.nodeId];
+        const record2 = action.ticked !== true && tickedRunIds.has(action.nodeId) ? `tickedArrival(${tickedRecordArgs(action.nodeId)});
+${pad(indent)}` : "";
+        if (pulsedRunIds.has(action.nodeId) && action.then.length === 0) {
+          const names2 = pulseNamesOf(def);
+          const run6 = `${record2}const ${names2.run} = runFunction(${def.fnName}, ${jsArgsObject(def, "handler")}, ${names2.node})`;
+          if (action.materialize === void 0) return run6;
+          return `${run6};
+${pad(indent)}${stateSetterOf(action.materialize)}({ ...${names2.run}.outputs })`;
+        }
         if (action.materialize !== void 0) {
-          const def = jsFunByNode[action.nodeId];
-          return `${stateSetterOf(action.materialize)}(${def.fnName}(${jsArgsObject(def, "handler")}))`;
+          return `${record2}${stateSetterOf(action.materialize)}(${def.fnName}(${jsArgsObject(def, "handler")}))`;
         }
         return expandActions(action.then).map(actionCode).join("; ");
       }
+      /**
+       * EXP-011 §86. One loop over the pulses the run sent, in the order it sent them; each arm is one signal's chain,
+       * and inside it this Function's outputs read as that pulse's targets read them (`exprCode`'s `jsfun-out`).
+       */
+      case "jsfun-pulses": {
+        const names2 = pulseNamesOf(jsFunByNode[action.nodeId]);
+        const arms = action.then.filter((a8) => a8.kind === "jsfun-pulse");
+        activePulses.set(action.nodeId, names2.pulse);
+        try {
+          const lines = [`for (const ${names2.pulse} of ${names2.run}.pulses) {`];
+          arms.forEach((arm, i) => {
+            const head = `${i === 0 ? "" : "} else "}if (${names2.pulse}.signal === ${tsLiteral(arm.signal)}) {`;
+            lines.push(`${pad(indent + 2)}${head}`, ...blockBody(expandActions(arm.then), indent + 4));
+          });
+          lines.push(`${pad(indent + 2)}}`, `${pad(indent)}}`);
+          return lines.join("\n");
+        } finally {
+          activePulses.delete(action.nodeId);
+        }
+      }
+      // Printed by its loop above; never on its own.
+      case "jsfun-pulse":
+        return expandActions(action.then).map((a8) => actionCode(a8, indent)).join("; ");
       // The functional updates are §3.3's closure-staleness-immune forms.
       case "state-set": {
         const setter = stateSetterOf(action.name);
@@ -268428,7 +270144,11 @@ ${at}`);
         );
         if (action.coerceId === "string") args[0] = `String(${args[0]} ?? '')`;
         const inner = pad(indent + 2);
+        const boundId = action.guardId && action.coerceId !== "string" && args[0].endsWith(")") ? `${action.errorState.replace(/Error$/, "")}RecordId` : void 0;
+        const idRead = args[0];
+        if (boundId !== void 0) args[0] = boundId;
         const body2 = [
+          ...boundId !== void 0 ? [`${inner}const ${boundId} = ${idRead};`] : [],
           // The runtime's "Missing Record Id" (RECORD-VERBS-TARGET §1), thrown rather than
           // branched so it lands in the catch below — which is already the graph's own error
           // path — skips the call and the done chain, and narrows the id for the call itself.
@@ -268461,6 +270181,8 @@ ${at}`);
           `${inner}${stateSetterOf(action.errorState)}(${action.errorState}Message);`,
           // EXP-011 §54. The Error row first, then the raise, then nothing — the order the setError funnels keep.
           `${inner}${raiseLine(action.nodeId, errorCodeOf(action), `${action.errorState}Message`)}`,
+          // EXP-011 §90. Then the Failure pulse's chain: `reportOutcome` raises before it sends the signal.
+          ...expandActions(action.failThen).map((a8) => `${inner}${actionCode(a8, indent + 2)};`),
           `${pad(indent)}}`
         ].join("\n");
       }
@@ -268507,9 +270229,10 @@ ${at}`);
       /**
        * A `Record`'s Fetch (EXP-011 §43). One argument, the Id; the runtime's own `Missing Id.`
        * thrown inside the try where the Id is empty — `scheduleFetch` reports it as Failure before
-       * any request, so the catch is exactly the arm it belongs in. The row is replaced, not
-       * merged: `setModelID` binds a fresh model per Id, so a column the answer lacks reads
-       * undefined, as the node's output does for a record that never carried it.
+       * any request, so the catch is exactly the arm it belongs in. The row is replaced by what
+       * the read answers. Where the app has a live Record (P18-S111-RECORDLIVE) that answer is the
+       * client's one copy of the record, the read merged into it field by field as `_fromJSON`
+       * merges into `Model.get(id)`; otherwise it is the wire's answer alone.
        */
       case "record-fetch": {
         const names2 = recordNamesOf(action.nodeId);
@@ -268517,11 +270240,9 @@ ${at}`);
         const idCode = action.coerceId === "string" ? `String(${exprCode(action.id, "handler")} ?? '')` : exprCode(action.id, "handler");
         const idLocal = names2.idLocal;
         const empty3 = `${idLocal} === undefined || ${idLocal} === null || ${idLocal} === ''`;
-        const guard = action.id.kind === "literal" ? [] : action.viaEffect ? [`${inner}if (${empty3}) return;`] : [`${inner}if (${empty3}) throw new Error('Missing Id.');`];
-        const clear2 = action.viaEffect && action.materialize !== void 0 ? [`${inner}${stateSetterOf(action.materialize)}(undefined);`] : [];
+        const guard = action.id.kind === "literal" ? [] : [`${inner}if (${empty3}) throw new Error('Missing Id.');`];
         return [
           "try {",
-          ...clear2,
           `${inner}const ${idLocal} = ${idCode};`,
           ...guard,
           `${inner}const ${names2.answerLocal} = await ${action.fnName}(${idLocal});`,
@@ -269044,7 +270765,9 @@ ${pad(indent)}}`;
     }
   };
   function actionIsStatement(a8) {
-    return a8.kind === "branch" || a8.kind === "popup-close" && a8.then.length > 0 || a8.kind === "collection-clear" && (a8.then.length > 0 || a8.unchangedThen.length > 0) || // EXP-011 §55. The mint is statements; a guarded mutator is an `if`/`else`.
+    return a8.kind === "branch" || // EXP-011 §86. A run with pulses declares its `const`, and its loop is a `for`.
+    a8.kind === "jsfun-run" && pulsedRunIds.has(a8.nodeId) || // P18-S119-TICKEDRUN. A Run that records what it read is two statements: the record, then the run. The sixth instance.
+    a8.kind === "jsfun-run" && a8.ticked !== true && tickedRunIds.has(a8.nodeId) || a8.kind === "jsfun-pulses" || a8.kind === "popup-close" && a8.then.length > 0 || a8.kind === "collection-clear" && (a8.then.length > 0 || a8.unchangedThen.length > 0) || // EXP-011 §55. The mint is statements; a guarded mutator is an `if`/`else`.
     a8.kind === "array-new" || mintedGuards(a8) || /**
      * 🔴 `Now`'s Read declares a `const`, and a `const` is a statement (EXP-011 Tier 1.3).
      * `() => const clockRead = new Date(); setClock(clockRead)` does not parse — the fourth
@@ -269086,17 +270809,21 @@ ${pad(indent)}}`;
     a8.kind === "stack-push" || a8.kind === "stack-pop" || a8.kind === "stack-reset" && a8.then.length > 0;
   }
   function actionTakesNoTerminator(a8) {
-    return a8.kind === "api-call" || a8.kind === "http-call" || // EXP-011 §41. A try/catch, like the two above.
-    a8.kind === "cloud-call" || // EXP-011 §43. A try/catch, like the three above.
-    a8.kind === "record-fetch" || // EXP-011 §45. Three more try/catches.
-    a8.kind === "file-pick" || a8.kind === "file-upload" || a8.kind === "file-sign" || a8.kind === "external-link" && externalLinkIsStatement(a8) || a8.kind === "navigate-path" && navigatePathIsStatement(a8) || // EXP-011 §39. The `if` form ends in `}` and must not take a terminator.
-    a8.kind === "delay" && delayIsBlock(a8) || // EXP-011 §55. The guarded mutator ends in `}` too.
-    mintedGuards(a8) || // EXP-011 §37. The block form ends in `}` and must not take a terminator; the
-    // `Unique Id` form is a run of statements and takes one, exactly as a Now Read does.
-    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";
+    if ("detached" in a8 && a8.detached === true) return false;
+    return (
+      // EXP-011 §86. The pulse loop ends in `}`.
+      a8.kind === "jsfun-pulses" || a8.kind === "api-call" || a8.kind === "http-call" || // EXP-011 §41. A try/catch, like the two above.
+      a8.kind === "cloud-call" || // EXP-011 §43. A try/catch, like the three above.
+      a8.kind === "record-fetch" || // EXP-011 §45. Three more try/catches.
+      a8.kind === "file-pick" || a8.kind === "file-upload" || a8.kind === "file-sign" || a8.kind === "external-link" && externalLinkIsStatement(a8) || a8.kind === "navigate-path" && navigatePathIsStatement(a8) || // EXP-011 §39. The `if` form ends in `}` and must not take a terminator.
+      a8.kind === "delay" && delayIsBlock(a8) || // EXP-011 §55. The guarded mutator ends in `}` too.
+      mintedGuards(a8) || // EXP-011 §37. The block form ends in `}` and must not take a terminator; the
+      // `Unique Id` form is a run of statements and takes one, exactly as a Now Read does.
+      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"
+    );
   }
   function actionsAwait(actions) {
     return deepActions(actions).some(
@@ -269107,7 +270834,7 @@ ${pad(indent)}}`;
   }
   function blockBody(expanded, indent) {
     return expanded.map(
-      (a8) => actionTakesNoTerminator(a8) ? `${pad(indent)}${actionCode(a8, indent)}` : `${pad(indent)}${actionCode(a8, 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" ? indent : 0)};`
+      (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)};`
     );
   }
   function effectBody(actions, indent) {
@@ -269148,12 +270875,14 @@ ${pad(indent)}}`;
     externalImports.push(`import { ${coreHooks.sort().join(", ")} } from '@nodegx/core/react';`);
   }
   const reactImports = [];
-  if (plan.queries.length > 0) reactImports.push("useEffect", "useState");
+  if (plan.queries.length > 0) reactImports.push(...plan.queries.some((q) => queryHasEffect(q)) ? ["useEffect"] : [], "useState");
   if (plan.popups.length > 0 && !reactImports.includes("useState")) reactImports.push("useState");
   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 || // EXP-011 §43. A Record with Fetch unwired is an effect keyed on its Id.
-  plan.recordEffects.length > 0 || // EXP-011 §67. A Variable's authored Value is a mount 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.
+  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.
   plan.objectSeeds.length > 0 || // EXP-011 §48. A CSS Definition is a mount effect.
   plan.styleSheets.length > 0 || // EXP-011 §49. A States' wired State input is an effect keyed on the read.
@@ -269162,8 +270891,8 @@ ${pad(indent)}}`;
     reactImports.push("useEffect");
   }
   if (radioNameLocals.size > 0) reactImports.push("useId");
-  if (delayRefs.size > 0 || plan.valueChangedEffects.length > 0 || usedKeptLocals.size > 0) reactImports.push("useRef");
-  if (plan.task !== void 0 || plan.repeaterItems.length > 0) {
+  if (delayRefs.size > 0 || plan.valueChangedEffects.length > 0 || usedKeptLocals.size > 0 || pulsedRunIds.size > 0 || plan.tickedRuns.length > 0) reactImports.push("useRef");
+  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");
   }
@@ -269188,7 +270917,7 @@ ${pad(indent)}}`;
   for (const read2 of plan.recordReads) stubModule(read2.moduleBase).reads.push(read2);
   for (const [moduleBase, { queries, mutations, reads }] of stubModules) {
     const specifier = `${relRoot}/api/${moduleBase}`;
-    const fetchNames = [.../* @__PURE__ */ new Set([...queries.map((q) => q.fetchName), ...reads.map((r) => r.fnName)])].sort();
+    const fetchNames = [.../* @__PURE__ */ new Set([...queries.map((q) => q.fetchName), ...reads.filter((r) => !r.binds).map((r) => r.fnName)])].sort();
     const fnNames = [...new Set(mutations.map((m) => m.fnName))].sort();
     const typeNames = [
       .../* @__PURE__ */ new Set([
@@ -269201,6 +270930,11 @@ ${pad(indent)}}`;
       `import { ${[...fetchNames, ...fnNames, ...typeNames.map((t) => `type ${t}`)].join(", ")} } from '${specifier}';`
     );
   }
+  const clientNames = [
+    ...plan.queries.some((q) => q.wiredClient === true && q.params?.wired !== void 0) ? ["filterValue"] : [],
+    ...liveRecordRows.length > 0 || recordBinds.length > 0 ? ["subscribeRecord"] : []
+  ];
+  if (clientNames.length > 0) internalImports.set(`${relRoot}/api/client`, `import { ${clientNames.join(", ")} } from '${relRoot}/api/client';`);
   if (plan.sessionCalls.length > 0) {
     const specifier = `${relRoot}/api/session`;
     const fnNames = [...new Set(plan.sessionCalls.map((c) => c.fnName))].sort();
@@ -269372,6 +271106,11 @@ ${pad(indent)}}`;
     const specifier = `${relRoot}/${ID_LIB_PATH.replace(/^src\//, "").replace(/\.ts$/, "")}`;
     internalImports.set(specifier, `import { ${[...usedIdHelpers].sort().join(", ")} } from '${specifier}';`);
   }
+  if (pulsedRunIds.size > 0 || tickedRunIds.size > 0) {
+    const specifier = `${relRoot}/${FUNCTION_RUN_LIB_PATH.replace(/^src\//, "").replace(/\.ts$/, "")}`;
+    const helpers = [...pulsedRunIds.size > 0 ? ["functionNode", "runFunction"] : [], ...tickedRunIds.size > 0 ? ["tickedArrival"] : []];
+    internalImports.set(specifier, `import { ${helpers.join(", ")} } from '${specifier}';`);
+  }
   if (usedVariableNames.size > 0) {
     const specifier = `${relRoot}/stores/variables`;
     const names2 = [...usedVariableNames].map((n) => variableByName.get(n).exportName).sort();
@@ -269669,6 +271408,12 @@ ${pad(indent)}}`;
     const roleEvents = ROLE_EVENT_ATTRS[plan.roleOf[node.id]] ?? {};
     for (const [port5, actions] of Object.entries(plan.handlers[node.id] ?? {})) {
       if (port5 === "onChange" && controlVarByNode.has(node.id)) continue;
+      if (port5 === "didMount" && mountHandled.has(node.id)) continue;
+      if (port5 === "didMount" && mountRefusals.has(node.id)) {
+        notes.push(`${plan.path}: signal ${node.id}.didMount dropped: ${mountRefusals.get(node.id)} \u2014 reported`);
+        defer(node.id, 'the "didMount" signal', mountRefusals.get(node.id));
+        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`);
@@ -270276,7 +272021,8 @@ ${pad(indent)}}`;
     const specifier = `../kits/${binding.modulePath.split("/").pop()}`;
     const existing = internalImports.get(specifier);
     const symbols = new Set(existing ? existing.replace(/^import \{ | \} from .*$/g, "").split(", ") : []);
-    symbols.add(binding.symbol);
+    const kitLocal = binding.symbol === plan.file.symbol ? `${binding.symbol}Kit` : binding.symbol;
+    symbols.add(kitLocal === binding.symbol ? binding.symbol : `${binding.symbol} as ${kitLocal}`);
     internalImports.set(specifier, `import { ${[...symbols].sort().join(", ")} } from '${specifier}';`);
     const attrs = [];
     for (const param of node.parameters) {
@@ -270341,7 +272087,7 @@ ${pad(indent)}}`;
       );
     }
     const blocks = renderChildBlocks(node.id, childIds, indent + 2).flat();
-    return element(binding.symbol, attrs, blocks.length > 0 ? blocks : null, indent, blocks.length > 0);
+    return element(kitLocal, attrs, blocks.length > 0 ? blocks : null, indent, blocks.length > 0);
   };
   const instanceAttrs = (node) => {
     const attrs = [];
@@ -270474,9 +272220,11 @@ ${pad(indent)}}`;
       const outputsType = outputFields.length > 0 ? `{ ${outputFields.join("; ")} }` : "Record<string, never>";
       const seeds = def.signals.map((s) => `${fieldKey(s)}: () => {}`);
       lines.push(`// From the Function node "${def.fnName}" \u2014 the body is preserved verbatim (EXP-003 \xA74).`);
-      lines.push(`function ${def.fnName}(${hasInputs ? INPUTS_PARAM : "Inputs"}: ${inputsType}): ${outputsType} {`);
+      const seedRecord = `{${seeds.length > 0 ? ` ${seeds.join(", ")} ` : ""}}`;
+      const outputsParam = def.pulsed ? `, Outputs: ${outputsType} = ${seedRecord}` : "";
+      lines.push(`function ${def.fnName}(${hasInputs ? INPUTS_PARAM : "Inputs"}: ${inputsType}${outputsParam}): ${outputsType} {`);
       if (hasInputs) lines.push(`  const Inputs = ${scopeCast(INPUTS_PARAM)};`);
-      lines.push(`  const Outputs: ${outputsType} = {${seeds.length > 0 ? ` ${seeds.join(", ")} ` : ""}};`);
+      if (!def.pulsed) lines.push(`  const Outputs: ${outputsType} = ${seedRecord};`);
       lines.push("  try {");
       if (def.scripts !== void 0 && def.scripts.length > 0) {
         const rows = def.scripts.map((u) => `${fieldKey(u.alias)}: ${PROJECT_SCRIPTS_SYMBOL}.load(${JSON.stringify(u.path)})`);
@@ -270548,12 +272296,39 @@ ${pad(indent)}}`;
       for (const alias of def.mathAliases) {
         lines.push(alias === "pi" ? "  const pi = Math.PI;" : `  const ${alias} = Math.${alias};`);
       }
-      lines.push("  try {");
-      lines.push(`    return (${def.body});`);
-      lines.push("  } catch (e) {");
-      lines.push(`    console.error('Expression node ${def.fnName} threw:', e);`);
-      lines.push("    return 0;");
-      lines.push("  }");
+      const gate = def.loadGate;
+      const unsetTest = gate !== void 0 ? gate.unset.map((n) => `${n} === undefined`).join(" && ") : "";
+      if (gate?.atLoad === "wait") {
+        lines.push(`  // Evaluate At Load is unticked: no answer until an input arrives.`);
+        lines.push(`  if (${unsetTest}) return null;`);
+      }
+      if (gate?.atLoad === "evaluate" && gate.unset.length === 0) {
+        lines.push("  // Nothing feeds its inputs: the load evaluation over them, which keeps null for a throw or a NaN.");
+        lines.push("  try {");
+        lines.push(`    const __value = (${def.body});`);
+        lines.push("    return Number.isNaN(__value) ? null : __value;");
+        lines.push("  } catch {");
+        lines.push("    return null;");
+        lines.push("  }");
+      } else if (gate?.atLoad === "evaluate") {
+        lines.push("  // Until an input arrives this is the load evaluation, which keeps null for a throw or a NaN.");
+        lines.push(`  const __unset = ${unsetTest};`);
+        lines.push("  try {");
+        lines.push(`    const __value = (${def.body});`);
+        lines.push("    return __unset && Number.isNaN(__value) ? null : __value;");
+        lines.push("  } catch (e) {");
+        lines.push("    if (__unset) return null;");
+        lines.push(`    console.error('Expression node ${def.fnName} threw:', e);`);
+        lines.push("    return 0;");
+        lines.push("  }");
+      } else {
+        lines.push("  try {");
+        lines.push(`    return (${def.body});`);
+        lines.push("  } catch (e) {");
+        lines.push(`    console.error('Expression node ${def.fnName} threw:', e);`);
+        lines.push("    return 0;");
+        lines.push("  }");
+      }
       lines.push("}");
     }
     return lines;
@@ -270629,9 +272404,11 @@ ${pad(indent)}}`;
     internalImports.set(specifier, `import { ${[...usedMediaHelpers].sort().join(", ")} } from '${specifier}';`);
   }
   const usesProjectScripts = Object.values(jsFunByNode).some((def) => referencedJsIds.has(def.nodeId) && (def.scripts?.length ?? 0) > 0);
-  if (usesProjectScripts) {
-    const specifier = `${relRoot}/${PROJECT_SCRIPT_FILES_PATH.replace(/^src\//, "").replace(/\.ts$/, "")}`;
-    internalImports.set(specifier, `import { ${PROJECT_SCRIPTS_SYMBOL} } from '${specifier}';`);
+  const functionFiles = Object.values(jsFunByNode).filter((def) => def.kind === "function" && referencedJsIds.has(def.nodeId)).map((def) => ({ def, file: `src/functions/${plan.file.dir}/${plan.file.fileBase}/${def.fnName}.ts` }));
+  const ownFileIds = new Set(functionFiles.map(({ def }) => def.nodeId));
+  for (const { def, file } of functionFiles) {
+    const from = `${relRoot}/${file.replace(/^src\//, "").replace(/\.ts$/, "")}`;
+    internalImports.set(from, `import { ${def.fnName} } from '${from}';`);
   }
   const importLines = [];
   if (externalImports.length > 0) importLines.push(...externalImports.sort());
@@ -270642,6 +272419,7 @@ ${pad(indent)}}`;
   }
   const body = [];
   for (const def of Object.values(jsFunByNode)) {
+    if (ownFileIds.has(def.nodeId)) continue;
     if (referencedJsIds.has(def.nodeId)) body.push(...jsWrapperLines(def), "");
     else body.push(...refusedSourceLines(def), "");
   }
@@ -270712,7 +272490,7 @@ ${pad(indent)}}`;
       body.push(`  ${ident}?: ${prop.tsType};`);
     }
     for (const output of plan.outputProps) body.push(`  ${output.prop}?: () => void;`);
-    for (const lifted6 of plan.liftedOutputProps) body.push(`  ${lifted6.prop}?: (value: ${lifted6.tsType}) => void;`);
+    for (const lifted6 of plan.liftedOutputProps) body.push(`  ${lifted6.prop}?: (value: ${lifted6.tsType} | undefined) => void;`);
     if (plan.closesPopup) body.push("  onClose?: (action?: string) => void;");
     if (plan.popsStack) body.push(`  /** The Component Stack that pushed this component \u2014 its Pop Component Stack's way back. */`, `  ${PAGE_STACK_ENTRY_PROP}?: PageStackEntryHandle;`);
     if (plan.childSlot !== void 0) body.push("  children?: ReactNode;");
@@ -270773,12 +272551,46 @@ ${pad(indent)}}`;
   }
   for (const [, ref] of delayRefs) body.push(`  const ${ref} = useRef<DelayHandle | null>(null);`);
   for (const effect of plan.valueChangedEffects) body.push(`  const ${effect.lastLocal} = useRef<unknown>(undefined);`);
-  for (const [id, local] of jsLocals) {
+  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;`);
+  }
+  for (const ticked3 of plan.tickedRuns) body.push(`  const ${pulseNamesOf(jsFunByNode[ticked3.nodeId]).held} = useRef<unknown[]>([]).current;`);
+  const hookLocalNames = [
+    ...plan.animations.map((a8) => a8.local),
+    ...plan.drags.map((d) => d.local),
+    ...plan.statesMachines.map((m) => m.local),
+    ...plan.scripts.map((s) => s.local),
+    ...plan.runTasks.map((r) => r.local),
+    ...plan.pageStacks.map((s) => s.local),
+    ...screenHooks.map((s) => s.local),
+    ...plan.appErrors.map((b) => b.local),
+    ...plan.streams.map((s) => s.local)
+  ];
+  const codeReads = (code, name) => new RegExp(`(^|[^A-Za-z0-9_$.])${name.replace(/\$/g, "\\$")}(?![A-Za-z0-9_$])`).test(code);
+  const renderLocalLines = [...jsLocals].map(([id, local]) => {
     const def = jsFunByNode[id];
-    body.push(`  const ${local} = ${def.fnName}(${jsArgsObject(def, "render")});`);
+    return { local, line: `  const ${local} = ${def.fnName}(${jsArgsObject(def, "render")});` };
+  });
+  const afterHooks = /* @__PURE__ */ new Set();
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const { local, line } of renderLocalLines) {
+      if (afterHooks.has(local)) continue;
+      const rhs = line.slice(line.indexOf("="));
+      if (hookLocalNames.some((name) => codeReads(rhs, name)) || [...afterHooks].some((name) => codeReads(rhs, name))) {
+        afterHooks.add(local);
+        grew = true;
+      }
+    }
   }
+  for (const { local, line } of renderLocalLines) if (!afterHooks.has(local)) body.push(line);
   for (const animation of plan.animations) {
-    const options = `{ duration: ${exprCode(animation.duration, "render")}, delay: ${exprCode(animation.delay, "render")}, ease: ${tsLiteral(animation.ease)} }`;
+    const optionCode = (input, expr) => {
+      const code = exprCode(expr, "render");
+      return animation.castToNumber?.includes(input) ? `${SIMPLE_REF.test(code) ? code : `(${code})`} as number` : code;
+    };
+    const options = `{ duration: ${optionCode("duration", animation.duration)}, delay: ${optionCode("delay", animation.delay)}, ease: ${tsLiteral(animation.ease)} }`;
     const arrive2 = animation.arrive !== void 0 ? `, ${handlerArrow(animation.arrive, "()", 2)}` : "";
     body.push(`  // ${animation.comment}`, `  const ${animation.local} = useAnimatedValue(${exprCode(animation.target, "render")}, ${options}${arrive2});`);
   }
@@ -270850,6 +272662,7 @@ ${pad(indent)}}`;
     if (listenerLines.length === 0) body.push(`  const ${stream.local} = ${spec.hook}(${source}, ${options});`);
     else body.push(`  const ${stream.local} = ${spec.hook}(${source}, ${options}, {`, listenerLines.join(",\n"), "  });");
   }
+  for (const { local, line } of renderLocalLines) if (afterHooks.has(local)) body.push(line);
   if (plan.task !== void 0) {
     const started = dedupeLocal("started");
     body.push(
@@ -270882,7 +272695,39 @@ ${pad(indent)}}`;
     body.push("");
   }
   for (const query2 of plan.queries) {
-    body.push("  useEffect(() => {", `    ${query2.fetchName}().then(${query2.setterName});`, "  }, []);", "");
+    const wired = query2.params?.wired;
+    const label2 = nodeById.get(query2.nodeId)?.authoredLabel;
+    const fetched = query2.fetchWired;
+    if (!queryHasEffect(query2)) {
+      body.push(`  // ${label2 ? `"${label2}"` : "The query"} asks only when its Fetch is sent (dbcollectionnode2.ts storageFetch); its boxes are unticked.`, "");
+      continue;
+    }
+    const once = fetched !== void 0 && !fetched.onValues;
+    if (query2.params !== void 0 && wired !== void 0 && query2.wiredValues !== void 0) {
+      const values = query2.wiredValues;
+      const codes = values.map((v) => exprCode(v.expr, "render"));
+      const locals = codes.map((code, i) => {
+        if (/^[A-Za-z_$][\w$]*$/.test(code)) return code;
+        let local = `${propIdentifier(values[i].name)}Value`;
+        while (codes.some((c) => new RegExp(`\\b${local.replace(/\$/g, "\\$")}\\b`).test(c))) local = `${local}_`;
+        return local;
+      });
+      const localOf = (name) => locals[values.findIndex((v) => v.name === name)];
+      const valueCode = (name, date3) => query2.wiredClient ? `filterValue(${localOf(name)}${date3 ? ", true" : ""})` : localOf(name);
+      const deps = [...new Set(values.flatMap((v) => effectDeps(v.expr)))].join(", ");
+      body.push(
+        once ? `  // ${label2 ? `"${label2}"` : "The query"} asks once as it is made (its Class or Query settings box is ticked); a new ${values.map((v) => `"${v.name}"`).join(" or ")} waits for its Fetch.` : `  // ${label2 ? `"${label2}"` : "The query"} asks again whenever ${values.map((v) => `"${v.name}"`).join(" or ")} changes (dbcollectionnode2.ts setQueryParameter).`,
+        "  useEffect(() => {",
+        ...codes.flatMap((code, i) => code === locals[i] ? [] : [`    const ${locals[i]} = ${code};`]),
+        `    const where = ${wiredWhereExpr(wired, locals, valueCode)};`,
+        `    ${query2.fetchName}(${queryParamsLiteral(query2.params, "where")}).then(${query2.setterName});`,
+        ...once ? ["    // eslint-disable-next-line react-hooks/exhaustive-deps -- once, as the node is made", "  }, []);"] : [`  }, [${deps}]);`],
+        ""
+      );
+      continue;
+    }
+    const params = query2.params === void 0 ? "" : queryParamsLiteral(query2.params);
+    body.push("  useEffect(() => {", `    ${query2.fetchName}(${params}).then(${query2.setterName});`, "  }, []);", "");
   }
   for (const seed of plan.variableSeeds) {
     body.push(`  // ${seed.comment}`, "  useEffect(() => {", ...effectBody([variableSeedAction(seed)], 4), "  }, []);", "");
@@ -270963,11 +272808,43 @@ ${pad(indent)}}`;
       );
     }
   }
+  for (const mount2 of plan.fieldMounts) {
+    const chain = plan.changeHandlers[mount2.inputId] ?? [];
+    if (chain.length === 0) continue;
+    const once = dedupeLocal("announced");
+    const lines = [];
+    let code = tsLiteral(mount2.start);
+    if (mount2.source !== void 0) {
+      const arrival = dedupeLocal("arrival");
+      code = dedupeLocal("mountValue");
+      lines.push(
+        `    const ${arrival} = ${exprCode(mount2.source, "render")};`,
+        `    const ${code} = ${arrival} === undefined ? ${tsLiteral(mount2.start)} : ${arrival} === null ? '' : String(${arrival});`
+      );
+    }
+    announcedCode = { inputId: mount2.inputId, code };
+    const chainLines = effectBody(chain, 4);
+    announcedCode = void 0;
+    body.push(
+      `  // ${mount2.comment}`,
+      `  const ${once} = useRef(false);`,
+      "  useEffect(() => {",
+      `    if (${once}.current) return;`,
+      `    ${once}.current = true;`,
+      ...lines,
+      ...chainLines,
+      "    // eslint-disable-next-line react-hooks/exhaustive-deps -- once, as the field mounts",
+      "  }, []);",
+      ""
+    );
+  }
   for (const push of plan.pushEffects) {
     const deps = [...effectDeps(push.expr), push.prop].join(", ");
+    const code = exprCode(push.expr, "render");
+    const pushed = push.castTo === void 0 ? code : `${SIMPLE_REF.test(code) ? code : `(${code})`} as ${push.castTo} | undefined`;
     body.push(
       "  useEffect(() => {",
-      `    ${push.prop}?.(${exprCode(push.expr, "render")});`,
+      `    ${push.prop}?.(${pushed});`,
       `  }, [${deps}]);`,
       ""
     );
@@ -270977,10 +272854,27 @@ ${pad(indent)}}`;
     const deps = effectDeps(action.cond).join(", ");
     body.push(`  // ${effect.comment}`, "  useEffect(() => {", ...effectBody([action], 4), `  }, [${deps}]);`, "");
   }
-  for (const effect of plan.recordEffects) {
-    const action = effect.action;
+  for (const { effect, action, read: read2, row } of recordBinds) {
     const deps = effectDeps(action.id).join(", ");
-    body.push(`  // ${effect.comment}`, "  useEffect(() => {", ...effectBody([action], 4), `  }, [${deps}]);`, "");
+    const idCode = action.coerceId === "string" ? `String(${exprCode(action.id, "render")} ?? '')` : exprCode(action.id, "render");
+    const bind2 = `subscribeRecord<${read2.typeName}>(${read2.idLocal}, ${stateSetterOf(row.name)})`;
+    body.push(
+      `  // ${effect.comment}`,
+      "  useEffect(() => {",
+      `    const ${read2.idLocal} = ${idCode};`,
+      ...action.id.kind === "literal" ? [] : [`    if (${read2.idLocal} === undefined || ${read2.idLocal} === null || ${read2.idLocal} === '') return undefined;`],
+      ...effect.follows ? [`    return ${bind2};`] : ['    // "Record properties" is unticked: the copy as it is at the bind, and no later write.', `    ${bind2}();`, "    return undefined;"],
+      `  }, [${deps}]);`,
+      ""
+    );
+  }
+  for (const { read: read2, row } of liveRecordRows) {
+    const label2 = nodeById.get(read2.nodeId)?.authoredLabel;
+    body.push(
+      `  // ${label2 ? `"${label2}"` : "The Record"} shows the app's one copy of its record, so a write anywhere in the app reaches it (dbmodelnode2.ts, "Record properties" ticked).`,
+      `  useEffect(() => (${row.name}?.id === undefined ? undefined : subscribeRecord<${read2.typeName}>(${row.name}.id, ${stateSetterOf(row.name)})), [${row.name}?.id]);`,
+      ""
+    );
   }
   for (const [, ref] of delayRefs) {
     body.push("  useEffect(() => () => {", `    stopDelay(${ref});`, "  }, []);", "");
@@ -271023,6 +272917,32 @@ ${pad(indent)}}`;
       ""
     );
   }
+  for (const ticked3 of plan.tickedRuns) {
+    const deps = [...new Set(ticked3.watch.flatMap(effectDeps))].join(", ");
+    body.push(
+      `  // ${ticked3.comment}`,
+      "  useEffect(() => {",
+      `    if (!tickedArrival(${tickedRecordArgs(ticked3.nodeId)})) return;`,
+      ...effectBody([ticked3.action], 4),
+      `  }, [${deps}]);`,
+      ""
+    );
+  }
+  for (const mount2 of mountChains) {
+    const node = nodeById.get(mount2.nodeId);
+    const mounted = dedupeLocal("mounted");
+    body.push(
+      `  // ${node.authoredLabel ?? node.type} \u2014 Did Mount: once, when it mounts, as the running app sends it.`,
+      `  const ${mounted} = useRef(false);`,
+      "  useEffect(() => {",
+      `    if (${mounted}.current) return;`,
+      `    ${mounted}.current = true;`,
+      ...effectBody(mount2.actions, 4),
+      "    // eslint-disable-next-line react-hooks/exhaustive-deps -- once, like the element's own Did Mount",
+      "  }, []);",
+      ""
+    );
+  }
   const actionExprsOf = (a8) => {
     switch (a8.kind) {
       case "emit":
@@ -271060,11 +272980,16 @@ ${pad(indent)}}`;
         return [a8.items];
       case "runtasks-abort":
         return [];
+      case "query-fetch":
+        return a8.values.map((v) => v.expr);
       // EXP-011 §58. The data; the config and listeners are walked off the plan.
       case "stream-action":
         return a8.value !== void 0 ? [a8.value] : [];
       case "jsfun-run":
         return [...jsArgExprs(a8.nodeId), ...a8.then.flatMap(actionExprsOf)];
+      case "jsfun-pulses":
+      case "jsfun-pulse":
+        return a8.then.flatMap(actionExprsOf);
       case "http-call":
       // EXP-011 §41. The same, one node over.
       case "cloud-call":
@@ -271088,7 +273013,8 @@ ${pad(indent)}}`;
       case "api-call":
         return [
           ...a8.args.flatMap((arg) => arg.kind === "expr" ? [arg.expr] : arg.props.map((p) => p.expr)),
-          ...a8.then.flatMap(actionExprsOf)
+          ...a8.then.flatMap(actionExprsOf),
+          ...a8.failThen.flatMap(actionExprsOf)
         ];
       // EXP-011 Tier 1.3. The Read reads nothing of its own; the chain is where the expressions
       // are, and a reader of this function wants them (the `usesPayload` test below is one).
@@ -271188,12 +273114,14 @@ ${pad(indent)}}`;
     for (const action of expandActions(receiver.actions)) body.push(`    ${actionCode(action)};`);
     body.push("  });", "");
   }
-  const providedJsx = printsRecord && !(jsxLines.length === 1 && jsxLines[0] === "    null") ? [
+  const removedRoot = jsxLines.length === 1 ? /^\s*\{\/\* (.*) \*\/\}$/.exec(jsxLines[0]) : null;
+  const providedJsx = printsRecord && removedRoot === null && !(jsxLines.length === 1 && jsxLines[0] === "    null") ? [
     `    <ParentComponentObjectContext.Provider value={${plan.componentObject.local}}>`,
     ...jsxLines.map((line) => line.trim().length === 0 ? line : `  ${line}`),
     "    </ParentComponentObjectContext.Provider>"
   ] : 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, "  );", "}");
   if (usesRowField) {
     body.push(
@@ -271263,6 +273191,7 @@ ${printDecls(query2.decls, "    ")}
     files[`${baseDir}/${plan.file.fileBase}.module.css`] = GENERATED_CSS2 + "\n" + cssBlocks.join("\n\n") + "\n";
   }
   for (const script2 of plan.scripts) files[script2.file] = scriptFileSource(script2, plan.path, plan.legacyPath);
+  for (const { def, file } of functionFiles) files[file] = functionFileSource(def, jsWrapperLines(def), plan.path);
   return {
     files,
     notes,
@@ -271270,6 +273199,8 @@ ${printDecls(query2.decls, "    ")}
     utilHelpers: usedUtilHelpers,
     idHelpers: usedIdHelpers,
     timerHelpers: usedTimerHelpers,
+    // EXP-011 §86.
+    functionRunLib: pulsedRunIds.size > 0 || tickedRunIds.size > 0,
     // EXP-011 §49. `states.ts` imports `animate.ts`, so a States alone earns both modules.
     animateLib: plan.animations.length > 0 || plan.statesMachines.length > 0,
     statesLib: plan.statesMachines.length > 0,
@@ -271366,6 +273297,24 @@ function scriptFileSource(script2, componentPath, legacyPath) {
   ];
   return lines.join("\n");
 }
+var GENERATED_FUNCTION_TS = "// @nodegx:generated (function node \u2014 provenance markers complete in EXP-007)";
+function functionFileSource(def, wrapper, componentPath) {
+  const safe = (text2) => text2.split("*/").join("* /");
+  const signature = `function ${def.fnName}(`;
+  const lines = [
+    "// @ts-nocheck",
+    GENERATED_FUNCTION_TS,
+    "//",
+    `// The Function node "${safe(def.fnName)}" (node ${safe(def.nodeId)}) of ${safe(componentPath)}, in a file of its own.`,
+    "// Type checking is off for this one file, as for a Script node's: the body is the author's JavaScript, not",
+    "// TypeScript. The signature is typed, and every call to it is checked in the component that makes it.",
+    ...(def.scripts?.length ?? 0) > 0 ? [`import { ${PROJECT_SCRIPTS_SYMBOL} } from '../../../${PROJECT_SCRIPT_FILES_PATH.replace(/^src\//, "").replace(/\.ts$/, "")}';`] : [],
+    "",
+    ...wrapper.map((line) => line.startsWith(signature) ? `export ${line}` : line),
+    ""
+  ];
+  return lines.join("\n");
+}
 function preOrder(plan) {
   if (!plan.rootId) return [];
   const out = [];
@@ -271424,7 +273373,7 @@ function jsxAttr(name, value) {
   return `${name}={${value}}`;
 }
 function jsxText(text2) {
-  if (/[{}<>]/.test(text2)) return `{${JSON.stringify(text2)}}`;
+  if (/[{}<>&\r\n]/.test(text2) || /^\s|\s$/.test(text2)) return `{${JSON.stringify(text2)}}`;
   return text2;
 }
 function withFallback(code, fallback) {
@@ -271506,6 +273455,14 @@ function filledArcPath(x, y, radius, startAngle, endAngle) {
     svgNumber(start3.y)
   ].join(" ");
 }
+function runIsPulsed(action) {
+  return action.then.some((a8) => a8.kind === "jsfun-pulses");
+}
+function pulseNamesOf(def) {
+  const camel = def.fnName.replace(/_+([A-Za-z0-9])/g, (_m, c) => c.toUpperCase()).replace(/_+$/, "");
+  const base = camel.charAt(0).toLowerCase() + camel.slice(1);
+  return { run: `${base}Run`, node: `${base}Node`, pulse: `${base}Pulse`, held: `${base}Held` };
+}
 
 // ../nodegx-export/src/emit/dateLib.ts
 var DATE_LIB_PATH = "src/lib/date.ts";
@@ -272067,8 +274024,8 @@ var coverage_ledger_default = {
     },
     {
       typeName: "DbCollection2",
-      status: "stubbed",
-      exemption: "typed api stub + useState/useEffect \u2014 the backend seam, by design (phase README: no backend code export)"
+      status: "translated",
+      note: "Was `stubbed` with \"no backend code export\", which EXP-009 overtook: the query is a fetch<Type>() in src/api/<class>.ts that calls the EXP-009 client's query() against the project's NodeGX backend, held in useState and run in a useEffect at mount, or in the handler of whatever sends Fetch (P18-S116-QUERYFETCH, the-query-fetch.test.ts). Reclassified 2026-10-17 by reading the api module emitted for tests/fixtures/puppy-test-3 (fetchPuppies() returns query<Puppy>('Puppy')); the internal disposition is still named 'stubbed' (visual.test.ts)."
     },
     {
       typeName: "DbModel",
@@ -273377,6 +275334,17 @@ function emitApp(ir, catalog2) {
     notes.push(cloud);
     projectNotes.push(cloud);
   }
+  for (const store2 of project2.stores) {
+    for (const n of store2.notes) {
+      const line = `${n.componentPath}: node ${n.nodeId} (net.noodl.GlobalStore, store "${store2.name}"): ${n.text}`;
+      notes.push(line);
+      projectNotes.push(line);
+    }
+  }
+  for (const line of routerNotes(ir)) {
+    notes.push(line);
+    projectNotes.push(line);
+  }
   const unreachable = /* @__PURE__ */ new Set();
   for (const legacy of project2.reachability.unreachable) {
     const path43 = legacy.replace(/^\//, "");
@@ -273389,6 +275357,7 @@ function emitApp(ir, catalog2) {
   const utilHelpersUsed = /* @__PURE__ */ new Set();
   const idHelpersUsed = /* @__PURE__ */ new Set();
   const timerHelpersUsed = /* @__PURE__ */ new Set();
+  let functionRunLibUsed = false;
   let animateLibUsed = false;
   let statesLibUsed = false;
   let scriptLibUsed = false;
@@ -273459,6 +275428,7 @@ function emitApp(ir, catalog2) {
     for (const helper of emitted.dateHelpers) dateHelpersUsed.add(helper);
     for (const helper of emitted.utilHelpers) utilHelpersUsed.add(helper);
     for (const helper of emitted.idHelpers) idHelpersUsed.add(helper);
+    if (emitted.functionRunLib) functionRunLibUsed = true;
     for (const helper of emitted.timerHelpers) timerHelpersUsed.add(helper);
     if (emitted.animateLib) animateLibUsed = true;
     if (emitted.statesLib) statesLibUsed = true;
@@ -273496,6 +275466,9 @@ function emitApp(ir, catalog2) {
   if (idHelpersUsed.size > 0) {
     files[ID_LIB_PATH] = GENERATED_MODULE_TS + idLibSource();
   }
+  if (functionRunLibUsed) {
+    files[FUNCTION_RUN_LIB_PATH] = GENERATED_MODULE_TS + functionRunLibSource();
+  }
   if (timerHelpersUsed.size > 0) {
     files[TIMER_LIB_PATH] = GENERATED_MODULE_TS + timerLibSource();
   }
@@ -273647,7 +275620,7 @@ function apiModules(ir, project2) {
     if (entry === void 0) {
       byCollection.set(
         collectionName4,
-        entry = { typeName: typeName3, moduleBase, querySites: [], readSites: [], mutations: /* @__PURE__ */ new Map(), writes: /* @__PURE__ */ new Map(), reads: /* @__PURE__ */ new Map() }
+        entry = { typeName: typeName3, moduleBase, querySites: [], queryParams: false, readSites: [], mutations: /* @__PURE__ */ new Map(), writes: /* @__PURE__ */ new Map(), reads: /* @__PURE__ */ new Map() }
       );
     }
     return entry;
@@ -273657,11 +275630,14 @@ function apiModules(ir, project2) {
       const entry = moduleFor(query2.collectionName, query2.typeName, query2.moduleBase);
       entry.fetchName = query2.fetchName;
       entry.querySites.push({ componentPath: plan.path, nodeId: query2.nodeId });
+      if (query2.params !== void 0) entry.queryParams = true;
     }
     for (const read2 of plan.recordReads) {
       const entry = moduleFor(read2.collectionName, read2.typeName, read2.moduleBase);
-      entry.fetchOneName = read2.fnName;
-      entry.readSites.push({ componentPath: plan.path, nodeId: read2.nodeId });
+      if (!read2.binds) {
+        entry.fetchOneName = read2.fnName;
+        entry.readSites.push({ componentPath: plan.path, nodeId: read2.nodeId });
+      }
       for (const column of read2.reads) {
         if (!entry.reads.has(column.name)) entry.reads.set(column.name, column.tsType);
       }
@@ -273682,6 +275658,8 @@ function apiModules(ir, project2) {
   const hasSubscriptions = project2.plans.some((plan) => plan.streams.some((stream) => stream.kind === "subscription"));
   const hasSignIns = project2.plans.some((plan) => plan.streams.some((stream) => stream.kind === "signin"));
   const hasReturnLeg = hasSignIns || project2.plans.some((plan) => plan.sessionCalls.some((call5) => call5.verb === "magic-link"));
+  const liveRecords = project2.plans.some((plan) => plan.recordReads.some((read2) => read2.live || read2.binds));
+  const wiredFilters = project2.plans.some((plan) => plan.queries.some((query2) => query2.params?.wired !== void 0 && query2.wiredClient === true));
   const hasApi = byCollection.size > 0 || hasSessionCalls || hasCloudCalls || hasFileOps || hasSubscriptions || hasSignIns;
   const notes = [];
   const backend = ir.project.cloudservices;
@@ -273704,7 +275682,7 @@ function apiModules(ir, project2) {
   let anyFileColumn = false;
   for (const [collectionName4, module2] of byCollection) {
     const schema = ir.project.collections.find((c) => c.name === collectionName4);
-    const { typeName: typeName3, moduleBase, fetchName, querySites, fetchOneName, readSites, mutations, writes, reads } = module2;
+    const { typeName: typeName3, moduleBase, fetchName, querySites, queryParams, fetchOneName, readSites, mutations, writes, reads } = module2;
     const columns = /* @__PURE__ */ new Map();
     for (const col of schema?.columns ?? []) columns.set(col.name, tsColumnType(col.type));
     for (const [name, tsType] of writes) if (!columns.has(name)) columns.set(name, tsType);
@@ -273726,16 +275704,20 @@ ${fields.join("\n")}${fields.length > 0 ? "\n" : ""}}
 ${querySites.map((s) => siteLine(s, "DbCollection2")).join("\n")}
  * Fetches the \`${collectionName4}\` collection from the project's NodeGX backend
  * (src/api/client.ts); the export report lists every call site.
- */
-export async function ${fetchName}(): Promise<${typeName3}[]> {
+` + (queryParams ? ` * Each site passes its own filter, order and limit, as the running app sends them.
+` : "") + ` */
+` + (queryParams ? `export async function ${fetchName}(params?: QueryParams): Promise<${typeName3}[]> {
+  return query<${typeName3}>(${tsStringLiteral(collectionName4)}, params);
+}
+` : `export async function ${fetchName}(): Promise<${typeName3}[]> {
   return query<${typeName3}>(${tsStringLiteral(collectionName4)});
 }
-` : `/**
+`) : `/**
 ${querySites.map((s) => siteLine(s, "DbCollection2")).join("\n")}
  * fetched the \`${collectionName4}\` collection from the project's NodeGX backend. Connect this to your
  * own data source; the export report lists every call site.
  */
-export async function ${fetchName}(): Promise<${typeName3}[]> {
+export async function ${fetchName}(${queryParams ? "_params?: unknown" : ""}): Promise<${typeName3}[]> {
   return [];
 }
 `
@@ -273824,9 +275806,11 @@ export async function ${fnName}${signature} {
           verb === "create" ? "create" : verb === "update" ? "update" : verb === "add-relation" ? "addRelation" : verb === "remove-relation" ? "removeRelation" : "remove"
         );
       }
-      const importLine = `import { ${[...clientImports].sort().join(", ")} } from './client';
+      const clientNames = [...[...clientImports].sort(), ...fetchName !== void 0 && queryParams ? ["type QueryParams"] : []];
+      const importLine = clientNames.length === 0 ? "" : `import { ${clientNames.join(", ")} } from './client';
 `;
-      stubs.push([`src/api/${moduleBase}.ts`, GENERATED_MODULE_TS + importLine + filesImport + "\n" + parts.join("\n")]);
+      const imports = importLine + filesImport;
+      stubs.push([`src/api/${moduleBase}.ts`, GENERATED_MODULE_TS + (imports === "" ? "" : imports + "\n") + parts.join("\n")]);
     } else {
       stubs.push([`src/api/${moduleBase}.ts`, GENERATED_TS4 + (filesImport === "" ? "" : filesImport + "\n") + parts.join("\n")]);
     }
@@ -273843,7 +275827,7 @@ export async function ${fnName}${signature} {
   const files = filesModule(project2, backend, siteLine, anyFileColumn);
   if (files !== null) stubs.push(files);
   if (backend !== void 0 && hasApi) {
-    stubs.push(["src/api/client.ts", clientModule(backend, hasReturnLeg)]);
+    stubs.push(["src/api/client.ts", clientModule(backend, hasReturnLeg, liveRecords, wiredFilters)]);
     stubs.push([".env.example", envExample(backend)]);
   }
   return { files: stubs, notes, usesBackend: hasApi };
@@ -274449,7 +276433,87 @@ function envLine(name, value) {
   return `${name}=${value.replace(/[\r\n]/g, "")}
 `;
 }
-function clientModule(backend, returnLeg) {
+var PLAIN_UPDATE_SOURCE = `export async function update<T extends { id: string }>(collection: string, id: string, data: Partial<T>): Promise<T> {
+  // The wire answers a PUT with the changed fields only (\`updatedAt\`), so the
+  // caller's own data is the record the graph continues with.
+  const response = await request<Record<string, unknown>>(\`/classes/\${collection}/\${encodeURIComponent(id)}\`, {
+    method: 'PUT',
+    body: data
+  });
+  const { objectId: _objectId, ...fields } = response;
+  return { ...data, ...fields, id } as unknown as T;
+}
+`;
+var HELD_RECORDS_SOURCE = `
+/**
+ * The app's one copy of each record, keyed by its id alone as the running app keys them
+ * (\`Model.get(id)\`). Every read merges into it field by field, as the running app's
+ * \`_fromJSON\` does, and nothing removes a field. A Record shows this copy, so a write
+ * anywhere in the app reaches it at once.
+ */
+type HeldRecord = { id: string } & Record<string, unknown>;
+const heldRecords = new Map<string, HeldRecord>();
+const recordListeners = new Map<string, Set<(row: HeldRecord) => void>>();
+
+function holdRecord<T extends { id: string }>(fields: T): T {
+  const row = { ...heldRecords.get(fields.id), ...fields } as HeldRecord;
+  heldRecords.set(fields.id, row);
+  recordListeners.get(fields.id)?.forEach((listener) => listener(row));
+  return row as unknown as T;
+}
+
+/** Hands \`listener\` the record's copy now, and again after every write to it, until the returned function is called. */
+export function subscribeRecord<T extends { id: string }>(id: string, listener: (row: T) => void): () => void {
+  const call = listener as unknown as (row: HeldRecord) => void;
+  const listeners = recordListeners.get(id) ?? new Set<(row: HeldRecord) => void>();
+  recordListeners.set(id, listeners);
+  listeners.add(call);
+  const held = heldRecords.get(id);
+  if (held !== undefined) call(held);
+  return () => {
+    listeners.delete(call);
+  };
+}
+`;
+var HELD_UPDATE_SOURCE = `export async function update<T extends { id: string }>(collection: string, id: string, data: Partial<T>): Promise<T> {
+  // The running app writes the record before the save and puts back what it held if the
+  // save fails, so a Record showing it moves at the press. The wire answers a PUT with
+  // the changed fields only (\`updatedAt\`), so the caller's own data is the record the
+  // graph continues with.
+  const held: Record<string, unknown> = heldRecords.get(id) ?? {};
+  const before: Record<string, unknown> = {};
+  for (const key of Object.keys(data)) before[key] = held[key];
+  holdRecord({ ...data, id });
+  let response: Record<string, unknown>;
+  try {
+    response = await request<Record<string, unknown>>(\`/classes/\${collection}/\${encodeURIComponent(id)}\`, {
+      method: 'PUT',
+      body: data
+    });
+  } catch (error) {
+    holdRecord({ ...before, id });
+    throw error;
+  }
+  const { objectId: _objectId, ...fields } = response;
+  holdRecord({ ...fields, id });
+  return { ...data, ...fields, id } as unknown as T;
+}
+`;
+var FILTER_VALUE_SOURCE = `
+/**
+ * A filter value as the running app puts it on the wire: a Date goes as the backend's date envelope, and so does a
+ * date written as text when its column is a Date. Anything else goes as it is.
+ */
+export function filterValue(value: unknown, dateColumn = false): unknown {
+  if (value instanceof Date) return { __type: 'Date', iso: value.toISOString() };
+  if (dateColumn && value !== null && value !== undefined) {
+    const asDate = new Date(String(value));
+    if (!Number.isNaN(asDate.getTime())) return { __type: 'Date', iso: asDate.toISOString() };
+  }
+  return value;
+}
+`;
+function clientModule(backend, returnLeg, liveRecords, wiredFilters = false) {
   return GENERATED_CLIENT_TS + `/**
  * The NodeGX backend client \u2014 the Parse wire protocol the running app speaks
  * (noodl-runtime's ParseWireAdapter), reduced to what this app's calls need:
@@ -274601,7 +276665,7 @@ function fromWire<T extends { id: string }>(record: Record<string, unknown>): T
   for (const [key, value] of Object.entries(fields)) row[key] = fromWireValue(value);
   return row as unknown as T;
 }
-
+${liveRecords ? HELD_RECORDS_SOURCE : ""}${wiredFilters ? FILTER_VALUE_SOURCE : ""}
 export interface QueryParams {
   where?: unknown;
   sort?: string[];
@@ -274622,13 +276686,13 @@ export async function query<T extends { id: string }>(collection: string, params
       skip: params.skip
     }
   });
-  return response.results.map((record) => fromWire<T>(record));
+  return response.results.map((record) => ${liveRecords ? "holdRecord(fromWire<T>(record))" : "fromWire<T>(record)"});
 }
 
 /** One record by Id \u2014 the runtime's own \`GET /classes/<collection>/<id>\` (ParseWireAdapter.fetch). */
 export async function fetchOne<T extends { id: string }>(collection: string, id: string): Promise<T> {
   const response = await request<Record<string, unknown>>(\`/classes/\${collection}/\${encodeURIComponent(id)}\`);
-  return fromWire<T>(response);
+  return ${liveRecords ? "holdRecord(fromWire<T>(response))" : "fromWire<T>(response)"};
 }
 
 export async function create<T extends { id: string }>(collection: string, data: Partial<T>): Promise<T> {
@@ -274636,20 +276700,10 @@ export async function create<T extends { id: string }>(collection: string, data:
     method: 'POST',
     body: data
   });
-  return fromWire<T>({ ...data, ...response });
-}
-
-export async function update<T extends { id: string }>(collection: string, id: string, data: Partial<T>): Promise<T> {
-  // The wire answers a PUT with the changed fields only (\`updatedAt\`), so the
-  // caller's own data is the record the graph continues with.
-  const response = await request<Record<string, unknown>>(\`/classes/\${collection}/\${encodeURIComponent(id)}\`, {
-    method: 'PUT',
-    body: data
-  });
-  const { objectId: _objectId, ...fields } = response;
-  return { ...data, ...fields, id } as unknown as T;
+  return ${liveRecords ? "holdRecord(fromWire<T>({ ...data, ...response }))" : "fromWire<T>({ ...data, ...response })"};
 }
 
+${liveRecords ? HELD_UPDATE_SOURCE : PLAIN_UPDATE_SOURCE}
 export async function remove(collection: string, id: string): Promise<void> {
   await request<unknown>(\`/classes/\${collection}/\${encodeURIComponent(id)}\`, { method: 'DELETE' });
 }
@@ -275764,6 +277818,11 @@ function byType() {
   }
   return cachedByType;
 }
+var cachedShipped;
+function shippedTypeNames() {
+  if (!cachedShipped) cachedShipped = new Set(shippedCatalog.nodes.map((n) => n.typeName));
+  return cachedShipped;
+}
 function allExamples() {
   return shippedCatalog.examples ?? [];
 }
@@ -276391,39 +278450,6 @@ function validateComponentPath(path43) {
 }
 
 // src/project/runOnChangePins.ts
-var projectWillBeCleanedUp = (version2) => projectPredatesRunOnValueChange(version2);
-var incomingOf = (connections, id) => JSON.stringify(
-  (connections ?? []).filter((c) => c.toId === id).map((c) => `${c.fromId}.${c.fromProperty}>${c.toProperty}`).sort()
-);
-function pinAuthoredRunOnChange(key2, files, onDisk) {
-  const nodes = files.nodes.nodes ?? [];
-  const plan = planRunOnValueChangeMigration({
-    components: [{ name: key2, graph: { roots: nodes, connections: files.connections.connections } }]
-  });
-  if (plan.writes.length === 0) return [];
-  const before = /* @__PURE__ */ new Map();
-  for (const n of onDisk?.nodes.nodes ?? []) before.set(n.id, n);
-  const authored = (n) => {
-    const old = before.get(n.id);
-    if (!old) return true;
-    if (JSON.stringify(old) !== JSON.stringify(n)) return true;
-    return incomingOf(onDisk?.connections.connections, n.id) !== incomingOf(files.connections.connections, n.id);
-  };
-  const byNode = /* @__PURE__ */ new Map();
-  for (const w of plan.writes) byNode.set(w.nodeId, [...byNode.get(w.nodeId) ?? [], w.parameter]);
-  const written2 = [];
-  for (const node of nodes) {
-    const parameters = byNode.get(node.id);
-    if (!parameters || !authored(node)) continue;
-    const existing = node.parameters ?? {};
-    const rebuilt = {};
-    for (const p of parameters) rebuilt[p] = true;
-    for (const name of Object.keys(existing)) if (!(name in rebuilt)) rebuilt[name] = existing[name];
-    node.parameters = rebuilt;
-    for (const p of parameters) written2.push({ node: node.id, parameter: p });
-  }
-  return written2;
-}
 var TICKED_WHY = 'This project was saved before the "run on value change" setting existed. The editor upgrades it the next time it opens. That upgrade unticks every unset box on a node whose Run is wired. The door wrote these boxes as ticked, which is what an unset box means today. Each node still runs when these values change. Send the parameter as false to switch one off.';
 function tickedPayload(boxes) {
   return boxes && boxes.length > 0 ? { ticked: { boxes: [...boxes], why: TICKED_WHY } } : {};
@@ -277629,6 +279655,70 @@ function completionPayload(state) {
   };
 }
 
+// src/honesty.ts
+var COMPONENT_SCRIPT_NODES_SHOWN = 12;
+var PROJECT_COMPONENTS_SHOWN = 5;
+var PROJECT_SCRIPT_TYPES_SHOWN = 8;
+function honestyComponents(store2) {
+  return portProjectFromStore(store2.format).components.map((c) => ({ name: c.name, nodes: c.nodes }));
+}
+function projectHonestyOf(store2) {
+  return projectHonesty(honestyComponents(store2), { coreTypes: shippedTypeNames() });
+}
+function componentHonestyOf(name, nodes) {
+  return componentHonesty({ name, nodes }, { coreTypes: shippedTypeNames() });
+}
+function projectHonestyPayload(h) {
+  const byType2 = {};
+  for (const p of h.scriptParts) byType2[p.type] = (byType2[p.type] ?? 0) + 1;
+  return {
+    line: honestyLine(h, 0),
+    percent: h.percent,
+    known: h.known,
+    script: h.script,
+    unspecced: h.unspecced,
+    percentByLines: h.percentByLines,
+    scriptLines: h.scriptLines,
+    scriptByType: Object.fromEntries(
+      Object.entries(byType2).sort((a8, b) => b[1] - a8[1] || a8[0].localeCompare(b[0])).slice(0, PROJECT_SCRIPT_TYPES_SHOWN)
+    ),
+    mostScript: h.components.filter((c) => c.script > 0).sort((a8, b) => b.script - a8.script || a8.component.localeCompare(b.component)).slice(0, PROJECT_COMPONENTS_SHOWN).map((c) => ({ component: c.component, percent: c.percent, script: c.script })),
+    about: HONESTY_SENTENCE
+  };
+}
+function componentHonestyPayload(h) {
+  const parts = [...h.scriptParts].sort((a8, b) => b.lines - a8.lines);
+  return {
+    line: honestyLine(h),
+    percent: h.percent,
+    known: h.known,
+    script: h.script,
+    unspecced: h.unspecced,
+    scriptNodes: parts.slice(0, COMPONENT_SCRIPT_NODES_SHOWN).map((p) => ({ id: p.id, type: p.type, ...p.label ? { label: p.label } : {}, lines: p.lines })),
+    ...parts.length > COMPONENT_SCRIPT_NODES_SHOWN ? { moreScriptNodes: parts.length - COMPONENT_SCRIPT_NODES_SHOWN } : {}
+  };
+}
+function writeHonestyPayload(store2, legacyName) {
+  const project2 = projectHonestyOf(store2);
+  const mine = project2.components.find((c) => c.component === legacyName);
+  return {
+    honesty: {
+      component: mine ? `this component: ${honestyLine(mine)}` : "this component: not found after the write",
+      project: `the project: ${honestyLine(project2, 0)}`
+    }
+  };
+}
+function honestySection(h) {
+  const most = projectHonestyPayload(h).mostScript;
+  const named = h.scriptParts.length ? [...h.scriptParts].sort((a8, b) => b.lines - a8.lines).slice(0, 3).map((p) => "`" + scriptPartName(p) + "`") : [];
+  return [
+    `HONESTY \u2014 ${honestyLine(h, 0)}` + (h.percentByLines !== null && h.script ? `; ${h.percentByLines}% weighed by script lines (${h.scriptLines} lines).` : "."),
+    most.length ? `Most script: ${most.map((c) => `${c.component} ${c.script} (${c.percent === null ? "\u2014" : c.percent + "%"})`).join(", ")}.` : "No script nodes.",
+    named.length ? `Largest script parts: ${named.join(", ")}.` : "",
+    HONESTY_SENTENCE
+  ].filter(Boolean).join("\n");
+}
+
 // src/tools/util.ts
 function jsonResult(payload) {
   return { content: [{ type: "text", text: JSON.stringify(payload) }] };
@@ -279108,7 +281198,9 @@ function registerAuthorTools(server, binding, plans, examples, ledger, disclosur
           // it yet. Said on every visual write rather than only on pages: a
           // section component is what the page is made of, and "I only changed
           // a card" is how a page stops being the thing anybody renders.
-          ...drawsSomething(candidate) ? completionPayload(ledger.state(store2.projectDir)) : {}
+          ...drawsSomething(candidate) ? completionPayload(ledger.state(store2.projectDir)) : {},
+          // P111 SEE-001 — the component's number with its script named, and the project's after this write
+          ...writeHonestyPayload(store2, legacyName)
         };
         return jsonResult(payload);
       }
@@ -279202,7 +281294,9 @@ function registerAuthorTools(server, binding, plans, examples, ledger, disclosur
           ...backendRevealPayload(disclosure?.revealForNodes(candidate.nodes.nodes) ?? []),
           ...unchanged ? {} : cloudDeployPayload([stored.legacyName], store2, disclosure),
           ...visualRootsPayload(candidate, args.set?.visual_roots),
-          ...drawsSomething(candidate) ? completionPayload(ledger.state(store2.projectDir)) : {}
+          ...drawsSomething(candidate) ? completionPayload(ledger.state(store2.projectDir)) : {},
+          // P111 SEE-001 — the component's number with its script named, and the project's after this write
+          ...writeHonestyPayload(store2, stored.legacyName)
         };
         return jsonResult(payload);
       }
@@ -281914,7 +284008,7 @@ function registerBackendWriteTools(server, binding) {
     }).optional().describe('Required for type "schedule"'),
     webhook: external_exports.object({
       slug: external_exports.string().describe("URL slug: POST /hooks/<backendId>/<slug>"),
-      scheme: external_exports.enum(["hmac-sha256", "token"]).optional().describe("Secret scheme (default hmac-sha256)"),
+      scheme: external_exports.enum(["hmac-sha256", "hmac-sha512", "token"]).optional().describe("Secret scheme (default hmac-sha256; hmac-sha512 is Paystack: secret = its key)"),
       maxBodyBytes: external_exports.number().optional().describe("Body size limit (default 1MB)")
     }).optional().describe('Required for type "webhook"'),
     dbChange: external_exports.object({
@@ -287007,7 +289101,9 @@ function registerReadTools(server, binding, options) {
             note: "Standing preferences this user wrote about themselves. They hold in every project, and they outrank your own habits and defaults. This project's own conventions (docs/CONVENTIONS.md) outrank them in turn: where the two disagree, follow the project and say that you did.",
             preferences: userPreferences
           }
-        } : {}
+        } : {},
+        // P111 SEE-001 — the honesty number, always (R2). A result field: no resident-surface cost.
+        honesty: projectHonestyPayload(projectHonestyOf(store2))
       };
       return jsonResult(payload);
     })
@@ -287081,6 +289177,7 @@ function registerReadTools(server, binding, options) {
       };
       const drawn3 = drawnPortsFor(store2, stored.files.component.path ?? "/" + stored.key, stored.files.nodes.nodes);
       if (Object.keys(drawn3).length) payload.drawnPorts = drawn3;
+      payload.honesty = componentHonestyPayload(componentHonestyOf(stored.legacyName, stored.files.nodes.nodes));
       return jsonResult(payload);
     })
   );
@@ -287210,6 +289307,9 @@ function registerRenderTools(server, binding, ledger, options = {}) {
             // page nobody could reach.
             ...verdict ? [{ type: "text", text: verdictHeadline(verdict) }] : [],
             { type: "text", text: JSON.stringify(report3) },
+            // P111 SEE-001 — the honesty number, the same one get_project_info and every write report (a result block:
+            // no resident-surface cost). Read from the files the render read.
+            { type: "text", text: honestySection(projectHonestyOf(binding.require())) },
             // FLD-011 AC1 — with `out_dir` the harness wrote files and returned no base64, so
             // `screenshots` is empty and the loop below produces nothing. The manifest replaces it,
             // because a caller told only "written to a folder" has to list a directory to find out
@@ -291275,7 +293375,7 @@ function refuseUnknownArguments(server) {
 // src/server.ts
 var PKG_VERSION3 = (
   // eslint-disable-next-line @typescript-eslint/no-var-requires
-  true ? "0.4.1" : null.version
+  true ? "0.4.2" : null.version
 );
 function createServer2(options) {
   setClientProfile(options.profile);