@unoverse-platform/studio 0.1.90 → 0.1.91

package/vendor/base/src/workflow/routing.ts

@@ -0,0 +1,122 @@
+/**
+ * Signal routing over a frozen route table — the runtime half of the workflow contract.
+ *
+ * The types here are the WIRE CONTRACT for a compiled workflow: the engine's compiler
+ * (RouteTableBuilder, engine-side — it needs the node metadata registry and must never
+ * enter this package) produces a RouteTable; anything that runs one consumes these shapes.
+ * The compiler's own declarations stay structurally identical — the runtime round-trip
+ * tests hold the two in parity.
+ *
+ * SignalRoutingEngine is pure routing logic: given a completed node's output and the
+ * route table, which downstream signals fire. No signal management, no execution.
+ */
+
+import { createLogger } from "../logger.js";
+
+/** One compiled edge: source → target with its signal type and connector handles. */
+export interface RouteEntry {
+  targetNodeId: string;
+  signalType: string; // "EXECUTE" | "SPAWN" | "RESET" etc.
+  targetHandle?: string; // Which input connector this edge connects to
+  sourceHandle?: string; // Which output connector this edge comes from
+}
+
+/** The frozen routing derived from a workflow's nodes + edges. */
+export interface RouteTable {
+  routing: Map<string, RouteEntry[]>; // Source → [RouteEntries with signal types]
+  dependencies: Map<string, string[]>; // Target → [Source Node IDs] (for execution order)
+  connectorDependencies?: Map<string, Map<string, string[]>>; // Target → Connector → [Source Node IDs]
+  triggerNodes: string[]; // Nodes that start execution
+  nodeTriggerMap?: Map<string, string>; // nodeId → upstream InputTrigger ID (Focus Mode routing)
+}
+
+/** A signal the router decided to send. */
+export interface SignalRoute {
+  targetNodeId: string;
+  signal: string;
+  sourceNodeId: string;
+  targetHandle?: string; // Which input connector this signal targets
+}
+
+const logger = createLogger("SignalRoutingEngine");
+
+export class SignalRoutingEngine {
+  /**
+   * Get signals to send when a node completes execution - ROUTE TABLE VERSION
+   * Ultra-fast O(1) lookup using pre-computed route table
+   * Now with multi-output support - filters based on active output connectors
+   */
+  static getSignalsForCompletedNode(nodeId: string, nodeOutput: any, routeTable: RouteTable): SignalRoute[] {
+    const signals: SignalRoute[] = [];
+
+    if (!routeTable?.routing) {
+      logger.warn(`No route table provided for node completion`, { nodeId });
+      return signals;
+    }
+
+    const routeEntries = routeTable.routing.get(nodeId) || [];
+
+    for (const routeEntry of routeEntries) {
+      // For nodes using __outputs pattern, check if the specific output exists
+      if (nodeOutput?.__outputs) {
+        // If there's a sourceHandle, check if that specific output exists
+        if (routeEntry.sourceHandle) {
+          const hasOutput =
+            routeEntry.sourceHandle in nodeOutput.__outputs &&
+            nodeOutput.__outputs[routeEntry.sourceHandle] !== undefined;
+
+          if (!hasOutput) {
+            // Debug level - this is normal for streaming nodes that emit partial outputs
+            logger.debug(`No signal - output connector has no data`, {
+              from: nodeId,
+              to: routeEntry.targetNodeId,
+              sourceHandle: routeEntry.sourceHandle,
+            });
+            continue; // Skip this route
+          }
+        }
+        // If no sourceHandle specified, node should have a default output
+      }
+      // For legacy multi-output nodes (IfElse, etc), check if the specific output exists
+      else if (routeEntry.sourceHandle && nodeOutput && typeof nodeOutput === "object") {
+        const hasOutput = routeEntry.sourceHandle in nodeOutput;
+
+        if (!hasOutput) {
+          logger.debug(`No signal - output connector has no data`, {
+            from: nodeId,
+            to: routeEntry.targetNodeId,
+            sourceHandle: routeEntry.sourceHandle,
+          });
+          continue; // Skip this route
+        }
+      }
+      // For flat output nodes or nodes with data, always send signal
+
+      signals.push({
+        targetNodeId: routeEntry.targetNodeId,
+        signal: routeEntry.signalType, // Use pre-computed signal type!
+        sourceNodeId: nodeId,
+        targetHandle: routeEntry.targetHandle, // Include target connector
+      });
+
+      if (routeEntry.signalType === "SPAWN") {
+        logger.debug(`Routing SPAWN signal`, {
+          from: nodeId,
+          to: routeEntry.targetNodeId,
+          targetHandle: routeEntry.targetHandle,
+          sourceHandle: routeEntry.sourceHandle,
+        });
+      }
+
+      logger.debug(`Using route table to add active signal`, {
+        from: nodeId,
+        to: routeEntry.targetNodeId,
+        signal: routeEntry.signalType,
+        targetHandle: routeEntry.targetHandle,
+        sourceHandle: routeEntry.sourceHandle,
+      });
+    }
+
+    return signals;
+  }
+}

package/vendor/sdk/lib/core/store.ts

@@ -215,12 +215,20 @@ export class ComponentStore {
    * lower states update silently underneath).
    */
   /**
-   * RULE 5's EMPTY DELIVERY (STATE_MODEL §5 rule 5, amended 2026-08-26): a discovery
-   * turn that ran with cards enabled and surfaced NONE still owns the screen — the
-   * server says so with COMPONENTS_CLEAR, and every earlier-turn component sitting in
-   * a public state retracts to inline. `supersede` for ALL states at once: same
-   * durable (`lifetime: "conversation"`) opt-out, same same-turn exemption. Rule 7
-   * stands — this rides the answer's delivery, never the guest's typing.
+   * RULE 5's EMPTY DELIVERY (STATE_MODEL §5 rule 5; the director is the sender since
+   * 2026-08-30 — confirmed-empty and spent-or-kept both arrive as COMPONENTS_CLEAR):
+   * every earlier-turn component sitting in a public state retires. Same durable
+   * (`lifetime: "conversation"`) opt-out, same same-turn exemption as `supersede`.
+   * Rule 7 stands — this rides the answer's delivery, never the guest's typing.
+   *
+   * A CLEAR NEVER STAMPS A STATE NOBODY DREW (STATE_MODEL §5 rule 5, 2026-09-03).
+   * `inline` is the retirement of a CHAT-lifetime card. A v2 slice whose public menu
+   * has no `inline` cannot wear it — worn anyway, the renderer fell back to the
+   * default drawing and the chat flow painted retired GRID cards into the
+   * conversation (observed live: BPP course cards). Such a slice retires to its
+   * DECLARED base, written WITHOUT a touch: its delivery was just spent
+   * (`spendDelivery` runs first), and a touch would re-admit it to the delivery it
+   * is leaving — the mount would hold the very cards the clear retired.
    */
   supersedeAll(arrivingChatId?: string): void {
     let changed = false;
@@ -229,6 +237,18 @@ export class ComponentStore {
       if (slice.lifetime === "conversation") continue;
       const v = (slice.state ?? slice.view ?? slice.defaultState) as unknown;
       if (typeof v !== "string" || !v || v === "inline") continue;
+      const menu = Array.isArray(slice.publicStates) ? (slice.publicStates as unknown[]) : undefined;
+      if (menu && !menu.includes("inline")) {
+        const base = typeof slice.initialView === "string" ? slice.initialView : undefined;
+        if (base && v !== base) {
+          const next: Record<string, unknown> = { ...slice };
+          next[this.faceKey(next)] = base;
+          if ("defaultState" in next) next.defaultState = base;
+          this.data.set(key, next);
+          changed = true;
+        }
+        continue;
+      }
       const next: Record<string, unknown> = { ...slice };
       next[this.faceKey(next)] = "inline";
       if ("defaultState" in next) next.defaultState = "inline";