pmx-canvas 0.1.35 → 0.2.0

package/src/server/html-surface.ts

@@ -108,22 +108,60 @@ function injectIntoHead(html: string, content: string): string {
  * injected when the node's AX capabilities are enabled (opt-in for `html`), and
  * the server re-validates every interaction — so this is a convenience surface,
  * not a trust boundary.
+ *
+ * `emit` returns a Promise that resolves with the interaction result once the
+ * parent acks it (report #55 — built-in confirmation so a click no longer looks
+ * like "nothing happened"). Authors can also `window.PMX_AX.on('ack', cb)` or
+ * listen for the `pmx-ax-ack` CustomEvent. Resolves with an `ax-ack-timeout`
+ * result after 10s if no ack arrives (e.g. an older parent), so `await emit()`
+ * never hangs.
  */
 export function buildAxBridge(axToken: string, nodeId: string): string {
   const token = JSON.stringify(axToken);
   const node = JSON.stringify(nodeId);
   return `<script data-pmx-canvas-ax-bridge>
-const PMX_AX_TOKEN = ${token};
-const PMX_AX_NODE_ID = ${node};
-window.PMX_AX = window.PMX_AX || {};
-window.PMX_AX.emit = function (type, payload) {
-  window.parent.postMessage({
-    source: 'pmx-canvas-ax',
-    token: PMX_AX_TOKEN,
-    nodeId: PMX_AX_NODE_ID,
-    interaction: { type: String(type), payload: payload && typeof payload === 'object' ? payload : {} },
-  }, '*');
-};
+(function () {
+  const PMX_AX_TOKEN = ${token};
+  const PMX_AX_NODE_ID = ${node};
+  window.PMX_AX = window.PMX_AX || {};
+  const pending = new Map();
+  const ackListeners = [];
+  let seq = 0;
+  window.PMX_AX.emit = function (type, payload) {
+    seq += 1;
+    const correlationId = PMX_AX_NODE_ID + '-' + seq + '-' + (Date.now ? Date.now() : 0);
+    window.parent.postMessage({
+      source: 'pmx-canvas-ax',
+      token: PMX_AX_TOKEN,
+      nodeId: PMX_AX_NODE_ID,
+      correlationId: correlationId,
+      interaction: { type: String(type), payload: payload && typeof payload === 'object' ? payload : {} },
+    }, '*');
+    return new Promise(function (resolve) {
+      const timer = setTimeout(function () {
+        pending.delete(correlationId);
+        // Match the real reject shape ({ ok:false, status, code:string, error }) so a
+        // surface inspecting r.code/r.status sees a consistent type on timeout vs reject.
+        resolve({ ok: false, status: 504, code: 'ax-ack-timeout', error: 'ax-ack-timeout' });
+      }, 10000);
+      pending.set(correlationId, function (result) { clearTimeout(timer); resolve(result); });
+    });
+  };
+  window.PMX_AX.on = function (eventType, cb) {
+    if (eventType === 'ack' && typeof cb === 'function') ackListeners.push(cb);
+  };
+  window.addEventListener('message', function (event) {
+    const m = event.data;
+    if (!m || m.source !== 'pmx-canvas-ax-ack' || m.token !== PMX_AX_TOKEN) return;
+    const result = m.result || { ok: false };
+    const resolver = m.correlationId ? pending.get(m.correlationId) : undefined;
+    if (resolver) { pending.delete(m.correlationId); resolver(result); }
+    for (let i = 0; i < ackListeners.length; i += 1) {
+      try { ackListeners[i](result, m.interaction || null); } catch (e) {}
+    }
+    try { window.dispatchEvent(new CustomEvent('pmx-ax-ack', { detail: { result: result, interaction: m.interaction || null } })); } catch (e) {}
+  });
+})();
 </script>`;
 }
 

package/src/server/index.ts

@@ -3,7 +3,9 @@ import { canvasState, IMAGE_MIME_MAP } from './canvas-state.js';
 import type { CanvasAnnotation, CanvasNodeState, CanvasEdge, CanvasLayout, ViewportState } from './canvas-state.js';
 import { buildCanvasAxContext } from './ax-context.js';
 import { applyAxInteraction, type AxInteractionInput, type AxInteractionPublicResult } from './ax-interaction.js';
+import { waitForAxResolution } from './ax-wait.js';
 import type {
+  PmxAxActivityKind,
   PmxAxApprovalGate,
   PmxAxCommandDescriptor,
   PmxAxContext,
@@ -29,7 +31,6 @@ import type {
   PmxAxWorkItemStatus,
 } from './ax-state.js';
 import type { AxTimelineQuery } from './canvas-db.js';
-import { findCanvasExtAppNodeId } from './ext-app-lookup.js';
 import { onFileNodeChanged } from './file-watcher.js';
 import { findOpenCanvasPosition, computeGroupBounds } from './placement.js';
 import { searchNodes, buildSpatialContext } from './spatial-analysis.js';
@@ -38,27 +39,18 @@ import { recomputeCodeGraph, buildCodeGraphSummary, formatCodeGraph } from './co
 import {
   addCanvasNode,
   addCanvasEdge,
-  appendCanvasJsonRenderStream,
-  createCanvasStreamingJsonRenderNode,
-  MARKDOWN_NODE_DEFAULT_SIZE,
-  MCP_APP_NODE_DEFAULT_SIZE,
-  IMAGE_NODE_DEFAULT_SIZE,
-  LEDGER_NODE_DEFAULT_SIZE,
   applyCanvasNodeUpdates,
   arrangeCanvasNodes,
   clearCanvas,
   createCanvasGraphNode,
   createCanvasGroup,
   createCanvasJsonRenderNode,
-  buildStructuredNodeUpdate,
   fitCanvasView,
   deleteCanvasSnapshot,
-  executeCanvasBatch,
   gcCanvasSnapshots,
   groupCanvasNodes,
   listCanvasSnapshots,
   refreshCanvasWebpageNode,
-  removeCanvasNode,
   removeCanvasEdge,
   resolveHtmlContent,
   restoreCanvasSnapshot,
@@ -67,11 +59,19 @@ import {
   syncCanvasRuntimeBackends,
   setCanvasContextPins,
   ungroupCanvasNodes,
-  validateCanvasNodePatch,
-  hasStructuredNodeUpdateFields,
-  hasTraceNodeDataFields,
-  mergeTraceNodeDataFields,
 } from './canvas-operations.js';
+import {
+  buildNodePatch,
+  createBasicCanvasNode,
+  removeNodeCore,
+  setGroupChildrenFromApi,
+} from './operations/ops/nodes.js';
+import { streamJsonRenderCore } from './operations/ops/json-render.js';
+import {
+  executeOperation,
+  runCanvasBatchOperation,
+  type OpenMcpAppCoreResult,
+} from './operations/index.js';
 import { validateCanvasLayout } from './canvas-validation.js';
 import { describeCanvasSchema, validateStructuredCanvasPayload } from './canvas-schema.js';
 import { serializeCanvasNode, type SerializedCanvasNode } from './canvas-serialization.js';
@@ -84,13 +84,9 @@ import {
 } from './web-artifacts.js';
 import {
   closeMcpAppSession,
-  openMcpApp as openExternalMcpApp,
   type ExternalMcpTransportConfig,
 } from './mcp-app-runtime.js';
 import {
-  buildExcalidrawOpenMcpAppInput,
-  ensureExcalidrawCheckpointId,
-  isExcalidrawCreateView,
   type DiagramPresetOpenInput,
 } from './diagram-presets.js';
 import {
@@ -257,29 +253,9 @@ export class PmxCanvas extends EventEmitter {
       if (!groupNode) throw new Error(`Group node "${groupId}" was not created.`);
       return toSdkNode(groupNode);
     }
-    const { id, needsCodeGraphRecompute } = addCanvasNode({
-      ...input,
-      defaultWidth: input.type === 'markdown'
-        ? MARKDOWN_NODE_DEFAULT_SIZE.width
-        : input.type === 'mcp-app'
-          ? MCP_APP_NODE_DEFAULT_SIZE.width
-          : input.type === 'image'
-            ? IMAGE_NODE_DEFAULT_SIZE.width
-            : input.type === 'ledger'
-              ? LEDGER_NODE_DEFAULT_SIZE.width
-              : 360,
-      defaultHeight: input.type === 'markdown'
-        ? MARKDOWN_NODE_DEFAULT_SIZE.height
-        : input.type === 'mcp-app'
-          ? MCP_APP_NODE_DEFAULT_SIZE.height
-          : input.type === 'image'
-            ? IMAGE_NODE_DEFAULT_SIZE.height
-            : input.type === 'ledger'
-              ? LEDGER_NODE_DEFAULT_SIZE.height
-              : 200,
-      fileMode: 'path',
-      ...(input.strictSize ? { strictSize: true } : {}),
-    });
+    // Thin wrapper over the shared operation core (plan-005); the SDK keeps
+    // fileMode 'path' as an explicit visible parameter instead of forked code.
+    const { node, needsCodeGraphRecompute } = createBasicCanvasNode(input, { fileMode: 'path' });
 
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
 
@@ -289,8 +265,6 @@ export class PmxCanvas extends EventEmitter {
       });
     }
 
-    const node = canvasState.getNode(id);
-    if (!node) throw new Error(`Node "${id}" was not created.`);
     return toSdkNode(node);
   }
 
@@ -337,58 +311,18 @@ export class PmxCanvas extends EventEmitter {
   updateNode(id: string, patch: Partial<CanvasNodeState> & Record<string, unknown>): void {
     const existing = canvasState.getNode(id);
     if (!existing) return;
-    const resolvedPatch: Partial<CanvasNodeState> = {};
-    if (patch.position) resolvedPatch.position = patch.position;
-    if (patch.size) resolvedPatch.size = patch.size;
-    if (patch.collapsed !== undefined) resolvedPatch.collapsed = patch.collapsed;
-    if (patch.pinned !== undefined) resolvedPatch.pinned = patch.pinned;
-    if (patch.dockPosition !== undefined) resolvedPatch.dockPosition = patch.dockPosition;
-
-    if (hasStructuredNodeUpdateFields(patch)) {
-      resolvedPatch.data = buildStructuredNodeUpdate(existing, patch).data;
-    } else if (
-      patch.data !== undefined ||
-      patch.title !== undefined ||
-      patch.content !== undefined ||
-      typeof patch.arrangeLocked === 'boolean' ||
-      typeof patch.strictSize === 'boolean' ||
-      (existing.type === 'trace' && hasTraceNodeDataFields(patch))
-    ) {
-      const nextData = {
-        ...existing.data,
-        ...(patch.data && typeof patch.data === 'object' && !Array.isArray(patch.data) ? patch.data : {}),
-        ...(typeof patch.title === 'string' ? { title: patch.title } : {}),
-        ...(typeof patch.content === 'string' ? { content: patch.content } : {}),
-        ...(typeof patch.arrangeLocked === 'boolean' ? { arrangeLocked: patch.arrangeLocked } : {}),
-        ...(typeof patch.strictSize === 'boolean' ? { strictSize: patch.strictSize } : {}),
-      };
-      resolvedPatch.data = existing.type === 'trace'
-        ? mergeTraceNodeDataFields(nextData, patch)
-        : nextData;
-    }
-
-    const error = validateCanvasNodePatch({
-      ...(resolvedPatch.position ? { position: resolvedPatch.position } : {}),
-      ...(resolvedPatch.size ? { size: resolvedPatch.size } : {}),
-    });
-    if (error) {
-      throw new Error(error);
-    }
+    // Thin wrapper over the shared patch core (plan-005): the SDK now carries
+    // the same superset semantics as HTTP/MCP (webpage titleSource/url, html
+    // top-level fields, axCapabilities merge, group children).
+    const { patch: resolvedPatch, groupChildIds } = buildNodePatch(existing, patch);
     canvasState.updateNode(id, resolvedPatch);
+    if (groupChildIds !== undefined) setGroupChildrenFromApi(id, groupChildIds);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
   }
 
+  /** Remove a node. Missing id throws (plan-005 unifies this across surfaces). */
   removeNode(id: string): void {
-    const existing = canvasState.getNode(id);
-    const appSessionId =
-      existing?.type === 'mcp-app' && typeof existing.data.appSessionId === 'string'
-        ? existing.data.appSessionId
-        : null;
-    if (appSessionId) {
-      closeMcpAppSession(appSessionId);
-    }
-    const { removed, needsCodeGraphRecompute } = removeCanvasNode(id);
-    if (!removed) return;
+    const { needsCodeGraphRecompute } = removeNodeCore(id);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
 
     if (needsCodeGraphRecompute) {
@@ -512,8 +446,8 @@ export class PmxCanvas extends EventEmitter {
     return canvasState.getAxState();
   }
 
-  getAxContext(): PmxAxContext {
-    return buildCanvasAxContext();
+  getAxContext(options?: { consumer?: string }): PmxAxContext {
+    return buildCanvasAxContext(options?.consumer);
   }
 
   setAxFocus(nodeIds: string[], options?: { source?: PmxAxSource }): PmxAxFocusState {
@@ -710,6 +644,84 @@ export class PmxCanvas extends EventEmitter {
     return modeRequest;
   }
 
+  // ── Activity ingestion (primitive A — bidirectional board) ────────
+  ingestActivity(
+    input: {
+      kind: PmxAxActivityKind;
+      title: string;
+      summary?: string | null;
+      outcome?: 'success' | 'failure';
+      ref?: string | null;
+      nodeIds?: string[];
+      data?: Record<string, unknown> | null;
+      reactions?: {
+        workItem?: false | { status?: PmxAxWorkItemStatus; detail?: string | null };
+        evidence?: false | { kind?: PmxAxEvidenceKind; body?: string | null };
+        review?: false | { severity?: PmxAxReviewSeverity; kind?: PmxAxReviewKind; anchorType?: PmxAxReviewAnchorType; nodeId?: string | null };
+      };
+    },
+    options?: { source?: PmxAxSource },
+  ): { event: PmxAxEvent; workItem: PmxAxWorkItem | null; evidence: PmxAxEvidence | null; review: PmxAxReviewAnnotation | null } {
+    const result = canvasState.ingestActivity(input, { source: options?.source ?? 'sdk' });
+    emitPrimaryWorkbenchEvent('ax-event-created', { event: result.event });
+    if (result.workItem) emitPrimaryWorkbenchEvent('ax-state-changed', { workItem: result.workItem });
+    if (result.evidence) emitPrimaryWorkbenchEvent('ax-event-created', { evidence: result.evidence });
+    if (result.review) emitPrimaryWorkbenchEvent('ax-state-changed', { reviewAnnotation: result.review });
+    return result;
+  }
+
+  // ── Single-item readers + blocking waits (primitive D — gates that gate) ──
+  getApproval(id: string): PmxAxApprovalGate | null {
+    return canvasState.getApproval(id);
+  }
+
+  getElicitation(id: string): PmxAxElicitation | null {
+    return canvasState.getElicitation(id);
+  }
+
+  getModeRequest(id: string): PmxAxModeRequest | null {
+    return canvasState.getModeRequest(id);
+  }
+
+  async awaitApproval(
+    id: string,
+    options?: { timeoutMs?: number; signal?: AbortSignal },
+  ): Promise<{ approvalGate: PmxAxApprovalGate | null; pending: boolean }> {
+    const { value, pending } = await waitForAxResolution<PmxAxApprovalGate>({
+      read: () => canvasState.getApproval(id),
+      isResolved: (g) => g.status !== 'pending',
+      timeoutMs: options?.timeoutMs ?? 30000,
+      ...(options?.signal ? { signal: options.signal } : {}),
+    });
+    return { approvalGate: value, pending };
+  }
+
+  async awaitElicitation(
+    id: string,
+    options?: { timeoutMs?: number; signal?: AbortSignal },
+  ): Promise<{ elicitation: PmxAxElicitation | null; pending: boolean }> {
+    const { value, pending } = await waitForAxResolution<PmxAxElicitation>({
+      read: () => canvasState.getElicitation(id),
+      isResolved: (e) => e.status !== 'pending',
+      timeoutMs: options?.timeoutMs ?? 30000,
+      ...(options?.signal ? { signal: options.signal } : {}),
+    });
+    return { elicitation: value, pending };
+  }
+
+  async awaitMode(
+    id: string,
+    options?: { timeoutMs?: number; signal?: AbortSignal },
+  ): Promise<{ modeRequest: PmxAxModeRequest | null; pending: boolean }> {
+    const { value, pending } = await waitForAxResolution<PmxAxModeRequest>({
+      read: () => canvasState.getModeRequest(id),
+      isResolved: (m) => m.status !== 'pending',
+      timeoutMs: options?.timeoutMs ?? 30000,
+      ...(options?.signal ? { signal: options.signal } : {}),
+    });
+    return { modeRequest: value, pending };
+  }
+
   getCommandRegistry(): PmxAxCommandDescriptor[] {
     return canvasState.getCommandRegistry();
   }
@@ -850,13 +862,6 @@ export class PmxCanvas extends EventEmitter {
     return validateCanvasLayout(canvasState.getLayout());
   }
 
-  private findCanvasExtAppNodeId(toolCallId: string): string | null {
-    return findCanvasExtAppNodeId(toolCallId, {
-      getNode: (id) => canvasState.getNode(id),
-      listNodes: () => canvasState.getLayout().nodes,
-    });
-  }
-
   describeSchema() {
     return describeCanvasSchema();
   }
@@ -870,14 +875,22 @@ export class PmxCanvas extends EventEmitter {
   }
 
   async runBatch(operations: Array<{ op: string; assign?: string; args?: Record<string, unknown> }>) {
-    const result = await executeCanvasBatch(operations);
-    emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
-    return result;
+    // Delegates to the canvas.batch registry meta-op (plan-008 Wave 2). The op
+    // emits the single final canvas-layout-update itself (via the registry
+    // emitter, which server.ts wires to emitPrimaryWorkbenchEvent) — do NOT
+    // emit again here or the frame would fire twice.
+    return await runCanvasBatchOperation(operations);
   }
 
   async buildWebArtifact(
-    input: WebArtifactBuildInput & { openInCanvas?: boolean },
+    input: WebArtifactBuildInput & { openInCanvas?: boolean; includeLogs?: boolean },
   ): Promise<WebArtifactCanvasBuildResult> {
+    // The registry's webartifact.build op wraps buildWebArtifactOnCanvas and
+    // returns a wire ENVELOPE (path/bytes/…); the SDK's documented return is the
+    // full WebArtifactCanvasBuildResult, so the SDK calls the build runtime
+    // directly here (the op core is the same buildWebArtifactOnCanvas; the node
+    // creation emits its own canvas-layout-update). The op and the SDK share the
+    // single build runtime — no behavior divergence.
     return buildWebArtifactOnCanvas(input);
   }
 
@@ -893,75 +906,21 @@ export class PmxCanvas extends EventEmitter {
     width?: number;
     height?: number;
     timeoutMs?: number;
-  }): Promise<{ ok: true; id?: string; nodeId: string | null; toolCallId: string; sessionId: string; resourceUri: string }> {
-    const targetNode = input.nodeId ? canvasState.getNode(input.nodeId) : undefined;
-    if (input.nodeId && !targetNode) {
-      throw new Error(`Node "${input.nodeId}" not found.`);
-    }
-    if (targetNode && (targetNode.type !== 'mcp-app' || targetNode.data.mode !== 'ext-app')) {
-      throw new Error(`Node "${input.nodeId}" is not an external app node.`);
-    }
-
-    const opened = await openExternalMcpApp({
-      transport: input.transport,
-      toolName: input.toolName,
-      ...(input.toolArguments ? { toolArguments: input.toolArguments } : {}),
-      ...(input.serverName ? { serverName: input.serverName } : {}),
-      ...(typeof input.timeoutMs === 'number' ? { timeoutMs: input.timeoutMs } : {}),
-    });
-    const toolCallId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    const previousSessionId = targetNode?.data.appSessionId;
-    if (typeof previousSessionId === 'string' && previousSessionId.trim().length > 0) {
-      closeMcpAppSession(previousSessionId);
-    }
-    const nodeIdSeed = input.nodeId ?? `ext-app-${toolCallId}`;
-    const toolResult = isExcalidrawCreateView(opened.serverName, opened.toolName)
-      ? ensureExcalidrawCheckpointId(opened.toolResult, nodeIdSeed)
-      : opened.toolResult;
-    emitPrimaryWorkbenchEvent('ext-app-open', {
-      toolCallId,
-      nodeId: nodeIdSeed,
-      title: input.title ?? opened.tool.title ?? opened.tool.name,
-      html: opened.html,
-      toolInput: opened.toolInput,
-      serverName: opened.serverName,
-      toolName: opened.toolName,
-      appSessionId: opened.sessionId,
-      transportConfig: input.transport,
-      resourceUri: opened.resourceUri,
-      toolDefinition: opened.tool,
-      sessionStatus: 'ready',
-      sessionError: null,
-      ...(opened.resourceMeta ? { resourceMeta: opened.resourceMeta } : {}),
-      ...(typeof input.x === 'number' ? { x: input.x } : {}),
-      ...(typeof input.y === 'number' ? { y: input.y } : {}),
-      ...(typeof input.width === 'number' ? { width: input.width } : {}),
-      ...(typeof input.height === 'number' ? { height: input.height } : {}),
-    });
-    emitPrimaryWorkbenchEvent('ext-app-result', {
-      toolCallId,
-      nodeId: nodeIdSeed,
-      serverName: opened.serverName,
-      toolName: opened.toolName,
-      success: toolResult.isError !== true,
-      result: toolResult,
-    });
-    const nodeId = input.nodeId ?? this.findCanvasExtAppNodeId(toolCallId);
-    return {
-      ok: true,
-      ...(nodeId ? { id: nodeId } : {}),
-      nodeId,
-      toolCallId,
-      sessionId: opened.sessionId,
-      resourceUri: opened.resourceUri,
-    };
+  }): Promise<OpenMcpAppCoreResult> {
+    // Delegate to the mcpapp.open registry op (plan-008 Wave 4). The op handler
+    // is the relocated legacy body (toolCallId, openExternalMcpApp, prior-session
+    // close, ext-app-open + ext-app-result via ctx.emit → the registry emitter
+    // wired to emitPrimaryWorkbenchEvent). mutates:false, so the registry adds no
+    // canvas-layout-update; the two ext-app-* frames fire exactly once.
+    return await executeOperation('mcpapp.open', input) as OpenMcpAppCoreResult;
   }
 
   async addDiagram(
     input: DiagramPresetOpenInput,
-  ): Promise<{ ok: true; id?: string; nodeId: string | null; toolCallId: string; sessionId: string; resourceUri: string }> {
-    const built = buildExcalidrawOpenMcpAppInput(input);
-    return this.openMcpApp(built);
+  ): Promise<OpenMcpAppCoreResult> {
+    // Delegate to the diagram.open registry op, which builds the Excalidraw
+    // OpenMcpApp input and dispatches to the shared open core (one ext-app-* pair).
+    return await executeOperation('diagram.open', input) as OpenMcpAppCoreResult;
   }
 
   addJsonRenderNode(
@@ -997,32 +956,17 @@ export class PmxCanvas extends EventEmitter {
     elementCount: number;
     streamStatus: 'open' | 'closed';
   } {
-    let nodeId = input.nodeId;
-    let url = '';
-    if (!nodeId) {
-      const created = createCanvasStreamingJsonRenderNode({
-        ...(input.title !== undefined ? { title: input.title } : {}),
-        ...(input.x !== undefined ? { x: input.x } : {}),
-        ...(input.y !== undefined ? { y: input.y } : {}),
-        ...(input.width !== undefined ? { width: input.width } : {}),
-        ...(input.height !== undefined ? { height: input.height } : {}),
-        ...(input.strictSize ? { strictSize: true } : {}),
-      });
-      nodeId = created.id;
-      url = created.url;
-    } else {
-      url = String(canvasState.getNode(nodeId)?.data.url ?? '');
-    }
-    const result = appendCanvasJsonRenderStream(
-      nodeId,
-      Array.isArray(input.patches) ? input.patches : [],
-      input.done === true,
-    );
-    if (!result.ok) throw new Error(result.error);
+    // Thin wrapper over the shared create-or-append core (plan-005). The op
+    // handler and this SDK method now share one implementation; the SDK emits
+    // the layout update itself (it does not flow through the registry's
+    // `mutates` path). `streamJsonRenderCore` throws OperationError (an Error
+    // subclass with the same message) on a bad append target. The core's
+    // result carries an extra `ok: true`; the SDK's wire shape omits it.
+    const result = streamJsonRenderCore(input);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
     return {
-      id: nodeId,
-      url,
+      id: result.id,
+      url: result.url,
       applied: result.applied,
       skipped: result.skipped,
       specVersion: result.specVersion,