@nodegx/preview 0.2.7 → 0.2.9

package/dist/nodegx-deploy.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[next2 + (huff >> drop2) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
+          table2[next2 + (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 | next2 - table_index | 0;
+          table2[low] = root2 << 24 | curr << 16 | next2 - table_index | 0;
         }
       }
       if (huff !== 0) {
-        table[next2 + huff] = len - drop2 << 24 | 64 << 16 | 0;
+        table2[next2 + 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 = finish3;
-    exports2.mark = mark;
+    exports2.mark = mark2;
     exports2.isIgnored = isIgnored;
     exports2.childrenIgnored = childrenIgnored;
     function ownProp(obj, field2) {
@@ -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 register3 = node.context && node.context.nodeRegister;
+        if (register3 && register3.hasNode(node.name)) declared2 = register3.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 port5 = inputs[name2];
+        if (port5 && isSignalPortType(port5.type)) continue;
+        const meta = declared2[name2];
+        if (meta && isSignalPortType(meta.type)) continue;
+        out[name2] = value2;
+      }
+      return out;
+    }
+    function snapshotOutputValues(node) {
+      const out = {};
+      const list2 = node._outputList || [];
+      for (const port5 of list2) {
+        if (!port5 || isSignalPortType(port5.type)) continue;
+        let value2;
+        try {
+          value2 = port5.value;
+        } catch (e) {
+          continue;
+        }
+        if (value2 === void 0 || typeof value2 === "function") continue;
+        out[port5.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;
         };
@@ -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 Model28 = 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, outputs2) {
+          this.inputs = inputs;
+          this.outputs = outputs2;
+          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, outputs2) {
+          this.inputs = inputs;
+          this.outputs = outputs2;
+          _this.destroy && _this.destroy.apply(this);
+        },
+        change: function(inputs, outputs2) {
+          this.inputs = inputs;
+          this.outputs = outputs2;
+          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, outputs2) {
+        const _this = this;
+        _Node.setOutputs = function(_outputs) {
+          for (var key2 in _outputs) {
+            outputs2[key2] = _outputs[key2];
+            _this.flagOutputDirty(key2);
+          }
+        };
+        _Node.OnInit && _Node.OnInit.apply(this);
+      };
+      this.destroy = _Node.OnDestroy || this.destory;
+      this.change = (inputs, outputs2, 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(script2, ports, options) {
+      function _exists(port5) {
+        if (typeof port5 === "string") return ports.find((p) => p.name === port5) !== void 0;
+        else return ports.find((p) => p.name === port5.name && p.plug === port5.plug) !== void 0;
+      }
+      function _addPortsFromMatch(match, options2) {
+        if (match === void 0 || match === null) return;
+        const unique2 = {};
+        for (const _s of match) {
+          let name2 = _s[1];
+          if (name2 === void 0) continue;
+          unique2[name2] = true;
+        }
+        Object.keys(unique2).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(script2.matchAll(/Inputs\.([A-Za-z0-9_]+)/g), {
+          type: options.inputType || "*",
+          plug: "input",
+          group: options.inputGroup || "Inputs",
+          prefix: options.inputPrefix || ""
+        });
+        _addPortsFromMatch(script2.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(script2.matchAll(/Outputs\.([A-Za-z0-9]+)\s*\(\s*\)/g), {
+            type: "signal",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+          _addPortsFromMatch(script2.matchAll(/Outputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]\(\s*\)/g), {
+            type: "signal",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+        }
+        if (!options.skipRegularOutputs) {
+          _addPortsFromMatch(script2.matchAll(/Outputs\.([A-Za-z0-9_]+)/g), {
+            type: "*",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+          _addPortsFromMatch(script2.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 inputPort2 = self2.inputs[name2];
+        var port5 = {
+          name: name2,
+          plug: "input"
+        };
+        if (typeof inputPort2 === "string") {
+          port5.type = {
+            name: inputPort2
+          };
+          port5.group = "Inputs";
+        } else {
+          for (var p in inputPort2) {
+            port5[p] = inputPort2[p];
+          }
+        }
+        ports.push(port5);
+      });
+      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 || Model28).get("componentState" + componentId);
+        _componentScopes[componentId].Object = componentObject;
+      }
+      const parentComponentObjectId = _findParentComponentStateModelId(node);
+      const parentComponentObject = parentComponentObjectId !== void 0 ? (node.nodeScope.modelScope || Model28).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 list2 = table()?.get(body);
+  return list2 && list2.find((e) => e.async === async && sameParams(e.params, params));
+}
+function findPrintedBody(body, async) {
+  const list2 = table()?.get(body);
+  return list2 && list2.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(script2) {
+  const JavascriptNodeParser4 = require_javascriptnodeparser();
+  return JavascriptNodeParser4.getCodePrefix() + script2;
+}
+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(script2) {
             try {
-              this._internal.requestFunc = new Function("Inputs", "Outputs", "Request", script2);
+              this._internal.requestFunc = compileCode(REST_REQUEST_PARAMS, script2);
             } catch (e) {
               console.log(e);
             }
@@ -24709,7 +25470,7 @@ var require_restnode = __commonJS({
           group: "Scripts",
           set: function(script2) {
             try {
-              this._internal.responseFunc = new Function("Inputs", "Outputs", "Response", script2);
+              this._internal.responseFunc = compileCode(REST_RESPONSE_PARAMS, script2);
             } catch (e) {
               console.log(e);
             }
@@ -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 Model28 = 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, outputs2) {
-          this.inputs = inputs;
-          this.outputs = outputs2;
-          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, outputs2) {
-          this.inputs = inputs;
-          this.outputs = outputs2;
-          _this.destroy && _this.destroy.apply(this);
-        },
-        change: function(inputs, outputs2) {
-          this.inputs = inputs;
-          this.outputs = outputs2;
-          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, outputs2) {
-        const _this = this;
-        _Node.setOutputs = function(_outputs) {
-          for (var key2 in _outputs) {
-            outputs2[key2] = _outputs[key2];
-            _this.flagOutputDirty(key2);
-          }
-        };
-        _Node.OnInit && _Node.OnInit.apply(this);
-      };
-      this.destroy = _Node.OnDestroy || this.destory;
-      this.change = (inputs, outputs2, 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(script2, ports, options) {
-      function _exists(port5) {
-        if (typeof port5 === "string") return ports.find((p) => p.name === port5) !== void 0;
-        else return ports.find((p) => p.name === port5.name && p.plug === port5.plug) !== void 0;
-      }
-      function _addPortsFromMatch(match, options2) {
-        if (match === void 0 || match === null) return;
-        const unique2 = {};
-        for (const _s of match) {
-          let name2 = _s[1];
-          if (name2 === void 0) continue;
-          unique2[name2] = true;
-        }
-        Object.keys(unique2).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(script2.matchAll(/Inputs\.([A-Za-z0-9_]+)/g), {
-          type: options.inputType || "*",
-          plug: "input",
-          group: options.inputGroup || "Inputs",
-          prefix: options.inputPrefix || ""
-        });
-        _addPortsFromMatch(script2.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(script2.matchAll(/Outputs\.([A-Za-z0-9]+)\s*\(\s*\)/g), {
-            type: "signal",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-          _addPortsFromMatch(script2.matchAll(/Outputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]\(\s*\)/g), {
-            type: "signal",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-        }
-        if (!options.skipRegularOutputs) {
-          _addPortsFromMatch(script2.matchAll(/Outputs\.([A-Za-z0-9_]+)/g), {
-            type: "*",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-          _addPortsFromMatch(script2.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 inputPort2 = self2.inputs[name2];
-        var port5 = {
-          name: name2,
-          plug: "input"
-        };
-        if (typeof inputPort2 === "string") {
-          port5.type = {
-            name: inputPort2
-          };
-          port5.group = "Inputs";
-        } else {
-          for (var p in inputPort2) {
-            port5[p] = inputPort2[p];
-          }
-        }
-        ports.push(port5);
-      });
-      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 || Model28).get("componentState" + componentId);
-        _componentScopes[componentId].Object = componentObject;
-      }
-      const parentComponentObjectId = _findParentComponentStateModelId(node);
-      const parentComponentObject = parentComponentObjectId !== void 0 ? (node.nodeScope.modelScope || Model28).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_EVALUATED2 = {};
-    function construct(constructor, args) {
-      function F() {
-        return constructor.apply(this, args);
-      }
-      F.prototype = constructor.prototype;
-      return new F();
-    }
     var compiledFunctionsCache2 = {};
     function reservedNameMessage2(names2) {
       const list2 = names2.length > 1 ? names2.slice(0, -1).join(", ") + " and " + names2[names2.length - 1] : names2.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 names2;
     }
     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(script2) {
           let func;
           try {
-            const AsyncFunction = Object.getPrototypeOf(async function() {
-            }).constructor;
-            func = new AsyncFunction(
-              "Inputs",
-              "Outputs",
-              "Noodl",
-              "Component",
-              "Scripts",
-              JavascriptNodeParser4.getCodePrefix() + script2
-            );
+            func = compileCode(FUNCTION_NODE_PARAMS, functionNodeBody(script2), { 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", script2);
+        new AsyncFunction2("Inputs", "Outputs", "Noodl", "Component", script2);
         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;
@@ -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((port5) => port5.name));
+  const ports = [];
+  for (const field2 of RECORD_BUILT_IN_DATES) {
+    if (have.has(`prop-${field2}`)) continue;
+    ports.push({ name: `prop-${field2}`, displayName: field2, type: { name: "date" }, plug: "output", group: "Properties" });
+    if (options.includeChangedSignals && !have.has(`changed-${field2}`)) {
+      ports.push({ name: `changed-${field2}`, displayName: `${field2} Changed`, type: "signal", plug: "output", group: "Events" });
+    }
+  }
+  return ports;
+}
 function recordPortType(field2) {
   if (field2.nativeType && Object.prototype.hasOwnProperty.call(PARSE_PORT_TYPES, field2.nativeType)) {
     return { name: PARSE_PORT_TYPES[field2.nativeType] };
@@ -30889,7 +31048,7 @@ function parseTypeNameFor(field2) {
 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({
@@ -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 list2 = out.get(col.targetClass) || [];
-      list2.push({ collection: table, field: col.name, rule });
+      list2.push({ collection: table2, field: col.name, rule });
       out.set(col.targetClass, list2);
     }
   }
@@ -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, field2, target] of rels) {
-    if (table === collection) {
-      const ids = schema.getRelatedIds(table, objectId, field2);
-      for (const relatedId of Array.isArray(ids) ? ids : []) out.push({ collection: table, objectId, field: field2, relatedId: String(relatedId) });
+  for (const [table2, field2, target] of rels) {
+    if (table2 === collection) {
+      const ids = schema.getRelatedIds(table2, objectId, field2);
+      for (const relatedId of Array.isArray(ids) ? ids : []) out.push({ collection: table2, objectId, field: field2, relatedId: String(relatedId) });
     }
-    if (target === collection) for (const owner of schema.getRelationOwners(table, field2, objectId)) out.push({ collection: table, objectId: owner, field: field2, relatedId: objectId });
+    if (target === collection) for (const owner of schema.getRelationOwners(table2, field2, objectId)) out.push({ collection: table2, objectId: owner, field: field2, relatedId: objectId });
   }
   return out;
 }
@@ -33089,7 +33249,7 @@ async function linkedIds(ctx, collection, field2, 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, field2) {
-  const col = ctx.schema.getTableSchema(table)?.columns?.find((c) => c.name === field2);
-  if (!col?.targetClass) throw new Error(`${table}.${field2} is not a link the schema knows the target of`);
+function targetOf(ctx, table2, field2) {
+  const col = ctx.schema.getTableSchema(table2)?.columns?.find((c) => c.name === field2);
+  if (!col?.targetClass) throw new Error(`${table2}.${field2} 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 + path10, {
+          const send = typeof _noodl_cloudservices !== "undefined" && _noodl_cloudservices.fetch ? _noodl_cloudservices.fetch : fetch;
+          send(endpoint + path10, {
             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 || Model28).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) && sameList2(m.get(key), value2)) continue;
         m.set(key, value2);
@@ -39438,8 +39612,19 @@ function convertVisualFilter(query2, 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 = {
@@ -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 (rendered2.indexOf(needle) === -1) return;
               rendered2 = rendered2.split(needle).join(render2());
             };
-            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(str4) {
       }
       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(str4) {
       chars.push("-");
       continue;
     }
-    const d = TABLE[cc - TABLE_OFFSET];
+    const d = TABLE2[cc - TABLE_OFFSET];
     chars.push(d !== NOT_DIGIT ? String.fromCharCode(d + 48) : str4[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 armed6 = spaceArmed;
+    spaceArmed = false;
+    if (armed6 && 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(text3);
   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 field2 = this.ref.current;
+              if (!field2 || !props.enabled || e.button !== 0 || field2.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 next2 = (owner.parentNodeScope || owner.nodeScope)?.componentOwner;
+    if (next2 === owner) return false;
+    owner = next2;
+  }
+  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");
@@ -111396,9 +111776,9 @@ var require_fast_uri = __commonJS({
     }
     function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved2 = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved3 = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
-      return serialize(resolved2, schemelessOptions);
+      return serialize(resolved3, schemelessOptions);
     }
     function resolveComponent(base, relative2, options, skipNormalization) {
       const target = {};
@@ -164973,7 +165353,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: {
@@ -167158,7 +167538,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: {
@@ -169770,7 +170150,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: {
@@ -171952,7 +172332,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: {
@@ -174357,7 +174737,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: {
@@ -177227,7 +177607,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"
@@ -182069,7 +182449,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",
@@ -184924,11 +185304,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.
@@ -185603,6 +185983,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();
@@ -185615,13 +186002,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();
   }
@@ -187095,8 +187492,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))) {
@@ -191683,11 +192080,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.
@@ -191706,15 +192103,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;
   }
   /**
@@ -191734,11 +192131,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.
@@ -191784,7 +192181,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 */
@@ -191792,6 +192189,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;
@@ -195296,8 +195699,8 @@ function readDeployedRoots(outDir) {
   };
   add(data.components);
   const bundleDir = path4.join(outDir, "noodl_bundles");
-  const named2 = Object.keys(data.componentIndex ?? {}).filter((id) => id !== "root");
-  for (const id of named2) {
+  const named3 = Object.keys(data.componentIndex ?? {}).filter((id) => id !== "root");
+  for (const id of named3) {
     const file = path4.join(bundleDir, `${id}.json`);
     if (fs3.existsSync(file)) {
       add(JSON.parse(fs3.readFileSync(file, "utf8")));
@@ -195309,7 +195712,7 @@ function readDeployedRoots(outDir) {
     }
   }
   if (fs3.existsSync(bundleDir)) {
-    const live = new Set(named2.map((id) => `${id}.json`));
+    const live = new Set(named3.map((id) => `${id}.json`));
     reading.staleBundles = fs3.readdirSync(bundleDir).filter((file) => file.endsWith(".json") && !live.has(file)).sort();
   }
   return reading;
@@ -195406,9 +195809,9 @@ function walk2(value2, path10, seen) {
         const c = walk2(item, `${path10}[${i2}]`, seen);
         return c === void 0 ? null : c;
       });
-      const named2 = obj;
-      if (typeof named2.getId === "function") {
-        const id = named2.getId();
+      const named3 = obj;
+      if (typeof named3.getId === "function") {
+        const id = named3.getId();
         if (typeof id === "string") return { $array: id, items };
       }
       return items;
@@ -198219,12 +198622,12 @@ function formatDate(t, formatString, timeZone, localeTag) {
       if (rendered2.indexOf(needle) === -1) return;
       rendered2 = rendered2.split(needle).join(render2());
     };
-    const named2 = (options) => new Intl.DateTimeFormat(locale, zone ? { ...options, timeZone: zone } : options).format(date);
+    const named3 = (options) => new Intl.DateTimeFormat(locale, zone ? { ...options, timeZone: zone } : options).format(date);
     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);
@@ -199194,7 +199597,10 @@ var invocations = [
   { headers: { "X-Parse-Session-Token": "t1", origin: "null", host: "h" } },
   { headers: { "x-parse-session-token": "t1" }, body: '{"a":null}', at: 100 },
   { headers: { host: "internal:8577", "x-forwarded-host": "public.example.com", "x-forwarded-proto": "https, http" }, body: '{"total":"7"}' },
-  { headers: { origin: ["https://app.example.com/", "https://b.example"], "x-forwarded-proto": "jAvascript", host: "h" }, body: "{}" }
+  { headers: { origin: ["https://app.example.com/", "https://b.example"], "x-forwarded-proto": "jAvascript", host: "h" }, body: "{}" },
+  { headers: {}, body: '{"total":3}', startedByApp: true },
+  { headers: { "x-parse-session-token": "t1" }, body: "{}", startedByApp: true },
+  { headers: { startedbyapp: "true" }, body: '{"startedByApp":true}' }
 ];
 var CLOUD = { appId: "app", masterKey: "mk", endpoint: "https://be.example" };
 var HOSTS3 = [{}];
@@ -199205,7 +199611,7 @@ for (const invocation of invocations) {
 HOSTS3.push({ invocation: invocations[0], cloudServices: { ...CLOUD, runId: "run-1" } });
 var CloudRequest = defineNode({
   type: "noodl.cloud.request",
-  version: 3,
+  version: 4,
   changes: [
     {
       version: 2,
@@ -199218,6 +199624,12 @@ var CloudRequest = defineNode({
       says: "User Id is text (it carries the id of the person the session token resolved to). It was declared a flag, so a wire into a Number read the id as NaN and the canvas offered it to a signal input",
       row: "P107-S97-USERIDBOOLEAN (the Beta sweep s6)",
       migration: { none: "No saved wire stops connecting: measured 106 wires from User Id in 13,839 project files, 70 into script inputs (any type), 35 into text ports, 1 into a record field, none into a signal" }
+    },
+    {
+      version: 4,
+      says: "A run the app starts itself \u2014 a schedule, a row change, a run from Studio \u2014 is not refused when Allow Unauthenticated is off: it runs with nobody signed in. It was refused, so a weekly job could only run a function opened to everyone. A webhook and a direct call are refused as before",
+      row: "P127-BKO006-SCHEDULEAUTH (Richard ruled 2026-10-27: a run the app starts itself counts as the app)",
+      migration: { none: "Nothing a project stores changes: only a run the backend marks as started by the app gets a different answer, and it gets the one its author had to open the function to everyone to get" }
     }
   ],
   source: "packages/noodl-viewer-cloud/src/nodes/cloud/request.ts; packages/noodl-viewer-cloud/src/nodes/cloud/requestContract.ts; packages/noodl-viewer-cloud/src/nodes/cloud/requestOrigin.ts; packages/noodl-viewer-cloud/src/services/userservice.js",
@@ -199244,7 +199656,7 @@ var CloudRequest = defineNode({
   state: { contract: {}, authenticated: void 0, authUserId: void 0, origin: void 0, requestParameters: {}, waiting: void 0 },
   inputs: {
     // :154-163 — held raw, read when the request comes and again when its lookup fails
-    allowNoAuth: { type: "boolean", default: false, coerce: "none", displayName: "Allow Unauthenticated", group: "General", description: "Whether a request with no valid session token is allowed to run this function at all", examples: [true, false, "false", 1] },
+    allowNoAuth: { type: "boolean", default: false, coerce: "none", displayName: "Allow Unauthenticated", group: "General", 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", examples: [true, false, "false", 1] },
     // :164-172 — held raw
     params: { type: "stringlist", coerce: "none", editOnly: true, group: "Parameters", description: "Names to pull out of the request body, each becoming an output \u2014 and a Type, Required and Default row to declare what it is", examples: ["total", "total,a", "a,0", "0,1", ""] }
   },
@@ -199291,7 +199703,7 @@ var CloudRequest = defineNode({
         }
         const waiting = { params, headers: req.headers };
         if (!token) {
-          if (!i2.allowNoAuth) return { send: [], answers: [{ op: "refuse", reason: UNAUTHENTICATED }] };
+          if (!i2.allowNoAuth && req.startedByApp !== true) return { send: [], answers: [{ op: "refuse", reason: UNAUTHENTICATED }] };
           return proceed(s, params, req.headers, i2, w, { set: {}, send: [] });
         }
         const cloud = w.hostCloud();
@@ -199770,6 +200182,7 @@ function selectedClass(params, context) {
 function shownFields(klass, skipRelations) {
   return Object.entries(klass?.fields ?? {}).filter(([field2, decl]) => field2 !== "ACL" && !(skipRelations && decl.relation !== void 0));
 }
+var RECORD_BUILT_IN_DATES2 = Object.freeze(["createdAt", "updatedAt"]);
 function onParseWire(context) {
   const type = context.schema?.backendType;
   return type === void 0 || type === "parse" || type === "nodegx";
@@ -202310,9 +202723,9 @@ var ZONE_NAMES_READ2 = ["UT", "UTC", "GMT", "Z", "EST", "EDT", "CST", "CDT", "MS
 function toISODate2(value2) {
   const raw = text2(value2).trim().replace(/\s*\([^)]*\)$/, "");
   if (!raw) return null;
-  const named2 = /\s([A-Z]{1,5})$/.exec(raw);
-  if (named2 && ZONE_NAMES_READ2.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_READ2.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();
@@ -203105,6 +203518,18 @@ function growChange(version) {
   };
 }
 
+// ../nodegx-node-spec/src/nodes/visible-at-once.ts
+function visibleAtOnceChange(version) {
+  return {
+    version,
+    says: "No app does anything differently. Visible shows or hides the control at once: a Focus sent in the same moment as Visible going on reaches it (Focused fires), and one sent as Visible goes off does nothing. The version before said Visible waited for the next paint, so it lost the first Focus and kept the second; the runtime never did either",
+    row: "BETA-S7-DROPDOWNFOCUSDIVERGE",
+    migration: {
+      none: "The runtime did not change; only the spec stopped saying Visible waits for the next paint. No stored project changes"
+    }
+  };
+}
+
 // ../nodegx-node-spec/src/nodes/button.ts
 var NONE = { send: [] };
 var Button3 = defineNode({
@@ -203113,8 +203538,9 @@ var Button3 = defineNode({
   // v3 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v4 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
   // v5 (NSP-019 R38): a wired Width in a row, or a wired Height in a column, that is a percent shows as its warning (wired-grow.ts)
-  version: 6,
-  changes: [focusAndIconSourceChange(4), growChange(5), repeatWhileSavingChange(6, "click")],
+  // v7 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 7,
+  changes: [focusAndIconSourceChange(4), growChange(5), repeatWhileSavingChange(6, "click"), visibleAtOnceChange(7)],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("button")), ...iconSourceDiagnostics(), ...wiredGrowDiagnostic },
   source: "packages/noodl-viewer-react/src/nodes/controls/button.ts",
   needs: ["person"],
@@ -203300,8 +203726,9 @@ var Button3 = defineNode({
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width"),
     height: sizeReducer("height"),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     // placed on the page with its params set — the first paint (react-component-node.ts :1740-1743 reads `wantsToBeMounted`):
@@ -203382,8 +203809,9 @@ var Checkbox2 = defineNode({
   // v3 (P109 ISL-031, P107-C64 ruled "Ignore touches, keep hover"): a finger on a disabled control reports nothing — no Pressed, no Pointer Down or Up — as Enabled promises; the pointer's hover still reports
   // v4 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v5 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
-  version: 5,
-  changes: [focusAndIconSourceChange(5)],
+  // v6 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 6,
+  changes: [focusAndIconSourceChange(5), visibleAtOnceChange(6)],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("checkbox")), ...iconSourceDiagnostics() },
   source: "packages/noodl-viewer-react/src/nodes/controls/checkbox.ts",
   needs: ["person"],
@@ -203567,8 +203995,9 @@ var Checkbox2 = defineNode({
       return { says: "it holds the keyboard: it is taken off it, and the Focused state goes false", set: { focused: false, elementFocused: false }, send: ["focusState"], emit: ["onBlur"], outcome: "done" };
     },
     scrollIntoView: () => ({ says: "always: the page, or the scrolling Group holding it, scrolls until the box can be seen", send: [] }),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     world: { place: (s) => painted2(s) },
@@ -203693,8 +204122,9 @@ var TextInput3 = defineNode({
   // v6 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v7 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
   // v8 (NSP-019 R38): a wired Width in a row, or a wired Height in a column, that is a percent shows as its warning (wired-grow.ts)
-  version: 9,
-  changes: [focusAndIconSourceChange(7), growChange(8), repeatWhileSavingChange(9, "Enter")],
+  // v10 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 10,
+  changes: [focusAndIconSourceChange(7), growChange(8), repeatWhileSavingChange(9, "Enter"), visibleAtOnceChange(10)],
   diagnostics: { ...focusDiagnostics(FIELD_FOCUS_NOT_MOUNTED), ...iconSourceDiagnostics(), ...wiredGrowDiagnostic },
   source: "packages/noodl-viewer-react/src/nodes/controls/text-input.ts",
   needs: ["person"],
@@ -204015,9 +204445,10 @@ var TextInput3 = defineNode({
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width"),
     height: sizeReducer("height"),
-    // node-shared-port-definitions.ts :366-375, :320-328 — the page follows at the next paint (TextInput.tsx :118-120 compares the
-    // Opacity the style holds with the number 0)
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] }),
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts); Opacity (:320-328) follows at the next paint (TextInput.tsx :118-120 compares the Opacity the style
+    // holds with the number 0)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] }),
     opacity: (_s, v) => ({ says: "always: how see-through it is; at exactly 0 it takes no pointer, and an act goes to what is behind it", set: { opacityZero: v === 0 }, send: [] })
   },
   {
@@ -204330,7 +204761,8 @@ var Dropdown = defineNode({
   // v10 (NSP-019 R38): a wired Width in a row, or a wired Height in a column, that is a percent shows as its warning (wired-grow.ts)
   // v11 (P121-TWO005-DROPDOWNSTALE): Items that do not offer the placed node's seed ("Option 1") clear it to '' and send Value
   // v12 (BETA-S7-DROPDOWNFIRSTPICK): with the value in no option, the element keeps its hidden empty option selected, so every option is a pick
-  version: 12,
+  // v13 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 13,
   // NSP-010 — v7 is the spec correcting itself, not the runtime changing
   changes: [
     {
@@ -204366,7 +204798,8 @@ var Dropdown = defineNode({
       migration: {
         none: "A pick that did nothing now does what the person asked; nothing an app could rely on, and no stored project changes"
       }
-    }
+    },
+    visibleAtOnceChange(13)
   ],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("dropdown")), ...iconSourceDiagnostics(), ...wiredGrowDiagnostic },
   source: "packages/noodl-viewer-react/src/nodes/controls/options.ts",
@@ -204648,8 +205081,9 @@ var Dropdown = defineNode({
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width"),
     height: sizeReducer("height"),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     // react-component-node.ts :785-830 `DATA_ATTRIBUTES_RULE` — one string input per name the Data Attributes list names, written
@@ -204818,7 +205252,8 @@ var Slider2 = defineNode({
   // v7 (NSP-019 R39, ruled "Yes, warn"): a Max below Min warns, as the Counter's Min above Max does; and a Value that is not a
   // number, which the runtime always reported on the error bus, is declared with it (the editor records the `slider/` keys)
   // v8 (NSP-019 R38): a wired Width in a row that is a percent shows as its warning (wired-grow.ts)
-  version: 8,
+  // v9 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 9,
   changes: [
     focusChange(6),
     {
@@ -204827,7 +205262,8 @@ var Slider2 = defineNode({
       row: "NSP-019 R39 (P107 s104)",
       migration: { none: "Only the editor is told. Nothing a wire carries changes, and nothing a person does moves differently" }
     },
-    growChange(8)
+    growChange(8),
+    visibleAtOnceChange(9)
   ],
   diagnostics: {
     ...focusDiagnostics(controlFocusNotMounted("slider")),
@@ -205061,8 +205497,9 @@ var Slider2 = defineNode({
     scrollIntoView: () => ({ says: "always: the page, or the scrolling Group holding it, scrolls until the slider can be seen", send: [] }),
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width", false),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     // placed on the page with its params set — the first render: Did Mount, and the mount's effect (Slider.tsx :88-90)
@@ -205720,8 +206157,8 @@ function busy(s) {
   return s.phase !== "idle" || s.carry >= 0;
 }
 function cardIndex(value2) {
-  const named2 = JSON.stringify(value2);
-  return CARDS.findIndex((c) => JSON.stringify(c) === named2);
+  const named3 = JSON.stringify(value2);
+  return CARDS.findIndex((c) => JSON.stringify(c) === named3);
 }
 function track2(s, over) {
   const here = over && zoneFor(s);
@@ -206450,12 +206887,12 @@ function busy2(s) {
   return s.phase !== "idle" || s.carry >= 0;
 }
 function cardIndex2(value2) {
-  const named2 = JSON.stringify(value2);
-  return CARDS2.findIndex((c) => JSON.stringify(c) === named2);
+  const named3 = JSON.stringify(value2);
+  return CARDS2.findIndex((c) => JSON.stringify(c) === named3);
 }
 function childIndexOf(value2) {
-  const named2 = JSON.stringify(value2);
-  return CHILDREN.findIndex((c) => JSON.stringify(c) === named2);
+  const named3 = JSON.stringify(value2);
+  return CHILDREN.findIndex((c) => JSON.stringify(c) === named3);
 }
 function track3(s, over) {
   const here = over && zoneFor2(s);
@@ -206977,8 +207414,8 @@ function busy3(s) {
   return s.phase !== "idle" || s.carry >= 0;
 }
 function cardIndex3(value2) {
-  const named2 = JSON.stringify(value2);
-  return CARDS3.findIndex((c) => JSON.stringify(c) === named2);
+  const named3 = JSON.stringify(value2);
+  return CARDS3.findIndex((c) => JSON.stringify(c) === named3);
 }
 function track4(s, over) {
   const here = over && zoneFor3(s);
@@ -207559,8 +207996,8 @@ function busy4(s) {
   return s.phase !== "idle" || s.carry >= 0;
 }
 function cardIndex4(value2) {
-  const named2 = JSON.stringify(value2);
-  return CARDS4.findIndex((c) => JSON.stringify(c) === named2);
+  const named3 = JSON.stringify(value2);
+  return CARDS4.findIndex((c) => JSON.stringify(c) === named3);
 }
 function track5(s, over) {
   const here = over && zoneFor4(s);
@@ -208042,7 +208479,7 @@ var Video2 = defineNode({
     autoplay: (_s, v) => ({ says: "always: drawn at the next paint, and read as a load completes \u2014 on, a video that may play (Muted, or a person has acted on the page) and that Pause or Reset has not stopped since the load began starts by itself: On Can Play, then On Play", set: { autoplay: v }, send: [] }),
     loop: (_s, v) => ({ says: "always: drawn at the next paint, and read as the video reaches its end \u2014 on, it goes back to the start and plays on; off, it pauses there (On Pause)", set: { loop: v }, send: [] }),
     // :35-47 — on the component, or waiting for it with the actions (`sourceObject`: only a `<video>` takes one, and only nothing is
-    // seen to change it; C96, C99 on the runtime)
+    // seen to change it; C99 on the runtime)
     srcObject: (s, v) => {
       if (!s.onPage) return said("off the page: waits for the element behind the actions already waiting, in order, and is written at the paint that puts the video there (at most 16 wait, and the oldest is pushed out)", toPatch2(waitFor(s, { srcObject: v })));
       if (s.kind !== "video" || v !== void 0) return { says: "null (what it already has), a value that is not a stream, or anything on an embedded player: nothing changes \u2014 a live stream itself plays in place of Source, and no scenario holds one", set: {}, send: [], emit: [] };
@@ -208421,8 +208858,8 @@ function busy5(s) {
   return s.phase !== "idle" || s.carry >= 0;
 }
 function cardIndex5(value2) {
-  const named2 = JSON.stringify(value2);
-  return CARDS5.findIndex((c) => JSON.stringify(c) === named2);
+  const named3 = JSON.stringify(value2);
+  return CARDS5.findIndex((c) => JSON.stringify(c) === named3);
 }
 function track6(s, over) {
   const here = over && zoneFor5(s);
@@ -210416,7 +210853,7 @@ function start(w, op) {
     if (b === MISSING) w.st.hops = HOPS_ADD_MISSING;
     else if (b === null) w.st.hops = 2;
     else w.st.building = { kind: "add", row: b, index: op.index, at: childIndexFor(w.st.rows, op.index) };
-  } else refresh(w);
+  } else refresh2(w);
 }
 function compileMapping(code, rethrow = false) {
   if (!code) return void 0;
@@ -210599,7 +211036,7 @@ function report2(w, heard3) {
     w.pulses.push(`itemOutputSignal-${signal2}`);
   }
 }
-function refresh(w) {
+function refresh2(w) {
   const st = w.st;
   st.refreshScheduled = false;
   const tokens = st.tokens;
@@ -211615,8 +212052,9 @@ var RadioButton3 = defineNode({
   // v3 (P109 ISL-031, P107-C64 ruled "Ignore touches, keep hover"): a finger on a disabled control reports nothing — no Pressed, no Pointer Down or Up — as Enabled promises; the pointer's hover still reports
   // v4 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v5 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
-  version: 5,
-  changes: [focusAndIconSourceChange(5)],
+  // v6 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 6,
+  changes: [focusAndIconSourceChange(5), visibleAtOnceChange(6)],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("radio button")), ...iconSourceDiagnostics() },
   source: "packages/noodl-viewer-react/src/nodes/controls/radiobutton.ts",
   needs: ["person", "group"],
@@ -211808,8 +212246,9 @@ var RadioButton3 = defineNode({
       return { says: "it holds the keyboard: it is taken off it, and the Focused state goes false", set: { focused: false, elementFocused: false }, send: ["focusState"], emit: ["onBlur"], outcome: "done" };
     },
     scrollIntoView: () => ({ says: "always: the page, or the scrolling Group holding it, scrolls until the button can be seen", send: [] }),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, it takes no click and a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, it takes no click and a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     world: {
@@ -213858,10 +214297,18 @@ var RecordNode = defineNode({
       // then `prop-` alone for every name a wire or a parameter declares and the schema does not (recordWiredFieldPorts :260-345)
       outputs: (params, context) => {
         const out = {};
-        for (const [field2, decl] of shownFields(selectedClass(params, context), true)) {
+        const klass = selectedClass(params, context);
+        for (const [field2, decl] of shownFields(klass, true)) {
           out["prop-" + field2] = { ...propertyOutput(field2), ...recordFieldPort(decl) };
           out["changed-" + field2] = changedSignal(field2);
         }
+        if (klass && onParseWire(context)) {
+          for (const field2 of RECORD_BUILT_IN_DATES2)
+            if (!("prop-" + field2 in out)) {
+              out["prop-" + field2] = propertyOutput(field2, "date");
+              if (!("changed-" + field2 in out)) out["changed-" + field2] = changedSignal(field2);
+            }
+        }
         for (const field2 of recordWiredFieldNames2(params, context)) if (!("prop-" + field2 in out)) out["prop-" + field2] = propertyOutput(field2);
         return out;
       },
@@ -215374,7 +215821,7 @@ function applyReturn(s, r) {
   if (r.inProgress) return { set: { signingIn: true }, send: ["signingIn"] };
   if (s.returned) return { send: [] };
   if (r.succeeded) {
-    return { set: { signingIn: false, notice: r.notice, error: void 0, returned: true }, send: ["signingIn", "notice", "error"], opens: [{ outcome: "done" }] };
+    return { set: { signingIn: false, notice: r.notice, error: "", returned: true }, send: ["signingIn", "notice", "error"], opens: [{ outcome: "done" }] };
   }
   return { set: { signingIn: false, error: r.error || SIGN_IN_NOT_COMPLETED, returned: true }, send: ["signingIn", "error"], opens: [{ outcome: "failure", error: SIGN_IN_WITH_ERROR_CODE2 }] };
 }
@@ -215384,7 +215831,19 @@ var SignInWith = defineNode({
   // v1 played the launcher only; no v1 trace moves (no v1 world carried a return)
   // v3 (P109 ISL-030, row C50 ruled "Fire it once"): a return's final state is reported once per page load; v2 reported a
   // provider's error twice — at mount and at the announcement a tick later.
-  version: 3,
+  // v4 (Beta sweep s19, row P109-S24-SIGNINWITHERRORKEPT ruled "Blank text, like magic link"): a succeeded return clears Error
+  // to blank text and sends it, as Request Magic Link's Done does (D25); v3 cleared it to `undefined`, never sent.
+  version: 4,
+  changes: [
+    {
+      version: 4,
+      says: "A sign-in that comes back succeeded clears Error to blank text and sends it, so a label wired to Error lets go of the last failure (before, the clear was nothing, which never reaches a wire)",
+      row: "P109-S24-SIGNINWITHERRORKEPT",
+      migration: {
+        none: "A page load gets one sign-in back and the node is new on it, so its Error never held an earlier failure: no project can see the before"
+      }
+    }
+  ],
   source: "packages/noodl-viewer-react/src/nodes/std-library/user/signinwith.ts; userservice.ts; RestAuthAdapter.ts; ParseAuthAdapter.ts",
   needs: ["backend", "registry", "clock"],
   worldPool: { backends: [...pool("signInWithProvider", null), ...RETURNS] },
@@ -217050,9 +217509,9 @@ function captureGroups2(m) {
 }
 function namedCaptureGroups2(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;
 }
@@ -221323,9 +221782,9 @@ var OUTPUT_TYPES = ["*", ...INPUT_TYPES, "signal"];
 var labelsOf = (list2) => Array.isArray(list2) ? list2.map((r) => r && r.label).filter((l) => typeof l === "string" && l.length > 0) : [];
 function parse(text3) {
   try {
-    const AsyncFunction = Object.getPrototypeOf(async function() {
+    const AsyncFunction2 = Object.getPrototypeOf(async function() {
     }).constructor;
-    new AsyncFunction(...PARAMETERS, CODE_PREFIX + text3);
+    new AsyncFunction2(...PARAMETERS, CODE_PREFIX + text3);
     return void 0;
   } catch (e) {
     return e && e.message ? String(e.message) : String(e);
@@ -221349,9 +221808,9 @@ function outputNames(params, script2) {
     if (params["outtype-" + label] === "signal") signals.push(label);
     else values2.push(label);
   }
-  const named2 = functionScriptPortNames2(script2);
-  for (const n of named2.signals) if (!signals.includes(n) && !values2.includes(n)) signals.push(n);
-  for (const n of named2.outputs) if (!signals.includes(n) && !values2.includes(n)) values2.push(n);
+  const named3 = functionScriptPortNames2(script2);
+  for (const n of named3.signals) if (!signals.includes(n) && !values2.includes(n)) signals.push(n);
+  for (const n of named3.outputs) if (!signals.includes(n) && !values2.includes(n)) values2.push(n);
   return { signals, values: values2 };
 }
 function runCode(s, signals) {
@@ -231392,7 +231851,7 @@ var cloud_node_library_default = {
           plug: "input",
           group: "General",
           displayName: "Allow Unauthenticated",
-          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",
           default: false
         },
         {
@@ -234581,9 +235040,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;
@@ -234622,6 +235081,7 @@ var NUMBER_WITH_UNIT = /^\s*(-?\d+(?:\.\d+)?)\s*(px|%|vw|vh|em|rem|deg|s|ms)\s*$
 function isPlainObject3(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(");
 }
@@ -234693,10 +235153,11 @@ function unitsFormat(type) {
           suggestion: JSON.stringify({ value: Number(parsed2[1]), unit: parsed2[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 ${describeValue3(value2)}.`,
-        suggestion: JSON.stringify({ value: 16, unit: unit2 })
+        message: `expects a number, a { "value", "unit" } object or a var(--token) reference. Got ${describeValue3(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 })
       };
     }
   };
@@ -235166,13 +235627,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,
@@ -235334,8 +235795,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;
@@ -235538,7 +235999,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
@@ -235678,6 +236143,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"
   }
 ];
 
@@ -236968,9 +237439,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",
@@ -237152,9 +237623,9 @@ var CODE_PREFIX3 = "const Script = (typeof Node !== 'undefined')?Node:undefined;
 var PARAMS2 = ["Inputs", "Outputs", "Noodl", "Component", "Scripts"];
 function functionScriptCompileError(script2) {
   try {
-    const AsyncFunction = Object.getPrototypeOf(async function() {
+    const AsyncFunction2 = Object.getPrototypeOf(async function() {
     }).constructor;
-    new AsyncFunction(...PARAMS2, CODE_PREFIX3 + script2);
+    new AsyncFunction2(...PARAMS2, CODE_PREFIX3 + script2);
     return void 0;
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
@@ -237264,6 +237735,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;
+      }, reaches5 = 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 reported3 = /* @__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 (reported3.has(reader)) continue;
+          const feeds = feedingValues(reader);
+          for (const writer of gates) {
+            if (writer === reader) continue;
+            if (exclusiveStates(reader, writer)) continue;
+            if (!reaches5(writer, feeds)) continue;
+            reported3.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"]);
@@ -237371,6 +237992,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"]) || painted15(params["borderStyle"]);
+var SECTION_ELEMENTS = /* @__PURE__ */ new Set(["section", "header", "footer"]);
+var painted15 = (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"]) || painted15(params["backgroundColor"]) || painted15(params["backgroundGradient"]) || painted15(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 bare2 = inside.filter((n) => !guarded(n));
+        if (bare2.length === 0) continue;
+        const what = bare2.length === inside.length && inside.length > 1 ? `it holds ${inside.length} things directly (${named2(inside)}) instead of one shell` : `${named2(bare2)} ${bare2.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_OUTPUTS2 = "Component Outputs";
+var clickWired = (component, node) => component.connections.some((c) => c.fromId === node.id && c.fromProperty === CLICK);
+function reaches4(component, nodeById, node, port5, used) {
+  return component.connections.some((c) => {
+    if (c.fromId !== node.id || c.fromProperty !== port5) return false;
+    if (nodeById.get(c.toId)?.type !== COMPONENT_OUTPUTS2) 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 path10 = refToPath(ref);
+      const key = `${path10}|${[...used].sort().join(",")}`;
+      if (memo.has(key)) return memo.get(key) ?? null;
+      memo.set(key, null);
+      const entry = byPath.get(path10);
+      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 (reaches4(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((port5) => reaches4(component, nodeById, node, port5, 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,
@@ -237427,6 +238223,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
@@ -237440,10 +238240,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
@@ -237543,11 +238348,11 @@ function readProjectForDeploy(dir, format) {
   const { legacy, warnings } = readLegacyProject(dir, format);
   const report3 = validateLegacyProject(legacy);
   if (report3.summary.errors > 0) {
-    const named2 = report3.diagnostics.filter((diagnostic) => diagnostic.severity === "error").slice(0, 5).map((d) => `  ${d.component}${d.nodeId ? ` \u203A ${d.nodeId}` : ""}: ${d.message}`);
+    const named3 = report3.diagnostics.filter((diagnostic) => diagnostic.severity === "error").slice(0, 5).map((d) => `  ${d.component}${d.nodeId ? ` \u203A ${d.nodeId}` : ""}: ${d.message}`);
     throw new Error(
       `${dir} has ${report3.summary.errors} validation error(s) and was not deployed:
-` + named2.join("\n") + (report3.summary.errors > named2.length ? `
-  \u2026 and ${report3.summary.errors - named2.length} more` : "")
+` + named3.join("\n") + (report3.summary.errors > named3.length ? `
+  \u2026 and ${report3.summary.errors - named3.length} more` : "")
     );
   }
   const built = buildProjectModel(legacy, dir);