@nodegx/preview 0.2.8 → 0.2.9

package/dist/noodl-preview.cjs

@@ -4936,7 +4936,7 @@ var require_lib3 = __commonJS({
         return this.resolve([]);
       }
       var values2 = new Array(len);
-      var resolved2 = 0;
+      var resolved3 = 0;
       var i2 = -1;
       var promise = new this(INTERNAL);
       while (++i2 < len) {
@@ -4952,7 +4952,7 @@ var require_lib3 = __commonJS({
         });
         function resolveFromAll(outValue) {
           values2[i3] = outValue;
-          if (++resolved2 === len && !called) {
+          if (++resolved3 === len && !called) {
             called = true;
             handlers.resolve(promise, values2);
           }
@@ -6222,15 +6222,15 @@ var require_crc32 = __commonJS({
     "use strict";
     var utils = require_utils3();
     function makeTable() {
-      var c, table = [];
+      var c, table2 = [];
       for (var n = 0; n < 256; n++) {
         c = n;
         for (var k = 0; k < 8; k++) {
           c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
         }
-        table[n] = c;
+        table2[n] = c;
       }
-      return table;
+      return table2;
     }
     var crcTable = makeTable();
     function crc32(crc, buf, len, pos) {
@@ -7228,15 +7228,15 @@ var require_crc322 = __commonJS({
   "../../node_modules/pako/lib/zlib/crc32.js"(exports2, module2) {
     "use strict";
     function makeTable() {
-      var c, table = [];
+      var c, table2 = [];
       for (var n = 0; n < 256; n++) {
         c = n;
         for (var k = 0; k < 8; k++) {
           c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
         }
-        table[n] = c;
+        table2[n] = c;
       }
-      return table;
+      return table2;
     }
     var crcTable = makeTable();
     function crc32(crc, buf, len, pos) {
@@ -9030,7 +9030,7 @@ var require_inftrees = __commonJS({
       64,
       64
     ];
-    module2.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
+    module2.exports = function inflate_table(type, lens, lens_index, codes, table2, table_index, work, opts) {
       var bits = opts.bits;
       var len = 0;
       var sym = 0;
@@ -9070,8 +9070,8 @@ var require_inftrees = __commonJS({
         root2 = max2;
       }
       if (max2 === 0) {
-        table[table_index++] = 1 << 24 | 64 << 16 | 0;
-        table[table_index++] = 1 << 24 | 64 << 16 | 0;
+        table2[table_index++] = 1 << 24 | 64 << 16 | 0;
+        table2[table_index++] = 1 << 24 | 64 << 16 | 0;
         opts.bits = 1;
         return 0;
       }
@@ -9146,7 +9146,7 @@ var require_inftrees = __commonJS({
         min2 = fill;
         do {
           fill -= incr;
-          table[next + (huff >> drop2) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
+          table2[next + (huff >> drop2) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
         } while (fill !== 0);
         incr = 1 << len - 1;
         while (huff & incr) {
@@ -9185,11 +9185,11 @@ var require_inftrees = __commonJS({
             return 1;
           }
           low = huff & mask;
-          table[low] = root2 << 24 | curr << 16 | next - table_index | 0;
+          table2[low] = root2 << 24 | curr << 16 | next - table_index | 0;
         }
       }
       if (huff !== 0) {
-        table[next + huff] = len - drop2 << 24 | 64 << 16 | 0;
+        table2[next + huff] = len - drop2 << 24 | 64 << 16 | 0;
       }
       opts.bits = root2;
       return 0;
@@ -9236,7 +9236,7 @@ var require_inflate = __commonJS({
     var STORED = 14;
     var COPY_ = 15;
     var COPY = 16;
-    var TABLE2 = 17;
+    var TABLE3 = 17;
     var LENLENS = 18;
     var CODELENS = 19;
     var LEN_ = 20;
@@ -9824,7 +9824,7 @@ var require_inflate = __commonJS({
                   }
                   break;
                 case 2:
-                  state2.mode = TABLE2;
+                  state2.mode = TABLE3;
                   break;
                 case 3:
                   strm.msg = "invalid block type";
@@ -9882,7 +9882,7 @@ var require_inflate = __commonJS({
               }
               state2.mode = TYPE;
               break;
-            case TABLE2:
+            case TABLE3:
               while (bits < 14) {
                 if (have === 0) {
                   break inf_leave;
@@ -18973,8 +18973,21 @@ var require_node2 = __commonJS({
       const scope = this.nodeScope;
       const runContext = scope && scope.runContext;
       if (!runContext || !runContext.beginStep || !runContext.endStep) return;
-      const step = runContext.beginStep({ nodeId: this.id, nodeType: this.name });
-      if (step !== void 0 && step !== null) runContext.endStep(step, { status: "failure", code, message, detail });
+      const recordValues = !!runContext.recordValues;
+      const step = runContext.beginStep({
+        nodeId: this.id,
+        nodeType: this.name,
+        ...recordValues ? { inputs: snapshotInputValues(this) } : {}
+      });
+      if (step !== void 0 && step !== null) {
+        runContext.endStep(step, {
+          status: "failure",
+          code,
+          message,
+          detail,
+          ...recordValues ? { outputs: snapshotOutputValues(this) } : {}
+        });
+      }
     };
     Node17.prototype.setDiagnostic = function(key, message) {
       setDiagnostic(this, key, message);
@@ -18984,6 +18997,47 @@ var require_node2 = __commonJS({
         return diagnosticsEnabled(this);
       }
     });
+    function isSignalPortType(type) {
+      if (type === "signal") return true;
+      return !!type && typeof type === "object" && type.name === "signal";
+    }
+    function snapshotInputValues(node) {
+      const out = {};
+      const values2 = node._inputValues || {};
+      const inputs = node._inputs || {};
+      let declared2 = {};
+      try {
+        const register = node.context && node.context.nodeRegister;
+        if (register && register.hasNode(node.name)) declared2 = register.getNodeMetadata(node.name).inputs || {};
+      } catch (e) {
+      }
+      for (const name2 of Object.keys(values2)) {
+        const value2 = values2[name2];
+        if (value2 === void 0 || typeof value2 === "function") continue;
+        const port = inputs[name2];
+        if (port && isSignalPortType(port.type)) continue;
+        const meta = declared2[name2];
+        if (meta && isSignalPortType(meta.type)) continue;
+        out[name2] = value2;
+      }
+      return out;
+    }
+    function snapshotOutputValues(node) {
+      const out = {};
+      const list = node._outputList || [];
+      for (const port of list) {
+        if (!port || isSignalPortType(port.type)) continue;
+        let value2;
+        try {
+          value2 = port.value;
+        } catch (e) {
+          continue;
+        }
+        if (value2 === void 0 || typeof value2 === "function") continue;
+        out[port.name] = value2;
+      }
+      return out;
+    }
     Node17.prototype.beginOutcome = function(inputData) {
       const token = { reported: void 0 };
       const cause = currentTraceCause(this.context);
@@ -18991,7 +19045,13 @@ var require_node2 = __commonJS({
       const scope = this.nodeScope;
       const runContext = scope && scope.runContext;
       if (runContext && runContext.beginStep) {
-        token.step = runContext.beginStep({ nodeId: this.id, nodeType: this.name, inputData });
+        token.step = runContext.beginStep({
+          nodeId: this.id,
+          nodeType: this.name,
+          inputData,
+          // P123-STU-FNRUNVALUES — opt-in; absent, the step object is exactly what it always was.
+          ...runContext.recordValues ? { inputs: snapshotInputValues(this) } : {}
+        });
       }
       return token;
     };
@@ -19070,7 +19130,10 @@ var require_node2 = __commonJS({
             message: options && options.message,
             // The subject of the failure, for a record whose steps are all called `http`. See
             // `RuntimeStepEnd.detail` — the node already composes this for the error bus.
-            detail: options && options.detail
+            detail: options && options.detail,
+            // P123-STU-FNRUNVALUES — read now, after the signals: "the outcome is the last thing an
+            // action does", so every value it produced is already on its ports.
+            ...runContext.recordValues ? { outputs: snapshotOutputValues(this) } : {}
           });
         }
       }
@@ -24604,9 +24667,704 @@ var require_runtasks = __commonJS({
   }
 });
 
+// ../noodl-runtime/src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  getAbsoluteUrl: () => getAbsoluteUrl,
+  logJavaScriptNodeError: () => logJavaScriptNodeError,
+  thrownMessage: () => thrownMessage
+});
+function getAbsoluteUrl(_url) {
+  const url = String(_url);
+  if (!url || url[0] === "/" || url.includes("://") || url.startsWith("data:")) {
+    return url;
+  }
+  return (Noodl.baseUrl || "/") + url;
+}
+function thrownMessage(error) {
+  if (error && error.message) return String(error.message);
+  try {
+    return String(error);
+  } catch {
+    return typeof error;
+  }
+}
+function logJavaScriptNodeError(error) {
+  const prefix = "Error in JS node run code.";
+  if (error === null || typeof error !== "object" && typeof error !== "function") {
+    console.log(prefix, thrownMessage(error));
+    return;
+  }
+  const proto = Object.getPrototypeOf(error);
+  const kind = proto && proto.constructor && proto.constructor.name ? proto.constructor.name : "Error";
+  console.log(prefix, kind + ": " + thrownMessage(error), error.stack);
+}
+var init_utils = __esm({
+  "../noodl-runtime/src/utils.ts"() {
+  }
+});
+
+// ../noodl-runtime/src/componentwalk.ts
+var componentwalk_exports = {};
+__export(componentwalk_exports, {
+  COMPONENT_OBJECT_TYPES: () => COMPONENT_OBJECT_TYPES,
+  componentAncestorNames: () => componentAncestorNames,
+  componentAncestors: () => componentAncestors,
+  findAncestorWithComponentObject: () => findAncestorWithComponentObject,
+  findAncestorWithName: () => findAncestorWithName,
+  findAncestorWithNodeType: () => findAncestorWithNodeType,
+  findAncestorWithProperty: () => findAncestorWithProperty,
+  findComponentAncestor: () => findComponentAncestor,
+  parentComponentOf: () => parentComponentOf,
+  scopeChain: () => scopeChain,
+  scopeChainNames: () => scopeChainNames
+});
+function parentComponentOf(component) {
+  if (!component) return void 0;
+  let parent;
+  if (component.getRoots().length > 0) {
+    const root2 = component.getRoots()[0];
+    if (root2.getVisualParentNode) {
+      const visualParent = root2.getVisualParentNode();
+      if (visualParent) {
+        parent = visualParent.nodeScope.componentOwner;
+      }
+    } else if (root2.parentNodeScope) {
+      parent = component.parentNodeScope.componentOwner;
+    }
+  } else if (component.parentNodeScope) {
+    parent = component.parentNodeScope.componentOwner;
+  }
+  if (parent && parent.nodeScope && parent.nodeScope.componentOwner !== component) {
+    return parent;
+  }
+  return void 0;
+}
+function componentAncestors(component) {
+  const ancestors = [];
+  let current = component;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    const parent = parentComponentOf(current);
+    if (!parent) break;
+    ancestors.push(parent);
+    current = parent;
+  }
+  return ancestors;
+}
+function findComponentAncestor(component, predicate) {
+  let current = component;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    const parent = parentComponentOf(current);
+    if (!parent) return void 0;
+    if (predicate(parent)) return parent;
+    current = parent;
+  }
+  return void 0;
+}
+function findAncestorWithNodeType(component, types) {
+  return findComponentAncestor(
+    component,
+    (candidate) => types.some((type) => candidate.nodeScope.getNodesWithType(type).length > 0)
+  );
+}
+function findAncestorWithComponentObject(component) {
+  return findAncestorWithNodeType(component, COMPONENT_OBJECT_TYPES);
+}
+function findAncestorWithName(component, name2) {
+  return findComponentAncestor(component, (candidate) => candidate.name === name2);
+}
+function scopeChain(component) {
+  const chain2 = [];
+  let current = component;
+  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+    if (!current) break;
+    chain2.push(current);
+    if (!current.parentNodeScope) break;
+    current = current.parentNodeScope.componentOwner;
+  }
+  return chain2;
+}
+function scopeChainNames(component) {
+  return scopeChain(component).map((entry) => entry.name);
+}
+function findAncestorWithProperty(component, property2) {
+  const chain2 = scopeChain(component);
+  for (let i2 = 0; i2 < chain2.length; i2++) {
+    if (chain2[i2][property2] !== void 0) return chain2[i2];
+  }
+  return void 0;
+}
+function componentAncestorNames(component) {
+  return componentAncestors(component).map((ancestor) => ancestor.name);
+}
+var MAX_WALK_DEPTH, COMPONENT_OBJECT_TYPES;
+var init_componentwalk = __esm({
+  "../noodl-runtime/src/componentwalk.ts"() {
+    "use strict";
+    MAX_WALK_DEPTH = 1e3;
+    COMPONENT_OBJECT_TYPES = ["net.noodl.ComponentObject", "Component State"];
+  }
+});
+
+// ../noodl-runtime/src/resolvedtarget.ts
+function summariseTargets(labels) {
+  const distinct = [];
+  for (let i2 = 0; i2 < labels.length; i2++) {
+    const label = labels[i2];
+    if (label === void 0) continue;
+    if (distinct.indexOf(label) === -1) distinct.push(label);
+  }
+  if (distinct.length === 0) return void 0;
+  if (distinct.length === 1) return "\u2192 " + distinct[0];
+  const listed = distinct.slice(0, MAX_NAMES_LISTED).join(", ");
+  const rest2 = distinct.length - MAX_NAMES_LISTED;
+  return "\u2192 " + distinct.length + " targets: " + listed + (rest2 > 0 ? ", +" + rest2 : "");
+}
+var MAX_NAMES_LISTED, ResolvedTargetReporter;
+var init_resolvedtarget = __esm({
+  "../noodl-runtime/src/resolvedtarget.ts"() {
+    "use strict";
+    MAX_NAMES_LISTED = 3;
+    ResolvedTargetReporter = class {
+      constructor() {
+        /** Weak, so a torn-down runtime's bookkeeping goes with it and needs no reset call. */
+        this._byContext = /* @__PURE__ */ new WeakMap();
+      }
+      /**
+       * Record what `node` bound to and push the summary to the editor.
+       *
+       * Safe to call every resolution; identical summaries are dropped rather than sent, so a
+       * node that re-resolves each frame costs one string comparison.
+       */
+      report(node, target) {
+        const state2 = this._stateFor(node);
+        if (!state2) return;
+        let instances = state2.byGraphNode.get(node.id);
+        if (!instances) {
+          instances = /* @__PURE__ */ new Map();
+          state2.byGraphNode.set(node.id, instances);
+        }
+        instances.set(node, target);
+        this._flush(node, state2, instances);
+      }
+      /** Drop an instance. Call from `_onNodeDeleted`, or this map is a leak. */
+      forget(node) {
+        const state2 = this._stateFor(node);
+        if (!state2) return;
+        const instances = state2.byGraphNode.get(node.id);
+        if (!instances) return;
+        instances.delete(node);
+        if (instances.size === 0) {
+          state2.byGraphNode.delete(node.id);
+          state2.lastSent.delete(node.id);
+          return;
+        }
+        this._flush(node, state2, instances);
+      }
+      _stateFor(node) {
+        const context = node.context;
+        if (!context) return void 0;
+        let state2 = this._byContext.get(context);
+        if (!state2) {
+          state2 = { byGraphNode: /* @__PURE__ */ new Map(), lastSent: /* @__PURE__ */ new Map() };
+          this._byContext.set(context, state2);
+        }
+        return state2;
+      }
+      _flush(node, state2, instances) {
+        const labels = [];
+        instances.forEach((label) => labels.push(label));
+        const summary = summariseTargets(labels);
+        if (state2.lastSent.has(node.id) && state2.lastSent.get(node.id) === summary) return;
+        state2.lastSent.set(node.id, summary);
+        const editorConnection = node.context && node.context.editorConnection;
+        if (!editorConnection || !editorConnection.isRunningLocally()) return;
+        if (typeof editorConnection.sendNodeSubLabel !== "function") return;
+        editorConnection.sendNodeSubLabel(node.id, summary);
+      }
+    };
+  }
+});
+
+// ../noodl-runtime/src/foreachitem.ts
+var foreachitem_exports = {};
+__export(foreachitem_exports, {
+  forgetForEachItem: () => forgetForEachItem,
+  resolveForEachItem: () => resolveForEachItem
+});
+function resolveForEachItem(node, options = {}) {
+  const chain2 = scopeChain(node.nodeScope.componentOwner);
+  const wanted = options.target;
+  if (wanted) {
+    const named3 = firstNamed(chain2, wanted);
+    if (!named3) {
+      return miss(
+        node,
+        "repeater-item/target-not-found",
+        'No component named "' + wanted + '" contains this node',
+        wanted,
+        { target: wanted, scope: scopeChainNames(node.nodeScope.componentOwner) }
+      );
+    }
+    if (named3[FOR_EACH_MODEL] === void 0) {
+      return miss(
+        node,
+        "repeater-item/target-has-no-item",
+        'The component "' + wanted + '" has no current item \u2014 it is not used as a Repeater or Run Tasks template',
+        wanted,
+        { target: wanted }
+      );
+    }
+    return hit(node, named3);
+  }
+  const owner = firstWithItem(chain2);
+  if (!owner) {
+    return miss(
+      node,
+      "repeater-item/no-item-in-scope",
+      'Id Source is set to "From repeater", but this node is not inside a Repeater or Run Tasks template',
+      void 0,
+      { scope: scopeChainNames(node.nodeScope.componentOwner) }
+    );
+  }
+  return hit(node, owner);
+}
+function forgetForEachItem(node) {
+  resolvedTargets.forget(node);
+  lastMissByNode.delete(node);
+}
+function firstNamed(chain2, name2) {
+  for (let i2 = 0; i2 < chain2.length; i2++) {
+    if (chain2[i2].name === name2) return chain2[i2];
+  }
+  return void 0;
+}
+function firstWithItem(chain2) {
+  for (let i2 = 0; i2 < chain2.length; i2++) {
+    if (chain2[i2][FOR_EACH_MODEL] !== void 0) return chain2[i2];
+  }
+  return void 0;
+}
+function hit(node, owner) {
+  lastMissByNode.delete(node);
+  resolvedTargets.report(node, owner.name);
+  return owner[FOR_EACH_MODEL];
+}
+function miss(node, code, message, target, detail) {
+  resolvedTargets.report(node, void 0);
+  const seen = code + "|" + (target || "");
+  if (lastMissByNode.get(node) !== seen) {
+    lastMissByNode.set(node, seen);
+    node.raiseRuntimeError(code, message, detail);
+  }
+  return void 0;
+}
+var FOR_EACH_MODEL, resolvedTargets, lastMissByNode;
+var init_foreachitem = __esm({
+  "../noodl-runtime/src/foreachitem.ts"() {
+    "use strict";
+    init_componentwalk();
+    init_resolvedtarget();
+    FOR_EACH_MODEL = "_forEachModel";
+    resolvedTargets = new ResolvedTargetReporter();
+    lastMissByNode = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../noodl-runtime/src/javascriptnodeparser.js
+var require_javascriptnodeparser = __commonJS({
+  "../noodl-runtime/src/javascriptnodeparser.js"(exports2, module2) {
+    "use strict";
+    var Model27 = require_model2();
+    var { getAbsoluteUrl: getAbsoluteUrl2 } = (init_utils(), __toCommonJS(utils_exports));
+    var { findAncestorWithComponentObject: findAncestorWithComponentObject2 } = (init_componentwalk(), __toCommonJS(componentwalk_exports));
+    var { resolveForEachItem: resolveForEachItem2 } = (init_foreachitem(), __toCommonJS(foreachitem_exports));
+    var userFunctionsCache = {};
+    function JavascriptNodeParser4(code, options) {
+      this.inputs = {};
+      this.outputs = {};
+      this.error = void 0;
+      this.code = code;
+      const node = options ? options.node : void 0;
+      this._initializeAPIs();
+      var userCode = userFunctionsCache[code];
+      if (!userCode) {
+        try {
+          userCode = new Function(["define", "script", "Node", "Component"], JavascriptNodeParser4.getCodePrefix() + code);
+          userFunctionsCache[code] = userCode;
+        } catch (e) {
+          this.error = e.message;
+          console.error(e);
+        }
+      }
+      if (userCode) {
+        try {
+          userCode(
+            this.define.bind(this),
+            this.script.bind(this),
+            this.apis.Node,
+            node ? JavascriptNodeParser4.getComponentScopeForNode(node) : {}
+          );
+          this._afterSourced();
+        } catch (e) {
+          this.error = e.message;
+          console.error(e);
+        }
+      }
+    }
+    JavascriptNodeParser4.prototype.define = function(userObject) {
+      this.inputs = userObject.inputs || {};
+      this.outputs = userObject.outputs || {};
+      this.setup = userObject.setup;
+      this.change = userObject.run || userObject.change;
+      this.destroy = userObject.destroy;
+      this.definedObject = userObject;
+    };
+    function _scriptExtend(_this) {
+      var _extended = {
+        inputs: _this.inputs || {},
+        outputs: _this.outputs || {},
+        setup: function(inputs, outputs) {
+          this.inputs = inputs;
+          this.outputs = outputs;
+          this.setOutputs = function(states) {
+            for (var key3 in states) {
+              this.outputs[key3] = states[key3];
+              this.flagOutputDirty(key3);
+            }
+          };
+          if (_this.methods) {
+            for (var key2 in _this.methods) {
+              this[key2] = _this.methods[key2];
+            }
+          }
+          _this.setup && _this.setup.apply(this);
+        },
+        destroy: function(inputs, outputs) {
+          this.inputs = inputs;
+          this.outputs = outputs;
+          _this.destroy && _this.destroy.apply(this);
+        },
+        change: function(inputs, outputs) {
+          this.inputs = inputs;
+          this.outputs = outputs;
+          var old = this._oldInputs || {};
+          if (_this.changed) {
+            for (var key2 in inputs) {
+              if (inputs[key2] !== old[key2]) {
+                var changedFunction = _this.changed[key2];
+                if (typeof changedFunction === "function") changedFunction.apply(this, [inputs[key2], old[key2]]);
+              }
+            }
+          }
+          this._oldInputs = Object.assign({}, inputs);
+        }
+      };
+      if (_this.signals) {
+        for (var key in _this.signals) {
+          _extended[key] = _this.signals[key];
+          _extended.inputs[key] = "signal";
+        }
+      }
+      return _extended;
+    }
+    JavascriptNodeParser4.prototype.script = function(userObject) {
+      var _userObjectExtended = _scriptExtend(userObject);
+      this.inputs = _userObjectExtended.inputs || {};
+      this.outputs = _userObjectExtended.outputs || {};
+      this.setup = _userObjectExtended.setup;
+      this.change = _userObjectExtended.run || _userObjectExtended.change;
+      this.destroy = _userObjectExtended.destroy;
+      this.definedObject = _userObjectExtended;
+    };
+    JavascriptNodeParser4.prototype._initializeAPIs = function() {
+      this.apis = {
+        Node: {
+          Inputs: {},
+          Outputs: {},
+          Signals: {},
+          Setters: {}
+        }
+      };
+    };
+    JavascriptNodeParser4.prototype._afterSourced = function() {
+      if (this.definedObject !== void 0) return;
+      var _Node = this.apis.Node;
+      this.inputs = Object.assign({}, _Node.Inputs || {});
+      this.outputs = Object.assign({}, _Node.Outputs || {});
+      this.setup = function(inputs, outputs) {
+        const _this = this;
+        _Node.setOutputs = function(_outputs) {
+          for (var key2 in _outputs) {
+            outputs[key2] = _outputs[key2];
+            _this.flagOutputDirty(key2);
+          }
+        };
+        _Node.OnInit && _Node.OnInit.apply(this);
+      };
+      this.destroy = _Node.OnDestroy || this.destory;
+      this.change = (inputs, outputs, changedInputs) => {
+        for (var key2 in changedInputs) {
+          if (typeof _Node.Setters[key2] === "function") {
+            _Node.Setters[key2](inputs[key2]);
+          }
+        }
+        if (typeof _Node.OnInputsChanged === "function") {
+          _Node.OnInputsChanged();
+        }
+      };
+      this.definedObject = {
+        inputs: this.inputs,
+        outputs: this.outputs,
+        setup: this.setup,
+        destroy: this.destroy,
+        change: this.change
+      };
+      if (_Node.Signals !== void 0) {
+        for (var key in _Node.Signals) {
+          if (typeof _Node.Signals[key] === "function") {
+            this.inputs[key] = "signal";
+            this.definedObject[key] = _Node.Signals[key];
+          }
+        }
+      }
+    };
+    JavascriptNodeParser4.createFromCode = function(code, options) {
+      return new JavascriptNodeParser4(code, options);
+    };
+    function failedParser(message) {
+      var parser = Object.create(JavascriptNodeParser4.prototype);
+      parser.inputs = {};
+      parser.outputs = {};
+      parser.error = message;
+      parser.code = void 0;
+      parser.apis = { Node: {} };
+      return parser;
+    }
+    JavascriptNodeParser4.createFromURL = function(url, callback, options) {
+      url = getAbsoluteUrl2(url);
+      var settled = false;
+      function settle(parser) {
+        if (settled) return;
+        settled = true;
+        callback(parser);
+      }
+      var xhr = new window.XMLHttpRequest();
+      xhr.open("GET", url, true);
+      xhr.onreadystatechange = function() {
+        if (this.readyState === 4 || this.readyState === XMLHttpRequest.DONE) {
+          if (this.status !== 0 && (this.status < 200 || this.status >= 300)) {
+            settle(failedParser('Could not load "' + url + '": the server answered ' + this.status));
+            return;
+          }
+          if (this.status === 0) {
+            settle(failedParser('Could not load "' + url + '": the request failed'));
+            return;
+          }
+          settle(new JavascriptNodeParser4(this.response, options));
+        }
+      };
+      xhr.onerror = function() {
+        settle(failedParser('Could not load "' + url + '": the request failed'));
+      };
+      xhr.send();
+    };
+    JavascriptNodeParser4.parseAndAddPortsFromScript = function(script, ports, options) {
+      function _exists(port) {
+        if (typeof port === "string") return ports.find((p) => p.name === port) !== void 0;
+        else return ports.find((p) => p.name === port.name && p.plug === port.plug) !== void 0;
+      }
+      function _addPortsFromMatch(match, options2) {
+        if (match === void 0 || match === null) return;
+        const unique = {};
+        for (const _s of match) {
+          let name2 = _s[1];
+          if (name2 === void 0) continue;
+          unique[name2] = true;
+        }
+        Object.keys(unique).forEach((p) => {
+          if (_exists({
+            name: options2.prefix + p,
+            plug: options2.plug
+          }))
+            return;
+          ports.push({
+            name: options2.prefix + p,
+            displayName: p,
+            plug: options2.plug,
+            type: options2.type,
+            group: options2.group
+          });
+        });
+      }
+      if (!options.skipInputs) {
+        _addPortsFromMatch(script.matchAll(/Inputs\.([A-Za-z0-9_]+)/g), {
+          type: options.inputType || "*",
+          plug: "input",
+          group: options.inputGroup || "Inputs",
+          prefix: options.inputPrefix || ""
+        });
+        _addPortsFromMatch(script.matchAll(/Inputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]/g), {
+          type: options.inputType || "*",
+          plug: "inputs",
+          group: options.inputGroup || "Inputs",
+          prefix: options.inputPrefix || ""
+        });
+      }
+      if (!options.skipOutputs) {
+        if (!options.skipOutputSignals) {
+          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9]+)\s*\(\s*\)/g), {
+            type: "signal",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]\(\s*\)/g), {
+            type: "signal",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+        }
+        if (!options.skipRegularOutputs) {
+          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9_]+)/g), {
+            type: "*",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*\"([^\"]*)\"\s*\]/g), {
+            type: "*",
+            plug: "output",
+            group: "Outputs",
+            prefix: options.outputPrefix || ""
+          });
+        }
+      }
+    };
+    JavascriptNodeParser4.prototype.getPorts = function() {
+      var ports = [];
+      var self2 = this;
+      Object.keys(this.inputs).forEach(function(name2) {
+        var inputPort = self2.inputs[name2];
+        var port = {
+          name: name2,
+          plug: "input"
+        };
+        if (typeof inputPort === "string") {
+          port.type = {
+            name: inputPort
+          };
+          port.group = "Inputs";
+        } else {
+          for (var p in inputPort) {
+            port[p] = inputPort[p];
+          }
+        }
+        ports.push(port);
+      });
+      Object.keys(this.outputs).forEach(function(name2) {
+        ports.push({
+          name: name2,
+          type: {
+            name: self2.outputs[name2]
+          },
+          plug: "output",
+          group: "Outputs"
+        });
+      });
+      JavascriptNodeParser4.parseAndAddPortsFromScript(this.code, ports, {});
+      return ports;
+    };
+    var _componentScopes = {};
+    function _findParentComponentStateModelId(node) {
+      const parent = findAncestorWithComponentObject2(node.nodeScope.componentOwner);
+      if (!parent) return;
+      return "componentState" + parent.getInstanceId();
+    }
+    JavascriptNodeParser4.getComponentScopeForNode = function(node) {
+      const componentId = node.nodeScope.componentOwner.getInstanceId();
+      if (_componentScopes[componentId] === void 0) {
+        _componentScopes[componentId] = {};
+        const componentObject = (node.nodeScope.modelScope || Model27).get("componentState" + componentId);
+        _componentScopes[componentId].Object = componentObject;
+      }
+      const parentComponentObjectId = _findParentComponentStateModelId(node);
+      const parentComponentObject = parentComponentObjectId !== void 0 ? (node.nodeScope.modelScope || Model27).get(parentComponentObjectId) : void 0;
+      _componentScopes[componentId].ParentObject = parentComponentObject;
+      Object.defineProperty(_componentScopes[componentId], "RepeaterObject", {
+        configurable: true,
+        enumerable: true,
+        get: function() {
+          return resolveForEachItem2(node);
+        }
+      });
+      return _componentScopes[componentId];
+    };
+    JavascriptNodeParser4.getCodePrefix = function() {
+      return "const Script = (typeof Node !== 'undefined')?Node:undefined;\n";
+    };
+    JavascriptNodeParser4.createNoodlAPI = function() {
+      return typeof window !== "undefined" && window.Noodl !== void 0 ? window.Noodl : {};
+    };
+    module2.exports = JavascriptNodeParser4;
+  }
+});
+
+// ../noodl-runtime/src/printedcode.ts
+function table() {
+  return globalThis[TABLE];
+}
+function hasPrintedCode() {
+  return table() !== void 0;
+}
+function sameParams(a, b) {
+  return a.length === b.length && a.every((p, i2) => p === b[i2]);
+}
+function findPrintedCode(params, body, async) {
+  const list = table()?.get(body);
+  return list && list.find((e) => e.async === async && sameParams(e.params, params));
+}
+function findPrintedBody(body, async) {
+  const list = table()?.get(body);
+  return list && list.find((e) => e.async === async);
+}
+function compileCode(params, body, options) {
+  const async = !!(options && options.async);
+  const printed = findPrintedCode(params, body, async);
+  if (printed) return printed.fn;
+  if (table()?.refuseOthers) throw new Error(NOT_PRINTED_MESSAGE);
+  const Ctor = async ? AsyncFunction : Function;
+  return new Ctor(...params, body);
+}
+function functionNodeBody(script) {
+  const JavascriptNodeParser4 = require_javascriptnodeparser();
+  return JavascriptNodeParser4.getCodePrefix() + script;
+}
+function expressionNodeBody(expression) {
+  return EXPRESSION_PREAMBLE + "return (" + expression + ");";
+}
+var NOT_PRINTED_MESSAGE, TABLE, AsyncFunction, FUNCTION_NODE_PARAMS, EXPRESSION_PREAMBLE, REST_REQUEST_PARAMS, REST_RESPONSE_PARAMS, MAP_COLLECTION_PARAMS;
+var init_printedcode = __esm({
+  "../noodl-runtime/src/printedcode.ts"() {
+    NOT_PRINTED_MESSAGE = "This code was not printed when the app was deployed, and code cannot be compiled here. Deploy the app again.";
+    TABLE = Symbol.for("nodegx.printedCode");
+    AsyncFunction = Object.getPrototypeOf(async function() {
+    }).constructor;
+    FUNCTION_NODE_PARAMS = ["Inputs", "Outputs", "Noodl", "Component", "Scripts"];
+    EXPRESSION_PREAMBLE = [
+      'var min = Math.min,    max = Math.max,    cos = Math.cos,    sin = Math.sin,    tan = Math.tan,    sqrt = Math.sqrt,    pi = Math.PI,    round = Math.round,    floor = Math.floor,    ceil = Math.ceil,    abs = Math.abs,    random = Math.random,    pow = Math.pow,    log = Math.log,    exp = Math.exp;try {  var NoodlContext = (typeof Noodl !== "undefined") ? Noodl : (typeof global !== "undefined" && global.Noodl) || {};  var Variables = NoodlContext.Variables || {};  var Objects = NoodlContext.Objects || {};  var Arrays = NoodlContext.Arrays || {};} catch (e) {  var Variables = {}, Objects = {}, Arrays = {};}'
+    ].join("");
+    REST_REQUEST_PARAMS = ["Inputs", "Outputs", "Request"];
+    REST_RESPONSE_PARAMS = ["Inputs", "Outputs", "Response"];
+    MAP_COLLECTION_PARAMS = ["map", "object"];
+  }
+});
+
 // ../noodl-runtime/src/nodes/std-library/data/restnode.ts
 var require_restnode = __commonJS({
   "../noodl-runtime/src/nodes/std-library/data/restnode.ts"(exports2, module2) {
+    init_printedcode();
     var defaultRequestScript = "//Add custom code to setup the request object before the request\n//is made.\n//\n//*Request.resource     contains the resource path of the request.\n//*Request.method       contains the method, GET, POST, PUT or DELETE.\n//*Request.headers      is a map where you can add additional headers.\n//*Request.parameters   is a map the parameters that will be appended\n//                      to the url.\n//*Request.content      contains the content of the request as a javascript\n//                      object.\n//\n";
     var defaultResponseScript = "// Add custom code to convert the response content to outputs\n//\n//*Response.status    The status code of the response\n//*Response.content   The content of the response as a javascript\n//                    object.\n//*Response.request   The request object that resulted in the response.\n//\n//*Inputs and *Outputs contain the inputs and outputs of the node.\n";
     var RestNode = {
@@ -24695,7 +25453,7 @@ var require_restnode = __commonJS({
           group: "Scripts",
           set: function(script) {
             try {
-              this._internal.requestFunc = new Function("Inputs", "Outputs", "Request", script);
+              this._internal.requestFunc = compileCode(REST_REQUEST_PARAMS, script);
             } catch (e) {
               console.log(e);
             }
@@ -24712,7 +25470,7 @@ var require_restnode = __commonJS({
           group: "Scripts",
           set: function(script) {
             try {
-              this._internal.responseFunc = new Function("Inputs", "Outputs", "Response", script);
+              this._internal.responseFunc = compileCode(REST_RESPONSE_PARAMS, script);
             } catch (e) {
               console.log(e);
             }
@@ -25702,656 +26460,13 @@ var require_lodash = __commonJS({
   }
 });
 
-// ../noodl-runtime/src/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  getAbsoluteUrl: () => getAbsoluteUrl,
-  logJavaScriptNodeError: () => logJavaScriptNodeError,
-  thrownMessage: () => thrownMessage
-});
-function getAbsoluteUrl(_url) {
-  const url = String(_url);
-  if (!url || url[0] === "/" || url.includes("://") || url.startsWith("data:")) {
-    return url;
-  }
-  return (Noodl.baseUrl || "/") + url;
-}
-function thrownMessage(error) {
-  if (error && error.message) return String(error.message);
-  try {
-    return String(error);
-  } catch {
-    return typeof error;
-  }
-}
-function logJavaScriptNodeError(error) {
-  const prefix = "Error in JS node run code.";
-  if (error === null || typeof error !== "object" && typeof error !== "function") {
-    console.log(prefix, thrownMessage(error));
-    return;
-  }
-  const proto = Object.getPrototypeOf(error);
-  const kind = proto && proto.constructor && proto.constructor.name ? proto.constructor.name : "Error";
-  console.log(prefix, kind + ": " + thrownMessage(error), error.stack);
-}
-var init_utils = __esm({
-  "../noodl-runtime/src/utils.ts"() {
-  }
-});
-
-// ../noodl-runtime/src/componentwalk.ts
-var componentwalk_exports = {};
-__export(componentwalk_exports, {
-  COMPONENT_OBJECT_TYPES: () => COMPONENT_OBJECT_TYPES,
-  componentAncestorNames: () => componentAncestorNames,
-  componentAncestors: () => componentAncestors,
-  findAncestorWithComponentObject: () => findAncestorWithComponentObject,
-  findAncestorWithName: () => findAncestorWithName,
-  findAncestorWithNodeType: () => findAncestorWithNodeType,
-  findAncestorWithProperty: () => findAncestorWithProperty,
-  findComponentAncestor: () => findComponentAncestor,
-  parentComponentOf: () => parentComponentOf,
-  scopeChain: () => scopeChain,
-  scopeChainNames: () => scopeChainNames
-});
-function parentComponentOf(component) {
-  if (!component) return void 0;
-  let parent;
-  if (component.getRoots().length > 0) {
-    const root2 = component.getRoots()[0];
-    if (root2.getVisualParentNode) {
-      const visualParent = root2.getVisualParentNode();
-      if (visualParent) {
-        parent = visualParent.nodeScope.componentOwner;
-      }
-    } else if (root2.parentNodeScope) {
-      parent = component.parentNodeScope.componentOwner;
-    }
-  } else if (component.parentNodeScope) {
-    parent = component.parentNodeScope.componentOwner;
-  }
-  if (parent && parent.nodeScope && parent.nodeScope.componentOwner !== component) {
-    return parent;
-  }
-  return void 0;
-}
-function componentAncestors(component) {
-  const ancestors = [];
-  let current = component;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
-    const parent = parentComponentOf(current);
-    if (!parent) break;
-    ancestors.push(parent);
-    current = parent;
-  }
-  return ancestors;
-}
-function findComponentAncestor(component, predicate) {
-  let current = component;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
-    const parent = parentComponentOf(current);
-    if (!parent) return void 0;
-    if (predicate(parent)) return parent;
-    current = parent;
-  }
-  return void 0;
-}
-function findAncestorWithNodeType(component, types) {
-  return findComponentAncestor(
-    component,
-    (candidate) => types.some((type) => candidate.nodeScope.getNodesWithType(type).length > 0)
-  );
-}
-function findAncestorWithComponentObject(component) {
-  return findAncestorWithNodeType(component, COMPONENT_OBJECT_TYPES);
-}
-function findAncestorWithName(component, name2) {
-  return findComponentAncestor(component, (candidate) => candidate.name === name2);
-}
-function scopeChain(component) {
-  const chain2 = [];
-  let current = component;
-  for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
-    if (!current) break;
-    chain2.push(current);
-    if (!current.parentNodeScope) break;
-    current = current.parentNodeScope.componentOwner;
-  }
-  return chain2;
-}
-function scopeChainNames(component) {
-  return scopeChain(component).map((entry) => entry.name);
-}
-function findAncestorWithProperty(component, property2) {
-  const chain2 = scopeChain(component);
-  for (let i2 = 0; i2 < chain2.length; i2++) {
-    if (chain2[i2][property2] !== void 0) return chain2[i2];
-  }
-  return void 0;
-}
-function componentAncestorNames(component) {
-  return componentAncestors(component).map((ancestor) => ancestor.name);
-}
-var MAX_WALK_DEPTH, COMPONENT_OBJECT_TYPES;
-var init_componentwalk = __esm({
-  "../noodl-runtime/src/componentwalk.ts"() {
-    "use strict";
-    MAX_WALK_DEPTH = 1e3;
-    COMPONENT_OBJECT_TYPES = ["net.noodl.ComponentObject", "Component State"];
-  }
-});
-
-// ../noodl-runtime/src/resolvedtarget.ts
-function summariseTargets(labels) {
-  const distinct = [];
-  for (let i2 = 0; i2 < labels.length; i2++) {
-    const label = labels[i2];
-    if (label === void 0) continue;
-    if (distinct.indexOf(label) === -1) distinct.push(label);
-  }
-  if (distinct.length === 0) return void 0;
-  if (distinct.length === 1) return "\u2192 " + distinct[0];
-  const listed = distinct.slice(0, MAX_NAMES_LISTED).join(", ");
-  const rest2 = distinct.length - MAX_NAMES_LISTED;
-  return "\u2192 " + distinct.length + " targets: " + listed + (rest2 > 0 ? ", +" + rest2 : "");
-}
-var MAX_NAMES_LISTED, ResolvedTargetReporter;
-var init_resolvedtarget = __esm({
-  "../noodl-runtime/src/resolvedtarget.ts"() {
-    "use strict";
-    MAX_NAMES_LISTED = 3;
-    ResolvedTargetReporter = class {
-      constructor() {
-        /** Weak, so a torn-down runtime's bookkeeping goes with it and needs no reset call. */
-        this._byContext = /* @__PURE__ */ new WeakMap();
-      }
-      /**
-       * Record what `node` bound to and push the summary to the editor.
-       *
-       * Safe to call every resolution; identical summaries are dropped rather than sent, so a
-       * node that re-resolves each frame costs one string comparison.
-       */
-      report(node, target) {
-        const state2 = this._stateFor(node);
-        if (!state2) return;
-        let instances = state2.byGraphNode.get(node.id);
-        if (!instances) {
-          instances = /* @__PURE__ */ new Map();
-          state2.byGraphNode.set(node.id, instances);
-        }
-        instances.set(node, target);
-        this._flush(node, state2, instances);
-      }
-      /** Drop an instance. Call from `_onNodeDeleted`, or this map is a leak. */
-      forget(node) {
-        const state2 = this._stateFor(node);
-        if (!state2) return;
-        const instances = state2.byGraphNode.get(node.id);
-        if (!instances) return;
-        instances.delete(node);
-        if (instances.size === 0) {
-          state2.byGraphNode.delete(node.id);
-          state2.lastSent.delete(node.id);
-          return;
-        }
-        this._flush(node, state2, instances);
-      }
-      _stateFor(node) {
-        const context = node.context;
-        if (!context) return void 0;
-        let state2 = this._byContext.get(context);
-        if (!state2) {
-          state2 = { byGraphNode: /* @__PURE__ */ new Map(), lastSent: /* @__PURE__ */ new Map() };
-          this._byContext.set(context, state2);
-        }
-        return state2;
-      }
-      _flush(node, state2, instances) {
-        const labels = [];
-        instances.forEach((label) => labels.push(label));
-        const summary = summariseTargets(labels);
-        if (state2.lastSent.has(node.id) && state2.lastSent.get(node.id) === summary) return;
-        state2.lastSent.set(node.id, summary);
-        const editorConnection = node.context && node.context.editorConnection;
-        if (!editorConnection || !editorConnection.isRunningLocally()) return;
-        if (typeof editorConnection.sendNodeSubLabel !== "function") return;
-        editorConnection.sendNodeSubLabel(node.id, summary);
-      }
-    };
-  }
-});
-
-// ../noodl-runtime/src/foreachitem.ts
-var foreachitem_exports = {};
-__export(foreachitem_exports, {
-  forgetForEachItem: () => forgetForEachItem,
-  resolveForEachItem: () => resolveForEachItem
-});
-function resolveForEachItem(node, options = {}) {
-  const chain2 = scopeChain(node.nodeScope.componentOwner);
-  const wanted = options.target;
-  if (wanted) {
-    const named2 = firstNamed(chain2, wanted);
-    if (!named2) {
-      return miss(
-        node,
-        "repeater-item/target-not-found",
-        'No component named "' + wanted + '" contains this node',
-        wanted,
-        { target: wanted, scope: scopeChainNames(node.nodeScope.componentOwner) }
-      );
-    }
-    if (named2[FOR_EACH_MODEL] === void 0) {
-      return miss(
-        node,
-        "repeater-item/target-has-no-item",
-        'The component "' + wanted + '" has no current item \u2014 it is not used as a Repeater or Run Tasks template',
-        wanted,
-        { target: wanted }
-      );
-    }
-    return hit(node, named2);
-  }
-  const owner = firstWithItem(chain2);
-  if (!owner) {
-    return miss(
-      node,
-      "repeater-item/no-item-in-scope",
-      'Id Source is set to "From repeater", but this node is not inside a Repeater or Run Tasks template',
-      void 0,
-      { scope: scopeChainNames(node.nodeScope.componentOwner) }
-    );
-  }
-  return hit(node, owner);
-}
-function forgetForEachItem(node) {
-  resolvedTargets.forget(node);
-  lastMissByNode.delete(node);
-}
-function firstNamed(chain2, name2) {
-  for (let i2 = 0; i2 < chain2.length; i2++) {
-    if (chain2[i2].name === name2) return chain2[i2];
-  }
-  return void 0;
-}
-function firstWithItem(chain2) {
-  for (let i2 = 0; i2 < chain2.length; i2++) {
-    if (chain2[i2][FOR_EACH_MODEL] !== void 0) return chain2[i2];
-  }
-  return void 0;
-}
-function hit(node, owner) {
-  lastMissByNode.delete(node);
-  resolvedTargets.report(node, owner.name);
-  return owner[FOR_EACH_MODEL];
-}
-function miss(node, code, message, target, detail) {
-  resolvedTargets.report(node, void 0);
-  const seen = code + "|" + (target || "");
-  if (lastMissByNode.get(node) !== seen) {
-    lastMissByNode.set(node, seen);
-    node.raiseRuntimeError(code, message, detail);
-  }
-  return void 0;
-}
-var FOR_EACH_MODEL, resolvedTargets, lastMissByNode;
-var init_foreachitem = __esm({
-  "../noodl-runtime/src/foreachitem.ts"() {
-    "use strict";
-    init_componentwalk();
-    init_resolvedtarget();
-    FOR_EACH_MODEL = "_forEachModel";
-    resolvedTargets = new ResolvedTargetReporter();
-    lastMissByNode = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// ../noodl-runtime/src/javascriptnodeparser.js
-var require_javascriptnodeparser = __commonJS({
-  "../noodl-runtime/src/javascriptnodeparser.js"(exports2, module2) {
-    "use strict";
-    var Model27 = require_model2();
-    var { getAbsoluteUrl: getAbsoluteUrl2 } = (init_utils(), __toCommonJS(utils_exports));
-    var { findAncestorWithComponentObject: findAncestorWithComponentObject2 } = (init_componentwalk(), __toCommonJS(componentwalk_exports));
-    var { resolveForEachItem: resolveForEachItem2 } = (init_foreachitem(), __toCommonJS(foreachitem_exports));
-    var userFunctionsCache = {};
-    function JavascriptNodeParser4(code, options) {
-      this.inputs = {};
-      this.outputs = {};
-      this.error = void 0;
-      this.code = code;
-      const node = options ? options.node : void 0;
-      this._initializeAPIs();
-      var userCode = userFunctionsCache[code];
-      if (!userCode) {
-        try {
-          userCode = new Function(["define", "script", "Node", "Component"], JavascriptNodeParser4.getCodePrefix() + code);
-          userFunctionsCache[code] = userCode;
-        } catch (e) {
-          this.error = e.message;
-          console.error(e);
-        }
-      }
-      if (userCode) {
-        try {
-          userCode(
-            this.define.bind(this),
-            this.script.bind(this),
-            this.apis.Node,
-            node ? JavascriptNodeParser4.getComponentScopeForNode(node) : {}
-          );
-          this._afterSourced();
-        } catch (e) {
-          this.error = e.message;
-          console.error(e);
-        }
-      }
-    }
-    JavascriptNodeParser4.prototype.define = function(userObject) {
-      this.inputs = userObject.inputs || {};
-      this.outputs = userObject.outputs || {};
-      this.setup = userObject.setup;
-      this.change = userObject.run || userObject.change;
-      this.destroy = userObject.destroy;
-      this.definedObject = userObject;
-    };
-    function _scriptExtend(_this) {
-      var _extended = {
-        inputs: _this.inputs || {},
-        outputs: _this.outputs || {},
-        setup: function(inputs, outputs) {
-          this.inputs = inputs;
-          this.outputs = outputs;
-          this.setOutputs = function(states) {
-            for (var key3 in states) {
-              this.outputs[key3] = states[key3];
-              this.flagOutputDirty(key3);
-            }
-          };
-          if (_this.methods) {
-            for (var key2 in _this.methods) {
-              this[key2] = _this.methods[key2];
-            }
-          }
-          _this.setup && _this.setup.apply(this);
-        },
-        destroy: function(inputs, outputs) {
-          this.inputs = inputs;
-          this.outputs = outputs;
-          _this.destroy && _this.destroy.apply(this);
-        },
-        change: function(inputs, outputs) {
-          this.inputs = inputs;
-          this.outputs = outputs;
-          var old = this._oldInputs || {};
-          if (_this.changed) {
-            for (var key2 in inputs) {
-              if (inputs[key2] !== old[key2]) {
-                var changedFunction = _this.changed[key2];
-                if (typeof changedFunction === "function") changedFunction.apply(this, [inputs[key2], old[key2]]);
-              }
-            }
-          }
-          this._oldInputs = Object.assign({}, inputs);
-        }
-      };
-      if (_this.signals) {
-        for (var key in _this.signals) {
-          _extended[key] = _this.signals[key];
-          _extended.inputs[key] = "signal";
-        }
-      }
-      return _extended;
-    }
-    JavascriptNodeParser4.prototype.script = function(userObject) {
-      var _userObjectExtended = _scriptExtend(userObject);
-      this.inputs = _userObjectExtended.inputs || {};
-      this.outputs = _userObjectExtended.outputs || {};
-      this.setup = _userObjectExtended.setup;
-      this.change = _userObjectExtended.run || _userObjectExtended.change;
-      this.destroy = _userObjectExtended.destroy;
-      this.definedObject = _userObjectExtended;
-    };
-    JavascriptNodeParser4.prototype._initializeAPIs = function() {
-      this.apis = {
-        Node: {
-          Inputs: {},
-          Outputs: {},
-          Signals: {},
-          Setters: {}
-        }
-      };
-    };
-    JavascriptNodeParser4.prototype._afterSourced = function() {
-      if (this.definedObject !== void 0) return;
-      var _Node = this.apis.Node;
-      this.inputs = Object.assign({}, _Node.Inputs || {});
-      this.outputs = Object.assign({}, _Node.Outputs || {});
-      this.setup = function(inputs, outputs) {
-        const _this = this;
-        _Node.setOutputs = function(_outputs) {
-          for (var key2 in _outputs) {
-            outputs[key2] = _outputs[key2];
-            _this.flagOutputDirty(key2);
-          }
-        };
-        _Node.OnInit && _Node.OnInit.apply(this);
-      };
-      this.destroy = _Node.OnDestroy || this.destory;
-      this.change = (inputs, outputs, changedInputs) => {
-        for (var key2 in changedInputs) {
-          if (typeof _Node.Setters[key2] === "function") {
-            _Node.Setters[key2](inputs[key2]);
-          }
-        }
-        if (typeof _Node.OnInputsChanged === "function") {
-          _Node.OnInputsChanged();
-        }
-      };
-      this.definedObject = {
-        inputs: this.inputs,
-        outputs: this.outputs,
-        setup: this.setup,
-        destroy: this.destroy,
-        change: this.change
-      };
-      if (_Node.Signals !== void 0) {
-        for (var key in _Node.Signals) {
-          if (typeof _Node.Signals[key] === "function") {
-            this.inputs[key] = "signal";
-            this.definedObject[key] = _Node.Signals[key];
-          }
-        }
-      }
-    };
-    JavascriptNodeParser4.createFromCode = function(code, options) {
-      return new JavascriptNodeParser4(code, options);
-    };
-    function failedParser(message) {
-      var parser = Object.create(JavascriptNodeParser4.prototype);
-      parser.inputs = {};
-      parser.outputs = {};
-      parser.error = message;
-      parser.code = void 0;
-      parser.apis = { Node: {} };
-      return parser;
-    }
-    JavascriptNodeParser4.createFromURL = function(url, callback, options) {
-      url = getAbsoluteUrl2(url);
-      var settled = false;
-      function settle(parser) {
-        if (settled) return;
-        settled = true;
-        callback(parser);
-      }
-      var xhr = new window.XMLHttpRequest();
-      xhr.open("GET", url, true);
-      xhr.onreadystatechange = function() {
-        if (this.readyState === 4 || this.readyState === XMLHttpRequest.DONE) {
-          if (this.status !== 0 && (this.status < 200 || this.status >= 300)) {
-            settle(failedParser('Could not load "' + url + '": the server answered ' + this.status));
-            return;
-          }
-          if (this.status === 0) {
-            settle(failedParser('Could not load "' + url + '": the request failed'));
-            return;
-          }
-          settle(new JavascriptNodeParser4(this.response, options));
-        }
-      };
-      xhr.onerror = function() {
-        settle(failedParser('Could not load "' + url + '": the request failed'));
-      };
-      xhr.send();
-    };
-    JavascriptNodeParser4.parseAndAddPortsFromScript = function(script, ports, options) {
-      function _exists(port) {
-        if (typeof port === "string") return ports.find((p) => p.name === port) !== void 0;
-        else return ports.find((p) => p.name === port.name && p.plug === port.plug) !== void 0;
-      }
-      function _addPortsFromMatch(match, options2) {
-        if (match === void 0 || match === null) return;
-        const unique = {};
-        for (const _s of match) {
-          let name2 = _s[1];
-          if (name2 === void 0) continue;
-          unique[name2] = true;
-        }
-        Object.keys(unique).forEach((p) => {
-          if (_exists({
-            name: options2.prefix + p,
-            plug: options2.plug
-          }))
-            return;
-          ports.push({
-            name: options2.prefix + p,
-            displayName: p,
-            plug: options2.plug,
-            type: options2.type,
-            group: options2.group
-          });
-        });
-      }
-      if (!options.skipInputs) {
-        _addPortsFromMatch(script.matchAll(/Inputs\.([A-Za-z0-9_]+)/g), {
-          type: options.inputType || "*",
-          plug: "input",
-          group: options.inputGroup || "Inputs",
-          prefix: options.inputPrefix || ""
-        });
-        _addPortsFromMatch(script.matchAll(/Inputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]/g), {
-          type: options.inputType || "*",
-          plug: "inputs",
-          group: options.inputGroup || "Inputs",
-          prefix: options.inputPrefix || ""
-        });
-      }
-      if (!options.skipOutputs) {
-        if (!options.skipOutputSignals) {
-          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9]+)\s*\(\s*\)/g), {
-            type: "signal",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*(?:'|")(.*)(?:'|")\s*\]\(\s*\)/g), {
-            type: "signal",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-        }
-        if (!options.skipRegularOutputs) {
-          _addPortsFromMatch(script.matchAll(/Outputs\.([A-Za-z0-9_]+)/g), {
-            type: "*",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-          _addPortsFromMatch(script.matchAll(/Outputs\s*\[\s*\"([^\"]*)\"\s*\]/g), {
-            type: "*",
-            plug: "output",
-            group: "Outputs",
-            prefix: options.outputPrefix || ""
-          });
-        }
-      }
-    };
-    JavascriptNodeParser4.prototype.getPorts = function() {
-      var ports = [];
-      var self2 = this;
-      Object.keys(this.inputs).forEach(function(name2) {
-        var inputPort = self2.inputs[name2];
-        var port = {
-          name: name2,
-          plug: "input"
-        };
-        if (typeof inputPort === "string") {
-          port.type = {
-            name: inputPort
-          };
-          port.group = "Inputs";
-        } else {
-          for (var p in inputPort) {
-            port[p] = inputPort[p];
-          }
-        }
-        ports.push(port);
-      });
-      Object.keys(this.outputs).forEach(function(name2) {
-        ports.push({
-          name: name2,
-          type: {
-            name: self2.outputs[name2]
-          },
-          plug: "output",
-          group: "Outputs"
-        });
-      });
-      JavascriptNodeParser4.parseAndAddPortsFromScript(this.code, ports, {});
-      return ports;
-    };
-    var _componentScopes = {};
-    function _findParentComponentStateModelId(node) {
-      const parent = findAncestorWithComponentObject2(node.nodeScope.componentOwner);
-      if (!parent) return;
-      return "componentState" + parent.getInstanceId();
-    }
-    JavascriptNodeParser4.getComponentScopeForNode = function(node) {
-      const componentId = node.nodeScope.componentOwner.getInstanceId();
-      if (_componentScopes[componentId] === void 0) {
-        _componentScopes[componentId] = {};
-        const componentObject = (node.nodeScope.modelScope || Model27).get("componentState" + componentId);
-        _componentScopes[componentId].Object = componentObject;
-      }
-      const parentComponentObjectId = _findParentComponentStateModelId(node);
-      const parentComponentObject = parentComponentObjectId !== void 0 ? (node.nodeScope.modelScope || Model27).get(parentComponentObjectId) : void 0;
-      _componentScopes[componentId].ParentObject = parentComponentObject;
-      Object.defineProperty(_componentScopes[componentId], "RepeaterObject", {
-        configurable: true,
-        enumerable: true,
-        get: function() {
-          return resolveForEachItem2(node);
-        }
-      });
-      return _componentScopes[componentId];
-    };
-    JavascriptNodeParser4.getCodePrefix = function() {
-      return "const Script = (typeof Node !== 'undefined')?Node:undefined;\n";
-    };
-    JavascriptNodeParser4.createNoodlAPI = function() {
-      return typeof window !== "undefined" && window.Noodl !== void 0 ? window.Noodl : {};
-    };
-    module2.exports = JavascriptNodeParser4;
-  }
-});
-
 // ../noodl-runtime/src/nodes/std-library/expression.ts
 var require_expression = __commonJS({
   "../noodl-runtime/src/nodes/std-library/expression.ts"(exports2, module2) {
     "use strict";
     init_expression_ports();
     init_logic_search_tags();
+    init_printedcode();
     init_outcome();
     init_run_on_value_change();
     var Node17 = require_node2();
@@ -26580,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;
@@ -26616,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;
@@ -26815,17 +26946,7 @@ var require_expression = __commonJS({
         }
       }
     };
-    var functionPreamble = [
-      'var min = Math.min,    max = Math.max,    cos = Math.cos,    sin = Math.sin,    tan = Math.tan,    sqrt = Math.sqrt,    pi = Math.PI,    round = Math.round,    floor = Math.floor,    ceil = Math.ceil,    abs = Math.abs,    random = Math.random,    pow = Math.pow,    log = Math.log,    exp = Math.exp;try {  var NoodlContext = (typeof Noodl !== "undefined") ? Noodl : (typeof global !== "undefined" && global.Noodl) || {};  var Variables = NoodlContext.Variables || {};  var Objects = NoodlContext.Objects || {};  var Arrays = NoodlContext.Arrays || {};} catch (e) {  var Variables = {}, Objects = {}, Arrays = {};}'
-    ].join("");
     var NOT_EVALUATED = {};
-    function construct(constructor, args) {
-      function F() {
-        return constructor.apply(this, args);
-      }
-      F.prototype = constructor.prototype;
-      return new F();
-    }
     var compiledFunctionsCache2 = {};
     function reservedNameMessage(names) {
       const list = names.length > 1 ? names.slice(0, -1).join(", ") + " and " + names[names.length - 1] : names.join("");
@@ -26929,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",
@@ -26987,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];
@@ -27196,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));
@@ -27722,16 +27844,7 @@ var require_simplejavascript = __commonJS({
         parseScript: function(script) {
           let func;
           try {
-            const AsyncFunction = Object.getPrototypeOf(async function() {
-            }).constructor;
-            func = new AsyncFunction(
-              "Inputs",
-              "Outputs",
-              "Noodl",
-              "Component",
-              "Scripts",
-              JavascriptNodeParser4.getCodePrefix() + script
-            );
+            func = compileCode(FUNCTION_NODE_PARAMS, functionNodeBody(script), { async: true });
             this._internal.parseError = void 0;
             this._internal.lastReportedError = void 0;
           } catch (e) {
@@ -27799,9 +27912,9 @@ var require_simplejavascript = __commonJS({
         return;
       }
       try {
-        const AsyncFunction = Object.getPrototypeOf(async function() {
+        const AsyncFunction2 = Object.getPrototypeOf(async function() {
         }).constructor;
-        new AsyncFunction("Inputs", "Outputs", "Noodl", "Component", script);
+        new AsyncFunction2("Inputs", "Outputs", "Noodl", "Component", script);
         context.editorConnection.clearWarning(node.component.name, node.id, "js-function-parse-waring");
       } catch (e) {
         context.editorConnection.sendWarning(node.component.name, node.id, "js-function-parse-waring", {
@@ -28304,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 = {
@@ -28658,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;
@@ -30148,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({
@@ -30809,6 +30925,19 @@ function recordFieldPorts(ctx, options) {
   }
   return ports;
 }
+function recordBuiltInDatePorts(ctx, existingPorts, options = {}) {
+  if (!ctx.selectedCollection || !isParseWireContext(ctx)) return [];
+  const have = new Set(existingPorts.map((port) => port.name));
+  const ports = [];
+  for (const field of RECORD_BUILT_IN_DATES) {
+    if (have.has(`prop-${field}`)) continue;
+    ports.push({ name: `prop-${field}`, displayName: field, type: { name: "date" }, plug: "output", group: "Properties" });
+    if (options.includeChangedSignals && !have.has(`changed-${field}`)) {
+      ports.push({ name: `changed-${field}`, displayName: `${field} Changed`, type: "signal", plug: "output", group: "Events" });
+    }
+  }
+  return ports;
+}
 function recordPortType(field) {
   if (field.nativeType && Object.prototype.hasOwnProperty.call(PARSE_PORT_TYPES, field.nativeType)) {
     return { name: PARSE_PORT_TYPES[field.nativeType] };
@@ -30919,7 +31048,7 @@ function parseTypeNameFor(field) {
 function recordFilterBackendType(ctx, fallback) {
   return ctx.backendType || fallback;
 }
-var PARSE_PORT_TYPES, PARSE_SYSTEM_CLASSES;
+var PARSE_PORT_TYPES, PARSE_SYSTEM_CLASSES, RECORD_BUILT_IN_DATES;
 var init_record_ports = __esm({
   "../noodl-runtime/src/nodes/std-library/data/record-ports.ts"() {
     init_resolveBackend_pure();
@@ -30934,6 +31063,7 @@ var init_record_ports = __esm({
       { label: "User", value: "_User" },
       { label: "Role", value: "_Role" }
     ]);
+    RECORD_BUILT_IN_DATES = Object.freeze(["createdAt", "updatedAt"]);
   }
 });
 
@@ -31233,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)) {
@@ -31246,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;
@@ -31264,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
@@ -31278,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",
@@ -31286,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" }
       });
@@ -31560,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({
@@ -33060,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") {
@@ -33080,12 +33210,12 @@ function whenTargetGoesProblems(table, columns) {
 }
 function rulesByTarget(schema) {
   const out = /* @__PURE__ */ new Map();
-  for (const table of schema.listTables()) {
-    for (const col of schema.getTableSchema(table)?.columns || []) {
+  for (const table2 of schema.listTables()) {
+    for (const col of schema.getTableSchema(table2)?.columns || []) {
       const rule = col.whenTargetGoes;
       if (col.type !== "Pointer" || !col.targetClass || !rule || !WHEN_TARGET_GOES.includes(rule)) continue;
       const list = out.get(col.targetClass) || [];
-      list.push({ collection: table, field: col.name, rule });
+      list.push({ collection: table2, field: col.name, rule });
       out.set(col.targetClass, list);
     }
   }
@@ -33093,18 +33223,18 @@ function rulesByTarget(schema) {
 }
 function relations(schema) {
   const out = [];
-  for (const table of schema.listTables())
-    for (const col of schema.getTableSchema(table)?.columns || []) if (col.type === "Relation") out.push([table, col.name, col.targetClass || ""]);
+  for (const table2 of schema.listTables())
+    for (const col of schema.getTableSchema(table2)?.columns || []) if (col.type === "Relation") out.push([table2, col.name, col.targetClass || ""]);
   return out;
 }
 function pairsOf(rels, schema, collection, objectId) {
   const out = [];
-  for (const [table, field, target] of rels) {
-    if (table === collection) {
-      const ids = schema.getRelatedIds(table, objectId, field);
-      for (const relatedId of Array.isArray(ids) ? ids : []) out.push({ collection: table, objectId, field, relatedId: String(relatedId) });
+  for (const [table2, field, target] of rels) {
+    if (table2 === collection) {
+      const ids = schema.getRelatedIds(table2, objectId, field);
+      for (const relatedId of Array.isArray(ids) ? ids : []) out.push({ collection: table2, objectId, field, relatedId: String(relatedId) });
     }
-    if (target === collection) for (const owner of schema.getRelationOwners(table, field, objectId)) out.push({ collection: table, objectId: owner, field, relatedId: objectId });
+    if (target === collection) for (const owner of schema.getRelationOwners(table2, field, objectId)) out.push({ collection: table2, objectId: owner, field, relatedId: objectId });
   }
   return out;
 }
@@ -33119,7 +33249,7 @@ async function linkedIds(ctx, collection, field, id) {
 async function planDelete(ctx, collection, objectId) {
   const rules2 = rulesByTarget(ctx.schema);
   const rels = relations(ctx.schema);
-  if (!rules2.has(collection) && !rels.some(([table, , target]) => table === collection || target === collection)) return null;
+  if (!rules2.has(collection) && !rels.some(([table2, , target]) => table2 === collection || target === collection)) return null;
   if (await ctx.count(collection, { objectId }) === 0) return null;
   const key = (c, id) => `${c}\0${id}`;
   const gone = [{ collection, objectId }];
@@ -33240,9 +33370,9 @@ function idOf(v) {
   if (typeof v === "string" && v) return v;
   return void 0;
 }
-function targetOf(ctx, table, field) {
-  const col = ctx.schema.getTableSchema(table)?.columns?.find((c) => c.name === field);
-  if (!col?.targetClass) throw new Error(`${table}.${field} is not a link the schema knows the target of`);
+function targetOf(ctx, table2, field) {
+  const col = ctx.schema.getTableSchema(table2)?.columns?.find((c) => c.name === field);
+  if (!col?.targetClass) throw new Error(`${table2}.${field} is not a link the schema knows the target of`);
   return col.targetClass;
 }
 async function dryRunMigration(ctx, plan) {
@@ -33937,7 +34067,8 @@ var init_ParseWireAdapter = __esm({
             runId !== void 0 ? { "X-NodeGX-Run": runId } : {},
             options.headers || {}
           );
-          fetch(endpoint + path8, {
+          const send = typeof _noodl_cloudservices !== "undefined" && _noodl_cloudservices.fetch ? _noodl_cloudservices.fetch : fetch;
+          send(endpoint + path8, {
             method: options.method || "GET",
             headers,
             body: JSON.stringify(options.content)
@@ -33992,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);
           }
         });
       }
@@ -35272,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 {
@@ -37609,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
           }
         );
       }
@@ -39158,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) {
@@ -39244,14 +39388,14 @@ var require_cloudstore = __commonJS({
     function _fromJSON(item, collectionName2, modelScope) {
       const m = (modelScope || Model27).get(item.objectId);
       m._class = collectionName2;
-      if (collectionName2 !== void 0 && CloudStore7._collections[collectionName2] !== void 0)
-        var schema = CloudStore7._collections[collectionName2].schema;
+      var schema = _schemaOf(collectionName2);
       for (var key in item) {
         if (key === "objectId" || key === "ACL") continue;
         var _type = schema && schema.properties && schema.properties[key] ? schema.properties[key].type : void 0;
         if (_type === void 0 && item[key] && item[key].__type === "Pointer" && item[key].objectId !== void 0) {
           _type = "Pointer";
         }
+        if (_type === void 0 && (key === "createdAt" || key === "updatedAt")) _type = "Date";
         const value2 = _deserializeJSON(item[key], _type, modelScope);
         if (Array.isArray(value2) && sameList(m.get(key), value2)) continue;
         m.set(key, value2);
@@ -39468,8 +39612,19 @@ function convertVisualFilter(query, options) {
   });
   return Object.keys(where2).length === 0 ? void 0 : where2;
 }
+function instantOf(operand) {
+  let at;
+  if (operand instanceof Date) at = operand.getTime();
+  else if (operand && operand.__type === "Date" && typeof operand.iso === "string") at = Date.parse(operand.iso);
+  else if (typeof operand === "string") at = Date.parse(operand);
+  return at === void 0 || Number.isNaN(at) ? void 0 : at;
+}
 function matchesOperator(value2, op, condition) {
   const operand = condition[op];
+  if (value2 instanceof Date && Object.prototype.hasOwnProperty.call(DATE_COMPARISONS, op)) {
+    const at = instantOf(operand);
+    if (at !== void 0) return DATE_COMPARISONS[op](value2.getTime(), at);
+  }
   switch (op) {
     case "$eq":
       return operand && operand.__type === "Pointer" ? value2 === operand.objectId : value2 == operand;
@@ -39548,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)
     });
@@ -39561,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
+    };
   }
 });
 
@@ -40148,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.");
             }
           });
@@ -40973,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 = {
@@ -45169,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();
@@ -45287,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);
@@ -47774,12 +47941,12 @@ var require_datetostring = __commonJS({
               if (rendered.indexOf(needle) === -1) return;
               rendered = rendered.split(needle).join(render());
             };
-            const named2 = (options) => new Intl.DateTimeFormat(locale, zone ? { ...options, timeZone: zone } : options).format(t);
+            const named3 = (options) => new Intl.DateTimeFormat(locale, zone ? { ...options, timeZone: zone } : options).format(t);
             const hours12 = (fields.hours + 11) % 12 + 1;
             const meridiem = fields.hours < 12 ? "am" : "pm";
-            substitute("dayName", () => named2({ weekday: "long" }));
-            substitute("dayShort", () => named2({ weekday: "short" }));
-            substitute("monthName", () => named2({ month: "long" }));
+            substitute("dayName", () => named3({ weekday: "long" }));
+            substitute("dayShort", () => named3({ weekday: "short" }));
+            substitute("monthName", () => named3({ month: "long" }));
             substitute("hours12", () => ("0" + hours12).slice(-2));
             substitute("h12", () => String(hours12));
             substitute("ampm", () => meridiem);
@@ -50467,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++;
@@ -51147,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 = [
@@ -51287,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);
         }
@@ -51330,7 +51497,7 @@ function anynum(str2) {
       }
       continue;
     }
-    if (TABLE[cc - TABLE_OFFSET] !== NOT_DIGIT || MINUS_SET.has(cc)) {
+    if (TABLE2[cc - TABLE_OFFSET] !== NOT_DIGIT || MINUS_SET.has(cc)) {
       firstHit = i2;
       break;
     }
@@ -51368,7 +51535,7 @@ function anynum(str2) {
       chars.push("-");
       continue;
     }
-    const d = TABLE[cc - TABLE_OFFSET];
+    const d = TABLE2[cc - TABLE_OFFSET];
     chars.push(d !== NOT_DIGIT ? String.fromCharCode(d + 48) : str2[i2]);
   }
   return chars.join("");
@@ -54316,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();
@@ -57377,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;
 }
@@ -60977,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));
           }
         },
@@ -68312,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);
@@ -72721,8 +72889,8 @@ function readColor(value2, depth = 0) {
   const asVar = VAR_FN.exec(text2);
   if (asVar) {
     if (depth >= 8) return null;
-    const resolved2 = cssVariableValue(asVar[1]);
-    if (resolved2) return readColor(resolved2, depth + 1);
+    const resolved3 = cssVariableValue(asVar[1]);
+    if (resolved3) return readColor(resolved3, depth + 1);
     if (asVar[2] !== void 0) return readColor(asVar[2], depth + 1);
     return null;
   }
@@ -76852,7 +77020,14 @@ var init_TextInput = __esm({
             ref: props.useLabel ? void 0 : noodlRootRef(this.props.noodlNode),
             ...props.useLabel ? void 0 : dataAttributeProps(props.dom),
             style: props.useLabel ? { ...clearedRootStyles(style2), ...inputWrapperStyle } : inputWrapperStyle,
-            "noodl-style-tag": "inputWrapper"
+            "noodl-style-tag": "inputWrapper",
+            onMouseDown: (e) => {
+              const field = this.ref.current;
+              if (!field || !props.enabled || e.button !== 0 || field.contains(e.target)) return;
+              e.preventDefault();
+              window.addEventListener("click", preventGlobalFocusChange, true);
+              this.focus();
+            }
           },
           props.useIcon && props.iconPlacement === "left" ? _renderIcon() : null,
           inputContent,
@@ -82051,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;
@@ -98015,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 + '"', {
@@ -98025,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(
@@ -98035,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) {
@@ -98218,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) {
@@ -100538,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 };
@@ -100958,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;
@@ -101011,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_",
@@ -111609,9 +111786,9 @@ var require_fast_uri = __commonJS({
     }
     function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved2 = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved3 = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
-      return serialize(resolved2, schemelessOptions);
+      return serialize(resolved3, schemelessOptions);
     }
     function resolveComponent(base, relative3, options, skipNormalization) {
       const target = {};
@@ -114922,7 +115099,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@nodegx/preview",
-      version: "0.2.8",
+      version: "0.2.9",
       description: "Standalone live-preview harness: renders a NodeGX (OpenNoodl) v2 project in a browser with no editor process, and reloads it when the files on disk change.",
       license: "GPL-3.0-only",
       homepage: "https://nodegx.io",
@@ -184419,6 +184596,13 @@ var CommentsModel = class extends import_model15.default {
 
 // ../noodl-editor/src/editor/src/models/warningsmodel.ts
 var import_model16 = __toESM(require_model());
+function sameWarning(a, b) {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
 var WarningsModel = class _WarningsModel extends import_model16.default {
   constructor() {
     super();
@@ -184431,13 +184615,23 @@ var WarningsModel = class _WarningsModel extends import_model16.default {
   static {
     this.instance = new _WarningsModel();
   }
+  /**
+   * P132-HIDDENPANELCHURN: a set that changes nothing says nothing. `readNameList` clears its warning on every read,
+   * and the Components panel reads page info (so names) on every `warningsChanged`: when a clear of a warning that was
+   * not there still announced a change, the two fed each other once per `setTimeout(1)`, ~480 times a second, for as
+   * long as a project was open (the panel, the top bar and every mounted dialog re-rendering each time).
+   * The same object set again still announces: its owner may have changed it in place.
+   */
   setWarning(ref, warning) {
     var w = this.getWarningsForRef(ref, warning !== void 0);
     if (!warning) {
-      if (w) delete w[ref.key];
+      if (!w || w[ref.key] === void 0) return;
+      delete w[ref.key];
     } else {
       warning.level = warning.level || "warning";
+      const had = w[ref.key];
       w[ref.key] = { ref, warning };
+      if (had && had.warning !== warning && sameWarning(had.warning, warning)) return;
     }
     this.scheduleNotifyChanged();
   }
@@ -189412,11 +189606,11 @@ var TokenResolver = class _TokenResolver {
     }
     const token = this.tokens.get(tokenName);
     if (!token) return void 0;
-    const resolved2 = this._resolveValue(token.value, depth);
-    if (resolved2 !== void 0) {
-      this.cache.set(tokenName, resolved2);
+    const resolved3 = this._resolveValue(token.value, depth);
+    if (resolved3 !== void 0) {
+      this.cache.set(tokenName, resolved3);
     }
-    return resolved2;
+    return resolved3;
   }
   /**
    * P102 CMP-001 §3 — resolve every `var()` **inside** a value, so a preview can paint it.
@@ -191324,11 +191518,11 @@ var ParameterValueResolver = class {
    * ```
    */
   static toString(paramValue) {
-    const resolved2 = this.resolve(paramValue, "display" /* Display */);
-    if (typeof resolved2 === "object" && resolved2 !== null) {
+    const resolved3 = this.resolve(paramValue, "display" /* Display */);
+    if (typeof resolved3 === "object" && resolved3 !== null) {
       return "";
     }
-    return String(resolved2 ?? "");
+    return String(resolved3 ?? "");
   }
   /**
    * Safely converts any parameter value to a number for display.
@@ -191347,15 +191541,15 @@ var ParameterValueResolver = class {
    * ```
    */
   static toNumber(paramValue) {
-    const resolved2 = this.resolve(paramValue, "display" /* Display */);
-    if (typeof resolved2 === "object" && resolved2 !== null) {
+    const resolved3 = this.resolve(paramValue, "display" /* Display */);
+    if (typeof resolved3 === "object" && resolved3 !== null) {
       return void 0;
     }
     const rawValue = isExpressionParameter(paramValue) ? paramValue.fallback : paramValue;
     if (rawValue === null || rawValue === void 0) {
       return void 0;
     }
-    const num = Number(resolved2);
+    const num = Number(resolved3);
     return isNaN(num) ? void 0 : num;
   }
   /**
@@ -191375,11 +191569,11 @@ var ParameterValueResolver = class {
    * ```
    */
   static toBoolean(paramValue) {
-    const resolved2 = this.resolve(paramValue, "display" /* Display */);
-    if (typeof resolved2 === "object" && resolved2 !== null) {
+    const resolved3 = this.resolve(paramValue, "display" /* Display */);
+    if (typeof resolved3 === "object" && resolved3 !== null) {
       return false;
     }
-    return Boolean(resolved2);
+    return Boolean(resolved3);
   }
   /**
    * Checks if a parameter value is an expression parameter.
@@ -191425,7 +191619,7 @@ var NodeGraphNode = class _NodeGraphNode extends import_model22.default {
   }
   /** Get the label of the node */
   get label() {
-    if (!this._label) return this.type.labelForNode(this);
+    if (!this._label) return this.derivedTitle ?? this.type.labelForNode(this);
     return this._label;
   }
   /** Set the label of the node */
@@ -191433,6 +191627,12 @@ var NodeGraphNode = class _NodeGraphNode extends import_model22.default {
     this._label = value2;
     this.notifyListeners("labelChanged");
   }
+  /** Set the derived title. `undefined` clears it. */
+  setDerivedTitle(title) {
+    if (this.derivedTitle === title) return;
+    this.derivedTitle = title;
+    this.notifyListeners("derivedTitleChanged");
+  }
   /** Set the runtime sub-label. `undefined` clears it. */
   setRuntimeSubLabel(subLabel) {
     if (this.runtimeSubLabel === subLabel) return;
@@ -194046,9 +194246,9 @@ function conditionIsUnsatisfied(condition, params) {
   return result2 === false;
 }
 function resolveAgainstDefaults(params, defaults) {
-  const resolved2 = { ...defaults };
-  for (const [name2, value2] of Object.entries(params)) if (value2 !== void 0) resolved2[name2] = value2;
-  return resolved2;
+  const resolved3 = { ...defaults };
+  for (const [name2, value2] of Object.entries(params)) if (value2 !== void 0) resolved3[name2] = value2;
+  return resolved3;
 }
 function conditionForInput(groups, portName) {
   if (!groups) return void 0;
@@ -194087,6 +194287,7 @@ var NUMBER_WITH_UNIT = /^\s*(-?\d+(?:\.\d+)?)\s*(px|%|vw|vh|em|rem|deg|s|ms)\s*$
 function isPlainObject2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
+var TOKEN_IN_VALUE = /var\(--[A-Za-z0-9_-]+\)/;
 function isTokenReference2(value2) {
   return typeof value2 === "string" && value2.startsWith("var(");
 }
@@ -194158,10 +194359,11 @@ function unitsFormat(type) {
           suggestion: JSON.stringify({ value: Number(parsed[1]), unit: parsed[2] })
         };
       }
+      const token = typeof value2 === "string" ? TOKEN_IN_VALUE.exec(value2)?.[0] : void 0;
       return {
         severity: "error",
-        message: `expects a number or { "value", "unit" } object. Got ${describeValue2(value2)}.`,
-        suggestion: JSON.stringify({ value: 16, unit: unit2 })
+        message: `expects a number, a { "value", "unit" } object or a var(--token) reference. Got ${describeValue2(value2)}.` + (token ? ` This port takes a token alone, not inside an expression: use ${token}, or add a token that holds the size you want.` : ""),
+        suggestion: JSON.stringify(token ?? { value: 16, unit: unit2 })
       };
     }
   };
@@ -194631,13 +194833,13 @@ function checkParameterValues(nodes, catalog, options) {
       });
     }
     if (dynamicSkips.length > 0) {
-      const named2 = dynamicSkips.map((n) => `"${n}"`).join(", ");
+      const named3 = dynamicSkips.map((n) => `"${n}"`).join(", ");
       const rawNote = catalog.dynamicPortNote(node.type) ?? "this node determines ports at runtime";
       const note = /[.!?]$/.test(rawNote.trim()) ? rawNote.trim() : `${rawNote.trim()}.`;
       diagnostics.push({
         code: "dynamic-port-skipped" /* DynamicPortSkipped */,
         severity: "info",
-        message: `${dynamicSkips.length === 1 ? "Parameter" : "Parameters"} ${named2} on ${node.type} ${dynamicSkips.length === 1 ? "names" : "name"} no port the catalog can see, and ${dynamicSkips.length === 1 ? "it was" : "they were"} not checked: ` + note + " So this node is unverified by that check rather than verified as correct.",
+        message: `${dynamicSkips.length === 1 ? "Parameter" : "Parameters"} ${named3} on ${node.type} ${dynamicSkips.length === 1 ? "names" : "name"} no port the catalog can see, and ${dynamicSkips.length === 1 ? "it was" : "they were"} not checked: ` + note + " So this node is unverified by that check rather than verified as correct.",
         location: {
           component,
           nodeId: node.id,
@@ -194832,8 +195034,8 @@ function parentAxis(parent, catalog) {
   const declared2 = PARENT_MAIN_AXIS[parent.type];
   if (declared2 === void 0) return void 0;
   if (declared2 !== "fromFlexDirection") return declared2;
-  const resolved2 = resolveAgainstDefaults(parent.parameters ?? {}, catalog.inputDefaults(parent.type));
-  const flexDirection = resolved2["flexDirection"];
+  const resolved3 = resolveAgainstDefaults(parent.parameters ?? {}, catalog.inputDefaults(parent.type));
+  const flexDirection = resolved3["flexDirection"];
   if (flexDirection === "row") return "row";
   if (flexDirection === "column" || flexDirection === void 0) return "column";
   return void 0;
@@ -196476,9 +196678,9 @@ var dialogWithoutName = {
         if (typeof accessibleName === "string" && accessibleName.trim() !== "") continue;
         const target = node.parameters?.target;
         if (typeof target !== "string" || target.trim() === "") continue;
-        const resolved2 = byName.has(target) ? target : void 0;
-        if (resolved2 === void 0) continue;
-        if (subtreeHasHeading(resolved2, byName, /* @__PURE__ */ new Set())) continue;
+        const resolved3 = byName.has(target) ? target : void 0;
+        if (resolved3 === void 0) continue;
+        if (subtreeHasHeading(resolved3, byName, /* @__PURE__ */ new Set())) continue;
         diagnostics.push({
           code: "dialog-without-name" /* DialogWithoutName */,
           severity: "warning",
@@ -196660,9 +196862,9 @@ var CODE_PREFIX = "const Script = (typeof Node !== 'undefined')?Node:undefined;\
 var PARAMS2 = ["Inputs", "Outputs", "Noodl", "Component", "Scripts"];
 function functionScriptCompileError(script) {
   try {
-    const AsyncFunction = Object.getPrototypeOf(async function() {
+    const AsyncFunction2 = Object.getPrototypeOf(async function() {
     }).constructor;
-    new AsyncFunction(...PARAMS2, CODE_PREFIX + script);
+    new AsyncFunction2(...PARAMS2, CODE_PREFIX + script);
     return void 0;
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
@@ -197029,6 +197231,90 @@ var rowOfWordsFillsItsColumn = {
   }
 };
 
+// ../noodl-editor/src/editor/src/validation/rules/bandWithoutShell.ts
+var GROUP2 = "Group";
+var resolved2 = (node, catalog) => resolveAgainstDefaults(node.parameters ?? {}, catalog.inputDefaults(node.type));
+var named2 = (nodes) => nodes.slice(0, 4).map((n) => n.label ? `"${n.label}"` : n.type).join(", ") + (nodes.length > 4 ? ", \u2026" : "");
+var isSet2 = (value2) => value2 !== void 0 && value2 !== null && value2 !== "" && value2 !== 0;
+function isFullWidth(value2) {
+  if (widthIsPercentage(value2) !== true) return false;
+  const n = typeof value2 === "object" && value2 !== null ? value2.value : parseFloat(String(value2));
+  return Number(n) >= 100;
+}
+function spans(params) {
+  return isFullWidth(params["width"]) && !isSet2(params["maxWidth"]) && !isSet2(params["paddingLeft"]) && !isSet2(params["paddingRight"]);
+}
+var isCard = (params) => isSet2(params["borderRadius"]) || painted(params["borderStyle"]);
+var SECTION_ELEMENTS = /* @__PURE__ */ new Set(["section", "header", "footer"]);
+var painted = (value2) => isSet2(value2) && value2 !== "transparent" && value2 !== "none";
+function isBand(node, catalog) {
+  if (node.type !== GROUP2) return false;
+  const params = resolved2(node, catalog);
+  if (!spans(params)) return false;
+  if ((params["flexDirection"] ?? "column") !== "column") return false;
+  if (params["alignItems"] !== "center") return false;
+  if (params["position"] === "absolute" || params["position"] === "fixed") return false;
+  if (isCard(params)) return false;
+  return isSet2(params["paddingTop"]) || isSet2(params["paddingBottom"]) || painted(params["backgroundColor"]) || painted(params["backgroundGradient"]) || painted(params["backgroundImage"]) || SECTION_ELEMENTS.has(String(params["as"] ?? ""));
+}
+var bandWithoutShell = {
+  code: "band-without-shell" /* BandWithoutShell */,
+  description: "A full-width band holds its content directly instead of inside one shell, so the content runs to the window edge.",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    for (const { component, nodeById } of ctx.components) {
+      const inFlowChildren2 = (parent) => (parent.children ?? []).map((id) => nodeById.get(id)).filter((n) => {
+        if (!n) return false;
+        if (isComponentRef(n.type)) return true;
+        if (!ctx.catalog.getNode(n.type)?.isVisual) return false;
+        const p = resolved2(n, ctx.catalog);
+        return p["position"] !== "absolute" && p["position"] !== "fixed";
+      });
+      const guarded = (n, depth = 0) => {
+        if (isComponentRef(n.type)) return true;
+        if (n.type !== GROUP2) return false;
+        const p = resolved2(n, ctx.catalog);
+        if (isSet2(p["maxWidth"]) || isSet2(p["paddingLeft"]) || isSet2(p["paddingRight"])) return true;
+        const kids = inFlowChildren2(n);
+        return depth < 4 && kids.length > 0 && kids.every((k) => guarded(k, depth + 1));
+      };
+      for (const band of component.nodes) {
+        if (!isBand(band, ctx.catalog)) continue;
+        let placed = true;
+        for (let up = band.parent ? nodeById.get(band.parent) : void 0; up; up = up.parent ? nodeById.get(up.parent) : void 0) {
+          if (up.type === "Page") break;
+          const p = up.type === GROUP2 ? resolved2(up, ctx.catalog) : void 0;
+          if (!p || !spans(p) || isCard(p)) {
+            placed = false;
+            break;
+          }
+        }
+        if (!placed) continue;
+        const inside = inFlowChildren2(band);
+        if (inside.length === 0) continue;
+        if (inside.some((n) => isBand(n, ctx.catalog))) continue;
+        const bare = inside.filter((n) => !guarded(n));
+        if (bare.length === 0) continue;
+        const what = bare.length === inside.length && inside.length > 1 ? `it holds ${inside.length} things directly (${named2(inside)}) instead of one shell` : `${named2(bare)} ${bare.length === 1 ? "sits" : "sit"} in it outside a shell`;
+        out.push({
+          code: "band-without-shell" /* BandWithoutShell */,
+          severity: "warning",
+          message: `This is a full-width band (a section of the page), but ${what}, so its words and pictures run to the edge of the window on a desktop. Put everything it holds inside ONE Group with the style vocabulary's "shell" look (maxWidth 1200px, paddingLeft and paddingRight var(--space-6), sizeMode contentHeight), and make that Group the band's only child.`,
+          location: {
+            component: component.name,
+            nodeId: band.id,
+            nodeType: band.type,
+            ...band.label ? { nodeLabel: band.label } : {}
+          },
+          suggestion: 'one child Group with the "shell" look'
+        });
+      }
+    }
+    return out;
+  }
+};
+
 // ../noodl-editor/src/editor/src/validation/rules/clickAreaHoldsAControl.ts
 var CONTROL_TYPES = /* @__PURE__ */ new Map([
   ["net.noodl.controls.button", "Button"],
@@ -197200,6 +197486,8 @@ var ALL_RULES = [
   // 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
@@ -197429,21 +197717,21 @@ function answering(port) {
   });
 }
 async function keepOwnBackend(projectDir, log2) {
-  const named2 = namedBackend(projectDir);
-  if (!named2) return { first: { state: "none" }, stop: () => void 0 };
+  const named3 = namedBackend(projectDir);
+  if (!named3) return { first: { state: "none" }, stop: () => void 0 };
   const root2 = backendsRoot();
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let child = null;
   let stopped = false;
-  const recordFile = path6.join(root2, named2.id, "runtime.json");
+  const recordFile = path6.join(root2, named3.id, "runtime.json");
   const writeRecord = (pid, entry, name2) => {
     const record = {
       version: 1,
-      backendId: named2.id,
+      backendId: named3.id,
       backendName: name2,
       pid,
-      port: named2.port,
-      endpoint: named2.endpoint,
+      port: named3.port,
+      endpoint: named3.endpoint,
       entry,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       owner: { kind: "preview", pid: process.pid, startedAt, projectDir },
@@ -197462,20 +197750,20 @@ async function keepOwnBackend(projectDir, log2) {
     }
   };
   const look = async () => {
-    const configFile = path6.join(root2, named2.id, "config.json");
-    if (!fs5.existsSync(configFile)) return { state: "missing", id: named2.id, root: root2 };
-    if (child && child.exitCode === null) return { state: "running", id: named2.id, port: named2.port, owner: "this preview" };
-    if (await answering(named2.port)) {
+    const configFile = path6.join(root2, named3.id, "config.json");
+    if (!fs5.existsSync(configFile)) return { state: "missing", id: named3.id, root: root2 };
+    if (child && child.exitCode === null) return { state: "running", id: named3.id, port: named3.port, owner: "this preview" };
+    if (await answering(named3.port)) {
       let owner = "another process";
       try {
         owner = JSON.parse(fs5.readFileSync(recordFile, "utf8"))?.owner?.kind ?? owner;
       } catch {
       }
-      return { state: "running", id: named2.id, port: named2.port, owner };
+      return { state: "running", id: named3.id, port: named3.port, owner };
     }
     const entry = resolveServiceEntry();
-    if (!entry) return { state: "no-service", id: named2.id };
-    let name2 = named2.id;
+    if (!entry) return { state: "no-service", id: named3.id };
+    let name2 = named3.id;
     try {
       name2 = JSON.parse(fs5.readFileSync(configFile, "utf8")).name || name2;
     } catch {
@@ -197484,11 +197772,11 @@ async function keepOwnBackend(projectDir, log2) {
       entry,
       "serve",
       "--data-dir",
-      path6.join(root2, named2.id),
+      path6.join(root2, named3.id),
       "--port",
-      String(named2.port),
+      String(named3.port),
       "--backend-id",
-      named2.id,
+      named3.id,
       "--backend-name",
       name2,
       "--parent-pid",
@@ -197519,7 +197807,7 @@ async function keepOwnBackend(projectDir, log2) {
         proc.kill("SIGKILL");
       } catch {
       }
-      return { state: "failed", id: named2.id, why: ready };
+      return { state: "failed", id: named3.id, why: ready };
     }
     child = proc;
     writeRecord(proc.pid, entry, name2);
@@ -197527,13 +197815,13 @@ async function keepOwnBackend(projectDir, log2) {
       if (ownRecord()) fs5.rmSync(recordFile, { force: true });
       if (!stopped) log2(`  ! the app's backend stopped; looking again in ${HEARTBEAT_MS / 1e3} s`);
     });
-    return { state: "started", id: named2.id, port: named2.port, pid: proc.pid };
+    return { state: "started", id: named3.id, port: named3.port, pid: proc.pid };
   };
   const say = (s, quiet) => {
-    if (s.state === "started") log2(`  \u2713 started the app's backend (${s.id}) on ${named2.endpoint}`);
+    if (s.state === "started") log2(`  \u2713 started the app's backend (${s.id}) on ${named3.endpoint}`);
     else if (s.state === "failed") log2(`  \u2717 the app's backend (${s.id}) did not start: ${s.why}`);
     else if (quiet) return;
-    else if (s.state === "running") log2(`  \u2713 the app's backend (${s.id}) is already running on ${named2.endpoint} (${s.owner})`);
+    else if (s.state === "running") log2(`  \u2713 the app's backend (${s.id}) is already running on ${named3.endpoint} (${s.owner})`);
     else if (s.state === "missing")
       log2(`  ! the app names a backend (${s.id}) that is not on this machine (${s.root}) \u2014 its saves and records will fail`);
     else if (s.state === "no-service") log2(`  ! the app names a backend (${s.id}) but this preview has no backend service to start it with`);