@unoverse-platform/studio 0.1.90 → 0.1.92

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";

package/local/mcp.ts

@@ -1,265 +0,0 @@
-/**
- * THE STUDIO MCP: a developer's Claude, authoring against their own folder.
- *
- * Same flow as Canvas. The developer clicks "Connect agent", Studio mints a short
- * single-use code, they paste it into Claude, and `bindProject` redeems it. Until a session
- * is bound, every other tool refuses.
- *
- * NO REDIS, and none needed: Canvas stores codes there because a universe is several
- * processes serving many users. Studio is one process serving one developer, so the code
- * lives in memory and dies with the server, which is the correct lifetime for it.
- *
- * THIS SERVER OWNS NO RULES. Saving goes through the same lint-gated chokepoint the editor
- * uses (source.ts), linting is the shared library, and completion data is the same
- * vocabulary. That is why it stays small: the guardrails already exist below it, and an
- * agent gets exactly the ones the human gets.
- *
- * See docs/architecture/LOCAL_STUDIO.md §The connected agent.
- */
-import { randomBytes } from "node:crypto";
-import { resolve } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-/** Human-typeable, unambiguous alphabet. The same one Canvas uses (no 0/O/1/I/L). */
-const CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
-const CODE_TTL_MS = 10 * 60 * 1000;
-
-let pending: { code: string; expires: number } | null = null;
-
-export function mintPairingCode(): { code: string; expiresInSeconds: number } {
-  const b = randomBytes(8);
-  let s = "";
-  for (let i = 0; i < 8; i++) s += CODE_ALPHABET[b[i] % CODE_ALPHABET.length];
-  const code = `${s.slice(0, 4)}-${s.slice(4)}`;
-  pending = { code, expires: Date.now() + CODE_TTL_MS };
-  return { code, expiresInSeconds: CODE_TTL_MS / 1000 };
-}
-
-/** Redeem and burn. A lingering copy in a transcript is inert. */
-function redeem(raw: string): boolean {
-  const code = raw.trim().toUpperCase();
-  if (!pending || pending.code !== code || Date.now() > pending.expires) return false;
-  pending = null;
-  return true;
-}
-
-export interface McpDeps {
-  projectRoot: string;
-  /** The catalog loaders, so the agent reads definitions the same way the screens do. */
-  catalog: () => Promise<{
-    listDefinitions: (kind: string, org?: string) => unknown[];
-    loadDefinition: (ref: string, kind: string) => unknown;
-    listOrgs: () => string[];
-  }>;
-  /** Files behind a definition, and their writability. */
-  sourceFiles: (uri: string) => { path: string; rel: string; writable: boolean }[];
-  readSource: (path: string) => { text: string; writable: boolean } | null;
-  /** The lint-gated write chokepoint. Identical to the one the editor presses. */
-  saveSource: (path: string, text: string) => Promise<{ saved: boolean; error?: string; findings?: unknown[] }>;
-  lintProject: () => Promise<{ problems: unknown[] }>;
-  /** What the developer last picked in the preview. */
-  selection: () => Record<string, unknown> | null;
-  vocabulary: () => Promise<unknown>;
-}
-
-const SKILL_DIRS = [
-  "vendor/skills/unoverse-create",
-  "../../.claude/skills/unoverse-create", // running from source: the authoring home
-  "../../prompts/skills/unoverse-create",
-];
-
-/** The vendored authoring skill, which is how an agent learns the rules before writing. */
-function authoringSkill(appRoot: string): string {
-  for (const d of SKILL_DIRS) {
-    const p = resolve(appRoot, d, "SKILL.md");
-    if (existsSync(p)) return readFileSync(p, "utf8");
-  }
-  return "No authoring skill is vendored with this Studio build.";
-}
-
-type Tool = {
-  description: string;
-  inputSchema: { type: "object"; properties: Record<string, unknown>; required?: string[] };
-  run: (args: Record<string, any>) => Promise<unknown>;
-};
-
-/**
- * The tool surface, deliberately short.
- *
- * Everything an agent needs to author and nothing that duplicates a rule: read the project,
- * learn the rules, read a definition and its files, save through the gate, lint, and ask
- * what the developer is pointing at.
- */
-export function buildTools(deps: McpDeps, appRoot: string): Record<string, Tool> {
-  let bound = false;
-  const needsBinding = () => {
-    if (!bound) throw new Error("Not bound. Call bindProject with the code from Studio's 'Connect agent' button.");
-  };
-
-  return {
-    bindProject: {
-      description:
-        "Bind this session to the developer's Studio project using the pairing code shown by Studio's 'Connect agent' button. Call this first; nothing else works until you do.",
-      inputSchema: { type: "object", properties: { code: { type: "string" } }, required: ["code"] },
-      run: async ({ code }) => {
-        if (!redeem(String(code ?? ""))) throw new Error("Invalid or expired pairing code. Generate a fresh one in Studio.");
-        bound = true;
-        const c = await deps.catalog();
-        return {
-          bound: true,
-          projectRoot: deps.projectRoot,
-          projects: c.listOrgs(),
-          note: "Saves are lint-gated and installed assets are read-only. Read the authoring skill before writing.",
-        };
-      },
-    },
-
-    readAuthoringSkill: {
-      description: "The rules for authoring unoverse definitions. Read this before writing or editing any definition.",
-      inputSchema: { type: "object", properties: {} },
-      run: async () => {
-        needsBinding();
-        return { skill: authoringSkill(appRoot) };
-      },
-    },
-
-    getVocabulary: {
-      description:
-        "The closed vocabulary: the primitive set, the style keys, and THIS project's own token names from its resolved theme. A value outside these will fail lint.",
-      inputSchema: { type: "object", properties: {} },
-      run: async () => {
-        needsBinding();
-        return deps.vocabulary();
-      },
-    },
-
-    listDefinitions: {
-      description: "The project's components or templates.",
-      inputSchema: {
-        type: "object",
-        properties: { kind: { type: "string", enum: ["component", "app", "atom", "template"] } },
-        required: ["kind"],
-      },
-      run: async ({ kind }) => {
-        needsBinding();
-        const c = await deps.catalog();
-        return { definitions: c.listDefinitions(String(kind)) };
-      },
-    },
-
-    readDefinition: {
-      description:
-        "One definition, composed, plus the source files behind it and whether each may be written. Installed assets read but never write.",
-      inputSchema: { type: "object", properties: { uri: { type: "string" } }, required: ["uri"] },
-      run: async ({ uri }) => {
-        needsBinding();
-        const c = await deps.catalog();
-        // `.../definition` is a suffix on the app's URI, not part of its ref.
-        const ref = String(uri).replace(/^unoverse:\/\/(components|atoms|apps|templates)\//, "").replace(/\/definition$/, "");
-        const kind = /\/apps\//.test(String(uri)) ? "app" : /\/atoms\//.test(String(uri)) ? "atom" : /^unoverse:\/\/templates\//.test(String(uri)) ? "template" : "component";
-        return { definition: c.loadDefinition(ref, kind), files: deps.sourceFiles(String(uri)) };
-      },
-    },
-
-    readSource: {
-      description: "One source file's text.",
-      inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
-      run: async ({ path }) => {
-        needsBinding();
-        const found = deps.readSource(String(path));
-        if (!found) throw new Error(`Not readable: ${path}`);
-        return found;
-      },
-    },
-
-    saveDefinition: {
-      description:
-        "Write a source file. The linter runs and a failing write is ROLLED BACK, so a refusal means nothing changed on disk. Installed assets are refused outright.",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string" }, text: { type: "string" } },
-        required: ["path", "text"],
-      },
-      run: async ({ path, text }) => {
-        needsBinding();
-        return deps.saveSource(String(path), String(text));
-      },
-    },
-
-    lintProject: {
-      description: "Lint every definition. The same rules that gate a save, a publish and CI.",
-      inputSchema: { type: "object", properties: {} },
-      run: async () => {
-        needsBinding();
-        return deps.lintProject();
-      },
-    },
-
-    getSelection: {
-      description:
-        "What the developer is pointing at: the element they picked in Studio's preview, as a file, an offset and the node's path. Call this when an instruction says 'this' or 'that'.",
-      inputSchema: { type: "object", properties: {} },
-      run: async () => {
-        needsBinding();
-        return deps.selection() ?? { empty: true, note: "Nothing picked. Ask the developer to use Studio's pick tool." };
-      },
-    },
-  };
-}
-
-/**
- * JSON-RPC over a single POST, which is all a local MCP client needs.
- *
- * The SDK's transport exists for sessions, SSE and resumability; none of that applies to a
- * loopback tool talking to one editor, so this handles `initialize`, `tools/list` and
- * `tools/call` directly rather than carrying that machinery.
- */
-export async function handleMcp(
-  req: IncomingMessage,
-  res: ServerResponse,
-  body: unknown,
-  tools: Record<string, Tool>,
-): Promise<void> {
-  const send = (payload: unknown, status = 200) => {
-    res.statusCode = status;
-    res.setHeader("content-type", "application/json");
-    res.end(JSON.stringify(payload));
-  };
-  const msg = body as { id?: unknown; method?: string; params?: any };
-  const reply = (result: unknown) => send({ jsonrpc: "2.0", id: msg?.id ?? null, result });
-  const fail = (code: number, message: string) => send({ jsonrpc: "2.0", id: msg?.id ?? null, error: { code, message } });
-
-  switch (msg?.method) {
-    case "initialize":
-      return reply({
-        protocolVersion: "2024-11-05",
-        capabilities: { tools: {} },
-        serverInfo: { name: "unoverse-studio", version: "1" },
-      });
-    case "notifications/initialized":
-      res.statusCode = 202;
-      return void res.end();
-    case "tools/list":
-      return reply({
-        tools: Object.entries(tools).map(([name, t]) => ({
-          name,
-          description: t.description,
-          inputSchema: t.inputSchema,
-        })),
-      });
-    case "tools/call": {
-      const tool = tools[msg.params?.name];
-      if (!tool) return fail(-32601, `Unknown tool: ${msg.params?.name}`);
-      try {
-        const out = await tool.run(msg.params?.arguments ?? {});
-        return reply({ content: [{ type: "text", text: JSON.stringify(out, null, 2) }] });
-      } catch (e) {
-        // A refusal is a RESULT, not a protocol error: the agent should read why and adjust.
-        return reply({ content: [{ type: "text", text: `Error: ${(e as Error).message}` }], isError: true });
-      }
-    }
-    default:
-      return fail(-32601, `Unsupported method: ${msg?.method}`);
-  }
-}