@nodegx/preview 0.2.7 → 0.2.9

package/dist/noodl-preview.cjs

@@ -4936,7 +4936,7 @@ var require_lib3 = __commonJS({
         return this.resolve([]);
       }
       var values2 = new Array(len);
-      var resolved2 = 0;
+      var resolved3 = 0;
       var i2 = -1;
       var promise = new this(INTERNAL);
       while (++i2 < len) {
@@ -4952,7 +4952,7 @@ var require_lib3 = __commonJS({
         });
         function resolveFromAll(outValue) {
           values2[i3] = outValue;
-          if (++resolved2 === len && !called) {
+          if (++resolved3 === len && !called) {
             called = true;
             handlers.resolve(promise, values2);
           }
@@ -6222,15 +6222,15 @@ var require_crc32 = __commonJS({
     "use strict";
     var utils = require_utils3();
     function makeTable() {
-      var c, table = [];
+      var c, table2 = [];
       for (var n = 0; n < 256; n++) {
         c = n;
         for (var k = 0; k < 8; k++) {
           c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
         }
-        table[n] = c;
+        table2[n] = c;
       }
-      return table;
+      return table2;
     }
     var crcTable = makeTable();
     function crc32(crc, buf, len, pos) {
@@ -7228,15 +7228,15 @@ var require_crc322 = __commonJS({
   "../../node_modules/pako/lib/zlib/crc32.js"(exports2, module2) {
     "use strict";
     function makeTable() {
-      var c, table = [];
+      var c, table2 = [];
       for (var n = 0; n < 256; n++) {
         c = n;
         for (var k = 0; k < 8; k++) {
           c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
         }
-        table[n] = c;
+        table2[n] = c;
       }
-      return table;
+      return table2;
     }
     var crcTable = makeTable();
     function crc32(crc, buf, len, pos) {
@@ -9030,7 +9030,7 @@ var require_inftrees = __commonJS({
       64,
       64
     ];
-    module2.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
+    module2.exports = function inflate_table(type, lens, lens_index, codes, table2, table_index, work, opts) {
       var bits = opts.bits;
       var len = 0;
       var sym = 0;
@@ -9070,8 +9070,8 @@ var require_inftrees = __commonJS({
         root2 = max2;
       }
       if (max2 === 0) {
-        table[table_index++] = 1 << 24 | 64 << 16 | 0;
-        table[table_index++] = 1 << 24 | 64 << 16 | 0;
+        table2[table_index++] = 1 << 24 | 64 << 16 | 0;
+        table2[table_index++] = 1 << 24 | 64 << 16 | 0;
         opts.bits = 1;
         return 0;
       }
@@ -9146,7 +9146,7 @@ var require_inftrees = __commonJS({
         min2 = fill;
         do {
           fill -= incr;
-          table[next + (huff >> drop2) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
+          table2[next + (huff >> drop2) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
         } while (fill !== 0);
         incr = 1 << len - 1;
         while (huff & incr) {
@@ -9185,11 +9185,11 @@ var require_inftrees = __commonJS({
             return 1;
           }
           low = huff & mask;
-          table[low] = root2 << 24 | curr << 16 | next - table_index | 0;
+          table2[low] = root2 << 24 | curr << 16 | next - table_index | 0;
         }
       }
       if (huff !== 0) {
-        table[next + huff] = len - drop2 << 24 | 64 << 16 | 0;
+        table2[next + huff] = len - drop2 << 24 | 64 << 16 | 0;
       }
       opts.bits = root2;
       return 0;
@@ -9236,7 +9236,7 @@ var require_inflate = __commonJS({
     var STORED = 14;
     var COPY_ = 15;
     var COPY = 16;
-    var TABLE2 = 17;
+    var TABLE3 = 17;
     var LENLENS = 18;
     var CODELENS = 19;
     var LEN_ = 20;
@@ -9824,7 +9824,7 @@ var require_inflate = __commonJS({
                   }
                   break;
                 case 2:
-                  state2.mode = TABLE2;
+                  state2.mode = TABLE3;
                   break;
                 case 3:
                   strm.msg = "invalid block type";
@@ -9882,7 +9882,7 @@ var require_inflate = __commonJS({
               }
               state2.mode = TYPE;
               break;
-            case TABLE2:
+            case TABLE3:
               while (bits < 14) {
                 if (have === 0) {
                   break inf_leave;
@@ -13786,7 +13786,7 @@ var require_common2 = __commonJS({
     exports2.ownProp = ownProp;
     exports2.makeAbs = makeAbs;
     exports2.finish = finish2;
-    exports2.mark = mark;
+    exports2.mark = mark2;
     exports2.isIgnored = isIgnored;
     exports2.childrenIgnored = childrenIgnored;
     function ownProp(obj, field) {
@@ -13922,7 +13922,7 @@ var require_common2 = __commonJS({
         });
       self2.found = all;
     }
-    function mark(self2, p) {
+    function mark2(self2, p) {
       var abs = makeAbs(self2, p);
       var c = self2.cache[abs];
       var m = p;
@@ -18973,8 +18973,21 @@ var require_node2 = __commonJS({
       const scope = this.nodeScope;
       const runContext = scope && scope.runContext;
       if (!runContext || !runContext.beginStep || !runContext.endStep) return;
-      const step = runContext.beginStep({ nodeId: this.id, nodeType: this.name });
-      if (step !== void 0 && step !== null) runContext.endStep(step, { status: "failure", code, message, detail });
+      const recordValues = !!runContext.recordValues;
+      const step = runContext.beginStep({
+        nodeId: this.id,
+        nodeType: this.name,
+        ...recordValues ? { inputs: snapshotInputValues(this) } : {}
+      });
+      if (step !== void 0 && step !== null) {
+        runContext.endStep(step, {
+          status: "failure",
+          code,
+          message,
+          detail,
+          ...recordValues ? { outputs: snapshotOutputValues(this) } : {}
+        });
+      }
     };
     Node17.prototype.setDiagnostic = function(key, message) {
       setDiagnostic(this, key, message);
@@ -18984,6 +18997,47 @@ var require_node2 = __commonJS({
         return diagnosticsEnabled(this);
       }
     });
+    function isSignalPortType(type) {
+      if (type === "signal") return true;
+      return !!type && typeof type === "object" && type.name === "signal";
+    }
+    function snapshotInputValues(node) {
+      const out = {};
+      const values2 = node._inputValues || {};
+      const inputs = node._inputs || {};
+      let declared2 = {};
+      try {
+        const register = node.context && node.context.nodeRegister;
+        if (register && register.hasNode(node.name)) declared2 = register.getNodeMetadata(node.name).inputs || {};
+      } catch (e) {
+      }
+      for (const name2 of Object.keys(values2)) {
+        const value2 = values2[name2];
+        if (value2 === void 0 || typeof value2 === "function") continue;
+        const port = inputs[name2];
+        if (port && isSignalPortType(port.type)) continue;
+        const meta = declared2[name2];
+        if (meta && isSignalPortType(meta.type)) continue;
+        out[name2] = value2;
+      }
+      return out;
+    }
+    function snapshotOutputValues(node) {
+      const out = {};
+      const list = node._outputList || [];
+      for (const port of list) {
+        if (!port || isSignalPortType(port.type)) continue;
+        let value2;
+        try {
+          value2 = port.value;
+        } catch (e) {
+          continue;
+        }
+        if (value2 === void 0 || typeof value2 === "function") continue;
+        out[port.name] = value2;
+      }
+      return out;
+    }
     Node17.prototype.beginOutcome = function(inputData) {
       const token = { reported: void 0 };
       const cause = currentTraceCause(this.context);
@@ -18991,7 +19045,13 @@ var require_node2 = __commonJS({
       const scope = this.nodeScope;
       const runContext = scope && scope.runContext;
       if (runContext && runContext.beginStep) {
-        token.step = runContext.beginStep({ nodeId: this.id, nodeType: this.name, inputData });
+        token.step = runContext.beginStep({
+          nodeId: this.id,
+          nodeType: this.name,
+          inputData,
+          // P123-STU-FNRUNVALUES — opt-in; absent, the step object is exactly what it always was.
+          ...runContext.recordValues ? { inputs: snapshotInputValues(this) } : {}
+        });
       }
       return token;
     };
@@ -19070,7 +19130,10 @@ var require_node2 = __commonJS({
             message: options && options.message,
             // The subject of the failure, for a record whose steps are all called `http`. See
             // `RuntimeStepEnd.detail` — the node already composes this for the error bus.
-            detail: options && options.detail
+            detail: options && options.detail,
+            // P123-STU-FNRUNVALUES — read now, after the signals: "the outcome is the last thing an
+            // action does", so every value it produced is already on its ports.
+            ...runContext.recordValues ? { outputs: snapshotOutputValues(this) } : {}
           });
         }
       }
@@ -19380,10 +19443,10 @@ var require_nodescope = __commonJS({
       } else {
         const parameters = nodeModel.parameters;
         var inputNames = Object.keys(parameters);
-        const RUN_ON_CHANGE_PREFIX4 = "runOnChange-";
+        const RUN_ON_CHANGE_PREFIX5 = "runOnChange-";
         const metadata = this.context.nodeRegister.hasNode(node.name) ? this.context.nodeRegister.getNodeMetadata(node.name) : void 0;
         const priorityOf = function(name2) {
-          if (name2.indexOf(RUN_ON_CHANGE_PREFIX4) === 0) return Number.MAX_SAFE_INTEGER;
+          if (name2.indexOf(RUN_ON_CHANGE_PREFIX5) === 0) return Number.MAX_SAFE_INTEGER;
           const input2 = metadata ? metadata.inputs[name2] : void 0;
           return input2 ? input2.inputPriority : 0;
         };
@@ -21345,11 +21408,11 @@ var require_editorconnection = __commonJS({
       });
     };
     var serviceRequests = {};
-    EditorConnection.prototype.sendServiceRequest = function(request, callback) {
-      request.token = guid4();
-      request.clientId = this.clientId;
-      serviceRequests[request.token] = callback;
-      this.send(request);
+    EditorConnection.prototype.sendServiceRequest = function(request2, callback) {
+      request2.token = guid4();
+      request2.clientId = this.clientId;
+      serviceRequests[request2.token] = callback;
+      this.send(request2);
     };
     EditorConnection.prototype.close = function() {
       this.reconnectOnClose = false;
@@ -23328,7 +23391,10 @@ var require_nodedefinition = __commonJS({
             node.registerOutput(name2, {
               getter: function() {
                 return void 0;
-              }
+              },
+              onFirstConnectionAdded: output.onFirstConnectionAdded,
+              onLastConnectionRemoved: output.onLastConnectionRemoved
+              // a signal keeps its wire hooks (P121-TWO003)
             });
           } else {
             node.registerOutput(name2, output);
@@ -24601,9 +24667,704 @@ var require_runtasks = __commonJS({
   }
 });
 
+// ../noodl-runtime/src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  getAbsoluteUrl: () => getAbsoluteUrl,
+  logJavaScriptNodeError: () => logJavaScriptNodeError,
+  thrownMessage: () => thrownMessage
+});
+function getAbsoluteUrl(_url) {
+  const url = String(_url);
+  if (!url || url[0] === "/" || url.includes("://") || url.startsWith("data:")) {
+    return url;
+  }
+  return (Noodl.baseUrl || "/") + url;
+}
+function thrownMessage(error) {
+  if (error && error.message) return String(error.message);
+  try {
+    return String(error);
+  } catch {
+    return typeof error;
+  }
+}
+function logJavaScriptNodeError(error) {
+  const prefix = "Error in JS node run code.";
+  if (error === null || typeof error !== "object" && typeof error !== "function") {
+    console.log(prefix, thrownMessage(error));
+    return;
+  }
+  const proto = Object.getPrototypeOf(error);
+  const kind = proto && proto.constructor && proto.constructor.name ? proto.constructor.name : "Error";
+  console.log(prefix, kind + ": " + thrownMessage(error), error.stack);
+}
+var init_utils = __esm({
+  "../noodl-runtime/src/utils.ts"() {
+  }
+});
+
+// ../noodl-runtime/src/componentwalk.ts
+var componentwalk_exports = {};
+__export(componentwalk_exports, {
+  COMPONENT_OBJECT_TYPES: () => COMPONENT_OBJECT_TYPES,
+  componentAncestorNames: () => componentAncestorNames,
+  componentAncestors: () => componentAncestors,
+  findAncestorWithComponentObject: () => findAncestorWithComponentObject,
+  findAncestorWithName: () => findAncestorWithName,
+  findAncestorWithNodeType: () => findAncestorWithNodeType,
+  findAncestorWithProperty: () => findAncestorWithProperty,
+  findComponentAncestor: () => findComponentAncestor,
+  parentComponentOf: () => parentComponentOf,
+  scopeChain: () => scopeChain,
+  scopeChainNames: () => scopeChainNames
+});
+function parentComponentOf(component) {
+  if (!component) return void 0;
+  let parent;
+  if (component.getRoots().length > 0) {
+    const root2 = component.getRoots()[0];
+    if (root2.getVisualParentNode) {
+      const visualParent = root2.getVisualParentNode();
+      if (visualParent) {
+        parent = visualParent.nodeScope.componentOwner;
+      }
+    } else if (root2.parentNodeScope) {
+      parent = component.parentNodeScope.componentOwner;
+    }
+  } else if (component.parentNodeScope) {
+    parent = component.parentNodeScope.componentOwner;
+  }
+  if (parent && parent.nodeScope && parent.nodeScope.componentOwner !== component) {
+    return parent;
+  }
+  return void 0;
+}
+function componentAncestors(component) {
+  const ancestors = [];
+  let current = component;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    const parent = parentComponentOf(current);
+    if (!parent) break;
+    ancestors.push(parent);
+    current = parent;
+  }
+  return ancestors;
+}
+function findComponentAncestor(component, predicate) {
+  let current = component;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    const parent = parentComponentOf(current);
+    if (!parent) return void 0;
+    if (predicate(parent)) return parent;
+    current = parent;
+  }
+  return void 0;
+}
+function findAncestorWithNodeType(component, types) {
+  return findComponentAncestor(
+    component,
+    (candidate) => types.some((type) => candidate.nodeScope.getNodesWithType(type).length > 0)
+  );
+}
+function findAncestorWithComponentObject(component) {
+  return findAncestorWithNodeType(component, COMPONENT_OBJECT_TYPES);
+}
+function findAncestorWithName(component, name2) {
+  return findComponentAncestor(component, (candidate) => candidate.name === name2);
+}
+function scopeChain(component) {
+  const chain2 = [];
+  let current = component;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    if (!current) break;
+    chain2.push(current);
+    if (!current.parentNodeScope) break;
+    current = current.parentNodeScope.componentOwner;
+  }
+  return chain2;
+}
+function scopeChainNames(component) {
+  return scopeChain(component).map((entry) => entry.name);
+}
+function findAncestorWithProperty(component, property2) {
+  const chain2 = scopeChain(component);
+  for (let i2 = 0; i2 < chain2.length; i2++) {
+    if (chain2[i2][property2] !== void 0) return chain2[i2];
+  }
+  return void 0;
+}
+function componentAncestorNames(component) {
+  return componentAncestors(component).map((ancestor) => ancestor.name);
+}
+var MAX_WALK_DEPTH, COMPONENT_OBJECT_TYPES;
+var init_componentwalk = __esm({
+  "../noodl-runtime/src/componentwalk.ts"() {
+    "use strict";
+    MAX_WALK_DEPTH = 1e3;
+    COMPONENT_OBJECT_TYPES = ["net.noodl.ComponentObject", "Component State"];
+  }
+});
+
+// ../noodl-runtime/src/resolvedtarget.ts
+function summariseTargets(labels) {
+  const distinct = [];
+  for (let i2 = 0; i2 < labels.length; i2++) {
+    const label = labels[i2];
+    if (label === void 0) continue;
+    if (distinct.indexOf(label) === -1) distinct.push(label);
+  }
+  if (distinct.length === 0) return void 0;
+  if (distinct.length === 1) return "\u2192 " + distinct[0];
+  const listed = distinct.slice(0, MAX_NAMES_LISTED).join(", ");
+  const rest2 = distinct.length - MAX_NAMES_LISTED;
+  return "\u2192 " + distinct.length + " targets: " + listed + (rest2 > 0 ? ", +" + rest2 : "");
+}
+var MAX_NAMES_LISTED, ResolvedTargetReporter;
+var init_resolvedtarget = __esm({
+  "../noodl-runtime/src/resolvedtarget.ts"() {
+    "use strict";
+    MAX_NAMES_LISTED = 3;
+    ResolvedTargetReporter = class {
+      constructor() {
+        /** Weak, so a torn-down runtime's bookkeeping goes with it and needs no reset call. */
+        this._byContext = /* @__PURE__ */ new WeakMap();
+      }
+      /**
+       * Record what `node` bound to and push the summary to the editor.
+       *
+       * Safe to call every resolution; identical summaries are dropped rather than sent, so a
+       * node that re-resolves each frame costs one string comparison.
+       */
+      report(node, target) {
+        const state2 = this._stateFor(node);
+        if (!state2) return;
+        let instances = state2.byGraphNode.get(node.id);
+        if (!instances) {
+          instances = /* @__PURE__ */ new Map();
+          state2.byGraphNode.set(node.id, instances);
+        }
+        instances.set(node, target);
+        this._flush(node, state2, instances);
+      }
+      /** Drop an instance. Call from `_onNodeDeleted`, or this map is a leak. */
+      forget(node) {
+        const state2 = this._stateFor(node);
+        if (!state2) return;
+        const instances = state2.byGraphNode.get(node.id);
+        if (!instances) return;
+        instances.delete(node);
+        if (instances.size === 0) {
+          state2.byGraphNode.delete(node.id);
+          state2.lastSent.delete(node.id);
+          return;
+        }
+        this._flush(node, state2, instances);
+      }
+      _stateFor(node) {
+        const context = node.context;
+        if (!context) return void 0;
+        let state2 = this._byContext.get(context);
+        if (!state2) {
+          state2 = { byGraphNode: /* @__PURE__ */ new Map(), lastSent: /* @__PURE__ */ new Map() };
+          this._byContext.set(context, state2);
+        }
+        return state2;
+      }
+      _flush(node, state2, instances) {
+        const labels = [];
+        instances.forEach((label) => labels.push(label));
+        const summary = summariseTargets(labels);
+        if (state2.lastSent.has(node.id) && state2.lastSent.get(node.id) === summary) return;
+        state2.lastSent.set(node.id, summary);
+        const editorConnection = node.context && node.context.editorConnection;
+        if (!editorConnection || !editorConnection.isRunningLocally()) return;
+        if (typeof editorConnection.sendNodeSubLabel !== "function") return;
+        editorConnection.sendNodeSubLabel(node.id, summary);
+      }
+    };
+  }
+});
+
+// ../noodl-runtime/src/foreachitem.ts
+var foreachitem_exports = {};
+__export(foreachitem_exports, {
+  forgetForEachItem: () => forgetForEachItem,
+  resolveForEachItem: () => resolveForEachItem
+});
+function resolveForEachItem(node, options = {}) {
+  const chain2 = scopeChain(node.nodeScope.componentOwner);
+  const wanted = options.target;
+  if (wanted) {
+    const named3 = firstNamed(chain2, wanted);
+    if (!named3) {
+      return miss(
+        node,
+        "repeater-item/target-not-found",
+        'No component named "' + wanted + '" contains this node',
+        wanted,
+        { target: wanted, scope: scopeChainNames(node.nodeScope.componentOwner) }
+      );
+    }
+    if (named3[FOR_EACH_MODEL] === void 0) {
+      return miss(
+        node,
+        "repeater-item/target-has-no-item",
+        'The component "' + wanted + '" has no current item \u2014 it is not used as a Repeater or Run Tasks template',
+        wanted,
+        { target: wanted }
+      );
+    }
+    return hit(node, named3);
+  }
+  const owner = firstWithItem(chain2);
+  if (!owner) {
+    return miss(
+      node,
+      "repeater-item/no-item-in-scope",
+      'Id Source is set to "From repeater", but this node is not inside a Repeater or Run Tasks template',
+      void 0,
+      { scope: scopeChainNames(node.nodeScope.componentOwner) }
+    );
+  }
+  return hit(node, owner);
+}
+function forgetForEachItem(node) {
+  resolvedTargets.forget(node);
+  lastMissByNode.delete(node);
+}
+function firstNamed(chain2, name2) {
+  for (let i2 = 0; i2 < chain2.length; i2++) {
+    if (chain2[i2].name === name2) return chain2[i2];
+  }
+  return void 0;
+}
+function firstWithItem(chain2) {
+  for (let i2 = 0; i2 < chain2.length; i2++) {
+    if (chain2[i2][FOR_EACH_MODEL] !== void 0) return chain2[i2];
+  }
+  return void 0;
+}
+function hit(node, owner) {
+  lastMissByNode.delete(node);
+  resolvedTargets.report(node, owner.name);
+  return owner[FOR_EACH_MODEL];
+}
+function miss(node, code, message, target, detail) {
+  resolvedTargets.report(node, void 0);
+  const seen = code + "|" + (target || "");
+  if (lastMissByNode.get(node) !== seen) {
+    lastMissByNode.set(node, seen);
+    node.raiseRuntimeError(code, message, detail);
+  }
+  return void 0;
+}
+var FOR_EACH_MODEL, resolvedTargets, lastMissByNode;
+var init_foreachitem = __esm({
+  "../noodl-runtime/src/foreachitem.ts"() {
+    "use strict";
+    init_componentwalk();
+    init_resolvedtarget();
+    FOR_EACH_MODEL = "_forEachModel";
+    resolvedTargets = new ResolvedTargetReporter();
+    lastMissByNode = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../noodl-runtime/src/javascriptnodeparser.js
+var require_javascriptnodeparser = __commonJS({
+  "../noodl-runtime/src/javascriptnodeparser.js"(exports2, module2) {
+    "use strict";
+    var Model27 = require_model2();
+    var { getAbsoluteUrl: getAbsoluteUrl2 } = (init_utils(), __toCommonJS(utils_exports));
+    var { findAncestorWithComponentObject: findAncestorWithComponentObject2 } = (init_componentwalk(), __toCommonJS(componentwalk_exports));
+    var { resolveForEachItem: resolveForEachItem2 } = (init_foreachitem(), __toCommonJS(foreachitem_exports));
+    var userFunctionsCache = {};
+    function JavascriptNodeParser4(code, options) {
+      this.inputs = {};
+      this.outputs = {};
+      this.error = void 0;
+      this.code = code;
+      const node = options ? options.node : void 0;
+      this._initializeAPIs();
+      var userCode = userFunctionsCache[code];
+      if (!userCode) {
+        try {
+          userCode = new Function(["define", "script", "Node", "Component"], JavascriptNodeParser4.getCodePrefix() + code);
+          userFunctionsCache[code] = userCode;
+        } catch (e) {
+          this.error = e.message;
+          console.error(e);
+        }
+      }
+      if (userCode) {
+        try {
+          userCode(
+            this.define.bind(this),
+            this.script.bind(this),
+            this.apis.Node,
+            node ? JavascriptNodeParser4.getComponentScopeForNode(node) : {}
+          );
+          this._afterSourced();
+        } catch (e) {
+          this.error = e.message;
+          console.error(e);
+        }
+      }
+    }
+    JavascriptNodeParser4.prototype.define = function(userObject) {
+      this.inputs = userObject.inputs || {};
+      this.outputs = userObject.outputs || {};
+      this.setup = userObject.setup;
+      this.change = userObject.run || userObject.change;
+      this.destroy = userObject.destroy;
+      this.definedObject = userObject;
+    };
+    function _scriptExtend(_this) {
+      var _extended = {
+        inputs: _this.inputs || {},
+        outputs: _this.outputs || {},
+        setup: function(inputs, outputs) {
+          this.inputs = inputs;
+          this.outputs = outputs;
+          this.setOutputs = function(states) {
+            for (var key3 in states) {
+              this.outputs[key3] = states[key3];
+              this.flagOutputDirty(key3);
+            }
+          };
+          if (_this.methods) {
+            for (var key2 in _this.methods) {
+              this[key2] = _this.methods[key2];
+            }
+          }
+          _this.setup && _this.setup.apply(this);
+        },
+        destroy: function(inputs, outputs) {
+          this.inputs = inputs;
+          this.outputs = outputs;
+          _this.destroy && _this.destroy.apply(this);
+        },
+        change: function(inputs, outputs) {
+          this.inputs = inputs;
+          this.outputs = outputs;
+          var old = this._oldInputs || {};
+          if (_this.changed) {
+            for (var key2 in inputs) {
+              if (inputs[key2] !== old[key2]) {
+                var changedFunction = _this.changed[key2];
+                if (typeof changedFunction === "function") changedFunction.apply(this, [inputs[key2], old[key2]]);
+              }
+            }
+          }
+          this._oldInputs = Object.assign({}, inputs);
+        }
+      };
+      if (_this.signals) {
+        for (var key in _this.signals) {
+          _extended[key] = _this.signals[key];
+          _extended.inputs[key] = "signal";
+        }
+      }
+      return _extended;
+    }
+    JavascriptNodeParser4.prototype.script = function(userObject) {
+      var _userObjectExtended = _scriptExtend(userObject);
+      this.inputs = _userObjectExtended.inputs || {};
+      this.outputs = _userObjectExtended.outputs || {};
+      this.setup = _userObjectExtended.setup;
+      this.change = _userObjectExtended.run || _userObjectExtended.change;
+      this.destroy = _userObjectExtended.destroy;
+      this.definedObject = _userObjectExtended;
+    };
+    JavascriptNodeParser4.prototype._initializeAPIs = function() {
+      this.apis = {
+        Node: {
+          Inputs: {},
+          Outputs: {},
+          Signals: {},
+          Setters: {}
+        }
+      };
+    };
+    JavascriptNodeParser4.prototype._afterSourced = function() {
+      if (this.definedObject !== void 0) return;
+      var _Node = this.apis.Node;
+      this.inputs = Object.assign({}, _Node.Inputs || {});
+      this.outputs = Object.assign({}, _Node.Outputs || {});
+      this.setup = function(inputs, outputs) {
+        const _this = this;
+        _Node.setOutputs = function(_outputs) {
+          for (var key2 in _outputs) {
+            outputs[key2] = _outputs[key2];
+            _this.flagOutputDirty(key2);
+          }
+        };
+        _Node.OnInit && _Node.OnInit.apply(this);
+      };
+      this.destroy = _Node.OnDestroy || this.destory;
+      this.change = (inputs, outputs, changedInputs) => {
+        for (var key2 in changedInputs) {
+          if (typeof _Node.Setters[key2] === "function") {
+            _Node.Setters[key2](inputs[key2]);
+          }
+        }
+        if (typeof _Node.OnInputsChanged === "function") {
+          _Node.OnInputsChanged();
+        }
+      };
+      this.definedObject = {
+        inputs: this.inputs,
+        outputs: this.outputs,
+        setup: this.setup,
+        destroy: this.destroy,
+        change: this.change
+      };
+      if (_Node.Signals !== void 0) {
+        for (var key in _Node.Signals) {
+          if (typeof _Node.Signals[key] === "function") {
+            this.inputs[key] = "signal";
+            this.definedObject[key] = _Node.Signals[key];
+          }
+        }
+      }
+    };
+    JavascriptNodeParser4.createFromCode = function(code, options) {
+      return new JavascriptNodeParser4(code, options);
+    };
+    function failedParser(message) {
+      var parser = Object.create(JavascriptNodeParser4.prototype);
+      parser.inputs = {};
+      parser.outputs = {};
+      parser.error = message;
+      parser.code = void 0;
+      parser.apis = { Node: {} };
+      return parser;
+    }
+    JavascriptNodeParser4.createFromURL = function(url, callback, options) {
+      url = getAbsoluteUrl2(url);
+      var settled = false;
+      function settle(parser) {
+        if (settled) return;
+        settled = true;
+        callback(parser);
+      }
+      var xhr = new window.XMLHttpRequest();
+      xhr.open("GET", url, true);
+      xhr.onreadystatechange = function() {
+        if (this.readyState === 4 || this.readyState === XMLHttpRequest.DONE) {
+          if (this.status !== 0 && (this.status < 200 || this.status >= 300)) {
+            settle(failedParser('Could not load "' + url + '": the server answered ' + this.status));
+            return;
+          }
+          if (this.status === 0) {
+            settle(failedParser('Could not load "' + url + '": the request failed'));
+            return;
+          }
+          settle(new JavascriptNodeParser4(this.response, options));
+        }
+      };
+      xhr.onerror = function() {
+        settle(failedParser('Could not load "' + url + '": the request failed'));
+      };
+      xhr.send();
+    };
+    JavascriptNodeParser4.parseAndAddPortsFromScript = function(script, ports, options) {
+      function _exists(port) {
+        if (typeof port === "string") return ports.find((p) => p.name === port) !== void 0;
+        else return ports.find((p) => p.name === port.name && p.plug === port.plug) !== void 0;
+      }
+      function _addPortsFromMatch(match, options2) {
+        if (match === void 0 || match === null) return;
+        const unique = {};
+        for (const _s of match) {
+          let name2 = _s[1];
+          if (name2 === void 0) continue;
+          unique[name2] = true;
+        }
+        Object.keys(unique).forEach((p) => {
+          if (_exists({
+            name: options2.prefix + p,
+            plug: options2.plug
+          }))
+            return;
+          ports.push({
+            name: options2.prefix + p,
+            displayName: p,
+            plug: options2.plug,
+            type: options2.type,
+            group: options2.group
+          });
+        });
+      }
+      if (!options.skipInputs) {
+        _addPortsFromMatch(script.matchAll(/Inputs\.([A-Za-z0-9_]+)/g), {
+          type: options.inputType || "*",
+          plug: "input",
+          group: options.inputGroup || "Inputs",
+          prefix: options.inputPrefix || ""
+        });
+        _addPortsFromMatch(script.matchAll(/Inputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]/g), {
+          type: options.inputType || "*",
+          plug: "inputs",
+          group: options.inputGroup || "Inputs",
+          prefix: options.inputPrefix || ""
+        });
+      }
+      if (!options.skipOutputs) {
+        if (!options.skipOutputSignals) {
+          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9]+)\s*\(\s*\)/g), {
+            type: "signal",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]\(\s*\)/g), {
+            type: "signal",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+        }
+        if (!options.skipRegularOutputs) {
+          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9_]+)/g), {
+            type: "*",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*\"([^\"]*)\"\s*\]/g), {
+            type: "*",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+        }
+      }
+    };
+    JavascriptNodeParser4.prototype.getPorts = function() {
+      var ports = [];
+      var self2 = this;
+      Object.keys(this.inputs).forEach(function(name2) {
+        var inputPort = self2.inputs[name2];
+        var port = {
+          name: name2,
+          plug: "input"
+        };
+        if (typeof inputPort === "string") {
+          port.type = {
+            name: inputPort
+          };
+          port.group = "Inputs";
+        } else {
+          for (var p in inputPort) {
+            port[p] = inputPort[p];
+          }
+        }
+        ports.push(port);
+      });
+      Object.keys(this.outputs).forEach(function(name2) {
+        ports.push({
+          name: name2,
+          type: {
+            name: self2.outputs[name2]
+          },
+          plug: "output",
+          group: "Outputs"
+        });
+      });
+      JavascriptNodeParser4.parseAndAddPortsFromScript(this.code, ports, {});
+      return ports;
+    };
+    var _componentScopes = {};
+    function _findParentComponentStateModelId(node) {
+      const parent = findAncestorWithComponentObject2(node.nodeScope.componentOwner);
+      if (!parent) return;
+      return "componentState" + parent.getInstanceId();
+    }
+    JavascriptNodeParser4.getComponentScopeForNode = function(node) {
+      const componentId = node.nodeScope.componentOwner.getInstanceId();
+      if (_componentScopes[componentId] === void 0) {
+        _componentScopes[componentId] = {};
+        const componentObject = (node.nodeScope.modelScope || Model27).get("componentState" + componentId);
+        _componentScopes[componentId].Object = componentObject;
+      }
+      const parentComponentObjectId = _findParentComponentStateModelId(node);
+      const parentComponentObject = parentComponentObjectId !== void 0 ? (node.nodeScope.modelScope || Model27).get(parentComponentObjectId) : void 0;
+      _componentScopes[componentId].ParentObject = parentComponentObject;
+      Object.defineProperty(_componentScopes[componentId], "RepeaterObject", {
+        configurable: true,
+        enumerable: true,
+        get: function() {
+          return resolveForEachItem2(node);
+        }
+      });
+      return _componentScopes[componentId];
+    };
+    JavascriptNodeParser4.getCodePrefix = function() {
+      return "const Script = (typeof Node !== 'undefined')?Node:undefined;\n";
+    };
+    JavascriptNodeParser4.createNoodlAPI = function() {
+      return typeof window !== "undefined" && window.Noodl !== void 0 ? window.Noodl : {};
+    };
+    module2.exports = JavascriptNodeParser4;
+  }
+});
+
+// ../noodl-runtime/src/printedcode.ts
+function table() {
+  return globalThis[TABLE];
+}
+function hasPrintedCode() {
+  return table() !== void 0;
+}
+function sameParams(a, b) {
+  return a.length === b.length && a.every((p, i2) => p === b[i2]);
+}
+function findPrintedCode(params, body, async) {
+  const list = table()?.get(body);
+  return list && list.find((e) => e.async === async && sameParams(e.params, params));
+}
+function findPrintedBody(body, async) {
+  const list = table()?.get(body);
+  return list && list.find((e) => e.async === async);
+}
+function compileCode(params, body, options) {
+  const async = !!(options && options.async);
+  const printed = findPrintedCode(params, body, async);
+  if (printed) return printed.fn;
+  if (table()?.refuseOthers) throw new Error(NOT_PRINTED_MESSAGE);
+  const Ctor = async ? AsyncFunction : Function;
+  return new Ctor(...params, body);
+}
+function functionNodeBody(script) {
+  const JavascriptNodeParser4 = require_javascriptnodeparser();
+  return JavascriptNodeParser4.getCodePrefix() + script;
+}
+function expressionNodeBody(expression) {
+  return EXPRESSION_PREAMBLE + "return (" + expression + ");";
+}
+var NOT_PRINTED_MESSAGE, TABLE, AsyncFunction, FUNCTION_NODE_PARAMS, EXPRESSION_PREAMBLE, REST_REQUEST_PARAMS, REST_RESPONSE_PARAMS, MAP_COLLECTION_PARAMS;
+var init_printedcode = __esm({
+  "../noodl-runtime/src/printedcode.ts"() {
+    NOT_PRINTED_MESSAGE = "This code was not printed when the app was deployed, and code cannot be compiled here. Deploy the app again.";
+    TABLE = Symbol.for("nodegx.printedCode");
+    AsyncFunction = Object.getPrototypeOf(async function() {
+    }).constructor;
+    FUNCTION_NODE_PARAMS = ["Inputs", "Outputs", "Noodl", "Component", "Scripts"];
+    EXPRESSION_PREAMBLE = [
+      'var min = Math.min,    max = Math.max,    cos = Math.cos,    sin = Math.sin,    tan = Math.tan,    sqrt = Math.sqrt,    pi = Math.PI,    round = Math.round,    floor = Math.floor,    ceil = Math.ceil,    abs = Math.abs,    random = Math.random,    pow = Math.pow,    log = Math.log,    exp = Math.exp;try {  var NoodlContext = (typeof Noodl !== "undefined") ? Noodl : (typeof global !== "undefined" && global.Noodl) || {};  var Variables = NoodlContext.Variables || {};  var Objects = NoodlContext.Objects || {};  var Arrays = NoodlContext.Arrays || {};} catch (e) {  var Variables = {}, Objects = {}, Arrays = {};}'
+    ].join("");
+    REST_REQUEST_PARAMS = ["Inputs", "Outputs", "Request"];
+    REST_RESPONSE_PARAMS = ["Inputs", "Outputs", "Response"];
+    MAP_COLLECTION_PARAMS = ["map", "object"];
+  }
+});
+
 // ../noodl-runtime/src/nodes/std-library/data/restnode.ts
 var require_restnode = __commonJS({
   "../noodl-runtime/src/nodes/std-library/data/restnode.ts"(exports2, module2) {
+    init_printedcode();
     var defaultRequestScript = "//Add custom code to setup the request object before the request\n//is made.\n//\n//*Request.resource     contains the resource path of the request.\n//*Request.method       contains the method, GET, POST, PUT or DELETE.\n//*Request.headers      is a map where you can add additional headers.\n//*Request.parameters   is a map the parameters that will be appended\n//                      to the url.\n//*Request.content      contains the content of the request as a javascript\n//                      object.\n//\n";
     var defaultResponseScript = "// Add custom code to convert the response content to outputs\n//\n//*Response.status    The status code of the response\n//*Response.content   The content of the response as a javascript\n//                    object.\n//*Response.request   The request object that resulted in the response.\n//\n//*Inputs and *Outputs contain the inputs and outputs of the node.\n";
     var RestNode = {
@@ -24692,7 +25453,7 @@ var require_restnode = __commonJS({
           group: "Scripts",
           set: function(script) {
             try {
-              this._internal.requestFunc = new Function("Inputs", "Outputs", "Request", script);
+              this._internal.requestFunc = compileCode(REST_REQUEST_PARAMS, script);
             } catch (e) {
               console.log(e);
             }
@@ -24709,7 +25470,7 @@ var require_restnode = __commonJS({
           group: "Scripts",
           set: function(script) {
             try {
-              this._internal.responseFunc = new Function("Inputs", "Outputs", "Response", script);
+              this._internal.responseFunc = compileCode(REST_RESPONSE_PARAMS, script);
             } catch (e) {
               console.log(e);
             }
@@ -24781,12 +25542,12 @@ var require_restnode = __commonJS({
             this.scheduleAfterInputsHaveUpdated(this.doFetch.bind(this));
           }
         },
-        doResponse: function(status, response, request) {
+        doResponse: function(status, response, request2) {
           if (this._internal.responseFunc) {
             this._internal.responseFunc.apply(this._internal.self, [
               this._internal.inputValues,
               this._internal.outputValuesProxy,
-              { status, content: response, request }
+              { status, content: response, request: request2 }
             ]);
           }
           this._internal.inspectData = { status, content: response };
@@ -24796,11 +25557,11 @@ var require_restnode = __commonJS({
             this.sendSignalOnOutput("failure");
           }
         },
-        doExternalFetch: function(request) {
-          let url = request.resource;
-          if (Object.keys(request.parameters).length > 0) {
-            const parameters = Object.keys(request.parameters).map(function(p) {
-              return p + "=" + encodeURIComponent(request.parameters[p]);
+        doExternalFetch: function(request2) {
+          let url = request2.resource;
+          if (Object.keys(request2.parameters).length > 0) {
+            const parameters = Object.keys(request2.parameters).map(function(p) {
+              return p + "=" + encodeURIComponent(request2.parameters[p]);
             });
             url += "?" + parameters.join("&");
           }
@@ -24808,9 +25569,9 @@ var require_restnode = __commonJS({
             const _this = this;
             const xhr = new window.XMLHttpRequest();
             this._xhr = xhr;
-            xhr.open(request.method, url, true);
-            for (const header in request.headers) {
-              xhr.setRequestHeader(header, request.headers[header]);
+            xhr.open(request2.method, url, true);
+            for (const header in request2.headers) {
+              xhr.setRequestHeader(header, request2.headers[header]);
             }
             xhr.onreadystatechange = function() {
               let sentResponse = false;
@@ -24822,11 +25583,11 @@ var require_restnode = __commonJS({
                 if (responseType) {
                   responseType = responseType.toLowerCase();
                   const responseData = responseType.indexOf("json") !== -1 ? JSON.parse(rawResponse) : rawResponse;
-                  _this.doResponse(statusCode, responseData, request);
+                  _this.doResponse(statusCode, responseData, request2);
                   sentResponse = true;
                 }
                 if (sentResponse === false) {
-                  _this.doResponse(statusCode, rawResponse, request);
+                  _this.doResponse(statusCode, rawResponse, request2);
                 }
               }
             };
@@ -24838,30 +25599,30 @@ var require_restnode = __commonJS({
               delete this._xhr;
               _this.sendSignalOnOutput("canceled");
             };
-            if (request.content) {
+            if (request2.content) {
               xhr.setRequestHeader("Content-Type", "application/json");
-              xhr.send(JSON.stringify(request.content));
+              xhr.send(JSON.stringify(request2.content));
             } else {
               xhr.send();
             }
           } else {
             const headers = Object.assign(
               {},
-              request.headers,
-              request.content ? {
+              request2.headers,
+              request2.content ? {
                 "Content-Type": "application/json"
               } : {}
             );
             fetch(url, {
-              method: request.method,
+              method: request2.method,
               headers,
-              body: request.content ? JSON.stringify(request.content) : void 0
+              body: request2.content ? JSON.stringify(request2.content) : void 0
             }).then((response) => {
               const responseType = response.headers.get("content-type");
               if (responseType) {
                 if (responseType.indexOf("/json") !== -1) {
                   response.json().then((json) => {
-                    this.doResponse(response.status, json, request);
+                    this.doResponse(response.status, json, request2);
                   });
                 } else {
                   if (this.context.editorConnection) {
@@ -24877,7 +25638,7 @@ var require_restnode = __commonJS({
                 }
               } else {
                 response.text().then((raw) => {
-                  this.doResponse(response.status, raw, request);
+                  this.doResponse(response.status, raw, request2);
                 });
               }
             }).catch((e) => {
@@ -24895,7 +25656,7 @@ var require_restnode = __commonJS({
               resource = resource.replace("{" + key + "}", this._internal.inputValues[key]);
             }
           }
-          const request = {
+          const request2 = {
             resource,
             headers: {},
             method: this._internal.method !== void 0 ? this._internal.method : "GET",
@@ -24905,10 +25666,10 @@ var require_restnode = __commonJS({
             this._internal.requestFunc.apply(this._internal.self, [
               this._internal.inputValues,
               this._internal.outputValuesProxy,
-              request
+              request2
             ]);
           }
-          this.doExternalFetch(request);
+          this.doExternalFetch(request2);
         },
         cancelFetch: function() {
           if (typeof _noodl_cloud_runtime_version === "undefined") {
@@ -25699,656 +26460,13 @@ var require_lodash = __commonJS({
   }
 });
 
-// ../noodl-runtime/src/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  getAbsoluteUrl: () => getAbsoluteUrl,
-  logJavaScriptNodeError: () => logJavaScriptNodeError,
-  thrownMessage: () => thrownMessage
-});
-function getAbsoluteUrl(_url) {
-  const url = String(_url);
-  if (!url || url[0] === "/" || url.includes("://") || url.startsWith("data:")) {
-    return url;
-  }
-  return (Noodl.baseUrl || "/") + url;
-}
-function thrownMessage(error) {
-  if (error && error.message) return String(error.message);
-  try {
-    return String(error);
-  } catch {
-    return typeof error;
-  }
-}
-function logJavaScriptNodeError(error) {
-  const prefix = "Error in JS node run code.";
-  if (error === null || typeof error !== "object" && typeof error !== "function") {
-    console.log(prefix, thrownMessage(error));
-    return;
-  }
-  const proto = Object.getPrototypeOf(error);
-  const kind = proto && proto.constructor && proto.constructor.name ? proto.constructor.name : "Error";
-  console.log(prefix, kind + ": " + thrownMessage(error), error.stack);
-}
-var init_utils = __esm({
-  "../noodl-runtime/src/utils.ts"() {
-  }
-});
-
-// ../noodl-runtime/src/componentwalk.ts
-var componentwalk_exports = {};
-__export(componentwalk_exports, {
-  COMPONENT_OBJECT_TYPES: () => COMPONENT_OBJECT_TYPES,
-  componentAncestorNames: () => componentAncestorNames,
-  componentAncestors: () => componentAncestors,
-  findAncestorWithComponentObject: () => findAncestorWithComponentObject,
-  findAncestorWithName: () => findAncestorWithName,
-  findAncestorWithNodeType: () => findAncestorWithNodeType,
-  findAncestorWithProperty: () => findAncestorWithProperty,
-  findComponentAncestor: () => findComponentAncestor,
-  parentComponentOf: () => parentComponentOf,
-  scopeChain: () => scopeChain,
-  scopeChainNames: () => scopeChainNames
-});
-function parentComponentOf(component) {
-  if (!component) return void 0;
-  let parent;
-  if (component.getRoots().length > 0) {
-    const root2 = component.getRoots()[0];
-    if (root2.getVisualParentNode) {
-      const visualParent = root2.getVisualParentNode();
-      if (visualParent) {
-        parent = visualParent.nodeScope.componentOwner;
-      }
-    } else if (root2.parentNodeScope) {
-      parent = component.parentNodeScope.componentOwner;
-    }
-  } else if (component.parentNodeScope) {
-    parent = component.parentNodeScope.componentOwner;
-  }
-  if (parent && parent.nodeScope && parent.nodeScope.componentOwner !== component) {
-    return parent;
-  }
-  return void 0;
-}
-function componentAncestors(component) {
-  const ancestors = [];
-  let current = component;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
-    const parent = parentComponentOf(current);
-    if (!parent) break;
-    ancestors.push(parent);
-    current = parent;
-  }
-  return ancestors;
-}
-function findComponentAncestor(component, predicate) {
-  let current = component;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
-    const parent = parentComponentOf(current);
-    if (!parent) return void 0;
-    if (predicate(parent)) return parent;
-    current = parent;
-  }
-  return void 0;
-}
-function findAncestorWithNodeType(component, types) {
-  return findComponentAncestor(
-    component,
-    (candidate) => types.some((type) => candidate.nodeScope.getNodesWithType(type).length > 0)
-  );
-}
-function findAncestorWithComponentObject(component) {
-  return findAncestorWithNodeType(component, COMPONENT_OBJECT_TYPES);
-}
-function findAncestorWithName(component, name2) {
-  return findComponentAncestor(component, (candidate) => candidate.name === name2);
-}
-function scopeChain(component) {
-  const chain2 = [];
-  let current = component;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
-    if (!current) break;
-    chain2.push(current);
-    if (!current.parentNodeScope) break;
-    current = current.parentNodeScope.componentOwner;
-  }
-  return chain2;
-}
-function scopeChainNames(component) {
-  return scopeChain(component).map((entry) => entry.name);
-}
-function findAncestorWithProperty(component, property2) {
-  const chain2 = scopeChain(component);
-  for (let i2 = 0; i2 < chain2.length; i2++) {
-    if (chain2[i2][property2] !== void 0) return chain2[i2];
-  }
-  return void 0;
-}
-function componentAncestorNames(component) {
-  return componentAncestors(component).map((ancestor) => ancestor.name);
-}
-var MAX_WALK_DEPTH, COMPONENT_OBJECT_TYPES;
-var init_componentwalk = __esm({
-  "../noodl-runtime/src/componentwalk.ts"() {
-    "use strict";
-    MAX_WALK_DEPTH = 1e3;
-    COMPONENT_OBJECT_TYPES = ["net.noodl.ComponentObject", "Component State"];
-  }
-});
-
-// ../noodl-runtime/src/resolvedtarget.ts
-function summariseTargets(labels) {
-  const distinct = [];
-  for (let i2 = 0; i2 < labels.length; i2++) {
-    const label = labels[i2];
-    if (label === void 0) continue;
-    if (distinct.indexOf(label) === -1) distinct.push(label);
-  }
-  if (distinct.length === 0) return void 0;
-  if (distinct.length === 1) return "\u2192 " + distinct[0];
-  const listed = distinct.slice(0, MAX_NAMES_LISTED).join(", ");
-  const rest2 = distinct.length - MAX_NAMES_LISTED;
-  return "\u2192 " + distinct.length + " targets: " + listed + (rest2 > 0 ? ", +" + rest2 : "");
-}
-var MAX_NAMES_LISTED, ResolvedTargetReporter;
-var init_resolvedtarget = __esm({
-  "../noodl-runtime/src/resolvedtarget.ts"() {
-    "use strict";
-    MAX_NAMES_LISTED = 3;
-    ResolvedTargetReporter = class {
-      constructor() {
-        /** Weak, so a torn-down runtime's bookkeeping goes with it and needs no reset call. */
-        this._byContext = /* @__PURE__ */ new WeakMap();
-      }
-      /**
-       * Record what `node` bound to and push the summary to the editor.
-       *
-       * Safe to call every resolution; identical summaries are dropped rather than sent, so a
-       * node that re-resolves each frame costs one string comparison.
-       */
-      report(node, target) {
-        const state2 = this._stateFor(node);
-        if (!state2) return;
-        let instances = state2.byGraphNode.get(node.id);
-        if (!instances) {
-          instances = /* @__PURE__ */ new Map();
-          state2.byGraphNode.set(node.id, instances);
-        }
-        instances.set(node, target);
-        this._flush(node, state2, instances);
-      }
-      /** Drop an instance. Call from `_onNodeDeleted`, or this map is a leak. */
-      forget(node) {
-        const state2 = this._stateFor(node);
-        if (!state2) return;
-        const instances = state2.byGraphNode.get(node.id);
-        if (!instances) return;
-        instances.delete(node);
-        if (instances.size === 0) {
-          state2.byGraphNode.delete(node.id);
-          state2.lastSent.delete(node.id);
-          return;
-        }
-        this._flush(node, state2, instances);
-      }
-      _stateFor(node) {
-        const context = node.context;
-        if (!context) return void 0;
-        let state2 = this._byContext.get(context);
-        if (!state2) {
-          state2 = { byGraphNode: /* @__PURE__ */ new Map(), lastSent: /* @__PURE__ */ new Map() };
-          this._byContext.set(context, state2);
-        }
-        return state2;
-      }
-      _flush(node, state2, instances) {
-        const labels = [];
-        instances.forEach((label) => labels.push(label));
-        const summary = summariseTargets(labels);
-        if (state2.lastSent.has(node.id) && state2.lastSent.get(node.id) === summary) return;
-        state2.lastSent.set(node.id, summary);
-        const editorConnection = node.context && node.context.editorConnection;
-        if (!editorConnection || !editorConnection.isRunningLocally()) return;
-        if (typeof editorConnection.sendNodeSubLabel !== "function") return;
-        editorConnection.sendNodeSubLabel(node.id, summary);
-      }
-    };
-  }
-});
-
-// ../noodl-runtime/src/foreachitem.ts
-var foreachitem_exports = {};
-__export(foreachitem_exports, {
-  forgetForEachItem: () => forgetForEachItem,
-  resolveForEachItem: () => resolveForEachItem
-});
-function resolveForEachItem(node, options = {}) {
-  const chain2 = scopeChain(node.nodeScope.componentOwner);
-  const wanted = options.target;
-  if (wanted) {
-    const named2 = firstNamed(chain2, wanted);
-    if (!named2) {
-      return miss(
-        node,
-        "repeater-item/target-not-found",
-        'No component named "' + wanted + '" contains this node',
-        wanted,
-        { target: wanted, scope: scopeChainNames(node.nodeScope.componentOwner) }
-      );
-    }
-    if (named2[FOR_EACH_MODEL] === void 0) {
-      return miss(
-        node,
-        "repeater-item/target-has-no-item",
-        'The component "' + wanted + '" has no current item \u2014 it is not used as a Repeater or Run Tasks template',
-        wanted,
-        { target: wanted }
-      );
-    }
-    return hit(node, named2);
-  }
-  const owner = firstWithItem(chain2);
-  if (!owner) {
-    return miss(
-      node,
-      "repeater-item/no-item-in-scope",
-      'Id Source is set to "From repeater", but this node is not inside a Repeater or Run Tasks template',
-      void 0,
-      { scope: scopeChainNames(node.nodeScope.componentOwner) }
-    );
-  }
-  return hit(node, owner);
-}
-function forgetForEachItem(node) {
-  resolvedTargets.forget(node);
-  lastMissByNode.delete(node);
-}
-function firstNamed(chain2, name2) {
-  for (let i2 = 0; i2 < chain2.length; i2++) {
-    if (chain2[i2].name === name2) return chain2[i2];
-  }
-  return void 0;
-}
-function firstWithItem(chain2) {
-  for (let i2 = 0; i2 < chain2.length; i2++) {
-    if (chain2[i2][FOR_EACH_MODEL] !== void 0) return chain2[i2];
-  }
-  return void 0;
-}
-function hit(node, owner) {
-  lastMissByNode.delete(node);
-  resolvedTargets.report(node, owner.name);
-  return owner[FOR_EACH_MODEL];
-}
-function miss(node, code, message, target, detail) {
-  resolvedTargets.report(node, void 0);
-  const seen = code + "|" + (target || "");
-  if (lastMissByNode.get(node) !== seen) {
-    lastMissByNode.set(node, seen);
-    node.raiseRuntimeError(code, message, detail);
-  }
-  return void 0;
-}
-var FOR_EACH_MODEL, resolvedTargets, lastMissByNode;
-var init_foreachitem = __esm({
-  "../noodl-runtime/src/foreachitem.ts"() {
-    "use strict";
-    init_componentwalk();
-    init_resolvedtarget();
-    FOR_EACH_MODEL = "_forEachModel";
-    resolvedTargets = new ResolvedTargetReporter();
-    lastMissByNode = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// ../noodl-runtime/src/javascriptnodeparser.js
-var require_javascriptnodeparser = __commonJS({
-  "../noodl-runtime/src/javascriptnodeparser.js"(exports2, module2) {
-    "use strict";
-    var Model27 = require_model2();
-    var { getAbsoluteUrl: getAbsoluteUrl2 } = (init_utils(), __toCommonJS(utils_exports));
-    var { findAncestorWithComponentObject: findAncestorWithComponentObject2 } = (init_componentwalk(), __toCommonJS(componentwalk_exports));
-    var { resolveForEachItem: resolveForEachItem2 } = (init_foreachitem(), __toCommonJS(foreachitem_exports));
-    var userFunctionsCache = {};
-    function JavascriptNodeParser4(code, options) {
-      this.inputs = {};
-      this.outputs = {};
-      this.error = void 0;
-      this.code = code;
-      const node = options ? options.node : void 0;
-      this._initializeAPIs();
-      var userCode = userFunctionsCache[code];
-      if (!userCode) {
-        try {
-          userCode = new Function(["define", "script", "Node", "Component"], JavascriptNodeParser4.getCodePrefix() + code);
-          userFunctionsCache[code] = userCode;
-        } catch (e) {
-          this.error = e.message;
-          console.error(e);
-        }
-      }
-      if (userCode) {
-        try {
-          userCode(
-            this.define.bind(this),
-            this.script.bind(this),
-            this.apis.Node,
-            node ? JavascriptNodeParser4.getComponentScopeForNode(node) : {}
-          );
-          this._afterSourced();
-        } catch (e) {
-          this.error = e.message;
-          console.error(e);
-        }
-      }
-    }
-    JavascriptNodeParser4.prototype.define = function(userObject) {
-      this.inputs = userObject.inputs || {};
-      this.outputs = userObject.outputs || {};
-      this.setup = userObject.setup;
-      this.change = userObject.run || userObject.change;
-      this.destroy = userObject.destroy;
-      this.definedObject = userObject;
-    };
-    function _scriptExtend(_this) {
-      var _extended = {
-        inputs: _this.inputs || {},
-        outputs: _this.outputs || {},
-        setup: function(inputs, outputs) {
-          this.inputs = inputs;
-          this.outputs = outputs;
-          this.setOutputs = function(states) {
-            for (var key3 in states) {
-              this.outputs[key3] = states[key3];
-              this.flagOutputDirty(key3);
-            }
-          };
-          if (_this.methods) {
-            for (var key2 in _this.methods) {
-              this[key2] = _this.methods[key2];
-            }
-          }
-          _this.setup && _this.setup.apply(this);
-        },
-        destroy: function(inputs, outputs) {
-          this.inputs = inputs;
-          this.outputs = outputs;
-          _this.destroy && _this.destroy.apply(this);
-        },
-        change: function(inputs, outputs) {
-          this.inputs = inputs;
-          this.outputs = outputs;
-          var old = this._oldInputs || {};
-          if (_this.changed) {
-            for (var key2 in inputs) {
-              if (inputs[key2] !== old[key2]) {
-                var changedFunction = _this.changed[key2];
-                if (typeof changedFunction === "function") changedFunction.apply(this, [inputs[key2], old[key2]]);
-              }
-            }
-          }
-          this._oldInputs = Object.assign({}, inputs);
-        }
-      };
-      if (_this.signals) {
-        for (var key in _this.signals) {
-          _extended[key] = _this.signals[key];
-          _extended.inputs[key] = "signal";
-        }
-      }
-      return _extended;
-    }
-    JavascriptNodeParser4.prototype.script = function(userObject) {
-      var _userObjectExtended = _scriptExtend(userObject);
-      this.inputs = _userObjectExtended.inputs || {};
-      this.outputs = _userObjectExtended.outputs || {};
-      this.setup = _userObjectExtended.setup;
-      this.change = _userObjectExtended.run || _userObjectExtended.change;
-      this.destroy = _userObjectExtended.destroy;
-      this.definedObject = _userObjectExtended;
-    };
-    JavascriptNodeParser4.prototype._initializeAPIs = function() {
-      this.apis = {
-        Node: {
-          Inputs: {},
-          Outputs: {},
-          Signals: {},
-          Setters: {}
-        }
-      };
-    };
-    JavascriptNodeParser4.prototype._afterSourced = function() {
-      if (this.definedObject !== void 0) return;
-      var _Node = this.apis.Node;
-      this.inputs = Object.assign({}, _Node.Inputs || {});
-      this.outputs = Object.assign({}, _Node.Outputs || {});
-      this.setup = function(inputs, outputs) {
-        const _this = this;
-        _Node.setOutputs = function(_outputs) {
-          for (var key2 in _outputs) {
-            outputs[key2] = _outputs[key2];
-            _this.flagOutputDirty(key2);
-          }
-        };
-        _Node.OnInit && _Node.OnInit.apply(this);
-      };
-      this.destroy = _Node.OnDestroy || this.destory;
-      this.change = (inputs, outputs, changedInputs) => {
-        for (var key2 in changedInputs) {
-          if (typeof _Node.Setters[key2] === "function") {
-            _Node.Setters[key2](inputs[key2]);
-          }
-        }
-        if (typeof _Node.OnInputsChanged === "function") {
-          _Node.OnInputsChanged();
-        }
-      };
-      this.definedObject = {
-        inputs: this.inputs,
-        outputs: this.outputs,
-        setup: this.setup,
-        destroy: this.destroy,
-        change: this.change
-      };
-      if (_Node.Signals !== void 0) {
-        for (var key in _Node.Signals) {
-          if (typeof _Node.Signals[key] === "function") {
-            this.inputs[key] = "signal";
-            this.definedObject[key] = _Node.Signals[key];
-          }
-        }
-      }
-    };
-    JavascriptNodeParser4.createFromCode = function(code, options) {
-      return new JavascriptNodeParser4(code, options);
-    };
-    function failedParser(message) {
-      var parser = Object.create(JavascriptNodeParser4.prototype);
-      parser.inputs = {};
-      parser.outputs = {};
-      parser.error = message;
-      parser.code = void 0;
-      parser.apis = { Node: {} };
-      return parser;
-    }
-    JavascriptNodeParser4.createFromURL = function(url, callback, options) {
-      url = getAbsoluteUrl2(url);
-      var settled = false;
-      function settle(parser) {
-        if (settled) return;
-        settled = true;
-        callback(parser);
-      }
-      var xhr = new window.XMLHttpRequest();
-      xhr.open("GET", url, true);
-      xhr.onreadystatechange = function() {
-        if (this.readyState === 4 || this.readyState === XMLHttpRequest.DONE) {
-          if (this.status !== 0 && (this.status < 200 || this.status >= 300)) {
-            settle(failedParser('Could not load "' + url + '": the server answered ' + this.status));
-            return;
-          }
-          if (this.status === 0) {
-            settle(failedParser('Could not load "' + url + '": the request failed'));
-            return;
-          }
-          settle(new JavascriptNodeParser4(this.response, options));
-        }
-      };
-      xhr.onerror = function() {
-        settle(failedParser('Could not load "' + url + '": the request failed'));
-      };
-      xhr.send();
-    };
-    JavascriptNodeParser4.parseAndAddPortsFromScript = function(script, ports, options) {
-      function _exists(port) {
-        if (typeof port === "string") return ports.find((p) => p.name === port) !== void 0;
-        else return ports.find((p) => p.name === port.name && p.plug === port.plug) !== void 0;
-      }
-      function _addPortsFromMatch(match, options2) {
-        if (match === void 0 || match === null) return;
-        const unique = {};
-        for (const _s of match) {
-          let name2 = _s[1];
-          if (name2 === void 0) continue;
-          unique[name2] = true;
-        }
-        Object.keys(unique).forEach((p) => {
-          if (_exists({
-            name: options2.prefix + p,
-            plug: options2.plug
-          }))
-            return;
-          ports.push({
-            name: options2.prefix + p,
-            displayName: p,
-            plug: options2.plug,
-            type: options2.type,
-            group: options2.group
-          });
-        });
-      }
-      if (!options.skipInputs) {
-        _addPortsFromMatch(script.matchAll(/Inputs\.([A-Za-z0-9_]+)/g), {
-          type: options.inputType || "*",
-          plug: "input",
-          group: options.inputGroup || "Inputs",
-          prefix: options.inputPrefix || ""
-        });
-        _addPortsFromMatch(script.matchAll(/Inputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]/g), {
-          type: options.inputType || "*",
-          plug: "inputs",
-          group: options.inputGroup || "Inputs",
-          prefix: options.inputPrefix || ""
-        });
-      }
-      if (!options.skipOutputs) {
-        if (!options.skipOutputSignals) {
-          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9]+)\s*\(\s*\)/g), {
-            type: "signal",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]\(\s*\)/g), {
-            type: "signal",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-        }
-        if (!options.skipRegularOutputs) {
-          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9_]+)/g), {
-            type: "*",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*\"([^\"]*)\"\s*\]/g), {
-            type: "*",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-        }
-      }
-    };
-    JavascriptNodeParser4.prototype.getPorts = function() {
-      var ports = [];
-      var self2 = this;
-      Object.keys(this.inputs).forEach(function(name2) {
-        var inputPort = self2.inputs[name2];
-        var port = {
-          name: name2,
-          plug: "input"
-        };
-        if (typeof inputPort === "string") {
-          port.type = {
-            name: inputPort
-          };
-          port.group = "Inputs";
-        } else {
-          for (var p in inputPort) {
-            port[p] = inputPort[p];
-          }
-        }
-        ports.push(port);
-      });
-      Object.keys(this.outputs).forEach(function(name2) {
-        ports.push({
-          name: name2,
-          type: {
-            name: self2.outputs[name2]
-          },
-          plug: "output",
-          group: "Outputs"
-        });
-      });
-      JavascriptNodeParser4.parseAndAddPortsFromScript(this.code, ports, {});
-      return ports;
-    };
-    var _componentScopes = {};
-    function _findParentComponentStateModelId(node) {
-      const parent = findAncestorWithComponentObject2(node.nodeScope.componentOwner);
-      if (!parent) return;
-      return "componentState" + parent.getInstanceId();
-    }
-    JavascriptNodeParser4.getComponentScopeForNode = function(node) {
-      const componentId = node.nodeScope.componentOwner.getInstanceId();
-      if (_componentScopes[componentId] === void 0) {
-        _componentScopes[componentId] = {};
-        const componentObject = (node.nodeScope.modelScope || Model27).get("componentState" + componentId);
-        _componentScopes[componentId].Object = componentObject;
-      }
-      const parentComponentObjectId = _findParentComponentStateModelId(node);
-      const parentComponentObject = parentComponentObjectId !== void 0 ? (node.nodeScope.modelScope || Model27).get(parentComponentObjectId) : void 0;
-      _componentScopes[componentId].ParentObject = parentComponentObject;
-      Object.defineProperty(_componentScopes[componentId], "RepeaterObject", {
-        configurable: true,
-        enumerable: true,
-        get: function() {
-          return resolveForEachItem2(node);
-        }
-      });
-      return _componentScopes[componentId];
-    };
-    JavascriptNodeParser4.getCodePrefix = function() {
-      return "const Script = (typeof Node !== 'undefined')?Node:undefined;\n";
-    };
-    JavascriptNodeParser4.createNoodlAPI = function() {
-      return typeof window !== "undefined" && window.Noodl !== void 0 ? window.Noodl : {};
-    };
-    module2.exports = JavascriptNodeParser4;
-  }
-});
-
 // ../noodl-runtime/src/nodes/std-library/expression.ts
 var require_expression = __commonJS({
   "../noodl-runtime/src/nodes/std-library/expression.ts"(exports2, module2) {
     "use strict";
     init_expression_ports();
     init_logic_search_tags();
+    init_printedcode();
     init_outcome();
     init_run_on_value_change();
     var Node17 = require_node2();
@@ -26577,11 +26695,27 @@ var require_expression = __commonJS({
           const args = Object.keys(this._internal.scope);
           this._internal.compiledWith = args.slice();
           args.push("Noodl");
+          const printed = findPrintedBody(expression, false);
+          if (printed) {
+            this._internal.compiledWith = printed.params.slice(0, -1);
+            this._internal.compileError = void 0;
+            return printed.fn;
+          }
+          if (hasPrintedCode()) {
+            try {
+              const fn = compileCode(args, expression);
+              this._internal.compileError = void 0;
+              return fn;
+            } catch (e) {
+              this._internal.compileError = e.message;
+              return void 0;
+            }
+          }
           const key = expression + args.join(" ");
           if (compiledFunctionsCache2.hasOwnProperty(key) === false) {
-            args.push(expression);
+            const params = args.slice();
             try {
-              compiledFunctionsCache2[key] = construct(Function, args);
+              compiledFunctionsCache2[key] = compileCode(params, expression);
               this._internal.compileError = void 0;
             } catch (e) {
               this._internal.compileError = e.message;
@@ -26613,7 +26747,7 @@ var require_expression = __commonJS({
           description: "JavaScript expression whose value becomes Result. Every name it reads becomes an input port, except JavaScript's own (String, Number, JSON, Date, parseInt, Math and the rest), the Math shortcuts (round, min, pi\u2026) and keywords such as typeof; a port can never be called one of those, nor run, expression or evaluateAtLoad, which are this node's own inputs",
           set: function(value2) {
             const internal2 = this._internal;
-            internal2.currentExpression = functionPreamble + "return (" + value2 + ");";
+            internal2.currentExpression = expressionNodeBody(value2);
             internal2.compiledFunction = void 0;
             const newInputs = expressionPorts(value2);
             internal2.referencedPorts = newInputs;
@@ -26812,17 +26946,7 @@ var require_expression = __commonJS({
         }
       }
     };
-    var functionPreamble = [
-      'var min = Math.min,    max = Math.max,    cos = Math.cos,    sin = Math.sin,    tan = Math.tan,    sqrt = Math.sqrt,    pi = Math.PI,    round = Math.round,    floor = Math.floor,    ceil = Math.ceil,    abs = Math.abs,    random = Math.random,    pow = Math.pow,    log = Math.log,    exp = Math.exp;try {  var NoodlContext = (typeof Noodl !== "undefined") ? Noodl : (typeof global !== "undefined" && global.Noodl) || {};  var Variables = NoodlContext.Variables || {};  var Objects = NoodlContext.Objects || {};  var Arrays = NoodlContext.Arrays || {};} catch (e) {  var Variables = {}, Objects = {}, Arrays = {};}'
-    ].join("");
     var NOT_EVALUATED = {};
-    function construct(constructor, args) {
-      function F() {
-        return constructor.apply(this, args);
-      }
-      F.prototype = constructor.prototype;
-      return new F();
-    }
     var compiledFunctionsCache2 = {};
     function reservedNameMessage(names) {
       const list = names.length > 1 ? names.slice(0, -1).join(", ") + " and " + names[names.length - 1] : names.join("");
@@ -26926,10 +27050,10 @@ function rawPositionFromStack(stack) {
 function stackLineOffset() {
   if (cachedOffset !== void 0) return cachedOffset;
   try {
-    const AsyncFunction = Object.getPrototypeOf(async function() {
+    const AsyncFunction2 = Object.getPrototypeOf(async function() {
     }).constructor;
     let captured;
-    const probe = new AsyncFunction(
+    const probe = new AsyncFunction2(
       "Inputs",
       "Outputs",
       "Noodl",
@@ -26984,12 +27108,12 @@ function undeclaredPortNameMessage(name2, side, isSignal = false) {
 function noOutputWrittenMessage(ports) {
   if (ports.length === 0) return "";
   const first2 = ports[0];
-  const named2 = ports.map((p) => '"' + p.label + '"').join(", ");
+  const named3 = ports.map((p) => '"' + p.label + '"').join(", ");
   const which = ports.length === 1 ? "it" : '"' + first2.label + '"';
   if (first2.isSignal) {
-    return "The script ran but produced no output: " + named2 + " never fired. Fire " + which + " in the script with " + portUsage("Outputs", first2.label, true) + ".";
+    return "The script ran but produced no output: " + named3 + " never fired. Fire " + which + " in the script with " + portUsage("Outputs", first2.label, true) + ".";
   }
-  return "The script ran but produced no output: " + named2 + " stayed empty. Write " + which + " in the script with " + portUsage("Outputs", first2.label, false) + " \u2014 assigning to a plain variable of the same name does not reach the port.";
+  return "The script ran but produced no output: " + named3 + " stayed empty. Write " + which + " in the script with " + portUsage("Outputs", first2.label, false) + " \u2014 assigning to a plain variable of the same name does not reach the port.";
 }
 function proplistLabels(model2, parameter) {
   const rows = model2 && model2.parameters && model2.parameters[parameter];
@@ -27193,6 +27317,7 @@ var require_simplejavascript = __commonJS({
     init_scriptfiles();
     init_function_ports();
     init_tracecause();
+    init_printedcode();
     var Node17 = require_node2();
     var JavascriptNodeParser4 = require_javascriptnodeparser();
     var { logJavaScriptNodeError: logJavaScriptNodeError2, thrownMessage: thrownMessage3 } = (init_utils(), __toCommonJS(utils_exports));
@@ -27291,6 +27416,7 @@ var require_simplejavascript = __commonJS({
       return names;
     }
     function publishHeldWrites(node) {
+      sendHeldChanges(node);
       node._internal.heldWrites.forEach((prop) => {
         node.registerOutputIfNeeded("out-" + prop);
         node.flagOutputDirty("out-" + prop);
@@ -27334,7 +27460,7 @@ var require_simplejavascript = __commonJS({
             if (value2 !== this._internal.outputValues[prop]) {
               this.registerOutputIfNeeded("out-" + prop);
               this._internal.outputValues[prop] = value2;
-              this.flagOutputDirty("out-" + prop);
+              holdChange(this, prop);
               this._internal.heldWrites.delete(prop);
             } else {
               this._internal.heldWrites.add(prop);
@@ -27513,7 +27639,7 @@ var require_simplejavascript = __commonJS({
           });
         },
         runScript: async function() {
-          const func = this._internal.func;
+          const func = sendingChangesAfterTheSyncPart(this, this._internal.func);
           const tokens = this._internal.pendingRunOutcomes || [];
           this._internal.pendingRunOutcomes = void 0;
           if (func === void 0) {
@@ -27718,16 +27844,7 @@ var require_simplejavascript = __commonJS({
         parseScript: function(script) {
           let func;
           try {
-            const AsyncFunction = Object.getPrototypeOf(async function() {
-            }).constructor;
-            func = new AsyncFunction(
-              "Inputs",
-              "Outputs",
-              "Noodl",
-              "Component",
-              "Scripts",
-              JavascriptNodeParser4.getCodePrefix() + script
-            );
+            func = compileCode(FUNCTION_NODE_PARAMS, functionNodeBody(script), { async: true });
             this._internal.parseError = void 0;
             this._internal.lastReportedError = void 0;
           } catch (e) {
@@ -27795,9 +27912,9 @@ var require_simplejavascript = __commonJS({
         return;
       }
       try {
-        const AsyncFunction = Object.getPrototypeOf(async function() {
+        const AsyncFunction2 = Object.getPrototypeOf(async function() {
         }).constructor;
-        new AsyncFunction("Inputs", "Outputs", "Noodl", "Component", script);
+        new AsyncFunction2("Inputs", "Outputs", "Noodl", "Component", script);
         context.editorConnection.clearWarning(node.component.name, node.id, "js-function-parse-waring");
       } catch (e) {
         context.editorConnection.sendWarning(node.component.name, node.id, "js-function-parse-waring", {
@@ -27955,6 +28072,32 @@ var require_simplejavascript = __commonJS({
         });
       }
     };
+    function holdChange(node, prop) {
+      const internal2 = node._internal;
+      if (!internal2.heldChanges) internal2.heldChanges = /* @__PURE__ */ new Set();
+      internal2.heldChanges.add(prop);
+      if (internal2.heldChangesQueued) return;
+      internal2.heldChangesQueued = true;
+      Promise.resolve().then(() => sendHeldChanges(node));
+    }
+    function sendHeldChanges(node) {
+      const internal2 = node._internal;
+      internal2.heldChangesQueued = false;
+      const held = internal2.heldChanges;
+      if (!held || held.size === 0 || node._deleted) return;
+      internal2.heldChanges = /* @__PURE__ */ new Set();
+      held.forEach((prop) => node.flagOutputDirty("out-" + prop));
+    }
+    function sendingChangesAfterTheSyncPart(node, func) {
+      if (func === void 0) return void 0;
+      return function(...args) {
+        try {
+          return func.apply(this, args);
+        } finally {
+          sendHeldChanges(node);
+        }
+      };
+    }
     module2.exports = SimpleJavascriptNodeModule;
   }
 });
@@ -28274,6 +28417,7 @@ var require_logic_builder = __commonJS({
     init_logic_builder_io2();
     init_logic_builder_probe();
     init_logic_search_tags();
+    init_printedcode();
     init_outcome();
     var EdgeTriggeredInput7 = require_edgetriggeredinput();
     var LogicBuilderNode = {
@@ -28628,47 +28772,49 @@ var require_logic_builder = __commonJS({
             return null;
           }
           try {
-            const fn = new Function(
-              "Inputs",
-              "Outputs",
-              "Noodl",
-              "Variables",
-              "Objects",
-              "Arrays",
-              "sendSignalOnOutput",
-              "__triggerSignal__",
-              /**
-               * LGC-003 §1 — the ninth and tenth parameters, and the reason there is only ever one
-               * generated string.
-               *
-               * The editor emits `__p("<blockId>", …)` around every value block and `__s("<blockId>")`
-               * before every statement, always — there is no debug build and no release build, so
-               * there is no class of defect that appears only when nobody is watching. What changes
-               * is which functions land here: the shared identity pair, or a recorder.
-               *
-               * ⚠️ **Declared unconditionally, including for code generated before this existed.**
-               * A `generatedCode` string saved by an older editor mentions neither name, and an
-               * unused parameter costs nothing — whereas making the list conditional on the code
-               * would put a `code.indexOf('__p')` on the compile path and give the runtime two
-               * shapes of compiled function to reason about.
-               */
-              "__p",
-              "__s",
-              /**
-               * The eleventh parameter, and the only one that shadows a global rather than adding a
-               * name (FIX-004 redaction ruling b).
-               *
-               * ⚠️ **Order is the contract.** This list and the argument list in `_executeLogic` are
-               * positional, so a parameter added here and not there — or added in a different place —
-               * silently shifts every argument after it. `__triggerSignal__` was already once built
-               * and then not passed, which read as `undefined` inside every block program ever run.
-               * A spec asserts this node's parameter names in order for that reason.
-               *
-               * Declared unconditionally, exactly as `__p`/`__s` are: code generated before this
-               * existed says `console.log`, which is the whole point, and code that never mentions
-               * `console` pays one unused parameter.
-               */
-              "console",
+            const fn = compileCode(
+              [
+                "Inputs",
+                "Outputs",
+                "Noodl",
+                "Variables",
+                "Objects",
+                "Arrays",
+                "sendSignalOnOutput",
+                "__triggerSignal__",
+                /**
+                 * LGC-003 §1 — the ninth and tenth parameters, and the reason there is only ever one
+                 * generated string.
+                 *
+                 * The editor emits `__p("<blockId>", …)` around every value block and `__s("<blockId>")`
+                 * before every statement, always — there is no debug build and no release build, so
+                 * there is no class of defect that appears only when nobody is watching. What changes
+                 * is which functions land here: the shared identity pair, or a recorder.
+                 *
+                 * ⚠️ **Declared unconditionally, including for code generated before this existed.**
+                 * A `generatedCode` string saved by an older editor mentions neither name, and an
+                 * unused parameter costs nothing — whereas making the list conditional on the code
+                 * would put a `code.indexOf('__p')` on the compile path and give the runtime two
+                 * shapes of compiled function to reason about.
+                 */
+                "__p",
+                "__s",
+                /**
+                 * The eleventh parameter, and the only one that shadows a global rather than adding a
+                 * name (FIX-004 redaction ruling b).
+                 *
+                 * ⚠️ **Order is the contract.** This list and the argument list in `_executeLogic` are
+                 * positional, so a parameter added here and not there — or added in a different place —
+                 * silently shifts every argument after it. `__triggerSignal__` was already once built
+                 * and then not passed, which read as `undefined` inside every block program ever run.
+                 * A spec asserts this node's parameter names in order for that reason.
+                 *
+                 * Declared unconditionally, exactly as `__p`/`__s` are: code generated before this
+                 * existed says `console.log`, which is the whole point, and code that never mentions
+                 * `console` pays one unused parameter.
+                 */
+                "console"
+              ],
               code
             );
             return fn;
@@ -29891,22 +30037,22 @@ function connectionKey(dialect, base, token, where2) {
   const filter2 = filterKey(where2);
   return dialect + " " + base + " " + token + (filter2 ? " #" + filter2 : "");
 }
-function connectionFor(request) {
-  const host = request.host || DEFAULT_HOST2;
+function connectionFor(request2) {
+  const host = request2.host || DEFAULT_HOST2;
   let pool = POOLS.get(host);
   if (!pool) {
     pool = /* @__PURE__ */ new Map();
     POOLS.set(host, pool);
   }
-  const key = connectionKey(request.dialect.name, request.base, request.token, request.where);
+  const key = connectionKey(request2.dialect.name, request2.base, request2.token, request2.where);
   const existing = pool.get(key);
   if (existing) return existing;
   const created = new SharedSseConnection(
-    request.dialect,
-    request.base,
-    request.token,
-    request.EventSourceImpl,
-    request.fetchImpl,
+    request2.dialect,
+    request2.base,
+    request2.token,
+    request2.EventSourceImpl,
+    request2.fetchImpl,
     () => {
       const current = POOLS.get(host);
       if (current && current.get(key) === created) current.delete(key);
@@ -30118,9 +30264,9 @@ var init_SseConnectionPool = __esm({
 // ../noodl-runtime/src/api/backends/realtime/SseTransport.ts
 function entryIsAbout(entry, collection) {
   if (!entry || typeof entry !== "object") return true;
-  const named2 = entry.collection;
-  if (typeof named2 !== "string") return true;
-  return named2 === collection;
+  const named3 = entry.collection;
+  if (typeof named3 !== "string") return true;
+  return named3 === collection;
 }
 var NODEGX_SSE, POCKETBASE_SSE, SseTransport;
 var init_SseTransport = __esm({
@@ -30779,6 +30925,19 @@ function recordFieldPorts(ctx, options) {
   }
   return ports;
 }
+function recordBuiltInDatePorts(ctx, existingPorts, options = {}) {
+  if (!ctx.selectedCollection || !isParseWireContext(ctx)) return [];
+  const have = new Set(existingPorts.map((port) => port.name));
+  const ports = [];
+  for (const field of RECORD_BUILT_IN_DATES) {
+    if (have.has(`prop-${field}`)) continue;
+    ports.push({ name: `prop-${field}`, displayName: field, type: { name: "date" }, plug: "output", group: "Properties" });
+    if (options.includeChangedSignals && !have.has(`changed-${field}`)) {
+      ports.push({ name: `changed-${field}`, displayName: `${field} Changed`, type: "signal", plug: "output", group: "Events" });
+    }
+  }
+  return ports;
+}
 function recordPortType(field) {
   if (field.nativeType && Object.prototype.hasOwnProperty.call(PARSE_PORT_TYPES, field.nativeType)) {
     return { name: PARSE_PORT_TYPES[field.nativeType] };
@@ -30889,7 +31048,7 @@ function parseTypeNameFor(field) {
 function recordFilterBackendType(ctx, fallback) {
   return ctx.backendType || fallback;
 }
-var PARSE_PORT_TYPES, PARSE_SYSTEM_CLASSES;
+var PARSE_PORT_TYPES, PARSE_SYSTEM_CLASSES, RECORD_BUILT_IN_DATES;
 var init_record_ports = __esm({
   "../noodl-runtime/src/nodes/std-library/data/record-ports.ts"() {
     init_resolveBackend_pure();
@@ -30904,6 +31063,7 @@ var init_record_ports = __esm({
       { label: "User", value: "_User" },
       { label: "Role", value: "_Role" }
     ]);
+    RECORD_BUILT_IN_DATES = Object.freeze(["createdAt", "updatedAt"]);
   }
 });
 
@@ -31203,8 +31363,8 @@ function relationsFromDirectus(rows) {
 function relationsFromPostgrestSpec(spec) {
   const definitions = spec?.definitions ?? {};
   const result2 = [];
-  const analyse = (table) => {
-    const properties2 = definitions[table]?.properties ?? {};
+  const analyse = (table2) => {
+    const properties2 = definitions[table2]?.properties ?? {};
     const foreignKeys = [];
     let primaryKeyCount = 0;
     for (const [column, definition4] of Object.entries(properties2)) {
@@ -31216,8 +31376,8 @@ function relationsFromPostgrestSpec(spec) {
     }
     return { foreignKeys, primaryKeyCount };
   };
-  for (const table of Object.keys(definitions)) {
-    const { foreignKeys, primaryKeyCount } = analyse(table);
+  for (const table2 of Object.keys(definitions)) {
+    const { foreignKeys, primaryKeyCount } = analyse(table2);
     const isJunction = foreignKeys.length === 2 && primaryKeyCount === 2 && foreignKeys.every((fk) => fk.primaryKey);
     if (isJunction) {
       const [left, right] = foreignKeys;
@@ -31234,7 +31394,7 @@ function relationsFromPostgrestSpec(spec) {
           cardinality: "many",
           write: {
             kind: "junction",
-            collection: table,
+            collection: table2,
             sourceField: near.column,
             targetField: far.column,
             // The pair *is* the primary key, so a duplicate is a `23505` and
@@ -31248,7 +31408,7 @@ function relationsFromPostgrestSpec(spec) {
     }
     for (const fk of foreignKeys) {
       result2.push({
-        collection: table,
+        collection: table2,
         field: fk.column,
         target: fk.target,
         cardinality: "one",
@@ -31256,8 +31416,8 @@ function relationsFromPostgrestSpec(spec) {
       });
       result2.push({
         collection: fk.target,
-        field: table,
-        target: table,
+        field: table2,
+        target: table2,
         cardinality: "many",
         write: { kind: "foreignKey", field: fk.column, on: "target" }
       });
@@ -31530,11 +31690,11 @@ var init_filter = __esm({
 
 // ../nodegx-backend-contract/src/descriptors/helpers.ts
 function filterTable(fallback, overrides) {
-  const table = {};
+  const table2 = {};
   for (const operator of FILTER_OPERATORS) {
-    table[operator] = overrides[operator] ?? fallback;
+    table2[operator] = overrides[operator] ?? fallback;
   }
-  return Object.freeze(table);
+  return Object.freeze(table2);
 }
 var supported, unsupported, degraded, conditional;
 var init_helpers = __esm({
@@ -32970,8 +33130,8 @@ var init_probes = __esm({
         const cacheKey = `${backendId}\0${key}`;
         const existing = this._inFlight.get(cacheKey);
         if (existing) return existing;
-        const request = { key, probe: capability.probe, url: url.replace(/\/+$/, ""), type };
-        const pending = this._runner(request).then((outcome) => {
+        const request2 = { key, probe: capability.probe, url: url.replace(/\/+$/, ""), type };
+        const pending = this._runner(request2).then((outcome) => {
           this._record(backendId, key, outcome);
           return outcome;
         }).catch(() => {
@@ -33030,12 +33190,12 @@ var init_operational = __esm({
 });
 
 // ../nodegx-backend-contract/src/targetGoes.ts
-function whenTargetGoesProblems(table, columns) {
+function whenTargetGoesProblems(table2, columns) {
   const out = [];
   for (const col of columns) {
     const rule = col.whenTargetGoes;
     if (rule === void 0) continue;
-    const at = `"${table}.${col.name}"`;
+    const at = `"${table2}.${col.name}"`;
     if (typeof rule !== "string" || !WHEN_TARGET_GOES.includes(rule)) {
       out.push(`${at} says "${String(rule)}" for when what it points at goes; it must be one of ${WHEN_TARGET_GOES.join(", ")}.`);
     } else if (col.type !== "Pointer") {
@@ -33050,12 +33210,12 @@ function whenTargetGoesProblems(table, columns) {
 }
 function rulesByTarget(schema) {
   const out = /* @__PURE__ */ new Map();
-  for (const table of schema.listTables()) {
-    for (const col of schema.getTableSchema(table)?.columns || []) {
+  for (const table2 of schema.listTables()) {
+    for (const col of schema.getTableSchema(table2)?.columns || []) {
       const rule = col.whenTargetGoes;
       if (col.type !== "Pointer" || !col.targetClass || !rule || !WHEN_TARGET_GOES.includes(rule)) continue;
       const list = out.get(col.targetClass) || [];
-      list.push({ collection: table, field: col.name, rule });
+      list.push({ collection: table2, field: col.name, rule });
       out.set(col.targetClass, list);
     }
   }
@@ -33063,18 +33223,18 @@ function rulesByTarget(schema) {
 }
 function relations(schema) {
   const out = [];
-  for (const table of schema.listTables())
-    for (const col of schema.getTableSchema(table)?.columns || []) if (col.type === "Relation") out.push([table, col.name, col.targetClass || ""]);
+  for (const table2 of schema.listTables())
+    for (const col of schema.getTableSchema(table2)?.columns || []) if (col.type === "Relation") out.push([table2, col.name, col.targetClass || ""]);
   return out;
 }
 function pairsOf(rels, schema, collection, objectId) {
   const out = [];
-  for (const [table, field, target] of rels) {
-    if (table === collection) {
-      const ids = schema.getRelatedIds(table, objectId, field);
-      for (const relatedId of Array.isArray(ids) ? ids : []) out.push({ collection: table, objectId, field, relatedId: String(relatedId) });
+  for (const [table2, field, target] of rels) {
+    if (table2 === collection) {
+      const ids = schema.getRelatedIds(table2, objectId, field);
+      for (const relatedId of Array.isArray(ids) ? ids : []) out.push({ collection: table2, objectId, field, relatedId: String(relatedId) });
     }
-    if (target === collection) for (const owner of schema.getRelationOwners(table, field, objectId)) out.push({ collection: table, objectId: owner, field, relatedId: objectId });
+    if (target === collection) for (const owner of schema.getRelationOwners(table2, field, objectId)) out.push({ collection: table2, objectId: owner, field, relatedId: objectId });
   }
   return out;
 }
@@ -33089,7 +33249,7 @@ async function linkedIds(ctx, collection, field, id) {
 async function planDelete(ctx, collection, objectId) {
   const rules2 = rulesByTarget(ctx.schema);
   const rels = relations(ctx.schema);
-  if (!rules2.has(collection) && !rels.some(([table, , target]) => table === collection || target === collection)) return null;
+  if (!rules2.has(collection) && !rels.some(([table2, , target]) => table2 === collection || target === collection)) return null;
   if (await ctx.count(collection, { objectId }) === 0) return null;
   const key = (c, id) => `${c}\0${id}`;
   const gone = [{ collection, objectId }];
@@ -33210,9 +33370,9 @@ function idOf(v) {
   if (typeof v === "string" && v) return v;
   return void 0;
 }
-function targetOf(ctx, table, field) {
-  const col = ctx.schema.getTableSchema(table)?.columns?.find((c) => c.name === field);
-  if (!col?.targetClass) throw new Error(`${table}.${field} is not a link the schema knows the target of`);
+function targetOf(ctx, table2, field) {
+  const col = ctx.schema.getTableSchema(table2)?.columns?.find((c) => c.name === field);
+  if (!col?.targetClass) throw new Error(`${table2}.${field} is not a link the schema knows the target of`);
   return col.targetClass;
 }
 async function dryRunMigration(ctx, plan) {
@@ -33907,7 +34067,8 @@ var init_ParseWireAdapter = __esm({
             runId !== void 0 ? { "X-NodeGX-Run": runId } : {},
             options.headers || {}
           );
-          fetch(endpoint + path8, {
+          const send = typeof _noodl_cloudservices !== "undefined" && _noodl_cloudservices.fetch ? _noodl_cloudservices.fetch : fetch;
+          send(endpoint + path8, {
             method: options.method || "GET",
             headers,
             body: JSON.stringify(options.content)
@@ -33962,8 +34123,9 @@ var init_ParseWireAdapter = __esm({
           // P99 HLT-023: pass the server's words on, as `fetch` and the rest do. Dropped here, a
           // refusal that names its cause (the per-run ceiling, a 429 with its class) reached the
           // function as "Failed to query."
-          error: function(res) {
-            options.error(res && res.error);
+          // P115-HST006-STALEROWS: and the status, so a reader can tell a refusal (403) from a blip.
+          error: function(res, status) {
+            options.error(res && res.error, status);
           }
         });
       }
@@ -35242,8 +35404,8 @@ function savedItemToNeutral(item, resolve5, options) {
   if (isSavedGroup(item)) return savedFilterToNeutral(item, resolve5, options);
   const condition = item;
   const isConnected = condition.valueSource === "connected" && !!condition.valuePortName;
-  const resolved2 = isConnected && resolve5 ? resolve5(condition.valuePortName) : void 0;
-  const value2 = isConnected ? resolved2 !== void 0 || options.dropUnresolvedConnected ? resolved2 : condition.value : condition.value;
+  const resolved3 = isConnected && resolve5 ? resolve5(condition.valuePortName) : void 0;
+  const value2 = isConnected ? resolved3 !== void 0 || options.dropUnresolvedConnected ? resolved3 : condition.value : condition.value;
   if (condition.kind === "relation") {
     if (value2 === void 0 || value2 === null || value2 === "") return null;
     return {
@@ -37579,7 +37741,8 @@ var init_RestDataAdapter = __esm({
               const total = options.count ? readTotalCount(profile, body, headers, rows.length) : void 0;
               options.success(records, total);
             },
-            fail: (message) => options.error(message)
+            fail: (message, status) => options.error(message, status)
+            // P115-HST006-STALEROWS: a refusal is told apart
           }
         );
       }
@@ -39128,8 +39291,19 @@ var require_cloudstore = __commonJS({
       }
       return obj;
     }
+    function _schemaOf(collectionName2) {
+      const collection = collectionName2 !== void 0 ? CloudStore7._collections[collectionName2] : void 0;
+      if (!collection) return void 0;
+      if (collection.schema) return collection.schema;
+      if (!Array.isArray(collection.columns)) return void 0;
+      const properties2 = {};
+      for (const column of collection.columns) {
+        if (column && column.name) properties2[column.name] = { type: column.type, targetClass: column.targetClass };
+      }
+      return { properties: properties2 };
+    }
     function _serializeObject(data, collectionName2, modelScope) {
-      if (CloudStore7._collections[collectionName2]) var schema = CloudStore7._collections[collectionName2].schema;
+      var schema = _schemaOf(collectionName2);
       for (var key in data) {
         var _type = schema && schema.properties && schema.properties[key] ? schema.properties[key].type : void 0;
         if (data[key] === void 0 || data[key] === null) {
@@ -39214,14 +39388,14 @@ var require_cloudstore = __commonJS({
     function _fromJSON(item, collectionName2, modelScope) {
       const m = (modelScope || Model27).get(item.objectId);
       m._class = collectionName2;
-      if (collectionName2 !== void 0 && CloudStore7._collections[collectionName2] !== void 0)
-        var schema = CloudStore7._collections[collectionName2].schema;
+      var schema = _schemaOf(collectionName2);
       for (var key in item) {
         if (key === "objectId" || key === "ACL") continue;
         var _type = schema && schema.properties && schema.properties[key] ? schema.properties[key].type : void 0;
         if (_type === void 0 && item[key] && item[key].__type === "Pointer" && item[key].objectId !== void 0) {
           _type = "Pointer";
         }
+        if (_type === void 0 && (key === "createdAt" || key === "updatedAt")) _type = "Date";
         const value2 = _deserializeJSON(item[key], _type, modelScope);
         if (Array.isArray(value2) && sameList(m.get(key), value2)) continue;
         m.set(key, value2);
@@ -39438,8 +39612,19 @@ function convertVisualFilter(query, options) {
   });
   return Object.keys(where2).length === 0 ? void 0 : where2;
 }
+function instantOf(operand) {
+  let at;
+  if (operand instanceof Date) at = operand.getTime();
+  else if (operand && operand.__type === "Date" && typeof operand.iso === "string") at = Date.parse(operand.iso);
+  else if (typeof operand === "string") at = Date.parse(operand);
+  return at === void 0 || Number.isNaN(at) ? void 0 : at;
+}
 function matchesOperator(value2, op, condition) {
   const operand = condition[op];
+  if (value2 instanceof Date && Object.prototype.hasOwnProperty.call(DATE_COMPARISONS, op)) {
+    const at = instantOf(operand);
+    if (at !== void 0) return DATE_COMPARISONS[op](value2.getTime(), at);
+  }
   switch (op) {
     case "$eq":
       return operand && operand.__type === "Pointer" ? value2 === operand.objectId : value2 == operand;
@@ -39518,8 +39703,8 @@ function convertVisualSorting(sorting) {
 }
 function convertFilterOp(filter2, options) {
   try {
-    const resolved2 = resolveRelatedClasses(filter2, options.modelScope);
-    return toParseWhere(resolved2, {
+    const resolved3 = resolveRelatedClasses(filter2, options.modelScope);
+    return toParseWhere(resolved3, {
       backend: backendType(),
       schema: schemaFor(options.collectionName)
     });
@@ -39531,13 +39716,21 @@ function convertFilterOp(filter2, options) {
     throw e;
   }
 }
-var CloudStore, ModelImport2, Model5;
+var CloudStore, ModelImport2, Model5, DATE_COMPARISONS;
 var init_queryutils = __esm({
   "../noodl-runtime/src/api/queryutils.ts"() {
     init_translators2();
     CloudStore = require_cloudstore();
     ModelImport2 = require_model2();
     Model5 = ModelImport2;
+    DATE_COMPARISONS = {
+      $eq: (a, b) => a === b,
+      $ne: (a, b) => a !== b,
+      $lt: (a, b) => a < b,
+      $lte: (a, b) => a <= b,
+      $gt: (a, b) => a > b,
+      $gte: (a, b) => a >= b
+    };
   }
 });
 
@@ -40118,8 +40311,9 @@ var require_dbcollectionnode2 = __commonJS({
               this.setCollection(_c);
               this.sendSignalOnOutput("fetched");
             },
-            error: (err) => {
-              if (this._internal.collection === void 0) this.setCollection(_c);
+            error: (err, status) => {
+              const refused = status === 401 || status === 403;
+              if (refused || this._internal.collection === void 0) this.setCollection(_c);
               this.setError(err || "Failed to fetch.");
             }
           });
@@ -40943,7 +41137,9 @@ var require_dbmodelnode2 = __commonJS({
         includeChangedSignals: true
       }) : [];
       ports.push(...fieldPorts);
-      ports.push(...recordWiredFieldPorts(node, fieldPorts, { plug: "output" }));
+      const datePorts = recordBuiltInDatePorts(ctx, fieldPorts, { includeChangedSignals: true });
+      ports.push(...datePorts);
+      ports.push(...recordWiredFieldPorts(node, [...fieldPorts, ...datePorts], { plug: "output" }));
       sendSchemaPorts(editorConnection, node.id, ports, { staticPorts: staticPortNames(ModelNodeDefinition3) });
     }
     var DbModelNodeModule = {
@@ -41514,8 +41710,8 @@ var require_dbmodelcrudbase = __commonJS({
         const store = CloudStore7.forBackend(modelScope, backendId);
         return store ? store.currentUserId() : void 0;
       } else {
-        const request = modelScope.get("Request");
-        return request.UserId;
+        const request2 = modelScope.get("Request");
+        return request2.UserId;
       }
     }
     function _addAccessControl(def2) {
@@ -45139,6 +45335,7 @@ var require_mapcollectionnode = __commonJS({
   "../noodl-runtime/src/nodes/std-library/data/mapcollectionnode.ts"(exports2, module2) {
     "use strict";
     init_outcome();
+    init_printedcode();
     init_itemsinput();
     var Node17 = require_node2();
     var Collection5 = require_collection();
@@ -45257,7 +45454,7 @@ var require_mapcollectionnode = __commonJS({
         compileMapScript: function(code) {
           this._internal.mapCode = code;
           try {
-            this._internal.mapFunc = new Function("map", "object", code);
+            this._internal.mapFunc = compileCode(MAP_COLLECTION_PARAMS, code);
           } catch (e) {
             this._internal.mapFunc = void 0;
             this._internal.mapCompileError = e.message || String(e);
@@ -47744,12 +47941,12 @@ var require_datetostring = __commonJS({
               if (rendered.indexOf(needle) === -1) return;
               rendered = rendered.split(needle).join(render());
             };
-            const named2 = (options) => new Intl.DateTimeFormat(locale, zone ? { ...options, timeZone: zone } : options).format(t);
+            const named3 = (options) => new Intl.DateTimeFormat(locale, zone ? { ...options, timeZone: zone } : options).format(t);
             const hours12 = (fields.hours + 11) % 12 + 1;
             const meridiem = fields.hours < 12 ? "am" : "pm";
-            substitute("dayName", () => named2({ weekday: "long" }));
-            substitute("dayShort", () => named2({ weekday: "short" }));
-            substitute("monthName", () => named2({ month: "long" }));
+            substitute("dayName", () => named3({ weekday: "long" }));
+            substitute("dayShort", () => named3({ weekday: "short" }));
+            substitute("monthName", () => named3({ month: "long" }));
             substitute("hours12", () => ("0" + hours12).slice(-2));
             substitute("h12", () => String(hours12));
             substitute("ampm", () => meridiem);
@@ -50437,9 +50634,9 @@ var init_EntityDecoder = __esm({
             replacement = ncrResult;
             tier = LIMIT_TIER_BASE;
           } else {
-            const resolved2 = this._resolveName(token);
-            replacement = resolved2?.value;
-            tier = resolved2?.tier;
+            const resolved3 = this._resolveName(token);
+            replacement = resolved3?.value;
+            tier = resolved3?.tier;
           }
           if (replacement === void 0) {
             i2++;
@@ -51117,7 +51314,7 @@ var init_DocTypeReader = __esm({
 });
 
 // ../../node_modules/anynum/digitTable.js
-var SCRIPT_ZEROS, NOT_DIGIT, HIGH_MAP, LOW_MAX, LOW_MIN, TABLE_OFFSET, TABLE_SIZE, TABLE;
+var SCRIPT_ZEROS, NOT_DIGIT, HIGH_MAP, LOW_MAX, LOW_MIN, TABLE_OFFSET, TABLE_SIZE, TABLE2;
 var init_digitTable = __esm({
   "../../node_modules/anynum/digitTable.js"() {
     SCRIPT_ZEROS = [
@@ -51257,12 +51454,12 @@ var init_digitTable = __esm({
     LOW_MIN = 1632;
     TABLE_OFFSET = LOW_MIN;
     TABLE_SIZE = LOW_MAX - LOW_MIN + 1;
-    TABLE = new Uint8Array(TABLE_SIZE).fill(NOT_DIGIT);
+    TABLE2 = new Uint8Array(TABLE_SIZE).fill(NOT_DIGIT);
     for (const zero of SCRIPT_ZEROS) {
       for (let d = 0; d < 10; d++) {
         const cp = zero + d;
         if (cp <= LOW_MAX) {
-          TABLE[cp - TABLE_OFFSET] = d;
+          TABLE2[cp - TABLE_OFFSET] = d;
         } else {
           HIGH_MAP.set(cp, d);
         }
@@ -51300,7 +51497,7 @@ function anynum(str2) {
       }
       continue;
     }
-    if (TABLE[cc - TABLE_OFFSET] !== NOT_DIGIT || MINUS_SET.has(cc)) {
+    if (TABLE2[cc - TABLE_OFFSET] !== NOT_DIGIT || MINUS_SET.has(cc)) {
       firstHit = i2;
       break;
     }
@@ -51338,7 +51535,7 @@ function anynum(str2) {
       chars.push("-");
       continue;
     }
-    const d = TABLE[cc - TABLE_OFFSET];
+    const d = TABLE2[cc - TABLE_OFFSET];
     chars.push(d !== NOT_DIGIT ? String.fromCharCode(d + 48) : str2[i2]);
   }
   return chars.join("");
@@ -54286,9 +54483,9 @@ function firstOf(...values2) {
 function toISODate(value2) {
   const raw = text(value2).trim().replace(/\s*\([^)]*\)$/, "");
   if (!raw) return null;
-  const named2 = /\s([A-Z]{1,5})$/.exec(raw);
-  if (named2 && ZONE_NAMES_READ.indexOf(named2[1]) === -1) return null;
-  const zoned = !!named2 || /(?:Z|[+-]\d{2}:?\d{2})$/.test(raw);
+  const named3 = /\s([A-Z]{1,5})$/.exec(raw);
+  if (named3 && ZONE_NAMES_READ.indexOf(named3[1]) === -1) return null;
+  const zoned = !!named3 || /(?:Z|[+-]\d{2}:?\d{2})$/.test(raw);
   const asUTC = zoned || /^\d{4}-\d{2}-\d{2}$/.test(raw) ? raw : /^\d{4}-\d{2}-\d{2}T/.test(raw) ? raw + "Z" : raw + " GMT";
   const ms = Date.parse(asUTC);
   return isNaN(ms) ? null : new Date(ms).toISOString();
@@ -57347,9 +57544,9 @@ function captureGroups(m) {
 }
 function namedCaptureGroups(m) {
   const out = {};
-  const named2 = m.groups;
-  if (named2) {
-    for (const key in named2) out[key] = named2[key] === void 0 ? "" : named2[key];
+  const named3 = m.groups;
+  if (named3) {
+    for (const key in named3) out[key] = named3[key] === void 0 ? "" : named3[key];
   }
   return out;
 }
@@ -60947,6 +61144,7 @@ var require_globalstoresubscribenode = __commonJS({
           description: "The watched value: one key gives that key, several give an object of just those keys, none gives the whole store",
           group: "Data",
           getter: function() {
+            if (!this._internal.unsubscribe) return void 0;
             return this.projectValue(globalStoreManager.getState(this._internal.storeName));
           }
         },
@@ -68282,8 +68480,8 @@ function sourceName(el) {
   return label.length > 60 ? label.slice(0, 57) + "\u2026" : label || "item";
 }
 function zoneName(zone, el) {
-  const named2 = String(zone._internal.dropZoneName || "").trim();
-  if (named2) return named2;
+  const named3 = String(zone._internal.dropZoneName || "").trim();
+  if (named3) return named3;
   const label = el && el.getAttribute("aria-label");
   if (label) return label;
   const all = orderedZones(zone);
@@ -69189,6 +69387,133 @@ var init_tooltips = __esm({
   }
 });
 
+// ../noodl-viewer-react/src/keyboard-click.ts
+function holdsPressable(el) {
+  return el.querySelector(PRESSABLE_INSIDE) !== null;
+}
+function clickIsWired(node) {
+  if (!node.hasOutput("onClick")) return false;
+  return reachesSomething(node.getOutput("onClick"), 0);
+}
+function reachesSomething(output, depth) {
+  if (!output.hasConnections()) return false;
+  if (!Array.isArray(output.connections)) return true;
+  return output.connections.some((c) => !goesNowhere(c, depth));
+}
+function goesNowhere(connection, depth) {
+  const target = connection.node;
+  if (!target || target.name !== "Component Outputs" || typeof connection.inputPortName !== "string") return false;
+  const owner = target.nodeScope?.componentOwner;
+  if (!owner || depth > 16 || owner._internal?.creatorCallbacks) return false;
+  if (typeof owner.hasOutput !== "function" || typeof owner.getOutput !== "function") return false;
+  if (!owner.hasOutput(connection.inputPortName)) return true;
+  return !reachesSomething(owner.getOutput(connection.inputPortName), depth + 1);
+}
+function isNativelyInteractive(el) {
+  const tag = el.tagName;
+  if (tag === "BUTTON" || tag === "INPUT" || tag === "SELECT" || tag === "TEXTAREA" || tag === "SUMMARY") return true;
+  if ((tag === "A" || tag === "AREA") && el.hasAttribute("href")) return true;
+  if ((tag === "VIDEO" || tag === "AUDIO") && el.hasAttribute("controls")) return true;
+  return el.isContentEditable === true;
+}
+function isSpace(e) {
+  return e.key === " " || e.key === "Spacebar";
+}
+function isOwnKey(el, e) {
+  return e.target === el && !e.defaultPrevented && !e.altKey && !e.ctrlKey && !e.metaKey && !e.isComposing;
+}
+function mark(el) {
+  let spaceArmed = false;
+  const onKeyDown2 = (e) => {
+    if (!isOwnKey(el, e)) return;
+    if (e.key === "Enter") {
+      e.preventDefault();
+      if (!e.repeat) el.click();
+    } else if (isSpace(e)) {
+      e.preventDefault();
+      if (!e.repeat) spaceArmed = true;
+    }
+  };
+  const onKeyUp = (e) => {
+    if (!isSpace(e)) return;
+    const armed = spaceArmed;
+    spaceArmed = false;
+    if (armed && e.target === el && !e.defaultPrevented) el.click();
+  };
+  const m = { el, added: [], onKeyDown: onKeyDown2, onKeyUp, observer: null };
+  if (isNativelyInteractive(el)) return m;
+  refresh(m);
+  if (typeof MutationObserver !== "undefined") {
+    m.observer = new MutationObserver(() => refresh(m));
+    m.observer.observe(el, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["tabindex", "contenteditable", "href", "controls", "type"]
+    });
+  }
+  return m;
+}
+function refresh(m) {
+  const { el } = m;
+  const want = !holdsPressable(el);
+  if (want && !m.added.length) {
+    if (!el.hasAttribute("tabindex")) {
+      el.setAttribute("tabindex", "0");
+      m.added.push("tabindex");
+    }
+    if (!el.hasAttribute("role")) {
+      el.setAttribute("role", "button");
+      m.added.push("role");
+    }
+    if (m.added.length) {
+      el.setAttribute(KEYBOARD_CLICK_ATTRIBUTE, "");
+      m.added.push(KEYBOARD_CLICK_ATTRIBUTE);
+      el.addEventListener("keydown", m.onKeyDown);
+      el.addEventListener("keyup", m.onKeyUp);
+    }
+  } else if (!want && m.added.length) {
+    giveBack(m);
+  }
+}
+function giveBack(m) {
+  for (const name2 of m.added) m.el.removeAttribute(name2);
+  m.added = [];
+  m.el.removeEventListener("keydown", m.onKeyDown);
+  m.el.removeEventListener("keyup", m.onKeyUp);
+}
+function unmark(m) {
+  m.observer?.disconnect();
+  giveBack(m);
+}
+function syncKeyboardClick(node) {
+  const el = typeof node.getDOMElement === "function" ? node.getDOMElement() : null;
+  const want = el && clickIsWired(node) ? el : null;
+  const was = marked.get(node);
+  if (was && was.el === want) return;
+  if (was) {
+    unmark(was);
+    marked.delete(node);
+  }
+  if (want) marked.set(node, mark(want));
+}
+var KEYBOARD_CLICK_ATTRIBUTE, PRESSABLE_INSIDE, marked, KEYBOARD_CLICK_HOOKS;
+var init_keyboard_click = __esm({
+  "../noodl-viewer-react/src/keyboard-click.ts"() {
+    KEYBOARD_CLICK_ATTRIBUTE = "data-ndl-keyboard-click";
+    PRESSABLE_INSIDE = 'button, input:not([type="hidden"]), select, textarea, summary, a[href], area[href], video[controls], audio[controls], [contenteditable=""], [contenteditable="true"], [tabindex]:not([tabindex="-1"])';
+    marked = /* @__PURE__ */ new WeakMap();
+    KEYBOARD_CLICK_HOOKS = {
+      onFirstConnectionAdded() {
+        syncKeyboardClick(this);
+      },
+      onLastConnectionRemoved() {
+        syncKeyboardClick(this);
+      }
+    };
+  }
+});
+
 // ../noodl-viewer-react/src/node-shared-port-definitions.ts
 function humanCorner(suffix) {
   return suffix.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
@@ -69456,6 +69781,7 @@ var init_node_shared_port_definitions = __esm({
     init_fontloader();
     init_media_source();
     init_tooltips();
+    init_keyboard_click();
     SIZE_MODES = ["explicit", "contentWidth", "contentHeight", "contentSize"];
     node_shared_port_definitions_default = {
       addInputProps: addInputProps2,
@@ -69963,7 +70289,9 @@ var init_node_shared_port_definitions = __esm({
             description: "Fires when this element is clicked or tapped",
             group: "Events",
             type: "signal",
-            propPath: "pointer"
+            propPath: "pointer",
+            ...KEYBOARD_CLICK_HOOKS
+            // P121-TWO003-GROUPKEYBOARD: wired, the element is a button to Tab and a screen reader
           },
           pointerDown: {
             displayName: "Pointer Down",
@@ -72561,8 +72889,8 @@ function readColor(value2, depth = 0) {
   const asVar = VAR_FN.exec(text2);
   if (asVar) {
     if (depth >= 8) return null;
-    const resolved2 = cssVariableValue(asVar[1]);
-    if (resolved2) return readColor(resolved2, depth + 1);
+    const resolved3 = cssVariableValue(asVar[1]);
+    if (resolved3) return readColor(resolved3, depth + 1);
     if (asVar[2] !== void 0) return readColor(asVar[2], depth + 1);
     return null;
   }
@@ -73684,6 +74012,7 @@ function createNodeFromReactComponent(def2) {
         }
         if (element) syncDataAttributesOnElement(this);
         if (element) elementChanged(this, element);
+        syncKeyboardClick(this);
       },
       /**
        * NDA-012 (Visual) check A3 — run an imperative action on the inner React component,
@@ -74110,6 +74439,7 @@ var init_react_component_node = __esm({
     init_mergedeep();
     init_node_shared_port_definitions();
     init_node_transitions();
+    init_keyboard_click();
     ICON_SOURCE_DIAGNOSTIC = "visual/icon-source-not-an-icon";
     DATA_ATTRIBUTE_NAME_PATTERN = "^data-[a-z0-9][a-z0-9._-]*$";
     DATA_ATTRIBUTE_NAME = new RegExp(DATA_ATTRIBUTE_NAME_PATTERN);
@@ -76690,7 +77020,14 @@ var init_TextInput = __esm({
             ref: props.useLabel ? void 0 : noodlRootRef(this.props.noodlNode),
             ...props.useLabel ? void 0 : dataAttributeProps(props.dom),
             style: props.useLabel ? { ...clearedRootStyles(style2), ...inputWrapperStyle } : inputWrapperStyle,
-            "noodl-style-tag": "inputWrapper"
+            "noodl-style-tag": "inputWrapper",
+            onMouseDown: (e) => {
+              const field = this.ref.current;
+              if (!field || !props.enabled || e.button !== 0 || field.contains(e.target)) return;
+              e.preventDefault();
+              window.addEventListener("click", preventGlobalFocusChange, true);
+              this.focus();
+            }
           },
           props.useIcon && props.iconPlacement === "left" ? _renderIcon() : null,
           inputContent,
@@ -80880,6 +81217,38 @@ function _typeName(t) {
   if (typeof t === "object") return t.name;
   else return t;
 }
+function isInsideRow(node, row) {
+  if (node === row) return true;
+  let owner = (node.parentNodeScope || node.nodeScope)?.componentOwner;
+  for (let depth = 0; owner && depth < 64; depth++) {
+    if (owner === row) return true;
+    const next = (owner.parentNodeScope || owner.nodeScope)?.componentOwner;
+    if (next === owner) return false;
+    owner = next;
+  }
+  return false;
+}
+function settleRow(context, row) {
+  const self2 = row;
+  for (let pass = 0; pass < 10; pass++) {
+    const dirty = context._dirtyNodes;
+    if (!Array.isArray(dirty)) return;
+    const mine = [];
+    for (let i2 = 0; i2 < dirty.length; i2++) {
+      const node = dirty[i2];
+      if (node && node._dirty && !node._deleted && mine.indexOf(node) === -1 && isInsideRow(node, self2))
+        mine.push(node);
+    }
+    if (mine.length === 0) return;
+    for (let i2 = 0; i2 < mine.length; i2++) {
+      try {
+        mine[i2].update();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+}
 var import_react16, import_runtime4, import_collection, import_model5, ITEMS_DIAGNOSTIC, defaultDynamicScript, ForEachDefinition, defaultMapCode, ForEachModule, foreach_default;
 var init_foreach = __esm({
   "../noodl-viewer-react/src/nodes/std-library/data/foreach.tsx"() {
@@ -81253,6 +81622,7 @@ var init_foreach = __esm({
               }
             }
           };
+          settleRow(this.context, itemNode);
           const forEachActions = itemNode.nodeScope.getNodesWithType("For Each Actions");
           for (let j = 0; j < forEachActions.length; j++) {
             forEachActions[j].signalAdded();
@@ -81856,18 +82226,18 @@ function Columns(props) {
     return () => observer.disconnect();
   }, [masonry, children.length, containerWidth]);
   const columnLayout = readColumnLayoutString(props.layoutString);
-  const resolved2 = columnLayout === null ? null : resolveColumnLayout(columnLayout, props, containerWidth, children.length);
-  const breakpoint = resolved2?.breakpoint ?? "Default";
+  const resolved3 = columnLayout === null ? null : resolveColumnLayout(columnLayout, props, containerWidth, children.length);
+  const breakpoint = resolved3?.breakpoint ?? "Default";
   (0, import_react17.useEffect)(() => {
     props.onBreakpointChanged?.(breakpoint);
     if (breakpoint === "Medium") props.onAtMedium?.();
     else if (breakpoint === "Small") props.onAtSmall?.();
   }, [breakpoint]);
   if (!props.children) return null;
-  if (resolved2 === null) {
+  if (resolved3 === null) {
     return /* @__PURE__ */ import_react17.default.createElement(import_react17.default.Fragment, null, props.children);
   }
-  const { layout, columnAmount, fractionSize } = resolved2;
+  const { layout, columnAmount, fractionSize } = resolved3;
   columnAmountRef.current = columnAmount;
   const columnLefts = masonry ? computeColumnOffsets(layout, fractionSize) : null;
   const packed = masonry && masonryOffsets !== null && masonryOffsets.tops.length === children.length;
@@ -90070,10 +90440,16 @@ function Text(props) {
       ...pointerProps(props),
       style: style2
     },
-    renderableText(props.text)
+    style2.textOverflow === "ellipsis" ? (
+      // P18-S112-FLEXELLIPSIS — the Text is `display: flex` (its default CSS, which Text Vertical Align's `alignItems`
+      // needs), so its words were an anonymous flex item and `text-overflow` on the element drew no "…": Ellipsis
+      // looked the same as Clip. The words go in a block of their own that may shrink to the box and draws the "…";
+      // the element keeps its flex, so both alignments still place them.
+      /* @__PURE__ */ import_react22.default.createElement("span", { style: { ...ELLIPSIS_LINE, overflow: style2.overflow } }, renderableText(props.text))
+    ) : renderableText(props.text)
   );
 }
-var import_react22;
+var import_react22, ELLIPSIS_LINE;
 var init_Text = __esm({
   "../noodl-viewer-react/src/components/visual/Text/Text.tsx"() {
     import_react22 = __toESM(require_react());
@@ -90081,6 +90457,7 @@ var init_Text = __esm({
     init_layout();
     init_pointerlisteners();
     init_noodl_root_ref();
+    ELLIPSIS_LINE = { minWidth: 0, textOverflow: "ellipsis", whiteSpace: "nowrap" };
   }
 });
 
@@ -90454,7 +90831,6 @@ var init_Video = __esm({
             ...videoProps,
             playsInline: true,
             src,
-            ...pointerProps(this.props),
             ref: (video) => {
               this.video = video;
               this.props.innerRef(video);
@@ -90473,7 +90849,7 @@ var init_Video = __esm({
         this.canPlay = false;
       }
       setSourceObject(src) {
-        if (this.video.srcObject !== src) {
+        if (this.video && this.video.srcObject !== src) {
           this.video.srcObject = src;
           this.canPlay = false;
         }
@@ -90579,6 +90955,7 @@ var init_Video = __esm({
           CachedVideo,
           {
             ...props.dom,
+            ...pointerProps(this.props),
             className: withDefaultsClass(props.className, defaultsClass),
             style: style2,
             innerRef: (video) => {
@@ -97687,6 +98064,7 @@ var init_parentcomponentobject = __esm({
        */
       nodeScopeDidInitialize() {
         this.context.scheduleAfterUpdate(() => {
+          if (this._deleted) return;
           this._internal.resolutionIsLoud = true;
           this.onComponentStateNodesChanged();
         });
@@ -97812,8 +98190,8 @@ var init_parentcomponentobject = __esm({
           const self2 = this.nodeScope.componentOwner;
           const wanted = this._internal.targetComponent;
           if (wanted) {
-            const named2 = findAncestorWithName(self2, wanted);
-            if (!named2) {
+            const named3 = findAncestorWithName(self2, wanted);
+            if (!named3) {
               this._internal.parentComponentName = void 0;
               resolvedTargets2.report(this, void 0);
               this.reportMiss("parent-component-object/target-not-found", 'No ancestor component named "' + wanted + '"', {
@@ -97822,7 +98200,7 @@ var init_parentcomponentobject = __esm({
               });
               return;
             }
-            if (!COMPONENT_OBJECT_TYPES.some((type) => named2.nodeScope.getNodesWithType(type).length > 0)) {
+            if (!COMPONENT_OBJECT_TYPES.some((type) => named3.nodeScope.getNodesWithType(type).length > 0)) {
               this._internal.parentComponentName = void 0;
               resolvedTargets2.report(this, void 0);
               this.reportMiss(
@@ -97832,11 +98210,11 @@ var init_parentcomponentobject = __esm({
               );
               return;
             }
-            this._internal.parentComponentName = named2.name;
+            this._internal.parentComponentName = named3.name;
             this._internal.lastMissCode = void 0;
             this._internal.lastError = void 0;
-            resolvedTargets2.report(this, named2.name);
-            return "componentState" + named2.getInstanceId();
+            resolvedTargets2.report(this, named3.name);
+            return "componentState" + named3.getInstanceId();
           }
           const parent = findAncestorWithComponentObject(self2);
           if (!parent) {
@@ -98015,22 +98393,22 @@ var init_setparentcomponentobjectproperties = __esm({
         const self2 = this.nodeScope.componentOwner;
         const wanted = this._internal.targetComponent;
         if (wanted) {
-          const named2 = findAncestorWithName(self2, wanted);
-          if (!named2) {
+          const named3 = findAncestorWithName(self2, wanted);
+          if (!named3) {
             return {
               missCode: "set-parent-component-object-properties/target-not-found",
               missMessage: 'No ancestor component named "' + wanted + '"',
               missDetail: { target: wanted, ancestors: componentAncestorNames(self2) }
             };
           }
-          if (!COMPONENT_OBJECT_TYPES.some((type) => named2.nodeScope.getNodesWithType(type).length > 0)) {
+          if (!COMPONENT_OBJECT_TYPES.some((type) => named3.nodeScope.getNodesWithType(type).length > 0)) {
             return {
               missCode: "set-parent-component-object-properties/target-has-no-object",
               missMessage: 'The component "' + wanted + '" has no Component Object node',
               missDetail: { target: wanted }
             };
           }
-          return { id: "componentState" + named2.getInstanceId(), name: named2.name };
+          return { id: "componentState" + named3.getInstanceId(), name: named3.name };
         }
         const parent = findAncestorWithComponentObject(self2);
         if (!parent) {
@@ -100335,15 +100713,15 @@ var init_closepopup = __esm({
           const candidates = popups.map((component) => component.name);
           const wanted = this._internal.targetComponent;
           if (wanted) {
-            const named2 = popups.find((component) => component.name === wanted);
-            if (!named2) {
+            const named3 = popups.find((component) => component.name === wanted);
+            if (!named3) {
               return {
                 candidates,
                 missCode: "close-popup/target-not-found",
                 missMessage: 'This node is not inside a popup named "' + wanted + '"' + (candidates.length ? " \u2014 it is inside: " + candidates.join(", ") : "")
               };
             }
-            return { popup: named2, close: named2._popupCloseHandler, candidates };
+            return { popup: named3, close: named3._popupCloseHandler, candidates };
           }
           if (this._internal.closeCallback) {
             return { popup: popups[0], close: this._internal.closeCallback, candidates };
@@ -100755,7 +101133,9 @@ var init_userservice = __esm({
         this.adapter = new ParseAuthAdapter({
           // The module-scope serialiser, exactly as before — `_User` properties have
           // always been serialised against the process-wide Model store.
-          serializeObject: (data, collectionName2) => import_cloudstore2.default._serializeObject(data, collectionName2)
+          // P115-HST006-VIEWERTS2554: the third argument (the model scope) is named, undefined, as JavaScript already
+          // passed it: the runtime's generated types declare all three, and the production viewer build type-checks.
+          serializeObject: (data, collectionName2) => import_cloudstore2.default._serializeObject(data, collectionName2, void 0)
         });
         this._bridge(this.adapter);
         if (this._consumeAuthReturn()) return;
@@ -100808,12 +101188,12 @@ var init_userservice = __esm({
        */
       _handle(backendId) {
         if (backendId && backendId !== ACTIVE_BACKEND) {
-          const named2 = resolveBackendFromRuntime(backendId);
-          return named2 ? named2.handle : void 0;
+          const named3 = resolveBackendFromRuntime(backendId);
+          return named3 ? named3.handle : void 0;
         }
         if (!this.endpoint) {
-          const resolved2 = resolveBackendFromRuntime(ACTIVE_BACKEND);
-          if (resolved2) return resolved2.handle;
+          const resolved3 = resolveBackendFromRuntime(ACTIVE_BACKEND);
+          if (resolved3) return resolved3.handle;
         }
         return {
           id: "_active_",
@@ -102063,7 +102443,7 @@ var init_signinwith = __esm({
           const tokens = [this.beginOutcome()];
           if (state2.succeeded) {
             this._internal.notice = state2.notice;
-            this._internal.error = void 0;
+            this._internal.error = "";
             this.flagOutputDirty("notice");
             this.flagOutputDirty("error");
             reportOutcomes(this, tokens, "done");
@@ -111406,9 +111786,9 @@ var require_fast_uri = __commonJS({
     }
     function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved2 = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved3 = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
-      return serialize(resolved2, schemelessOptions);
+      return serialize(resolved3, schemelessOptions);
     }
     function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
@@ -114719,7 +115099,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@nodegx/preview",
-      version: "0.2.7",
+      version: "0.2.9",
       description: "Standalone live-preview harness: renders a NodeGX (OpenNoodl) v2 project in a browser with no editor process, and reloads it when the files on disk change.",
       license: "GPL-3.0-only",
       homepage: "https://nodegx.io",
@@ -164665,7 +165045,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -166850,7 +167230,7 @@ var node_catalog_default = {
           "always: the page, or the scrolling Group holding it, scrolls until the box can be seen"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -169462,7 +169842,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -171644,7 +172024,7 @@ var node_catalog_default = {
           "always: the page, or the scrolling Group holding it, scrolls until the button can be seen"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, it takes no click and a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, it takes no click and a Focus does not reach it"
         ]
       },
       warnings: {
@@ -174049,7 +174429,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -176919,7 +177299,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ],
         opacity: [
           "always: how see-through it is; at exactly 0 it takes no pointer, and an act goes to what is behind it"
@@ -181761,7 +182141,7 @@ var node_catalog_default = {
           },
           isSignal: false,
           default: false,
-          description: "Whether a request with no valid session token is allowed to run this function at all"
+          description: "Whether a request with no valid session token is allowed to run this function at all. A run the app starts itself \u2014 a schedule, a row change, a run from Studio \u2014 is always allowed and sees nobody signed in; a webhook is a request like any other"
         },
         {
           name: "params",
@@ -183818,14 +184198,14 @@ var TOKEN_COOKIE = "nodegx_token";
 function mintToken() {
   return (0, import_node_crypto.randomBytes)(32).toString("hex");
 }
-function resolveAccess(request = {}) {
-  const shared = request.share === true;
+function resolveAccess(request2 = {}) {
+  const shared = request2.share === true;
   return {
-    host: shared ? request.host || ALL_INTERFACES : LOOPBACK,
+    host: shared ? request2.host || ALL_INTERFACES : LOOPBACK,
     shared,
     // A shared server always has a token. An unshared one still gets one, so that turning
     // sharing on later cannot find itself without a credential and invent a weaker path.
-    token: request.token || mintToken()
+    token: request2.token || mintToken()
   };
 }
 function tokenMatches(candidate, token) {
@@ -183841,15 +184221,15 @@ function isLoopbackAddress(address) {
   if (addr === "::1") return true;
   return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(addr);
 }
-function tokenFromRequest(request) {
-  const headers = request.headers || {};
+function tokenFromRequest(request2) {
+  const headers = request2.headers || {};
   const header = headers[TOKEN_HEADER];
   if (typeof header === "string" && header.length > 0) return header;
   const auth = headers["authorization"];
   if (typeof auth === "string" && /^Bearer\s+/i.test(auth)) return auth.replace(/^Bearer\s+/i, "");
-  if (typeof request.url === "string") {
+  if (typeof request2.url === "string") {
     try {
-      const query = new URL(request.url, "http://placeholder.invalid").searchParams.get(TOKEN_QUERY);
+      const query = new URL(request2.url, "http://placeholder.invalid").searchParams.get(TOKEN_QUERY);
       if (query) return query;
     } catch {
     }
@@ -183863,11 +184243,11 @@ function tokenFromRequest(request) {
   }
   return null;
 }
-function authoriseRequest(request, access) {
-  if (!access.shared || isLoopbackAddress(request.remoteAddress)) {
+function authoriseRequest(request2, access) {
+  if (!access.shared || isLoopbackAddress(request2.remoteAddress)) {
     return { ok: true, reason: "loopback", setCookie: null };
   }
-  const presented = tokenFromRequest(request);
+  const presented = tokenFromRequest(request2);
   if (presented === null) {
     return { ok: false, reason: "no-token", status: 401, body: UNAUTHORISED_BODY };
   }
@@ -184216,6 +184596,13 @@ var CommentsModel = class extends import_model15.default {
 
 // ../noodl-editor/src/editor/src/models/warningsmodel.ts
 var import_model16 = __toESM(require_model());
+function sameWarning(a, b) {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
 var WarningsModel = class _WarningsModel extends import_model16.default {
   constructor() {
     super();
@@ -184228,13 +184615,23 @@ var WarningsModel = class _WarningsModel extends import_model16.default {
   static {
     this.instance = new _WarningsModel();
   }
+  /**
+   * P132-HIDDENPANELCHURN: a set that changes nothing says nothing. `readNameList` clears its warning on every read,
+   * and the Components panel reads page info (so names) on every `warningsChanged`: when a clear of a warning that was
+   * not there still announced a change, the two fed each other once per `setTimeout(1)`, ~480 times a second, for as
+   * long as a project was open (the panel, the top bar and every mounted dialog re-rendering each time).
+   * The same object set again still announces: its owner may have changed it in place.
+   */
   setWarning(ref, warning) {
     var w = this.getWarningsForRef(ref, warning !== void 0);
     if (!warning) {
-      if (w) delete w[ref.key];
+      if (!w || w[ref.key] === void 0) return;
+      delete w[ref.key];
     } else {
       warning.level = warning.level || "warning";
+      const had = w[ref.key];
       w[ref.key] = { ref, warning };
+      if (had && had.warning !== warning && sameWarning(had.warning, warning)) return;
     }
     this.scheduleNotifyChanged();
   }
@@ -185708,8 +186105,8 @@ function renderMarkdown(md) {
       continue;
     }
     if (lines.every((l) => /^\s*>\s?/.test(l))) {
-      const quoted = lines.map((l) => l.replace(/^\s*>\s?/, "")).join("\n");
-      html.push(`<blockquote>${renderMarkdown(quoted)}</blockquote>`);
+      const quoted2 = lines.map((l) => l.replace(/^\s*>\s?/, "")).join("\n");
+      html.push(`<blockquote>${renderMarkdown(quoted2)}</blockquote>`);
       continue;
     }
     if (lines.every((l) => /^\s*[-*]\s+/.test(l))) {
@@ -189209,11 +189606,11 @@ var TokenResolver = class _TokenResolver {
     }
     const token = this.tokens.get(tokenName);
     if (!token) return void 0;
-    const resolved2 = this._resolveValue(token.value, depth);
-    if (resolved2 !== void 0) {
-      this.cache.set(tokenName, resolved2);
+    const resolved3 = this._resolveValue(token.value, depth);
+    if (resolved3 !== void 0) {
+      this.cache.set(tokenName, resolved3);
     }
-    return resolved2;
+    return resolved3;
   }
   /**
    * P102 CMP-001 §3 — resolve every `var()` **inside** a value, so a preview can paint it.
@@ -190891,18 +191288,18 @@ function capabilityProbes() {
   if (!instance) instance = new CapabilityProbeCache({ runner: runProbe });
   return instance;
 }
-async function runProbe(request) {
-  switch (request.key) {
+async function runProbe(request2) {
+  switch (request2.key) {
     case "realtime.subscribe":
-      return probeRealtime(request);
+      return probeRealtime(request2);
     case "data.aggregate":
-      return probeAggregate(request);
+      return probeAggregate(request2);
     default:
-      throw new Error(`No probe implemented for ${request.key}`);
+      throw new Error(`No probe implemented for ${request2.key}`);
   }
 }
-function probeRealtime(request) {
-  const url = websocketUrl(request.url, request.probe.path);
+function probeRealtime(request2) {
+  const url = websocketUrl(request2.url, request2.probe.path);
   return new Promise((resolve5) => {
     let settled = false;
     let socket = null;
@@ -190935,8 +191332,8 @@ function probeRealtime(request) {
     socket.onclose = () => settle({ verdict: "unsupported", at: Date.now(), detail: "the websocket closed without upgrading" });
   });
 }
-async function probeAggregate(request) {
-  const response = await fetchWithDeadline(`${request.url}${request.probe.path}`, request.probe.method);
+async function probeAggregate(request2) {
+  const response = await fetchWithDeadline(`${request2.url}${request2.probe.path}`, request2.probe.method);
   if (!response) return { verdict: "unsupported", at: Date.now(), detail: "the server did not answer" };
   if (response.status !== 200) {
     return { verdict: "unsupported", at: Date.now(), detail: `the server answered ${response.status}` };
@@ -191121,11 +191518,11 @@ var ParameterValueResolver = class {
    * ```
    */
   static toString(paramValue) {
-    const resolved2 = this.resolve(paramValue, "display" /* Display */);
-    if (typeof resolved2 === "object" && resolved2 !== null) {
+    const resolved3 = this.resolve(paramValue, "display" /* Display */);
+    if (typeof resolved3 === "object" && resolved3 !== null) {
       return "";
     }
-    return String(resolved2 ?? "");
+    return String(resolved3 ?? "");
   }
   /**
    * Safely converts any parameter value to a number for display.
@@ -191144,15 +191541,15 @@ var ParameterValueResolver = class {
    * ```
    */
   static toNumber(paramValue) {
-    const resolved2 = this.resolve(paramValue, "display" /* Display */);
-    if (typeof resolved2 === "object" && resolved2 !== null) {
+    const resolved3 = this.resolve(paramValue, "display" /* Display */);
+    if (typeof resolved3 === "object" && resolved3 !== null) {
       return void 0;
     }
     const rawValue = isExpressionParameter(paramValue) ? paramValue.fallback : paramValue;
     if (rawValue === null || rawValue === void 0) {
       return void 0;
     }
-    const num = Number(resolved2);
+    const num = Number(resolved3);
     return isNaN(num) ? void 0 : num;
   }
   /**
@@ -191172,11 +191569,11 @@ var ParameterValueResolver = class {
    * ```
    */
   static toBoolean(paramValue) {
-    const resolved2 = this.resolve(paramValue, "display" /* Display */);
-    if (typeof resolved2 === "object" && resolved2 !== null) {
+    const resolved3 = this.resolve(paramValue, "display" /* Display */);
+    if (typeof resolved3 === "object" && resolved3 !== null) {
       return false;
     }
-    return Boolean(resolved2);
+    return Boolean(resolved3);
   }
   /**
    * Checks if a parameter value is an expression parameter.
@@ -191222,7 +191619,7 @@ var NodeGraphNode = class _NodeGraphNode extends import_model22.default {
   }
   /** Get the label of the node */
   get label() {
-    if (!this._label) return this.type.labelForNode(this);
+    if (!this._label) return this.derivedTitle ?? this.type.labelForNode(this);
     return this._label;
   }
   /** Set the label of the node */
@@ -191230,6 +191627,12 @@ var NodeGraphNode = class _NodeGraphNode extends import_model22.default {
     this._label = value2;
     this.notifyListeners("labelChanged");
   }
+  /** Set the derived title. `undefined` clears it. */
+  setDerivedTitle(title) {
+    if (this.derivedTitle === title) return;
+    this.derivedTitle = title;
+    this.notifyListeners("derivedTitleChanged");
+  }
   /** Set the runtime sub-label. `undefined` clears it. */
   setRuntimeSubLabel(subLabel) {
     if (this.runtimeSubLabel === subLabel) return;
@@ -193843,9 +194246,9 @@ function conditionIsUnsatisfied(condition, params) {
   return result2 === false;
 }
 function resolveAgainstDefaults(params, defaults) {
-  const resolved2 = { ...defaults };
-  for (const [name2, value2] of Object.entries(params)) if (value2 !== void 0) resolved2[name2] = value2;
-  return resolved2;
+  const resolved3 = { ...defaults };
+  for (const [name2, value2] of Object.entries(params)) if (value2 !== void 0) resolved3[name2] = value2;
+  return resolved3;
 }
 function conditionForInput(groups, portName) {
   if (!groups) return void 0;
@@ -193884,6 +194287,7 @@ var NUMBER_WITH_UNIT = /^\s*(-?\d+(?:\.\d+)?)\s*(px|%|vw|vh|em|rem|deg|s|ms)\s*$
 function isPlainObject2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
+var TOKEN_IN_VALUE = /var\(--[A-Za-z0-9_-]+\)/;
 function isTokenReference2(value2) {
   return typeof value2 === "string" && value2.startsWith("var(");
 }
@@ -193955,10 +194359,11 @@ function unitsFormat(type) {
           suggestion: JSON.stringify({ value: Number(parsed[1]), unit: parsed[2] })
         };
       }
+      const token = typeof value2 === "string" ? TOKEN_IN_VALUE.exec(value2)?.[0] : void 0;
       return {
         severity: "error",
-        message: `expects a number or { "value", "unit" } object. Got ${describeValue2(value2)}.`,
-        suggestion: JSON.stringify({ value: 16, unit: unit2 })
+        message: `expects a number, a { "value", "unit" } object or a var(--token) reference. Got ${describeValue2(value2)}.` + (token ? ` This port takes a token alone, not inside an expression: use ${token}, or add a token that holds the size you want.` : ""),
+        suggestion: JSON.stringify(token ?? { value: 16, unit: unit2 })
       };
     }
   };
@@ -194428,13 +194833,13 @@ function checkParameterValues(nodes, catalog, options) {
       });
     }
     if (dynamicSkips.length > 0) {
-      const named2 = dynamicSkips.map((n) => `"${n}"`).join(", ");
+      const named3 = dynamicSkips.map((n) => `"${n}"`).join(", ");
       const rawNote = catalog.dynamicPortNote(node.type) ?? "this node determines ports at runtime";
       const note = /[.!?]$/.test(rawNote.trim()) ? rawNote.trim() : `${rawNote.trim()}.`;
       diagnostics.push({
         code: "dynamic-port-skipped" /* DynamicPortSkipped */,
         severity: "info",
-        message: `${dynamicSkips.length === 1 ? "Parameter" : "Parameters"} ${named2} on ${node.type} ${dynamicSkips.length === 1 ? "names" : "name"} no port the catalog can see, and ${dynamicSkips.length === 1 ? "it was" : "they were"} not checked: ` + note + " So this node is unverified by that check rather than verified as correct.",
+        message: `${dynamicSkips.length === 1 ? "Parameter" : "Parameters"} ${named3} on ${node.type} ${dynamicSkips.length === 1 ? "names" : "name"} no port the catalog can see, and ${dynamicSkips.length === 1 ? "it was" : "they were"} not checked: ` + note + " So this node is unverified by that check rather than verified as correct.",
         location: {
           component,
           nodeId: node.id,
@@ -194529,6 +194934,55 @@ function cloudPortMeaning(type, plug) {
 init_scriptfiles();
 var FUNCTION_NODE_TYPE = "JavaScriptFunction";
 
+// ../noodl-editor/src/editor/src/models/nodelibrary/cloudDynamicPorts.ts
+init_function_ports();
+function proplist(parameters, name2) {
+  const value2 = parameters[name2];
+  return Array.isArray(value2) ? value2 : [];
+}
+function scriptPortsFromSource(script) {
+  const ports = [];
+  if (typeof script !== "string") return ports;
+  const names = functionScriptPortNames(script);
+  const add = (name2, plug, type, prefix) => {
+    if (ports.some((p) => p.name === prefix + name2 && p.plug === plug)) return;
+    ports.push({ name: prefix + name2, displayName: name2, plug, type, group: plug === "input" ? "Inputs" : "Outputs" });
+  };
+  for (const name2 of names.inputs) add(name2, "input", "*", "in-");
+  for (const name2 of names.signals) add(name2, "output", "signal", "out-");
+  for (const name2 of names.outputs) add(name2, "output", "*", "out-");
+  return ports;
+}
+function scriptPortsForNode(node) {
+  const parameters = node.parameters || {};
+  const ports = [];
+  for (const spec of proplist(parameters, "scriptOutputs")) {
+    if (!spec.label) continue;
+    ports.push({
+      name: "out-" + spec.label,
+      displayName: spec.label,
+      plug: "output",
+      type: parameters["outtype-" + spec.label] || "*",
+      group: "Outputs"
+    });
+  }
+  for (const spec of proplist(parameters, "scriptInputs")) {
+    if (!spec.label) continue;
+    ports.push({
+      name: "in-" + spec.label,
+      displayName: spec.label,
+      plug: "input",
+      type: parameters["intype-" + spec.label] || "string",
+      group: "Inputs"
+    });
+  }
+  for (const port of scriptPortsFromSource(parameters["functionScript"])) {
+    if (ports.some((p) => p.name === port.name && p.plug === port.plug)) continue;
+    ports.push(port);
+  }
+  return ports;
+}
+
 // ../noodl-editor/src/editor/src/validation/functionPorts.ts
 var SCRIPT_NODE_API_MEMBERS = [
   "Inputs",
@@ -194580,8 +195034,8 @@ function parentAxis(parent, catalog) {
   const declared2 = PARENT_MAIN_AXIS[parent.type];
   if (declared2 === void 0) return void 0;
   if (declared2 !== "fromFlexDirection") return declared2;
-  const resolved2 = resolveAgainstDefaults(parent.parameters ?? {}, catalog.inputDefaults(parent.type));
-  const flexDirection = resolved2["flexDirection"];
+  const resolved3 = resolveAgainstDefaults(parent.parameters ?? {}, catalog.inputDefaults(parent.type));
+  const flexDirection = resolved3["flexDirection"];
   if (flexDirection === "row") return "row";
   if (flexDirection === "column" || flexDirection === void 0) return "column";
   return void 0;
@@ -194784,7 +195238,11 @@ var AUTHORED_BLOCKING_WARNINGS = /* @__PURE__ */ new Set([
   // Bug P121-TWO003-SCRIPTCOMPILE — the runtime's own compile fails, so every Run fails. No benign
   // reading for a graph an agent just wrote; the write said nothing before, and the first person
   // to run the function got "That could not be done."
-  "function-script-not-compiled" /* FunctionScriptNotCompiled */
+  "function-script-not-compiled" /* FunctionScriptNotCompiled */,
+  // Bug P127-BKO006-RUNONCHANGEGUESS — a `runOnChange-` name a Function does not have is never read
+  // (2,805 right and 5 wrong over 2,718 Functions, all five agent-written); the message names the
+  // right one.
+  "function-run-on-change-unknown" /* FunctionRunOnChangeUnknown */
 ]);
 
 // ../noodl-editor/src/editor/src/validation/diagnosticExamples.ts
@@ -194924,6 +195382,12 @@ var DIAGNOSTIC_EXAMPLES = [
     code: "function-guards-an-open-collection" /* FunctionGuardsAnOpenCollection */,
     examples: ["cloud-members-can-edit-my-records"],
     why: `the records only a function creates, with the collection's create rule "nobody": the function runs as the system`
+  },
+  // P112-OWN018-FANOUT (ruled 2026-10-27 "Teach it and warn") — the warning carries the chained shape.
+  {
+    code: "condition-reads-a-siblings-change" /* ConditionReadsASiblingsChange */,
+    examples: ["score-then-move-on"],
+    why: "the press evaluating the gate that reads, and that gate's Done evaluating the gate that moves on, so the score is decided first"
   }
 ];
 
@@ -196214,9 +196678,9 @@ var dialogWithoutName = {
         if (typeof accessibleName === "string" && accessibleName.trim() !== "") continue;
         const target = node.parameters?.target;
         if (typeof target !== "string" || target.trim() === "") continue;
-        const resolved2 = byName.has(target) ? target : void 0;
-        if (resolved2 === void 0) continue;
-        if (subtreeHasHeading(resolved2, byName, /* @__PURE__ */ new Set())) continue;
+        const resolved3 = byName.has(target) ? target : void 0;
+        if (resolved3 === void 0) continue;
+        if (subtreeHasHeading(resolved3, byName, /* @__PURE__ */ new Set())) continue;
         diagnostics.push({
           code: "dialog-without-name" /* DialogWithoutName */,
           severity: "warning",
@@ -196398,9 +196862,9 @@ var CODE_PREFIX = "const Script = (typeof Node !== 'undefined')?Node:undefined;\
 var PARAMS2 = ["Inputs", "Outputs", "Noodl", "Component", "Scripts"];
 function functionScriptCompileError(script) {
   try {
-    const AsyncFunction = Object.getPrototypeOf(async function() {
+    const AsyncFunction2 = Object.getPrototypeOf(async function() {
     }).constructor;
-    new AsyncFunction(...PARAMS2, CODE_PREFIX + script);
+    new AsyncFunction2(...PARAMS2, CODE_PREFIX + script);
     return void 0;
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
@@ -196510,6 +196974,156 @@ var functionNeverReruns = {
   }
 };
 
+// ../noodl-editor/src/editor/src/validation/rules/functionRunOnChangeUnknown.ts
+var RUN_ON_CHANGE_PREFIX4 = "runOnChange-";
+var FUNCTION_INPUT_PREFIX = "in-";
+var functionRunOnChangeUnknown = {
+  code: "function-run-on-change-unknown" /* FunctionRunOnChangeUnknown */,
+  description: "A Function has a Run On Value Change setting under a name it does not have (its boxes are runOnChange-in-<input>).",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    for (const { component } of ctx.components) {
+      for (const node of component.nodes) {
+        if (node.type !== FUNCTION_NODE_TYPE || !node.parameters) continue;
+        const guessed = Object.keys(node.parameters).filter(
+          (key) => key.startsWith(RUN_ON_CHANGE_PREFIX4) && !key.startsWith(RUN_ON_CHANGE_PREFIX4 + FUNCTION_INPUT_PREFIX)
+        );
+        if (guessed.length === 0) continue;
+        const inputs = scriptPortsForNode(node).filter((p) => p.plug === "input" && p.name.startsWith(FUNCTION_INPUT_PREFIX)).map((p) => p.name.slice(FUNCTION_INPUT_PREFIX.length));
+        const name2 = node.label ? `"${node.label}"` : "This Function";
+        for (const key of guessed) {
+          const wanted = key.slice(RUN_ON_CHANGE_PREFIX4.length);
+          const input2 = inputs.includes(wanted) ? wanted : nearest(wanted, inputs);
+          const right = input2 !== void 0 ? `${RUN_ON_CHANGE_PREFIX4}${FUNCTION_INPUT_PREFIX}${input2}` : void 0;
+          out.push({
+            code: "function-run-on-change-unknown" /* FunctionRunOnChangeUnknown */,
+            severity: "warning",
+            message: `${name2} has no setting "${key}", so nothing reads it` + (input2 === wanted ? ` and a new "${wanted}" still runs it. ` : ". ") + `A Function's Run On Value Change box for an input is "runOnChange-in-<input>"` + (right ? input2 === wanted ? `: write "${right}".` : `; its script reads no "${wanted}" (the nearest input is "${input2}": "${right}").` : `, and its script reads no inputs.`),
+            location: {
+              component: component.name,
+              nodeId: node.id,
+              nodeType: node.type,
+              nodeLabel: node.label,
+              port: key,
+              plug: "input"
+            },
+            ...right ? { suggestion: `${right}: ${JSON.stringify(node.parameters[key])}` } : {}
+          });
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// ../noodl-editor/src/editor/src/validation/rules/conditionReadsASiblingsChange.ts
+var CONDITION = "Condition";
+var conditionReadsASiblingsChange = {
+  code: "condition-reads-a-siblings-change" /* ConditionReadsASiblingsChange */,
+  description: "Two Conditions evaluated by one signal, where one's On True or On False changes what the other reads.",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    const { catalog } = ctx;
+    for (const { component, nodeById } of ctx.components) {
+      let exclusiveStates = function(a, b) {
+        const stateOf = (gate) => {
+          const c = (incoming.get(gate) ?? []).find((w) => w.toProperty === "condition");
+          return c && nodeById.get(c.fromId)?.type === "States" && c.fromProperty.startsWith("at-") ? c : void 0;
+        };
+        const sa = stateOf(a);
+        const sb = stateOf(b);
+        return !!sa && !!sb && sa.fromId === sb.fromId && sa.fromProperty !== sb.fromProperty;
+      }, feedingValues = function(gate) {
+        const seen = /* @__PURE__ */ new Set();
+        const stack = (incoming.get(gate) ?? []).filter((c) => c.toProperty === "condition").map((c) => c.fromId);
+        while (stack.length > 0) {
+          const id = stack.pop();
+          if (id === gate || seen.has(id)) continue;
+          seen.add(id);
+          if (!passesThrough(id)) continue;
+          const type = nodeById.get(id)?.type;
+          for (const c of incoming.get(id) ?? []) {
+            if (type && catalog.getPort(type, "input", c.toProperty)?.isSignal) continue;
+            stack.push(c.fromId);
+          }
+        }
+        return seen;
+      }, reaches2 = function(gate, targets) {
+        if (targets.size === 0) return false;
+        const seen = /* @__PURE__ */ new Set([gate]);
+        const stack = (outgoing.get(gate) ?? []).map((c) => c.toId);
+        while (stack.length > 0) {
+          const id = stack.pop();
+          if (targets.has(id)) return true;
+          if (seen.has(id)) continue;
+          seen.add(id);
+          if (!passesThrough(id)) continue;
+          for (const c of outgoing.get(id) ?? []) stack.push(c.toId);
+        }
+        return false;
+      };
+      const outgoing = /* @__PURE__ */ new Map();
+      const incoming = /* @__PURE__ */ new Map();
+      for (const c of component.connections) {
+        (outgoing.get(c.fromId) ?? outgoing.set(c.fromId, []).get(c.fromId)).push(c);
+        (incoming.get(c.toId) ?? incoming.set(c.toId, []).get(c.toId)).push(c);
+      }
+      const isCondition = (id) => nodeById.get(id)?.type === CONDITION;
+      const passesThrough = (id) => {
+        const type = nodeById.get(id)?.type;
+        const known = type ? catalog.getNode(type) : void 0;
+        return !!known && !known.isVisual;
+      };
+      const gatesBySource = /* @__PURE__ */ new Map();
+      for (const c of component.connections) {
+        if (c.toProperty !== "eval" || !isCondition(c.toId)) continue;
+        const key = `${c.fromId}\0${c.fromProperty}`;
+        const gates = gatesBySource.get(key) ?? [];
+        if (!gates.includes(c.toId)) gates.push(c.toId);
+        gatesBySource.set(key, gates);
+      }
+      const reported = /* @__PURE__ */ new Set();
+      for (const [key, gates] of gatesBySource) {
+        if (gates.length < 2) continue;
+        const sourceId = key.split("\0")[0];
+        for (const reader of gates) {
+          if (reported.has(reader)) continue;
+          const feeds = feedingValues(reader);
+          for (const writer of gates) {
+            if (writer === reader) continue;
+            if (exclusiveStates(reader, writer)) continue;
+            if (!reaches2(writer, feeds)) continue;
+            reported.add(reader);
+            const r = nodeById.get(reader);
+            const w = nodeById.get(writer);
+            const rName = r.label ? `"${r.label}"` : "This Condition";
+            const wName = w.label ? `"${w.label}"` : "another Condition";
+            const sName = nodeById.get(sourceId)?.label ? `"${nodeById.get(sourceId).label}"` : "the same signal";
+            out.push({
+              code: "condition-reads-a-siblings-change" /* ConditionReadsASiblingsChange */,
+              severity: "warning",
+              message: `${rName} and ${wName} are both evaluated by ${sName}, and what ${wName} does changes what ${rName} reads. ${rName} reads its Condition after that change, whichever order the two are wired in. If it should decide on the value from before, chain them: ${rName}'s Done into ${wName}'s Evaluate, instead of both from ${sName}.`,
+              location: {
+                component: component.name,
+                nodeId: r.id,
+                nodeType: r.type,
+                nodeLabel: r.label,
+                port: "eval",
+                plug: "input"
+              },
+              suggestion: `${r.id}.done \u2192 ${w.id}.eval`
+            });
+            break;
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+
 // ../noodl-editor/src/editor/src/validation/rules/layoutFillTraps.ts
 var GROUP = "Group";
 var CONTENT_WIDTH = /* @__PURE__ */ new Set(["contentSize", "contentWidth"]);
@@ -196617,6 +197231,181 @@ var rowOfWordsFillsItsColumn = {
   }
 };
 
+// ../noodl-editor/src/editor/src/validation/rules/bandWithoutShell.ts
+var GROUP2 = "Group";
+var resolved2 = (node, catalog) => resolveAgainstDefaults(node.parameters ?? {}, catalog.inputDefaults(node.type));
+var named2 = (nodes) => nodes.slice(0, 4).map((n) => n.label ? `"${n.label}"` : n.type).join(", ") + (nodes.length > 4 ? ", \u2026" : "");
+var isSet2 = (value2) => value2 !== void 0 && value2 !== null && value2 !== "" && value2 !== 0;
+function isFullWidth(value2) {
+  if (widthIsPercentage(value2) !== true) return false;
+  const n = typeof value2 === "object" && value2 !== null ? value2.value : parseFloat(String(value2));
+  return Number(n) >= 100;
+}
+function spans(params) {
+  return isFullWidth(params["width"]) && !isSet2(params["maxWidth"]) && !isSet2(params["paddingLeft"]) && !isSet2(params["paddingRight"]);
+}
+var isCard = (params) => isSet2(params["borderRadius"]) || painted(params["borderStyle"]);
+var SECTION_ELEMENTS = /* @__PURE__ */ new Set(["section", "header", "footer"]);
+var painted = (value2) => isSet2(value2) && value2 !== "transparent" && value2 !== "none";
+function isBand(node, catalog) {
+  if (node.type !== GROUP2) return false;
+  const params = resolved2(node, catalog);
+  if (!spans(params)) return false;
+  if ((params["flexDirection"] ?? "column") !== "column") return false;
+  if (params["alignItems"] !== "center") return false;
+  if (params["position"] === "absolute" || params["position"] === "fixed") return false;
+  if (isCard(params)) return false;
+  return isSet2(params["paddingTop"]) || isSet2(params["paddingBottom"]) || painted(params["backgroundColor"]) || painted(params["backgroundGradient"]) || painted(params["backgroundImage"]) || SECTION_ELEMENTS.has(String(params["as"] ?? ""));
+}
+var bandWithoutShell = {
+  code: "band-without-shell" /* BandWithoutShell */,
+  description: "A full-width band holds its content directly instead of inside one shell, so the content runs to the window edge.",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    for (const { component, nodeById } of ctx.components) {
+      const inFlowChildren2 = (parent) => (parent.children ?? []).map((id) => nodeById.get(id)).filter((n) => {
+        if (!n) return false;
+        if (isComponentRef(n.type)) return true;
+        if (!ctx.catalog.getNode(n.type)?.isVisual) return false;
+        const p = resolved2(n, ctx.catalog);
+        return p["position"] !== "absolute" && p["position"] !== "fixed";
+      });
+      const guarded = (n, depth = 0) => {
+        if (isComponentRef(n.type)) return true;
+        if (n.type !== GROUP2) return false;
+        const p = resolved2(n, ctx.catalog);
+        if (isSet2(p["maxWidth"]) || isSet2(p["paddingLeft"]) || isSet2(p["paddingRight"])) return true;
+        const kids = inFlowChildren2(n);
+        return depth < 4 && kids.length > 0 && kids.every((k) => guarded(k, depth + 1));
+      };
+      for (const band of component.nodes) {
+        if (!isBand(band, ctx.catalog)) continue;
+        let placed = true;
+        for (let up = band.parent ? nodeById.get(band.parent) : void 0; up; up = up.parent ? nodeById.get(up.parent) : void 0) {
+          if (up.type === "Page") break;
+          const p = up.type === GROUP2 ? resolved2(up, ctx.catalog) : void 0;
+          if (!p || !spans(p) || isCard(p)) {
+            placed = false;
+            break;
+          }
+        }
+        if (!placed) continue;
+        const inside = inFlowChildren2(band);
+        if (inside.length === 0) continue;
+        if (inside.some((n) => isBand(n, ctx.catalog))) continue;
+        const bare = inside.filter((n) => !guarded(n));
+        if (bare.length === 0) continue;
+        const what = bare.length === inside.length && inside.length > 1 ? `it holds ${inside.length} things directly (${named2(inside)}) instead of one shell` : `${named2(bare)} ${bare.length === 1 ? "sits" : "sit"} in it outside a shell`;
+        out.push({
+          code: "band-without-shell" /* BandWithoutShell */,
+          severity: "warning",
+          message: `This is a full-width band (a section of the page), but ${what}, so its words and pictures run to the edge of the window on a desktop. Put everything it holds inside ONE Group with the style vocabulary's "shell" look (maxWidth 1200px, paddingLeft and paddingRight var(--space-6), sizeMode contentHeight), and make that Group the band's only child.`,
+          location: {
+            component: component.name,
+            nodeId: band.id,
+            nodeType: band.type,
+            ...band.label ? { nodeLabel: band.label } : {}
+          },
+          suggestion: 'one child Group with the "shell" look'
+        });
+      }
+    }
+    return out;
+  }
+};
+
+// ../noodl-editor/src/editor/src/validation/rules/clickAreaHoldsAControl.ts
+var CONTROL_TYPES = /* @__PURE__ */ new Map([
+  ["net.noodl.controls.button", "Button"],
+  ["net.noodl.controls.textinput", "Text Input"],
+  ["net.noodl.controls.checkbox", "Checkbox"],
+  ["net.noodl.controls.radiobutton", "Radio Button"],
+  ["net.noodl.controls.options", "Dropdown"],
+  ["net.noodl.controls.range", "Slider"]
+]);
+var CLICK = "onClick";
+var COMPONENT_OUTPUTS = "Component Outputs";
+var clickWired = (component, node) => component.connections.some((c) => c.fromId === node.id && c.fromProperty === CLICK);
+function reaches(component, nodeById, node, port, used) {
+  return component.connections.some((c) => {
+    if (c.fromId !== node.id || c.fromProperty !== port) return false;
+    if (nodeById.get(c.toId)?.type !== COMPONENT_OUTPUTS) return true;
+    return used === "all" || used.has(c.toProperty);
+  });
+}
+var quoted = (node) => node.label ? ` ("${node.label}")` : "";
+var clickAreaHoldsAControl = {
+  code: "click-area-holds-a-control" /* ClickAreaHoldsAControl */,
+  description: "An element whose Click is wired holds a control, so the keyboard reaches the control and not the element.",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    const byPath = new Map(ctx.components.map((c) => [refToPath(c.component.name), c]));
+    const memo = /* @__PURE__ */ new Map();
+    const componentHolds = (ref, used) => {
+      const path8 = refToPath(ref);
+      const key = `${path8}|${[...used].sort().join(",")}`;
+      if (memo.has(key)) return memo.get(key) ?? null;
+      memo.set(key, null);
+      const entry = byPath.get(path8);
+      let found = null;
+      if (entry) {
+        for (const node of entry.component.nodes) {
+          found = held(node, entry.component, entry.nodeById, used);
+          if (found) break;
+        }
+      }
+      memo.set(key, found);
+      return found;
+    };
+    function held(node, component, nodeById, used) {
+      const control = CONTROL_TYPES.get(node.type);
+      if (control) return `a ${control}${quoted(node)}`;
+      if (reaches(component, nodeById, node, CLICK, used)) {
+        return `${node.label ? `"${node.label}"` : "an element"}, which answers a click of its own`;
+      }
+      if (isComponentRef(node.type)) {
+        const ports = new Set(component.connections.filter((c) => c.fromId === node.id).map((c) => c.fromProperty));
+        const usedHere = new Set([...ports].filter((port) => reaches(component, nodeById, node, port, used)));
+        const inside = componentHolds(node.type, usedHere);
+        if (inside) return `the component ${node.label ? `"${node.label}"` : `"${refToPath(node.type)}"`}, which holds ${inside}`;
+      }
+      return null;
+    }
+    for (const { component, nodeById } of ctx.components) {
+      for (const area of component.nodes) {
+        if (CONTROL_TYPES.has(area.type) || !clickWired(component, area)) continue;
+        if (!ctx.catalog.getNode(area.type)?.isVisual) continue;
+        let inner = null;
+        const stack = [...area.children ?? []];
+        while (stack.length && !inner) {
+          const node = nodeById.get(stack.shift());
+          if (!node) continue;
+          inner = held(node, component, nodeById, "all");
+          stack.push(...node.children ?? []);
+        }
+        if (!inner) continue;
+        const name2 = area.label ? `"${area.label}"` : `This ${ctx.catalog.getNode(area.type)?.displayName ?? area.type}`;
+        out.push({
+          code: "click-area-holds-a-control" /* ClickAreaHoldsAControl */,
+          severity: "info",
+          message: `${name2} answers a click. It holds ${inner}. The Tab key stops on what it holds instead. A person using a keyboard or a screen reader cannot press ${area.label ? name2 : "it"} itself. If its click does something nothing inside it does, give that its own Button.`,
+          location: {
+            component: component.name,
+            nodeId: area.id,
+            nodeType: area.type,
+            ...area.label ? { nodeLabel: area.label } : {},
+            port: CLICK,
+            plug: "output"
+          }
+        });
+      }
+    }
+    return out;
+  }
+};
+
 // ../noodl-editor/src/editor/src/validation/rules/index.ts
 var ALL_RULES = [
   duplicateNodeId,
@@ -196673,6 +197462,10 @@ var ALL_RULES = [
   // arrangement ones.
   functionScriptNotCompiled,
   functionNeverReruns,
+  functionRunOnChangeUnknown,
+  // P112-OWN018-FANOUT (ruled 2026-10-27 "Teach it and warn") — beside the Function rules: what a graph's signals do in
+  // what order, read from the wires. Two gates off one signal, one changing what the other reads.
+  conditionReadsASiblingsChange,
   repeatedSiblingSubtree,
   // DEF-025 — beside `repeatedSiblingSubtree` because both read the visual
   // tree's arrangement rather than wires: that one asks whether siblings
@@ -196686,10 +197479,15 @@ var ALL_RULES = [
   // against the shipped corpus before they were written — this one is 0 hits
   // on all ten templates.
   dialogWithoutName,
+  // P121-TWO003-NESTEDBUTTON (ruled 2026-10-27) — beside the two above: what a keyboard and a screen reader reach, read
+  // from the arrangement. An info, live, so the Problems panel and an agent's write both say it.
+  clickAreaHoldsAControl,
   // P112-OWN020-PILLWRAP / FILLGROW (ruled 2026-10-26: warn and teach) — a node with no size setting fills its parent,
   // read from the arrangement like the two above, and live so a person sees it while editing.
   contentRowSplitsItsChildren,
   rowOfWordsFillsItsColumn,
+  // P112 OWN-028 AC3 — beside the two above: a band's content outside a shell, read from the arrangement, live.
+  bandWithoutShell,
   oversizedPage,
   // LEG-002 — last, and deliberately: it is the only rule in the set that
   // reports a matter of legibility rather than of correctness, and a reader
@@ -196919,21 +197717,21 @@ function answering(port) {
   });
 }
 async function keepOwnBackend(projectDir, log2) {
-  const named2 = namedBackend(projectDir);
-  if (!named2) return { first: { state: "none" }, stop: () => void 0 };
+  const named3 = namedBackend(projectDir);
+  if (!named3) return { first: { state: "none" }, stop: () => void 0 };
   const root2 = backendsRoot();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let child = null;
   let stopped = false;
-  const recordFile = path6.join(root2, named2.id, "runtime.json");
+  const recordFile = path6.join(root2, named3.id, "runtime.json");
   const writeRecord = (pid, entry, name2) => {
     const record = {
       version: 1,
-      backendId: named2.id,
+      backendId: named3.id,
       backendName: name2,
       pid,
-      port: named2.port,
-      endpoint: named2.endpoint,
+      port: named3.port,
+      endpoint: named3.endpoint,
       entry,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       owner: { kind: "preview", pid: process.pid, startedAt, projectDir },
@@ -196952,20 +197750,20 @@ async function keepOwnBackend(projectDir, log2) {
     }
   };
   const look = async () => {
-    const configFile = path6.join(root2, named2.id, "config.json");
-    if (!fs5.existsSync(configFile)) return { state: "missing", id: named2.id, root: root2 };
-    if (child && child.exitCode === null) return { state: "running", id: named2.id, port: named2.port, owner: "this preview" };
-    if (await answering(named2.port)) {
+    const configFile = path6.join(root2, named3.id, "config.json");
+    if (!fs5.existsSync(configFile)) return { state: "missing", id: named3.id, root: root2 };
+    if (child && child.exitCode === null) return { state: "running", id: named3.id, port: named3.port, owner: "this preview" };
+    if (await answering(named3.port)) {
       let owner = "another process";
       try {
         owner = JSON.parse(fs5.readFileSync(recordFile, "utf8"))?.owner?.kind ?? owner;
       } catch {
       }
-      return { state: "running", id: named2.id, port: named2.port, owner };
+      return { state: "running", id: named3.id, port: named3.port, owner };
     }
     const entry = resolveServiceEntry();
-    if (!entry) return { state: "no-service", id: named2.id };
-    let name2 = named2.id;
+    if (!entry) return { state: "no-service", id: named3.id };
+    let name2 = named3.id;
     try {
       name2 = JSON.parse(fs5.readFileSync(configFile, "utf8")).name || name2;
     } catch {
@@ -196974,11 +197772,11 @@ async function keepOwnBackend(projectDir, log2) {
       entry,
       "serve",
       "--data-dir",
-      path6.join(root2, named2.id),
+      path6.join(root2, named3.id),
       "--port",
-      String(named2.port),
+      String(named3.port),
       "--backend-id",
-      named2.id,
+      named3.id,
       "--backend-name",
       name2,
       "--parent-pid",
@@ -197009,7 +197807,7 @@ async function keepOwnBackend(projectDir, log2) {
         proc.kill("SIGKILL");
       } catch {
       }
-      return { state: "failed", id: named2.id, why: ready };
+      return { state: "failed", id: named3.id, why: ready };
     }
     child = proc;
     writeRecord(proc.pid, entry, name2);
@@ -197017,13 +197815,13 @@ async function keepOwnBackend(projectDir, log2) {
       if (ownRecord()) fs5.rmSync(recordFile, { force: true });
       if (!stopped) log2(`  ! the app's backend stopped; looking again in ${HEARTBEAT_MS / 1e3} s`);
     });
-    return { state: "started", id: named2.id, port: named2.port, pid: proc.pid };
+    return { state: "started", id: named3.id, port: named3.port, pid: proc.pid };
   };
   const say = (s, quiet) => {
-    if (s.state === "started") log2(`  \u2713 started the app's backend (${s.id}) on ${named2.endpoint}`);
+    if (s.state === "started") log2(`  \u2713 started the app's backend (${s.id}) on ${named3.endpoint}`);
     else if (s.state === "failed") log2(`  \u2717 the app's backend (${s.id}) did not start: ${s.why}`);
     else if (quiet) return;
-    else if (s.state === "running") log2(`  \u2713 the app's backend (${s.id}) is already running on ${named2.endpoint} (${s.owner})`);
+    else if (s.state === "running") log2(`  \u2713 the app's backend (${s.id}) is already running on ${named3.endpoint} (${s.owner})`);
     else if (s.state === "missing")
       log2(`  ! the app names a backend (${s.id}) that is not on this machine (${s.root}) \u2014 its saves and records will fail`);
     else if (s.state === "no-service") log2(`  ! the app names a backend (${s.id}) but this preview has no backend service to start it with`);
@@ -197464,6 +198262,7 @@ function validationWarningLines(state2) {
   if (state2.kind !== "ok" || !state2.report) return [];
   return state2.report.diagnostics.filter((d) => d.severity === "warning").map((d) => `${d.code} in ${d.component}${d.nodeLabel || d.nodeId ? ` (${d.nodeLabel ?? d.nodeId})` : ""}: ${d.message}`);
 }
+var BACKEND_PREFIX = "/__nodegx/backend";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -197577,6 +198376,10 @@ var PreviewServer = class {
     const url = new URL(req.url ?? "/", "http://localhost");
     const pathname = decodeURIComponent(url.pathname);
     if (pathname === "/__preview/events") return this.serveEvents(req, res);
+    const backendPort = this.sharedBackendPort();
+    if (backendPort && (pathname === BACKEND_PREFIX || pathname.startsWith(BACKEND_PREFIX + "/"))) {
+      return this.proxyToBackend(req, res, backendPort);
+    }
     if (pathname === "/__preview/state") {
       const status = {
         state: this.state,
@@ -197600,7 +198403,11 @@ var PreviewServer = class {
       if (!bundle) return this.notFound(res);
       return this.sendDynamic(res, bundle, "application/json; charset=utf-8");
     }
-    if (pathname === "/nodegx-config.json") return this.sendDynamic(res, "{}", "application/json; charset=utf-8");
+    if (pathname === "/nodegx-config.json") {
+      const origin = backendPort ? pageOrigin(req) : null;
+      const config = origin ? { cloudservices: { endpoint: origin + BACKEND_PREFIX } } : {};
+      return this.sendDynamic(res, JSON.stringify(config), "application/json; charset=utf-8");
+    }
     const asset = pathname.slice(1);
     if (DEPLOY_ASSETS.includes(asset)) {
       return this.sendFile(req, res, deployAssetPath(asset));
@@ -197651,6 +198458,46 @@ var PreviewServer = class {
       this.clients.delete(res);
     });
   }
+  /** The backend port a SHARED preview carries, else undefined. */
+  sharedBackendPort() {
+    return this.access.shared && this.options.backendPort ? this.options.backendPort : void 0;
+  }
+  /**
+   * P112-OWN023-PHONEPREVIEW — one request on to the backend on loopback, streamed both ways (its realtime channel is a
+   * long `text/event-stream`). The backend is told where the page reached it (`Host`, `X-Forwarded-Prefix`), so a
+   * File's url it answers with leads back through here; the preview's own token is not passed on.
+   */
+  proxyToBackend(req, res, port) {
+    const raw = req.url ?? "/";
+    const rest2 = raw.slice(BACKEND_PREFIX.length) || "/";
+    const headers = { ...req.headers };
+    delete headers[TOKEN_HEADER];
+    const cookie = withoutCookie(req.headers.cookie, TOKEN_COOKIE);
+    if (cookie) headers.cookie = cookie;
+    else delete headers.cookie;
+    headers["x-forwarded-prefix"] = BACKEND_PREFIX;
+    headers["x-forwarded-proto"] = "http";
+    const peer = req.socket.remoteAddress;
+    if (peer) headers["x-forwarded-for"] = peer;
+    const upstream = http.request(
+      { host: "127.0.0.1", port, method: req.method, path: rest2.startsWith("/") ? rest2 : "/" + rest2, headers },
+      (answer) => {
+        res.writeHead(answer.statusCode ?? 502, answer.headers);
+        answer.pipe(res);
+      }
+    );
+    upstream.on("error", (err) => {
+      if (res.headersSent) {
+        res.destroy(err);
+        return;
+      }
+      res.writeHead(502, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
+      res.end(`The app's backend on this computer (port ${port}) did not answer: ${err.message}
+`);
+    });
+    res.on("close", () => upstream.destroy());
+    req.pipe(upstream);
+  }
   sendJson(res, body) {
     this.sendDynamic(res, JSON.stringify(body, null, 2), "application/json; charset=utf-8");
   }
@@ -197695,6 +198542,15 @@ var PreviewServer = class {
     res.end("Not found");
   }
 };
+function pageOrigin(req) {
+  const host = String(req.headers.host || "");
+  return /^[A-Za-z0-9.\-[\]:]+$/.test(host) ? `http://${host}` : null;
+}
+function withoutCookie(header, name2) {
+  if (!header) return void 0;
+  const kept = header.split(";").map((part) => part.trim()).filter((part) => part && part.split("=")[0].trim() !== name2);
+  return kept.length ? kept.join("; ") : void 0;
+}
 
 // src/watcher.ts
 var import_chokidar = __toESM(require("chokidar"));
@@ -197747,6 +198603,7 @@ Options:
   --port <n>        Port to listen on (default 8575, 0 for any free port).
   --host <addr>     Address to bind (default 127.0.0.1). Any address but loopback also turns
                     on the token: the printed URL carries it, and without it nothing is served.
+                    A phone on the same Wi-Fi then reaches the app's own backend through it too.
   --token <t>       Use this token rather than minting one.
   --debounce <ms>   Quiet period before rebuilding after a change (default 120).
   --no-watch        Render once and serve; do not watch for changes.
@@ -197860,7 +198717,8 @@ async function main() {
   log(`noodl-preview \u2014 ${dir} (${format}), ${types} node types`);
   const shared = args.host !== "127.0.0.1" && args.host !== "localhost";
   const access = resolveAccess({ share: shared, host: args.host, token: args.token });
-  const server = new PreviewServer({ projectDir: dir, port: args.port, host: args.host, access });
+  const backendPort = format === "v2" ? namedBackend(dir)?.port : void 0;
+  const server = new PreviewServer({ projectDir: dir, port: args.port, host: args.host, access, backendPort });
   let port;
   try {
     port = await server.listen();