@nodegx/preview 0.2.7 → 0.2.8

package/dist/nodegx-deploy.cjs

@@ -13786,7 +13786,7 @@ var require_common2 = __commonJS({
     exports2.ownProp = ownProp;
     exports2.makeAbs = makeAbs;
     exports2.finish = finish3;
-    exports2.mark = mark;
+    exports2.mark = mark2;
     exports2.isIgnored = isIgnored;
     exports2.childrenIgnored = childrenIgnored;
     function ownProp(obj, field2) {
@@ -13922,7 +13922,7 @@ var require_common2 = __commonJS({
         });
       self2.found = all;
     }
-    function mark(self2, p) {
+    function mark2(self2, p) {
       var abs = makeAbs(self2, p);
       var c = self2.cache[abs];
       var m = p;
@@ -19380,10 +19380,10 @@ var require_nodescope = __commonJS({
       } else {
         const parameters = nodeModel.parameters;
         var inputNames = Object.keys(parameters);
-        const RUN_ON_CHANGE_PREFIX4 = "runOnChange-";
+        const RUN_ON_CHANGE_PREFIX5 = "runOnChange-";
         const metadata = this.context.nodeRegister.hasNode(node.name) ? this.context.nodeRegister.getNodeMetadata(node.name) : void 0;
         const priorityOf = function(name2) {
-          if (name2.indexOf(RUN_ON_CHANGE_PREFIX4) === 0) return Number.MAX_SAFE_INTEGER;
+          if (name2.indexOf(RUN_ON_CHANGE_PREFIX5) === 0) return Number.MAX_SAFE_INTEGER;
           const input2 = metadata ? metadata.inputs[name2] : void 0;
           return input2 ? input2.inputPriority : 0;
         };
@@ -23328,7 +23328,10 @@ var require_nodedefinition = __commonJS({
             node.registerOutput(name2, {
               getter: function() {
                 return void 0;
-              }
+              },
+              onFirstConnectionAdded: output.onFirstConnectionAdded,
+              onLastConnectionRemoved: output.onLastConnectionRemoved
+              // a signal keeps its wire hooks (P121-TWO003)
             });
           } else {
             node.registerOutput(name2, output);
@@ -27291,6 +27294,7 @@ var require_simplejavascript = __commonJS({
       return names2;
     }
     function publishHeldWrites(node) {
+      sendHeldChanges(node);
       node._internal.heldWrites.forEach((prop) => {
         node.registerOutputIfNeeded("out-" + prop);
         node.flagOutputDirty("out-" + prop);
@@ -27334,7 +27338,7 @@ var require_simplejavascript = __commonJS({
             if (value2 !== this._internal.outputValues[prop]) {
               this.registerOutputIfNeeded("out-" + prop);
               this._internal.outputValues[prop] = value2;
-              this.flagOutputDirty("out-" + prop);
+              holdChange(this, prop);
               this._internal.heldWrites.delete(prop);
             } else {
               this._internal.heldWrites.add(prop);
@@ -27513,7 +27517,7 @@ var require_simplejavascript = __commonJS({
           });
         },
         runScript: async function() {
-          const func = this._internal.func;
+          const func = sendingChangesAfterTheSyncPart(this, this._internal.func);
           const tokens = this._internal.pendingRunOutcomes || [];
           this._internal.pendingRunOutcomes = void 0;
           if (func === void 0) {
@@ -27955,6 +27959,32 @@ var require_simplejavascript = __commonJS({
         });
       }
     };
+    function holdChange(node, prop) {
+      const internal2 = node._internal;
+      if (!internal2.heldChanges) internal2.heldChanges = /* @__PURE__ */ new Set();
+      internal2.heldChanges.add(prop);
+      if (internal2.heldChangesQueued) return;
+      internal2.heldChangesQueued = true;
+      Promise.resolve().then(() => sendHeldChanges(node));
+    }
+    function sendHeldChanges(node) {
+      const internal2 = node._internal;
+      internal2.heldChangesQueued = false;
+      const held = internal2.heldChanges;
+      if (!held || held.size === 0 || node._deleted) return;
+      internal2.heldChanges = /* @__PURE__ */ new Set();
+      held.forEach((prop) => node.flagOutputDirty("out-" + prop));
+    }
+    function sendingChangesAfterTheSyncPart(node, func) {
+      if (func === void 0) return void 0;
+      return function(...args) {
+        try {
+          return func.apply(this, args);
+        } finally {
+          sendHeldChanges(node);
+        }
+      };
+    }
     module2.exports = SimpleJavascriptNodeModule;
   }
 });
@@ -69189,6 +69219,133 @@ var init_tooltips = __esm({
   }
 });
 
+// ../noodl-viewer-react/src/keyboard-click.ts
+function holdsPressable(el) {
+  return el.querySelector(PRESSABLE_INSIDE) !== null;
+}
+function clickIsWired(node) {
+  if (!node.hasOutput("onClick")) return false;
+  return reachesSomething(node.getOutput("onClick"), 0);
+}
+function reachesSomething(output, depth) {
+  if (!output.hasConnections()) return false;
+  if (!Array.isArray(output.connections)) return true;
+  return output.connections.some((c) => !goesNowhere(c, depth));
+}
+function goesNowhere(connection, depth) {
+  const target = connection.node;
+  if (!target || target.name !== "Component Outputs" || typeof connection.inputPortName !== "string") return false;
+  const owner = target.nodeScope?.componentOwner;
+  if (!owner || depth > 16 || owner._internal?.creatorCallbacks) return false;
+  if (typeof owner.hasOutput !== "function" || typeof owner.getOutput !== "function") return false;
+  if (!owner.hasOutput(connection.inputPortName)) return true;
+  return !reachesSomething(owner.getOutput(connection.inputPortName), depth + 1);
+}
+function isNativelyInteractive(el) {
+  const tag = el.tagName;
+  if (tag === "BUTTON" || tag === "INPUT" || tag === "SELECT" || tag === "TEXTAREA" || tag === "SUMMARY") return true;
+  if ((tag === "A" || tag === "AREA") && el.hasAttribute("href")) return true;
+  if ((tag === "VIDEO" || tag === "AUDIO") && el.hasAttribute("controls")) return true;
+  return el.isContentEditable === true;
+}
+function isSpace(e) {
+  return e.key === " " || e.key === "Spacebar";
+}
+function isOwnKey(el, e) {
+  return e.target === el && !e.defaultPrevented && !e.altKey && !e.ctrlKey && !e.metaKey && !e.isComposing;
+}
+function mark(el) {
+  let spaceArmed = false;
+  const onKeyDown2 = (e) => {
+    if (!isOwnKey(el, e)) return;
+    if (e.key === "Enter") {
+      e.preventDefault();
+      if (!e.repeat) el.click();
+    } else if (isSpace(e)) {
+      e.preventDefault();
+      if (!e.repeat) spaceArmed = true;
+    }
+  };
+  const onKeyUp = (e) => {
+    if (!isSpace(e)) return;
+    const armed6 = spaceArmed;
+    spaceArmed = false;
+    if (armed6 && e.target === el && !e.defaultPrevented) el.click();
+  };
+  const m = { el, added: [], onKeyDown: onKeyDown2, onKeyUp, observer: null };
+  if (isNativelyInteractive(el)) return m;
+  refresh(m);
+  if (typeof MutationObserver !== "undefined") {
+    m.observer = new MutationObserver(() => refresh(m));
+    m.observer.observe(el, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["tabindex", "contenteditable", "href", "controls", "type"]
+    });
+  }
+  return m;
+}
+function refresh(m) {
+  const { el } = m;
+  const want = !holdsPressable(el);
+  if (want && !m.added.length) {
+    if (!el.hasAttribute("tabindex")) {
+      el.setAttribute("tabindex", "0");
+      m.added.push("tabindex");
+    }
+    if (!el.hasAttribute("role")) {
+      el.setAttribute("role", "button");
+      m.added.push("role");
+    }
+    if (m.added.length) {
+      el.setAttribute(KEYBOARD_CLICK_ATTRIBUTE, "");
+      m.added.push(KEYBOARD_CLICK_ATTRIBUTE);
+      el.addEventListener("keydown", m.onKeyDown);
+      el.addEventListener("keyup", m.onKeyUp);
+    }
+  } else if (!want && m.added.length) {
+    giveBack(m);
+  }
+}
+function giveBack(m) {
+  for (const name2 of m.added) m.el.removeAttribute(name2);
+  m.added = [];
+  m.el.removeEventListener("keydown", m.onKeyDown);
+  m.el.removeEventListener("keyup", m.onKeyUp);
+}
+function unmark(m) {
+  m.observer?.disconnect();
+  giveBack(m);
+}
+function syncKeyboardClick(node) {
+  const el = typeof node.getDOMElement === "function" ? node.getDOMElement() : null;
+  const want = el && clickIsWired(node) ? el : null;
+  const was = marked.get(node);
+  if (was && was.el === want) return;
+  if (was) {
+    unmark(was);
+    marked.delete(node);
+  }
+  if (want) marked.set(node, mark(want));
+}
+var KEYBOARD_CLICK_ATTRIBUTE, PRESSABLE_INSIDE, marked, KEYBOARD_CLICK_HOOKS;
+var init_keyboard_click = __esm({
+  "../noodl-viewer-react/src/keyboard-click.ts"() {
+    KEYBOARD_CLICK_ATTRIBUTE = "data-ndl-keyboard-click";
+    PRESSABLE_INSIDE = 'button, input:not([type="hidden"]), select, textarea, summary, a[href], area[href], video[controls], audio[controls], [contenteditable=""], [contenteditable="true"], [tabindex]:not([tabindex="-1"])';
+    marked = /* @__PURE__ */ new WeakMap();
+    KEYBOARD_CLICK_HOOKS = {
+      onFirstConnectionAdded() {
+        syncKeyboardClick(this);
+      },
+      onLastConnectionRemoved() {
+        syncKeyboardClick(this);
+      }
+    };
+  }
+});
+
 // ../noodl-viewer-react/src/node-shared-port-definitions.ts
 function humanCorner(suffix) {
   return suffix.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
@@ -69456,6 +69613,7 @@ var init_node_shared_port_definitions = __esm({
     init_fontloader();
     init_media_source();
     init_tooltips();
+    init_keyboard_click();
     SIZE_MODES = ["explicit", "contentWidth", "contentHeight", "contentSize"];
     node_shared_port_definitions_default = {
       addInputProps: addInputProps2,
@@ -69963,7 +70121,9 @@ var init_node_shared_port_definitions = __esm({
             description: "Fires when this element is clicked or tapped",
             group: "Events",
             type: "signal",
-            propPath: "pointer"
+            propPath: "pointer",
+            ...KEYBOARD_CLICK_HOOKS
+            // P121-TWO003-GROUPKEYBOARD: wired, the element is a button to Tab and a screen reader
           },
           pointerDown: {
             displayName: "Pointer Down",
@@ -73684,6 +73844,7 @@ function createNodeFromReactComponent(def2) {
         }
         if (element) syncDataAttributesOnElement(this);
         if (element) elementChanged(this, element);
+        syncKeyboardClick(this);
       },
       /**
        * NDA-012 (Visual) check A3 — run an imperative action on the inner React component,
@@ -74110,6 +74271,7 @@ var init_react_component_node = __esm({
     init_mergedeep();
     init_node_shared_port_definitions();
     init_node_transitions();
+    init_keyboard_click();
     ICON_SOURCE_DIAGNOSTIC = "visual/icon-source-not-an-icon";
     DATA_ATTRIBUTE_NAME_PATTERN = "^data-[a-z0-9][a-z0-9._-]*$";
     DATA_ATTRIBUTE_NAME = new RegExp(DATA_ATTRIBUTE_NAME_PATTERN);
@@ -80880,6 +81042,38 @@ function _typeName(t) {
   if (typeof t === "object") return t.name;
   else return t;
 }
+function isInsideRow(node, row) {
+  if (node === row) return true;
+  let owner = (node.parentNodeScope || node.nodeScope)?.componentOwner;
+  for (let depth = 0; owner && depth < 64; depth++) {
+    if (owner === row) return true;
+    const next2 = (owner.parentNodeScope || owner.nodeScope)?.componentOwner;
+    if (next2 === owner) return false;
+    owner = next2;
+  }
+  return false;
+}
+function settleRow(context, row) {
+  const self2 = row;
+  for (let pass = 0; pass < 10; pass++) {
+    const dirty = context._dirtyNodes;
+    if (!Array.isArray(dirty)) return;
+    const mine = [];
+    for (let i2 = 0; i2 < dirty.length; i2++) {
+      const node = dirty[i2];
+      if (node && node._dirty && !node._deleted && mine.indexOf(node) === -1 && isInsideRow(node, self2))
+        mine.push(node);
+    }
+    if (mine.length === 0) return;
+    for (let i2 = 0; i2 < mine.length; i2++) {
+      try {
+        mine[i2].update();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+}
 var import_react16, import_runtime4, import_collection, import_model5, ITEMS_DIAGNOSTIC, defaultDynamicScript, ForEachDefinition, defaultMapCode, ForEachModule, foreach_default;
 var init_foreach = __esm({
   "../noodl-viewer-react/src/nodes/std-library/data/foreach.tsx"() {
@@ -81253,6 +81447,7 @@ var init_foreach = __esm({
               }
             }
           };
+          settleRow(this.context, itemNode);
           const forEachActions = itemNode.nodeScope.getNodesWithType("For Each Actions");
           for (let j = 0; j < forEachActions.length; j++) {
             forEachActions[j].signalAdded();
@@ -90070,10 +90265,16 @@ function Text(props) {
       ...pointerProps(props),
       style: style2
     },
-    renderableText(props.text)
+    style2.textOverflow === "ellipsis" ? (
+      // P18-S112-FLEXELLIPSIS — the Text is `display: flex` (its default CSS, which Text Vertical Align's `alignItems`
+      // needs), so its words were an anonymous flex item and `text-overflow` on the element drew no "…": Ellipsis
+      // looked the same as Clip. The words go in a block of their own that may shrink to the box and draws the "…";
+      // the element keeps its flex, so both alignments still place them.
+      /* @__PURE__ */ import_react22.default.createElement("span", { style: { ...ELLIPSIS_LINE, overflow: style2.overflow } }, renderableText(props.text))
+    ) : renderableText(props.text)
   );
 }
-var import_react22;
+var import_react22, ELLIPSIS_LINE;
 var init_Text = __esm({
   "../noodl-viewer-react/src/components/visual/Text/Text.tsx"() {
     import_react22 = __toESM(require_react());
@@ -90081,6 +90282,7 @@ var init_Text = __esm({
     init_layout();
     init_pointerlisteners();
     init_noodl_root_ref();
+    ELLIPSIS_LINE = { minWidth: 0, textOverflow: "ellipsis", whiteSpace: "nowrap" };
   }
 });
 
@@ -90454,7 +90656,6 @@ var init_Video = __esm({
             ...videoProps,
             playsInline: true,
             src,
-            ...pointerProps(this.props),
             ref: (video) => {
               this.video = video;
               this.props.innerRef(video);
@@ -90473,7 +90674,7 @@ var init_Video = __esm({
         this.canPlay = false;
       }
       setSourceObject(src) {
-        if (this.video.srcObject !== src) {
+        if (this.video && this.video.srcObject !== src) {
           this.video.srcObject = src;
           this.canPlay = false;
         }
@@ -90579,6 +90780,7 @@ var init_Video = __esm({
           CachedVideo,
           {
             ...props.dom,
+            ...pointerProps(this.props),
             className: withDefaultsClass(props.className, defaultsClass),
             style: style2,
             innerRef: (video) => {
@@ -97687,6 +97889,7 @@ var init_parentcomponentobject = __esm({
        */
       nodeScopeDidInitialize() {
         this.context.scheduleAfterUpdate(() => {
+          if (this._deleted) return;
           this._internal.resolutionIsLoud = true;
           this.onComponentStateNodesChanged();
         });
@@ -102063,7 +102266,7 @@ var init_signinwith = __esm({
           const tokens = [this.beginOutcome()];
           if (state2.succeeded) {
             this._internal.notice = state2.notice;
-            this._internal.error = void 0;
+            this._internal.error = "";
             this.flagOutputDirty("notice");
             this.flagOutputDirty("error");
             reportOutcomes(this, tokens, "done");
@@ -164973,7 +165176,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -167158,7 +167361,7 @@ var node_catalog_default = {
           "always: the page, or the scrolling Group holding it, scrolls until the box can be seen"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -169770,7 +169973,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -171952,7 +172155,7 @@ var node_catalog_default = {
           "always: the page, or the scrolling Group holding it, scrolls until the button can be seen"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, it takes no click and a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, it takes no click and a Focus does not reach it"
         ]
       },
       warnings: {
@@ -174357,7 +174560,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ]
       },
       warnings: {
@@ -177227,7 +177430,7 @@ var node_catalog_default = {
           "always: the size it holds now, a bare number read in the unit it held; drawn at the next paint"
         ],
         visible: [
-          "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it"
+          "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it"
         ],
         opacity: [
           "always: how see-through it is; at exactly 0 it takes no pointer, and an act goes to what is behind it"
@@ -182069,7 +182272,7 @@ var node_catalog_default = {
           },
           isSignal: false,
           default: false,
-          description: "Whether a request with no valid session token is allowed to run this function at all"
+          description: "Whether a request with no valid session token is allowed to run this function at all. A run the app starts itself \u2014 a schedule, a row change, a run from Studio \u2014 is always allowed and sees nobody signed in; a webhook is a request like any other"
         },
         {
           name: "params",
@@ -187095,8 +187298,8 @@ function renderMarkdown(md) {
       continue;
     }
     if (lines.every((l) => /^\s*>\s?/.test(l))) {
-      const quoted = lines.map((l) => l.replace(/^\s*>\s?/, "")).join("\n");
-      html.push(`<blockquote>${renderMarkdown(quoted)}</blockquote>`);
+      const quoted2 = lines.map((l) => l.replace(/^\s*>\s?/, "")).join("\n");
+      html.push(`<blockquote>${renderMarkdown(quoted2)}</blockquote>`);
       continue;
     }
     if (lines.every((l) => /^\s*[-*]\s+/.test(l))) {
@@ -199194,7 +199397,10 @@ var invocations = [
   { headers: { "X-Parse-Session-Token": "t1", origin: "null", host: "h" } },
   { headers: { "x-parse-session-token": "t1" }, body: '{"a":null}', at: 100 },
   { headers: { host: "internal:8577", "x-forwarded-host": "public.example.com", "x-forwarded-proto": "https, http" }, body: '{"total":"7"}' },
-  { headers: { origin: ["https://app.example.com/", "https://b.example"], "x-forwarded-proto": "jAvascript", host: "h" }, body: "{}" }
+  { headers: { origin: ["https://app.example.com/", "https://b.example"], "x-forwarded-proto": "jAvascript", host: "h" }, body: "{}" },
+  { headers: {}, body: '{"total":3}', startedByApp: true },
+  { headers: { "x-parse-session-token": "t1" }, body: "{}", startedByApp: true },
+  { headers: { startedbyapp: "true" }, body: '{"startedByApp":true}' }
 ];
 var CLOUD = { appId: "app", masterKey: "mk", endpoint: "https://be.example" };
 var HOSTS3 = [{}];
@@ -199205,7 +199411,7 @@ for (const invocation of invocations) {
 HOSTS3.push({ invocation: invocations[0], cloudServices: { ...CLOUD, runId: "run-1" } });
 var CloudRequest = defineNode({
   type: "noodl.cloud.request",
-  version: 3,
+  version: 4,
   changes: [
     {
       version: 2,
@@ -199218,6 +199424,12 @@ var CloudRequest = defineNode({
       says: "User Id is text (it carries the id of the person the session token resolved to). It was declared a flag, so a wire into a Number read the id as NaN and the canvas offered it to a signal input",
       row: "P107-S97-USERIDBOOLEAN (the Beta sweep s6)",
       migration: { none: "No saved wire stops connecting: measured 106 wires from User Id in 13,839 project files, 70 into script inputs (any type), 35 into text ports, 1 into a record field, none into a signal" }
+    },
+    {
+      version: 4,
+      says: "A run the app starts itself \u2014 a schedule, a row change, a run from Studio \u2014 is not refused when Allow Unauthenticated is off: it runs with nobody signed in. It was refused, so a weekly job could only run a function opened to everyone. A webhook and a direct call are refused as before",
+      row: "P127-BKO006-SCHEDULEAUTH (Richard ruled 2026-10-27: a run the app starts itself counts as the app)",
+      migration: { none: "Nothing a project stores changes: only a run the backend marks as started by the app gets a different answer, and it gets the one its author had to open the function to everyone to get" }
     }
   ],
   source: "packages/noodl-viewer-cloud/src/nodes/cloud/request.ts; packages/noodl-viewer-cloud/src/nodes/cloud/requestContract.ts; packages/noodl-viewer-cloud/src/nodes/cloud/requestOrigin.ts; packages/noodl-viewer-cloud/src/services/userservice.js",
@@ -199244,7 +199456,7 @@ var CloudRequest = defineNode({
   state: { contract: {}, authenticated: void 0, authUserId: void 0, origin: void 0, requestParameters: {}, waiting: void 0 },
   inputs: {
     // :154-163 — held raw, read when the request comes and again when its lookup fails
-    allowNoAuth: { type: "boolean", default: false, coerce: "none", displayName: "Allow Unauthenticated", group: "General", description: "Whether a request with no valid session token is allowed to run this function at all", examples: [true, false, "false", 1] },
+    allowNoAuth: { type: "boolean", default: false, coerce: "none", displayName: "Allow Unauthenticated", group: "General", description: "Whether a request with no valid session token is allowed to run this function at all. A run the app starts itself \u2014 a schedule, a row change, a run from Studio \u2014 is always allowed and sees nobody signed in; a webhook is a request like any other", examples: [true, false, "false", 1] },
     // :164-172 — held raw
     params: { type: "stringlist", coerce: "none", editOnly: true, group: "Parameters", description: "Names to pull out of the request body, each becoming an output \u2014 and a Type, Required and Default row to declare what it is", examples: ["total", "total,a", "a,0", "0,1", ""] }
   },
@@ -199291,7 +199503,7 @@ var CloudRequest = defineNode({
         }
         const waiting = { params, headers: req.headers };
         if (!token) {
-          if (!i2.allowNoAuth) return { send: [], answers: [{ op: "refuse", reason: UNAUTHENTICATED }] };
+          if (!i2.allowNoAuth && req.startedByApp !== true) return { send: [], answers: [{ op: "refuse", reason: UNAUTHENTICATED }] };
           return proceed(s, params, req.headers, i2, w, { set: {}, send: [] });
         }
         const cloud = w.hostCloud();
@@ -203105,6 +203317,18 @@ function growChange(version) {
   };
 }
 
+// ../nodegx-node-spec/src/nodes/visible-at-once.ts
+function visibleAtOnceChange(version) {
+  return {
+    version,
+    says: "No app does anything differently. Visible shows or hides the control at once: a Focus sent in the same moment as Visible going on reaches it (Focused fires), and one sent as Visible goes off does nothing. The version before said Visible waited for the next paint, so it lost the first Focus and kept the second; the runtime never did either",
+    row: "BETA-S7-DROPDOWNFOCUSDIVERGE",
+    migration: {
+      none: "The runtime did not change; only the spec stopped saying Visible waits for the next paint. No stored project changes"
+    }
+  };
+}
+
 // ../nodegx-node-spec/src/nodes/button.ts
 var NONE = { send: [] };
 var Button3 = defineNode({
@@ -203113,8 +203337,9 @@ var Button3 = defineNode({
   // v3 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v4 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
   // v5 (NSP-019 R38): a wired Width in a row, or a wired Height in a column, that is a percent shows as its warning (wired-grow.ts)
-  version: 6,
-  changes: [focusAndIconSourceChange(4), growChange(5), repeatWhileSavingChange(6, "click")],
+  // v7 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 7,
+  changes: [focusAndIconSourceChange(4), growChange(5), repeatWhileSavingChange(6, "click"), visibleAtOnceChange(7)],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("button")), ...iconSourceDiagnostics(), ...wiredGrowDiagnostic },
   source: "packages/noodl-viewer-react/src/nodes/controls/button.ts",
   needs: ["person"],
@@ -203300,8 +203525,9 @@ var Button3 = defineNode({
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width"),
     height: sizeReducer("height"),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     // placed on the page with its params set — the first paint (react-component-node.ts :1740-1743 reads `wantsToBeMounted`):
@@ -203382,8 +203608,9 @@ var Checkbox2 = defineNode({
   // v3 (P109 ISL-031, P107-C64 ruled "Ignore touches, keep hover"): a finger on a disabled control reports nothing — no Pressed, no Pointer Down or Up — as Enabled promises; the pointer's hover still reports
   // v4 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v5 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
-  version: 5,
-  changes: [focusAndIconSourceChange(5)],
+  // v6 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 6,
+  changes: [focusAndIconSourceChange(5), visibleAtOnceChange(6)],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("checkbox")), ...iconSourceDiagnostics() },
   source: "packages/noodl-viewer-react/src/nodes/controls/checkbox.ts",
   needs: ["person"],
@@ -203567,8 +203794,9 @@ var Checkbox2 = defineNode({
       return { says: "it holds the keyboard: it is taken off it, and the Focused state goes false", set: { focused: false, elementFocused: false }, send: ["focusState"], emit: ["onBlur"], outcome: "done" };
     },
     scrollIntoView: () => ({ says: "always: the page, or the scrolling Group holding it, scrolls until the box can be seen", send: [] }),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     world: { place: (s) => painted2(s) },
@@ -203693,8 +203921,9 @@ var TextInput3 = defineNode({
   // v6 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v7 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
   // v8 (NSP-019 R38): a wired Width in a row, or a wired Height in a column, that is a percent shows as its warning (wired-grow.ts)
-  version: 9,
-  changes: [focusAndIconSourceChange(7), growChange(8), repeatWhileSavingChange(9, "Enter")],
+  // v10 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 10,
+  changes: [focusAndIconSourceChange(7), growChange(8), repeatWhileSavingChange(9, "Enter"), visibleAtOnceChange(10)],
   diagnostics: { ...focusDiagnostics(FIELD_FOCUS_NOT_MOUNTED), ...iconSourceDiagnostics(), ...wiredGrowDiagnostic },
   source: "packages/noodl-viewer-react/src/nodes/controls/text-input.ts",
   needs: ["person"],
@@ -204015,9 +204244,10 @@ var TextInput3 = defineNode({
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width"),
     height: sizeReducer("height"),
-    // node-shared-port-definitions.ts :366-375, :320-328 — the page follows at the next paint (TextInput.tsx :118-120 compares the
-    // Opacity the style holds with the number 0)
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] }),
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts); Opacity (:320-328) follows at the next paint (TextInput.tsx :118-120 compares the Opacity the style
+    // holds with the number 0)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] }),
     opacity: (_s, v) => ({ says: "always: how see-through it is; at exactly 0 it takes no pointer, and an act goes to what is behind it", set: { opacityZero: v === 0 }, send: [] })
   },
   {
@@ -204330,7 +204560,8 @@ var Dropdown = defineNode({
   // v10 (NSP-019 R38): a wired Width in a row, or a wired Height in a column, that is a percent shows as its warning (wired-grow.ts)
   // v11 (P121-TWO005-DROPDOWNSTALE): Items that do not offer the placed node's seed ("Option 1") clear it to '' and send Value
   // v12 (BETA-S7-DROPDOWNFIRSTPICK): with the value in no option, the element keeps its hidden empty option selected, so every option is a pick
-  version: 12,
+  // v13 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 13,
   // NSP-010 — v7 is the spec correcting itself, not the runtime changing
   changes: [
     {
@@ -204366,7 +204597,8 @@ var Dropdown = defineNode({
       migration: {
         none: "A pick that did nothing now does what the person asked; nothing an app could rely on, and no stored project changes"
       }
-    }
+    },
+    visibleAtOnceChange(13)
   ],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("dropdown")), ...iconSourceDiagnostics(), ...wiredGrowDiagnostic },
   source: "packages/noodl-viewer-react/src/nodes/controls/options.ts",
@@ -204648,8 +204880,9 @@ var Dropdown = defineNode({
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width"),
     height: sizeReducer("height"),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     // react-component-node.ts :785-830 `DATA_ATTRIBUTES_RULE` — one string input per name the Data Attributes list names, written
@@ -204818,7 +205051,8 @@ var Slider2 = defineNode({
   // v7 (NSP-019 R39, ruled "Yes, warn"): a Max below Min warns, as the Counter's Min above Max does; and a Value that is not a
   // number, which the runtime always reported on the error bus, is declared with it (the editor records the `slider/` keys)
   // v8 (NSP-019 R38): a wired Width in a row that is a percent shows as its warning (wired-grow.ts)
-  version: 8,
+  // v9 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 9,
   changes: [
     focusChange(6),
     {
@@ -204827,7 +205061,8 @@ var Slider2 = defineNode({
       row: "NSP-019 R39 (P107 s104)",
       migration: { none: "Only the editor is told. Nothing a wire carries changes, and nothing a person does moves differently" }
     },
-    growChange(8)
+    growChange(8),
+    visibleAtOnceChange(9)
   ],
   diagnostics: {
     ...focusDiagnostics(controlFocusNotMounted("slider")),
@@ -205061,8 +205296,9 @@ var Slider2 = defineNode({
     scrollIntoView: () => ({ says: "always: the page, or the scrolling Group holding it, scrolls until the slider can be seen", send: [] }),
     // NSP-019 R38 — node.ts :446-458, react-component-node.ts :706-753 (wired-grow.ts)
     width: sizeReducer("width", false),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     // placed on the page with its params set — the first render: Did Mount, and the mount's effect (Slider.tsx :88-90)
@@ -208042,7 +208278,7 @@ var Video2 = defineNode({
     autoplay: (_s, v) => ({ says: "always: drawn at the next paint, and read as a load completes \u2014 on, a video that may play (Muted, or a person has acted on the page) and that Pause or Reset has not stopped since the load began starts by itself: On Can Play, then On Play", set: { autoplay: v }, send: [] }),
     loop: (_s, v) => ({ says: "always: drawn at the next paint, and read as the video reaches its end \u2014 on, it goes back to the start and plays on; off, it pauses there (On Pause)", set: { loop: v }, send: [] }),
     // :35-47 — on the component, or waiting for it with the actions (`sourceObject`: only a `<video>` takes one, and only nothing is
-    // seen to change it; C96, C99 on the runtime)
+    // seen to change it; C99 on the runtime)
     srcObject: (s, v) => {
       if (!s.onPage) return said("off the page: waits for the element behind the actions already waiting, in order, and is written at the paint that puts the video there (at most 16 wait, and the oldest is pushed out)", toPatch2(waitFor(s, { srcObject: v })));
       if (s.kind !== "video" || v !== void 0) return { says: "null (what it already has), a value that is not a stream, or anything on an embedded player: nothing changes \u2014 a live stream itself plays in place of Source, and no scenario holds one", set: {}, send: [], emit: [] };
@@ -210416,7 +210652,7 @@ function start(w, op) {
     if (b === MISSING) w.st.hops = HOPS_ADD_MISSING;
     else if (b === null) w.st.hops = 2;
     else w.st.building = { kind: "add", row: b, index: op.index, at: childIndexFor(w.st.rows, op.index) };
-  } else refresh(w);
+  } else refresh2(w);
 }
 function compileMapping(code, rethrow = false) {
   if (!code) return void 0;
@@ -210599,7 +210835,7 @@ function report2(w, heard3) {
     w.pulses.push(`itemOutputSignal-${signal2}`);
   }
 }
-function refresh(w) {
+function refresh2(w) {
   const st = w.st;
   st.refreshScheduled = false;
   const tokens = st.tokens;
@@ -211615,8 +211851,9 @@ var RadioButton3 = defineNode({
   // v3 (P109 ISL-031, P107-C64 ruled "Ignore touches, keep hover"): a finger on a disabled control reports nothing — no Pressed, no Pointer Down or Up — as Enabled promises; the pointer's hover still reports
   // v4 (P109 ISL-031, P107-D30 ruled "Reset and announce"): a control leaving the page (Mounted off) takes Focused, Hover and Pressed with it — each goes false, sent if it was true, with Blurred and Hover End for the ones that were on
   // v5 (NSP-019 R35): a Focus that finds the node off the page shows as its warning until a Focus reaches it, and an Icon Source that is not an icon shows as one until an icon or nothing arrives (`diagnostics`)
-  version: 5,
-  changes: [focusAndIconSourceChange(5)],
+  // v6 (BETA-S7-DROPDOWNFOCUSDIVERGE, the spec correcting itself): Visible reaches the element at once, so a Focus in the same frame meets it (visible-at-once.ts)
+  version: 6,
+  changes: [focusAndIconSourceChange(5), visibleAtOnceChange(6)],
   diagnostics: { ...focusDiagnostics(controlFocusNotMounted("radio button")), ...iconSourceDiagnostics() },
   source: "packages/noodl-viewer-react/src/nodes/controls/radiobutton.ts",
   needs: ["person", "group"],
@@ -211808,8 +212045,9 @@ var RadioButton3 = defineNode({
       return { says: "it holds the keyboard: it is taken off it, and the Focused state goes false", set: { focused: false, elementFocused: false }, send: ["focusState"], emit: ["onBlur"], outcome: "done" };
     },
     scrollIntoView: () => ({ says: "always: the page, or the scrolling Group holding it, scrolls until the button can be seen", send: [] }),
-    // node-shared-port-definitions.ts :366-375 — the page follows at the next paint
-    visible: (_s, v) => ({ says: "always: shown or hidden at the next paint, its space kept; hidden, it takes no click and a Focus does not reach it", set: { visible: !!v }, send: [] })
+    // node-shared-port-definitions.ts :374-388 — written onto the element at once, so a Focus in the same frame meets it
+    // (visible-at-once.ts)
+    visible: (_s, v) => ({ says: "always: shown or hidden at once, its space kept; hidden, it takes no click and a Focus does not reach it", set: { visible: !!v, pageVisible: !!v }, send: [] })
   },
   {
     world: {
@@ -215374,7 +215612,7 @@ function applyReturn(s, r) {
   if (r.inProgress) return { set: { signingIn: true }, send: ["signingIn"] };
   if (s.returned) return { send: [] };
   if (r.succeeded) {
-    return { set: { signingIn: false, notice: r.notice, error: void 0, returned: true }, send: ["signingIn", "notice", "error"], opens: [{ outcome: "done" }] };
+    return { set: { signingIn: false, notice: r.notice, error: "", returned: true }, send: ["signingIn", "notice", "error"], opens: [{ outcome: "done" }] };
   }
   return { set: { signingIn: false, error: r.error || SIGN_IN_NOT_COMPLETED, returned: true }, send: ["signingIn", "error"], opens: [{ outcome: "failure", error: SIGN_IN_WITH_ERROR_CODE2 }] };
 }
@@ -215384,7 +215622,19 @@ var SignInWith = defineNode({
   // v1 played the launcher only; no v1 trace moves (no v1 world carried a return)
   // v3 (P109 ISL-030, row C50 ruled "Fire it once"): a return's final state is reported once per page load; v2 reported a
   // provider's error twice — at mount and at the announcement a tick later.
-  version: 3,
+  // v4 (Beta sweep s19, row P109-S24-SIGNINWITHERRORKEPT ruled "Blank text, like magic link"): a succeeded return clears Error
+  // to blank text and sends it, as Request Magic Link's Done does (D25); v3 cleared it to `undefined`, never sent.
+  version: 4,
+  changes: [
+    {
+      version: 4,
+      says: "A sign-in that comes back succeeded clears Error to blank text and sends it, so a label wired to Error lets go of the last failure (before, the clear was nothing, which never reaches a wire)",
+      row: "P109-S24-SIGNINWITHERRORKEPT",
+      migration: {
+        none: "A page load gets one sign-in back and the node is new on it, so its Error never held an earlier failure: no project can see the before"
+      }
+    }
+  ],
   source: "packages/noodl-viewer-react/src/nodes/std-library/user/signinwith.ts; userservice.ts; RestAuthAdapter.ts; ParseAuthAdapter.ts",
   needs: ["backend", "registry", "clock"],
   worldPool: { backends: [...pool("signInWithProvider", null), ...RETURNS] },
@@ -231392,7 +231642,7 @@ var cloud_node_library_default = {
           plug: "input",
           group: "General",
           displayName: "Allow Unauthenticated",
-          description: "Whether a request with no valid session token is allowed to run this function at all",
+          description: "Whether a request with no valid session token is allowed to run this function at all. A run the app starts itself \u2014 a schedule, a row change, a run from Studio \u2014 is always allowed and sees nobody signed in; a webhook is a request like any other",
           default: false
         },
         {
@@ -235538,7 +235788,11 @@ var AUTHORED_BLOCKING_WARNINGS = /* @__PURE__ */ new Set([
   // Bug P121-TWO003-SCRIPTCOMPILE — the runtime's own compile fails, so every Run fails. No benign
   // reading for a graph an agent just wrote; the write said nothing before, and the first person
   // to run the function got "That could not be done."
-  "function-script-not-compiled" /* FunctionScriptNotCompiled */
+  "function-script-not-compiled" /* FunctionScriptNotCompiled */,
+  // Bug P127-BKO006-RUNONCHANGEGUESS — a `runOnChange-` name a Function does not have is never read
+  // (2,805 right and 5 wrong over 2,718 Functions, all five agent-written); the message names the
+  // right one.
+  "function-run-on-change-unknown" /* FunctionRunOnChangeUnknown */
 ]);
 
 // ../noodl-editor/src/editor/src/validation/diagnosticExamples.ts
@@ -235678,6 +235932,12 @@ var DIAGNOSTIC_EXAMPLES = [
     code: "function-guards-an-open-collection" /* FunctionGuardsAnOpenCollection */,
     examples: ["cloud-members-can-edit-my-records"],
     why: `the records only a function creates, with the collection's create rule "nobody": the function runs as the system`
+  },
+  // P112-OWN018-FANOUT (ruled 2026-10-27 "Teach it and warn") — the warning carries the chained shape.
+  {
+    code: "condition-reads-a-siblings-change" /* ConditionReadsASiblingsChange */,
+    examples: ["score-then-move-on"],
+    why: "the press evaluating the gate that reads, and that gate's Done evaluating the gate that moves on, so the score is decided first"
   }
 ];
 
@@ -237264,6 +237524,156 @@ var functionNeverReruns = {
   }
 };
 
+// ../noodl-editor/src/editor/src/validation/rules/functionRunOnChangeUnknown.ts
+var RUN_ON_CHANGE_PREFIX4 = "runOnChange-";
+var FUNCTION_INPUT_PREFIX = "in-";
+var functionRunOnChangeUnknown = {
+  code: "function-run-on-change-unknown" /* FunctionRunOnChangeUnknown */,
+  description: "A Function has a Run On Value Change setting under a name it does not have (its boxes are runOnChange-in-<input>).",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    for (const { component } of ctx.components) {
+      for (const node of component.nodes) {
+        if (node.type !== FUNCTION_NODE_TYPE || !node.parameters) continue;
+        const guessed = Object.keys(node.parameters).filter(
+          (key) => key.startsWith(RUN_ON_CHANGE_PREFIX4) && !key.startsWith(RUN_ON_CHANGE_PREFIX4 + FUNCTION_INPUT_PREFIX)
+        );
+        if (guessed.length === 0) continue;
+        const inputs = scriptPortsForNode(node).filter((p) => p.plug === "input" && p.name.startsWith(FUNCTION_INPUT_PREFIX)).map((p) => p.name.slice(FUNCTION_INPUT_PREFIX.length));
+        const name2 = node.label ? `"${node.label}"` : "This Function";
+        for (const key of guessed) {
+          const wanted = key.slice(RUN_ON_CHANGE_PREFIX4.length);
+          const input2 = inputs.includes(wanted) ? wanted : nearest(wanted, inputs);
+          const right = input2 !== void 0 ? `${RUN_ON_CHANGE_PREFIX4}${FUNCTION_INPUT_PREFIX}${input2}` : void 0;
+          out.push({
+            code: "function-run-on-change-unknown" /* FunctionRunOnChangeUnknown */,
+            severity: "warning",
+            message: `${name2} has no setting "${key}", so nothing reads it` + (input2 === wanted ? ` and a new "${wanted}" still runs it. ` : ". ") + `A Function's Run On Value Change box for an input is "runOnChange-in-<input>"` + (right ? input2 === wanted ? `: write "${right}".` : `; its script reads no "${wanted}" (the nearest input is "${input2}": "${right}").` : `, and its script reads no inputs.`),
+            location: {
+              component: component.name,
+              nodeId: node.id,
+              nodeType: node.type,
+              nodeLabel: node.label,
+              port: key,
+              plug: "input"
+            },
+            ...right ? { suggestion: `${right}: ${JSON.stringify(node.parameters[key])}` } : {}
+          });
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// ../noodl-editor/src/editor/src/validation/rules/conditionReadsASiblingsChange.ts
+var CONDITION = "Condition";
+var conditionReadsASiblingsChange = {
+  code: "condition-reads-a-siblings-change" /* ConditionReadsASiblingsChange */,
+  description: "Two Conditions evaluated by one signal, where one's On True or On False changes what the other reads.",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    const { catalog } = ctx;
+    for (const { component, nodeById } of ctx.components) {
+      let exclusiveStates = function(a, b) {
+        const stateOf = (gate) => {
+          const c = (incoming.get(gate) ?? []).find((w) => w.toProperty === "condition");
+          return c && nodeById.get(c.fromId)?.type === "States" && c.fromProperty.startsWith("at-") ? c : void 0;
+        };
+        const sa = stateOf(a);
+        const sb = stateOf(b);
+        return !!sa && !!sb && sa.fromId === sb.fromId && sa.fromProperty !== sb.fromProperty;
+      }, feedingValues = function(gate) {
+        const seen = /* @__PURE__ */ new Set();
+        const stack = (incoming.get(gate) ?? []).filter((c) => c.toProperty === "condition").map((c) => c.fromId);
+        while (stack.length > 0) {
+          const id = stack.pop();
+          if (id === gate || seen.has(id)) continue;
+          seen.add(id);
+          if (!passesThrough(id)) continue;
+          const type = nodeById.get(id)?.type;
+          for (const c of incoming.get(id) ?? []) {
+            if (type && catalog.getPort(type, "input", c.toProperty)?.isSignal) continue;
+            stack.push(c.fromId);
+          }
+        }
+        return seen;
+      }, reaches5 = function(gate, targets) {
+        if (targets.size === 0) return false;
+        const seen = /* @__PURE__ */ new Set([gate]);
+        const stack = (outgoing.get(gate) ?? []).map((c) => c.toId);
+        while (stack.length > 0) {
+          const id = stack.pop();
+          if (targets.has(id)) return true;
+          if (seen.has(id)) continue;
+          seen.add(id);
+          if (!passesThrough(id)) continue;
+          for (const c of outgoing.get(id) ?? []) stack.push(c.toId);
+        }
+        return false;
+      };
+      const outgoing = /* @__PURE__ */ new Map();
+      const incoming = /* @__PURE__ */ new Map();
+      for (const c of component.connections) {
+        (outgoing.get(c.fromId) ?? outgoing.set(c.fromId, []).get(c.fromId)).push(c);
+        (incoming.get(c.toId) ?? incoming.set(c.toId, []).get(c.toId)).push(c);
+      }
+      const isCondition = (id) => nodeById.get(id)?.type === CONDITION;
+      const passesThrough = (id) => {
+        const type = nodeById.get(id)?.type;
+        const known = type ? catalog.getNode(type) : void 0;
+        return !!known && !known.isVisual;
+      };
+      const gatesBySource = /* @__PURE__ */ new Map();
+      for (const c of component.connections) {
+        if (c.toProperty !== "eval" || !isCondition(c.toId)) continue;
+        const key = `${c.fromId}\0${c.fromProperty}`;
+        const gates = gatesBySource.get(key) ?? [];
+        if (!gates.includes(c.toId)) gates.push(c.toId);
+        gatesBySource.set(key, gates);
+      }
+      const reported3 = /* @__PURE__ */ new Set();
+      for (const [key, gates] of gatesBySource) {
+        if (gates.length < 2) continue;
+        const sourceId = key.split("\0")[0];
+        for (const reader of gates) {
+          if (reported3.has(reader)) continue;
+          const feeds = feedingValues(reader);
+          for (const writer of gates) {
+            if (writer === reader) continue;
+            if (exclusiveStates(reader, writer)) continue;
+            if (!reaches5(writer, feeds)) continue;
+            reported3.add(reader);
+            const r = nodeById.get(reader);
+            const w = nodeById.get(writer);
+            const rName = r.label ? `"${r.label}"` : "This Condition";
+            const wName = w.label ? `"${w.label}"` : "another Condition";
+            const sName = nodeById.get(sourceId)?.label ? `"${nodeById.get(sourceId).label}"` : "the same signal";
+            out.push({
+              code: "condition-reads-a-siblings-change" /* ConditionReadsASiblingsChange */,
+              severity: "warning",
+              message: `${rName} and ${wName} are both evaluated by ${sName}, and what ${wName} does changes what ${rName} reads. ${rName} reads its Condition after that change, whichever order the two are wired in. If it should decide on the value from before, chain them: ${rName}'s Done into ${wName}'s Evaluate, instead of both from ${sName}.`,
+              location: {
+                component: component.name,
+                nodeId: r.id,
+                nodeType: r.type,
+                nodeLabel: r.label,
+                port: "eval",
+                plug: "input"
+              },
+              suggestion: `${r.id}.done \u2192 ${w.id}.eval`
+            });
+            break;
+          }
+        }
+      }
+    }
+    return out;
+  }
+};
+
 // ../noodl-editor/src/editor/src/validation/rules/layoutFillTraps.ts
 var GROUP = "Group";
 var CONTENT_WIDTH = /* @__PURE__ */ new Set(["contentSize", "contentWidth"]);
@@ -237371,6 +237781,97 @@ var rowOfWordsFillsItsColumn = {
   }
 };
 
+// ../noodl-editor/src/editor/src/validation/rules/clickAreaHoldsAControl.ts
+var CONTROL_TYPES = /* @__PURE__ */ new Map([
+  ["net.noodl.controls.button", "Button"],
+  ["net.noodl.controls.textinput", "Text Input"],
+  ["net.noodl.controls.checkbox", "Checkbox"],
+  ["net.noodl.controls.radiobutton", "Radio Button"],
+  ["net.noodl.controls.options", "Dropdown"],
+  ["net.noodl.controls.range", "Slider"]
+]);
+var CLICK = "onClick";
+var COMPONENT_OUTPUTS2 = "Component Outputs";
+var clickWired = (component, node) => component.connections.some((c) => c.fromId === node.id && c.fromProperty === CLICK);
+function reaches4(component, nodeById, node, port5, used) {
+  return component.connections.some((c) => {
+    if (c.fromId !== node.id || c.fromProperty !== port5) return false;
+    if (nodeById.get(c.toId)?.type !== COMPONENT_OUTPUTS2) return true;
+    return used === "all" || used.has(c.toProperty);
+  });
+}
+var quoted = (node) => node.label ? ` ("${node.label}")` : "";
+var clickAreaHoldsAControl = {
+  code: "click-area-holds-a-control" /* ClickAreaHoldsAControl */,
+  description: "An element whose Click is wired holds a control, so the keyboard reaches the control and not the element.",
+  defaultEnabled: true,
+  run(ctx) {
+    const out = [];
+    const byPath = new Map(ctx.components.map((c) => [refToPath(c.component.name), c]));
+    const memo = /* @__PURE__ */ new Map();
+    const componentHolds = (ref, used) => {
+      const path10 = refToPath(ref);
+      const key = `${path10}|${[...used].sort().join(",")}`;
+      if (memo.has(key)) return memo.get(key) ?? null;
+      memo.set(key, null);
+      const entry = byPath.get(path10);
+      let found = null;
+      if (entry) {
+        for (const node of entry.component.nodes) {
+          found = held(node, entry.component, entry.nodeById, used);
+          if (found) break;
+        }
+      }
+      memo.set(key, found);
+      return found;
+    };
+    function held(node, component, nodeById, used) {
+      const control = CONTROL_TYPES.get(node.type);
+      if (control) return `a ${control}${quoted(node)}`;
+      if (reaches4(component, nodeById, node, CLICK, used)) {
+        return `${node.label ? `"${node.label}"` : "an element"}, which answers a click of its own`;
+      }
+      if (isComponentRef(node.type)) {
+        const ports = new Set(component.connections.filter((c) => c.fromId === node.id).map((c) => c.fromProperty));
+        const usedHere = new Set([...ports].filter((port5) => reaches4(component, nodeById, node, port5, used)));
+        const inside = componentHolds(node.type, usedHere);
+        if (inside) return `the component ${node.label ? `"${node.label}"` : `"${refToPath(node.type)}"`}, which holds ${inside}`;
+      }
+      return null;
+    }
+    for (const { component, nodeById } of ctx.components) {
+      for (const area of component.nodes) {
+        if (CONTROL_TYPES.has(area.type) || !clickWired(component, area)) continue;
+        if (!ctx.catalog.getNode(area.type)?.isVisual) continue;
+        let inner = null;
+        const stack = [...area.children ?? []];
+        while (stack.length && !inner) {
+          const node = nodeById.get(stack.shift());
+          if (!node) continue;
+          inner = held(node, component, nodeById, "all");
+          stack.push(...node.children ?? []);
+        }
+        if (!inner) continue;
+        const name2 = area.label ? `"${area.label}"` : `This ${ctx.catalog.getNode(area.type)?.displayName ?? area.type}`;
+        out.push({
+          code: "click-area-holds-a-control" /* ClickAreaHoldsAControl */,
+          severity: "info",
+          message: `${name2} answers a click. It holds ${inner}. The Tab key stops on what it holds instead. A person using a keyboard or a screen reader cannot press ${area.label ? name2 : "it"} itself. If its click does something nothing inside it does, give that its own Button.`,
+          location: {
+            component: component.name,
+            nodeId: area.id,
+            nodeType: area.type,
+            ...area.label ? { nodeLabel: area.label } : {},
+            port: CLICK,
+            plug: "output"
+          }
+        });
+      }
+    }
+    return out;
+  }
+};
+
 // ../noodl-editor/src/editor/src/validation/rules/index.ts
 var ALL_RULES = [
   duplicateNodeId,
@@ -237427,6 +237928,10 @@ var ALL_RULES = [
   // arrangement ones.
   functionScriptNotCompiled,
   functionNeverReruns,
+  functionRunOnChangeUnknown,
+  // P112-OWN018-FANOUT (ruled 2026-10-27 "Teach it and warn") — beside the Function rules: what a graph's signals do in
+  // what order, read from the wires. Two gates off one signal, one changing what the other reads.
+  conditionReadsASiblingsChange,
   repeatedSiblingSubtree,
   // DEF-025 — beside `repeatedSiblingSubtree` because both read the visual
   // tree's arrangement rather than wires: that one asks whether siblings
@@ -237440,6 +237945,9 @@ var ALL_RULES = [
   // against the shipped corpus before they were written — this one is 0 hits
   // on all ten templates.
   dialogWithoutName,
+  // P121-TWO003-NESTEDBUTTON (ruled 2026-10-27) — beside the two above: what a keyboard and a screen reader reach, read
+  // from the arrangement. An info, live, so the Problems panel and an agent's write both say it.
+  clickAreaHoldsAControl,
   // P112-OWN020-PILLWRAP / FILLGROW (ruled 2026-10-26: warn and teach) — a node with no size setting fills its parent,
   // read from the arrangement like the two above, and live so a person sees it while editing.
   contentRowSplitsItsChildren,