@tuongaz/seeflow 0.1.42 → 0.1.51

package/src/cli-ops.ts

@@ -0,0 +1,18 @@
+import { type Operations, createOperations } from './operations.ts';
+import { createRegistry } from './registry.ts';
+
+/**
+ * Build a single Operations handle for in-process CLI use.
+ *
+ * The CLI has no watcher and no statusRunner — play/reset are server-only
+ * features that still go via HTTP. When a CLI mutates a flow file, the
+ * running studio's flow watcher picks up the disk write externally and
+ * broadcasts flow:reload to connected SPA clients.
+ *
+ * `OperationsDeps` doesn't currently carry an EventBus, so we don't pass one;
+ * the *Impl functions only broadcast through `watcher.broadcastReload`, which
+ * is undefined in the CLI.
+ */
+export function createCliOperations(): Operations {
+  return createOperations({ registry: createRegistry() });
+}

package/src/cli.ts

@@ -1,8 +1,18 @@
 #!/usr/bin/env bun
 import { closeSync, cpSync, existsSync, mkdirSync, openSync, readFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { drainStdin, loadBody, printError, printOk } from './cli-helpers.ts';
+import { drainStdin, loadBody, printError, printOk, printOutcome } from './cli-helpers.ts';
+import { COMMAND_MANIFEST, renderCommandHelp, renderCommandList } from './cli-manifest.ts';
+import { createCliOperations } from './cli-ops.ts';
 import { createEventBus } from './events.ts';
+import type { LayoutOptions } from './layout.ts';
+import {
+  ConnectorPatchBodySchema,
+  ConnectorsBulkBodySchema,
+  NodePatchBodySchema,
+  NodesBulkBodySchema,
+  ReorderBodySchema,
+} from './operations.ts';
 import { seeflowHome } from './paths.ts';
 import { defaultProcessSpawner } from './process-spawner.ts';
 import { type Registry, createRegistry } from './registry.ts';
@@ -72,18 +82,6 @@ async function postJson(url: string, body: unknown): Promise<Response> {
   });
 }
 
-async function patchJson(url: string, body: unknown): Promise<Response> {
-  return fetch(url, {
-    method: 'PATCH',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  });
-}
-
-async function deleteRequest(url: string): Promise<Response> {
-  return fetch(url, { method: 'DELETE' });
-}
-
 async function handleResponse(res: Response): Promise<unknown> {
   const text = await res.text();
   let parsed: unknown = text;
@@ -111,7 +109,7 @@ const daemonLogPath = () => join(seeflowHome(), 'seeflow.log');
 if (argv.includes('--version') || argv.includes('-v')) {
   await printVersion();
 } else if (sub === 'help' || sub === '--help' || sub === '-h') {
-  printHelp();
+  await runHelp();
 } else if (sub === 'version') {
   await printVersion();
 } else if (!sub || sub === 'start' || sub.startsWith('-')) {
@@ -126,8 +124,12 @@ if (argv.includes('--version') || argv.includes('-v')) {
   await runProjectsCreate();
 } else if (sub === 'flows:list') {
   await runFlowsList();
+} else if (sub === 'flows:summary') {
+  await runFlowsSummary();
 } else if (sub === 'flows:get') {
   await runFlowsGet();
+} else if (sub === 'flows:graph') {
+  await runFlowsGraph();
 } else if (sub === 'flows:delete') {
   await runFlowsDelete();
 } else if (sub === 'flows:layout') {
@@ -138,6 +140,8 @@ if (argv.includes('--version') || argv.includes('-v')) {
   await runNodesAdd();
 } else if (sub === 'nodes:add-bulk') {
   await runNodesAddBulk();
+} else if (sub === 'nodes:get') {
+  await runNodesGet();
 } else if (sub === 'nodes:patch') {
   await runNodesPatch();
 } else if (sub === 'nodes:move') {
@@ -172,19 +176,21 @@ seeflow — local studio for file-defined interactive demos
 Usage:
   npx -y @tuongaz/seeflow@latest [command] [options]
 
-Commands:
+Commands (work without a running studio):
   start                Start the SeeFlow Studio server (default port 4321) — default when no command is given
   stop                 Stop a background studio instance
-  register             Register a demo repo with the running studio (alias of flows:register)
-  flows:register       Register a demo repo with the running studio
+  register             Register a demo repo, writing to ~/.seeflow/registry.json (alias of flows:register)
+  flows:register       Register a demo repo
   projects:create      Create a new project (--name <name>)
   flows:list           List registered flows
+  flows:summary        List registered flows (id + name + description only)
   flows:get <id>       Get flow details
+  flows:graph <id>     List nodes + connectors without inlined file content
   flows:delete <id>    Unregister a flow
-  flows:layout <id>    POST a layout payload (--json/--file/--stdin)
-  flows:play <id> <n>  Trigger a play on node <n>
+  flows:layout <id>    Apply ELK layout, writing style.json (--json/--file/--stdin optional)
   nodes:add <id>       Add a node (--json/--file/--stdin)
   nodes:add-bulk <id>  Add many nodes (--json/--file/--stdin)
+  nodes:get <id> <n>   Get a node with detail / html content inlined
   nodes:patch <id> <n> Patch a node (--json/--file/--stdin)
   nodes:move <id> <n>  Move a node (--x N --y N)
   nodes:reorder <id> <n> Reorder a node (--op forward|backward|toFront|toBack|toIndex [--index N])
@@ -194,13 +200,18 @@ Commands:
   connectors:patch <id> <connId>  Patch a connector (--json/--file/--stdin)
   connectors:delete <id> <connId> Delete a connector
   validate             Schema-validate a flow.json (--file <file> [--style <file>])
+
+Commands (require a running studio):
+  flows:play <id> <n>  Trigger a play on node <n>
   e2e <id>             End-to-end validate a registered flow (--skip-nodes a,b)
+
+Meta:
   version              Print the CLI version
   help                 Show this help message
 
 Global options:
   --version, -v        Print the CLI version and exit
-  --no-start           Fail if studio is not already running
+  --no-start           For flows:play / e2e: fail instead of auto-starting the studio
 
 Body source flags (where applicable):
   --json '<JSON>'      Inline JSON body
@@ -230,6 +241,19 @@ Examples:
   );
 }
 
+async function runHelp() {
+  const target = argv[1] && !argv[1].startsWith('--') ? argv[1] : undefined;
+  if (target) {
+    try {
+      console.log(renderCommandHelp(target));
+    } catch (err) {
+      printError(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
+  console.log(renderCommandList());
+}
+
 async function runStart() {
   const config = readConfig();
   const portArg = flagValue('port');
@@ -458,10 +482,6 @@ function isEsrch(err: unknown): boolean {
 async function runRegister() {
   const repoPath = resolve(flagValue('path') ?? '.');
   const demoPathArg = flagValue('flow') ?? DEFAULT_FLOW_PATH;
-  const noStart = hasFlag('no-start');
-  const config = readConfig();
-  const overrideUrl = process.env.SEEFLOW_STUDIO_URL?.replace(/\/+$/, '');
-  const url = overrideUrl ?? studioUrl(config);
 
   const fullPath = isAbsolute(demoPathArg) ? demoPathArg : join(repoPath, demoPathArg);
   if (!existsSync(fullPath)) {
@@ -487,38 +507,28 @@ async function runRegister() {
     process.exit(1);
   }
 
-  await ensureStudioRunning(url, config.port, noStart);
-
-  let res: Response;
-  try {
-    res = await fetch(`${url}/api/flows/register`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        name: parsed.data.name,
-        repoPath,
-        flowPath: demoPathArg,
-      }),
-    });
-  } catch (err) {
-    console.error(`Could not reach studio at ${url}: ${String(err)}`);
-    console.error('Start it first: seeflow start');
-    process.exit(1);
+  const ops = createCliOperations();
+  const result = await ops.registerFlow({
+    name: parsed.data.name,
+    repoPath,
+    flowPath: demoPathArg,
+  });
+  if (result.kind !== 'ok') {
+    printOutcome(result);
   }
+  const body = result.data;
 
-  if (!res.ok) {
-    const text = await res.text();
-    console.error(`Studio returned ${res.status}: ${text}`);
-    process.exit(1);
+  // Show the studio URL only when a daemon is actually running.
+  const pid = readPid();
+  if (pid && isPidAlive(pid)) {
+    const config = readConfig();
+    const overrideUrl = process.env.SEEFLOW_STUDIO_URL?.replace(/\/+$/, '');
+    const url = overrideUrl ?? studioUrl(config);
+    console.log(`Registered "${parsed.data.name}" → ${url}/d/${body.slug}`);
+  } else {
+    console.log(`Registered "${parsed.data.name}" (slug: ${body.slug})`);
   }
 
-  const body = (await res.json()) as {
-    id: string;
-    slug: string;
-    sdk?: { outcome: 'written' | 'present' | 'skipped'; filePath: string | null };
-  };
-  console.log(`Registered "${parsed.data.name}" → ${url}/d/${body.slug}`);
-
   if (body.sdk?.outcome === 'written') {
     console.log(`Wrote ${body.sdk.filePath} (event-bound state node detected)`);
   } else if (body.sdk?.outcome === 'present') {
@@ -577,42 +587,55 @@ async function waitForHealth(url: string, timeoutMs: number): Promise<boolean> {
 async function runProjectsCreate() {
   const name = flagValue('name');
   if (!name) printError('Missing required flag: --name');
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(`${url}/api/projects`, { name });
-  const body = (await handleResponse(res)) as object;
-  printOk(body);
+  const ops = createCliOperations();
+  const result = await ops.createProject({ name: name as string });
+  printOutcome(result);
 }
 
 async function runFlowsList() {
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await fetch(`${url}/api/flows`);
-  const body = (await handleResponse(res)) as unknown[];
-  printOk({ flows: body });
+  const ops = createCliOperations();
+  const result = ops.listFlows();
+  printOk({ flows: result.data });
+}
+
+async function runFlowsSummary() {
+  const ops = createCliOperations();
+  const result = ops.listFlowsSummary();
+  printOk({ flows: result.data });
 }
 
 async function runFlowsGet() {
   const flowId = requireArg(1, '<flowId>');
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await fetch(`${url}/api/flows/${encodeURIComponent(flowId)}`);
-  const body = (await handleResponse(res)) as object;
-  printOk(body);
+  const ops = createCliOperations();
+  const result = await ops.getFlow(flowId);
+  printOutcome(result);
+}
+
+async function runFlowsGraph() {
+  const flowId = requireArg(1, '<flowId>');
+  const ops = createCliOperations();
+  const result = await ops.getFlowGraph(flowId);
+  printOutcome(result);
 }
 
 async function runFlowsDelete() {
   const flowId = requireArg(1, '<flowId>');
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await deleteRequest(`${url}/api/flows/${encodeURIComponent(flowId)}`);
-  const body = (await handleResponse(res)) as object;
-  printOk(body);
+  const ops = createCliOperations();
+  const result = ops.deleteFlow(flowId);
+  printOutcome(result);
 }
 
 async function runFlowsLayout() {
   const flowId = requireArg(1, '<flowId>');
-  const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(`${url}/api/flows/${encodeURIComponent(flowId)}/layout`, body);
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  // Body is optional — `{ options? }` shape if provided. Empty when omitted.
+  let options: LayoutOptions | undefined;
+  if (hasFlag('json') || hasFlag('file') || hasFlag('stdin')) {
+    const body = (await bodyFromFlags()) as { options?: LayoutOptions } | undefined;
+    options = body?.options;
+  }
+  const ops = createCliOperations();
+  const result = await ops.applyLayout(flowId, options);
+  printOutcome(result);
 }
 
 async function runFlowsPlay() {
@@ -630,32 +653,45 @@ async function runFlowsPlay() {
 async function runNodesAdd() {
   const flowId = requireArg(1, '<flowId>');
   const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(`${url}/api/flows/${encodeURIComponent(flowId)}/nodes`, body);
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    printError('Body must be an object');
+  }
+  const ops = createCliOperations();
+  const result = await ops.addNode(flowId, body as Record<string, unknown>);
+  printOutcome(result);
 }
 
 async function runNodesAddBulk() {
   const flowId = requireArg(1, '<flowId>');
   const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(`${url}/api/flows/${encodeURIComponent(flowId)}/nodes/bulk`, body);
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const parsed = NodesBulkBodySchema.safeParse(body);
+  if (!parsed.success) {
+    printError(`Invalid nodes:add-bulk body: ${JSON.stringify(parsed.error.issues)}`);
+  }
+  const ops = createCliOperations();
+  const result = await ops.addNodesBulk(flowId, parsed.data);
+  printOutcome(result);
+}
+
+async function runNodesGet() {
+  const flowId = requireArg(1, '<flowId>');
+  const nodeId = requireArg(2, '<nodeId>');
+  const ops = createCliOperations();
+  const result = await ops.getNode(flowId, nodeId);
+  printOutcome(result);
 }
 
 async function runNodesPatch() {
   const flowId = requireArg(1, '<flowId>');
   const nodeId = requireArg(2, '<nodeId>');
   const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await patchJson(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/nodes/${encodeURIComponent(nodeId)}`,
-    body,
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const parsed = NodePatchBodySchema.safeParse(body);
+  if (!parsed.success) {
+    printError(`Invalid nodes:patch body: ${JSON.stringify(parsed.error.issues)}`);
+  }
+  const ops = createCliOperations();
+  const result = await ops.patchNode(flowId, nodeId, parsed.data);
+  printOutcome(result);
 }
 
 async function runNodesMove() {
@@ -671,13 +707,9 @@ async function runNodesMove() {
   if (!Number.isFinite(x) || !Number.isFinite(y)) {
     printError('--x and --y must be finite numbers');
   }
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await patchJson(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/nodes/${encodeURIComponent(nodeId)}/position`,
-    { x, y },
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const ops = createCliOperations();
+  const result = await ops.moveNode(flowId, nodeId, { x, y });
+  printOutcome(result);
 }
 
 async function runNodesReorder() {
@@ -685,7 +717,7 @@ async function runNodesReorder() {
   const nodeId = requireArg(2, '<nodeId>');
   const op = flagValue('op');
   if (!op) printError('nodes:reorder requires --op forward|backward|toFront|toBack|toIndex');
-  let body: Record<string, unknown> = { op };
+  let raw: Record<string, unknown> = { op };
   if (op === 'toIndex') {
     const idxRaw = flagValue('index');
     if (idxRaw === undefined) printError('nodes:reorder --op toIndex requires --index <n>');
@@ -693,71 +725,67 @@ async function runNodesReorder() {
     if (!Number.isInteger(index) || index < 0) {
       printError('--index must be a non-negative integer');
     }
-    body = { op, index };
+    raw = { op, index };
   }
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await patchJson(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/nodes/${encodeURIComponent(nodeId)}/order`,
-    body,
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const parsed = ReorderBodySchema.safeParse(raw);
+  if (!parsed.success) {
+    printError(`Invalid nodes:reorder body: ${JSON.stringify(parsed.error.issues)}`);
+  }
+  const ops = createCliOperations();
+  const result = await ops.reorderNode(flowId, nodeId, parsed.data);
+  printOutcome(result);
 }
 
 async function runNodesDelete() {
   const flowId = requireArg(1, '<flowId>');
   const nodeId = requireArg(2, '<nodeId>');
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await deleteRequest(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/nodes/${encodeURIComponent(nodeId)}`,
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const ops = createCliOperations();
+  const result = await ops.deleteNode(flowId, nodeId);
+  printOutcome(result);
 }
 
 async function runConnectorsAdd() {
   const flowId = requireArg(1, '<flowId>');
   const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(`${url}/api/flows/${encodeURIComponent(flowId)}/connectors`, body);
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    printError('Body must be an object');
+  }
+  const ops = createCliOperations();
+  const result = await ops.addConnector(flowId, body as Record<string, unknown>);
+  printOutcome(result);
 }
 
 async function runConnectorsAddBulk() {
   const flowId = requireArg(1, '<flowId>');
   const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/connectors/bulk`,
-    body,
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const parsed = ConnectorsBulkBodySchema.safeParse(body);
+  if (!parsed.success) {
+    printError(`Invalid connectors:add-bulk body: ${JSON.stringify(parsed.error.issues)}`);
+  }
+  const ops = createCliOperations();
+  const result = await ops.addConnectorsBulk(flowId, parsed.data);
+  printOutcome(result);
 }
 
 async function runConnectorsPatch() {
   const flowId = requireArg(1, '<flowId>');
   const connId = requireArg(2, '<connectorId>');
   const body = await bodyFromFlags();
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await patchJson(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/connectors/${encodeURIComponent(connId)}`,
-    body,
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const parsed = ConnectorPatchBodySchema.safeParse(body);
+  if (!parsed.success) {
+    printError(`Invalid connectors:patch body: ${JSON.stringify(parsed.error.issues)}`);
+  }
+  const ops = createCliOperations();
+  const result = await ops.patchConnector(flowId, connId, parsed.data);
+  printOutcome(result);
 }
 
 async function runConnectorsDelete() {
   const flowId = requireArg(1, '<flowId>');
   const connId = requireArg(2, '<connectorId>');
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await deleteRequest(
-    `${url}/api/flows/${encodeURIComponent(flowId)}/connectors/${encodeURIComponent(connId)}`,
-  );
-  const out = (await handleResponse(res)) as object;
-  printOk(out);
+  const ops = createCliOperations();
+  const result = await ops.deleteConnector(flowId, connId);
+  printOutcome(result);
 }
 
 async function runValidate() {
@@ -780,9 +808,8 @@ async function runValidate() {
       );
     }
   }
-  const { url } = await studioUrlOrDie(hasFlag('no-start'));
-  const res = await postJson(`${url}/api/validate`, { flow, style });
-  const body = (await handleResponse(res)) as { ok?: boolean; issues?: unknown[] };
+  const ops = createCliOperations();
+  const body = ops.validate({ flow, style });
   if (body.ok === false) {
     printError(`Schema validation failed: ${JSON.stringify(body.issues ?? [])}`);
   }

package/src/events.ts

@@ -11,7 +11,8 @@ export type StudioEventType =
   | 'node:done'
   | 'node:error'
   | 'node:status'
-  | 'file:changed';
+  | 'file:changed'
+  | 'registry:reload';
 
 export interface StudioEvent {
   type: StudioEventType;

package/src/file-ref.ts

@@ -14,13 +14,18 @@ const isCleanRelativePath = (p: string): boolean => {
 const invalidMarker = (rawPath: string) => `[seeflow: invalid file:// path '${rawPath}']`;
 const missingMarker = (rawPath: string) => `[seeflow: missing file '${rawPath}']`;
 
+const looksLikeFlowNode = (obj: Record<string, unknown>): obj is { id: string; data: object } =>
+  typeof obj.id === 'string' && obj.data !== null && typeof obj.data === 'object';
+
 /**
  * Resolve every `file://<relative-path>` string in `raw` by reading the file
- * under `<seeflowRoot>` and substituting its UTF-8 content. Missing or invalid
- * paths are replaced with placeholder markers so schema parse still succeeds.
+ * under `<seeflowRoot>/nodes/<nodeId>/` (node-relative) and substituting its
+ * UTF-8 content. Strings outside any enclosing flow node are treated as
+ * invalid — every supported file:// ref currently lives inside `node.data`.
  *
- * Returns the mutated tree plus the sorted, de-duplicated list of relative
- * paths that resolved cleanly (the watcher tracks these for live reload).
+ * Returns the mutated tree plus the sorted, de-duplicated list of seeflow-root-relative
+ * paths that resolved cleanly (the watcher tracks these for live reload, so the
+ * external contract uses `nodes/<id>/<file>` even though the source string is short).
  */
 export function resolveFileRefs(
   raw: unknown,
@@ -34,46 +39,52 @@ export function resolveFileRefs(
     seeflowRealRoot = seeflowRoot;
   }
 
-  const resolveString = (s: string): string => {
+  const resolveString = (s: string, nodeId: string | null): string => {
     if (!s.startsWith(FILE_PREFIX)) return s;
     const relPath = s.slice(FILE_PREFIX.length);
     if (!isCleanRelativePath(relPath)) return invalidMarker(relPath);
+    if (nodeId === null) return invalidMarker(relPath);
 
-    const abs = join(seeflowRoot, relPath);
-    if (!existsSync(abs)) return missingMarker(relPath);
+    const seeflowRelPath = `nodes/${nodeId}/${relPath}`;
+    const abs = join(seeflowRoot, seeflowRelPath);
+    if (!existsSync(abs)) return missingMarker(seeflowRelPath);
 
     // Symlink-escape defense: resolve realpath and confirm it stays inside root.
     let realAbs: string;
     try {
       realAbs = realpathSync(abs);
     } catch {
-      return missingMarker(relPath);
+      return missingMarker(seeflowRelPath);
     }
     const rel = relative(seeflowRealRoot, realAbs);
     if (rel.startsWith('..') || isAbsolute(rel)) return invalidMarker(relPath);
 
     try {
       const content = readFileSync(realAbs, 'utf8');
-      refs.add(relPath);
+      refs.add(seeflowRelPath);
       return content;
     } catch {
-      return missingMarker(relPath);
+      return missingMarker(seeflowRelPath);
     }
   };
 
-  const walk = (node: unknown): unknown => {
-    if (typeof node === 'string') return resolveString(node);
-    if (Array.isArray(node)) return node.map(walk);
+  const walk = (node: unknown, nodeId: string | null): unknown => {
+    if (typeof node === 'string') return resolveString(node, nodeId);
+    if (Array.isArray(node)) return node.map((v) => walk(v, nodeId));
     if (node && typeof node === 'object') {
+      const obj = node as Record<string, unknown>;
+      // Entering a flow node carves out a new resolution context for its subtree:
+      // any file:// inside `data` now resolves relative to nodes/<id>/.
+      const childNodeId = looksLikeFlowNode(obj) ? obj.id : nodeId;
       const out: Record<string, unknown> = {};
-      for (const [k, v] of Object.entries(node as Record<string, unknown>)) {
-        out[k] = walk(v);
+      for (const [k, v] of Object.entries(obj)) {
+        out[k] = walk(v, childNodeId);
       }
       return out;
     }
     return node;
   };
 
-  const resolved = walk(raw);
+  const resolved = walk(raw, null);
   return { resolved, refs: [...refs].sort() };
 }