pmx-canvas 0.3.2 → 0.3.4

package/src/mcp/server.ts

@@ -175,53 +175,6 @@ function encodeBase64(bytes: Uint8Array): string {
   return Buffer.from(bytes).toString('base64');
 }
 
-function wantsFullPayload(input: { full?: boolean; verbose?: boolean; includeData?: boolean } = {}): boolean {
-  return input.full === true || input.verbose === true || input.includeData === true;
-}
-
-function compactNodePayload(node: Awaited<ReturnType<CanvasAccess['getNode']>>): Record<string, unknown> | null {
-  if (!node) return null;
-  const serialized = serializeCanvasNode(node);
-  return {
-    id: serialized.id,
-    type: serialized.type,
-    kind: serialized.kind,
-    title: serialized.title,
-    content: serialized.content,
-    position: serialized.position,
-    size: serialized.size,
-    pinned: serialized.pinned,
-    collapsed: serialized.collapsed,
-    dockPosition: serialized.dockPosition,
-    provenance: serialized.provenance,
-  };
-}
-
-function compactLayoutPayload(
-  layout: Awaited<ReturnType<CanvasAccess['getLayout']>>,
-  pinnedIds: string[],
-): Record<string, unknown> {
-  return {
-    summary: buildSummaryFromLayout(layout, pinnedIds),
-    viewport: layout.viewport,
-    annotations: (layout.annotations ?? []).map((annotation) =>
-      summarizeCanvasAnnotationForContext(annotation, layout.nodes),
-    ),
-    nodes: layout.nodes
-      .map((node) => compactNodePayload(node))
-      .filter((node): node is Record<string, unknown> => node !== null),
-    edges: layout.edges.map((edge) => ({
-      id: edge.id,
-      from: edge.from,
-      to: edge.to,
-      type: edge.type,
-      ...(edge.label ? { label: edge.label } : {}),
-      ...(edge.style ? { style: edge.style } : {}),
-      ...(edge.animated !== undefined ? { animated: edge.animated } : {}),
-    })),
-  };
-}
-
 function agentSafeFullLayoutPayload(layout: Awaited<ReturnType<CanvasAccess['getLayout']>>): Record<string, unknown> {
   return {
     ...serializeCanvasLayoutForAgent(layout),

package/src/server/bundled-skills.ts

@@ -65,7 +65,11 @@ export function findBundledSkillsRoot(): string | null {
   return null;
 }
 
-function parseFrontmatterDescription(markdown: string): string {
+function parseFrontmatterDescription(rawMarkdown: string): string {
+  // Normalize CRLF first: a git checkout with autocrlf (the Windows default)
+  // puts a trailing \r on every line, which `(.*)$` cannot match (JS `.` and
+  // `$` both exclude \r), silently emptying every description.
+  const markdown = rawMarkdown.replace(/\r\n/g, '\n');
   // YAML frontmatter lives between two `---` fences at the very top.
   if (!markdown.startsWith('---')) return '';
   const end = markdown.indexOf('\n---', 3);

package/src/server/canvas-operations.ts

@@ -856,6 +856,14 @@ export function scheduleCodeGraphRecompute(onComplete?: () => void): void {
   }, 300);
 }
 
+/** Clear a pending recompute so the timer cannot outlive its server (start/stop cycles, tests). */
+export function cancelCodeGraphRecompute(): void {
+  if (codeGraphTimer) {
+    clearTimeout(codeGraphTimer);
+    codeGraphTimer = null;
+  }
+}
+
 /**
  * Resolve an html-node `html` field that may be a path to a local .html/.htm file.
  *

package/src/server/diagram-presets.ts

@@ -41,6 +41,20 @@ export const EXCALIDRAW_MCP_TRANSPORT: ExternalMcpTransportConfig = {
   url: EXCALIDRAW_MCP_URL,
 };
 
+/**
+ * The diagram preset targets the hosted Excalidraw MCP server. Tests set
+ * PMX_CANVAS_EXCALIDRAW_MCP_COMMAND (a stdio command line, e.g.
+ * "bun run tests/fixtures/mcp-app-fixture.ts") so the unit suite never does a
+ * real network round-trip — the hosted dependency made diagram tests time out
+ * under parallel load (plan-009 M8).
+ */
+export function resolveExcalidrawTransport(): ExternalMcpTransportConfig {
+  const override = process.env.PMX_CANVAS_EXCALIDRAW_MCP_COMMAND?.trim();
+  if (!override) return EXCALIDRAW_MCP_TRANSPORT;
+  const [command = override, ...args] = override.split(/\s+/);
+  return { type: 'stdio', command, args };
+}
+
 export interface DiagramPresetOpenInput {
   elements: unknown;
   nodeId?: string;
@@ -379,7 +393,7 @@ export function ensureExcalidrawCheckpointId(
 export function buildExcalidrawOpenMcpAppInput(input: DiagramPresetOpenInput): ExcalidrawOpenMcpAppInput {
   const elements = normalizeExcalidrawElementsForToolInput(input.elements);
   const out: ExcalidrawOpenMcpAppInput = {
-    transport: EXCALIDRAW_MCP_TRANSPORT,
+    transport: resolveExcalidrawTransport(),
     toolName: EXCALIDRAW_CREATE_VIEW_TOOL,
     serverName: EXCALIDRAW_SERVER_NAME,
     toolArguments: { elements },

package/src/server/html-surface.ts

@@ -15,6 +15,11 @@
  * postMessage required.
  */
 
+import {
+  AX_SURFACE_ACK_SOURCE,
+  AX_SURFACE_EMIT_SOURCE,
+  HTML_SURFACE_PUSH_SOURCE,
+} from '../shared/ax-surface-protocol.js';
 import { contentHeightReporterTag } from '../shared/content-height-reporter.js';
 
 export type SurfaceTheme = 'dark' | 'light' | 'high-contrast';
@@ -54,7 +59,7 @@ function buildThemeBridge(themeToken: string): string {
 const PMX_CANVAS_THEME_TOKEN = ${token};
 window.addEventListener('message', (event) => {
   const message = event.data;
-  if (!message || message.source !== 'pmx-canvas-html-node' || message.type !== 'theme-update' || message.token !== PMX_CANVAS_THEME_TOKEN) return;
+  if (!message || message.source !== '${HTML_SURFACE_PUSH_SOURCE}' || message.type !== 'theme-update' || message.token !== PMX_CANVAS_THEME_TOKEN) return;
   if (typeof message.theme !== 'string') return;
   document.documentElement.setAttribute('data-pmx-canvas-theme', message.theme);
   document.documentElement.setAttribute('data-theme', message.theme);
@@ -74,12 +79,12 @@ function buildPresentationEscapeBridge(exitToken: string): string {
 const PMX_CANVAS_PRESENTATION_EXIT_TOKEN = ${token};
 document.addEventListener('keydown', (event) => {
   if (event.key === 'Escape') {
-    window.parent.postMessage({ source: 'pmx-canvas-html-node', type: 'presentation-exit', token: PMX_CANVAS_PRESENTATION_EXIT_TOKEN }, '*');
+    window.parent.postMessage({ source: '${HTML_SURFACE_PUSH_SOURCE}', type: 'presentation-exit', token: PMX_CANVAS_PRESENTATION_EXIT_TOKEN }, '*');
   }
 }, true);
 window.addEventListener('message', (event) => {
   const message = event.data;
-  if (!message || message.source !== 'pmx-canvas-html-node' || message.type !== 'presentation-key' || message.token !== PMX_CANVAS_PRESENTATION_EXIT_TOKEN) return;
+  if (!message || message.source !== '${HTML_SURFACE_PUSH_SOURCE}' || message.type !== 'presentation-key' || message.token !== PMX_CANVAS_PRESENTATION_EXIT_TOKEN) return;
   if (typeof message.key !== 'string') return;
   if (typeof window.PMX_CANVAS_PRESENTATION_HANDLE_KEY === 'function') {
     window.PMX_CANVAS_PRESENTATION_HANDLE_KEY(message.key);
@@ -131,7 +136,7 @@ export function buildAxBridge(axToken: string, nodeId: string): string {
     seq += 1;
     const correlationId = PMX_AX_NODE_ID + '-' + seq + '-' + (Date.now ? Date.now() : 0);
     window.parent.postMessage({
-      source: 'pmx-canvas-ax',
+      source: '${AX_SURFACE_EMIT_SOURCE}',
       token: PMX_AX_TOKEN,
       nodeId: PMX_AX_NODE_ID,
       correlationId: correlationId,
@@ -152,7 +157,7 @@ export function buildAxBridge(axToken: string, nodeId: string): string {
   };
   window.addEventListener('message', function (event) {
     const m = event.data;
-    if (!m || m.source !== 'pmx-canvas-ax-ack' || m.token !== PMX_AX_TOKEN) return;
+    if (!m || m.source !== '${AX_SURFACE_ACK_SOURCE}' || 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); }
@@ -182,7 +187,7 @@ export function buildAxStateBridge(axToken: string, snapshotJson: string): strin
   window.PMX_AX.state = ${snapshotJson};
   window.addEventListener('message', function (event) {
     const m = event.data;
-    if (!m || m.source !== 'pmx-canvas-html-node' || m.type !== 'ax-update' || m.token !== PMX_AX_STATE_TOKEN) return;
+    if (!m || m.source !== '${HTML_SURFACE_PUSH_SOURCE}' || m.type !== 'ax-update' || m.token !== PMX_AX_STATE_TOKEN) return;
     window.PMX_AX.state = m.state;
     try { window.dispatchEvent(new CustomEvent('pmx-ax-update', { detail: m.state })); } catch (e) {}
   });

package/src/server/operations/composites.ts

@@ -94,12 +94,6 @@ export interface CompositeToolDefinition {
    * raise a loud error instead of silently no-op'ing.
    */
   resolveOp?: (input: { kind: string; action: string }) => string | undefined;
-  /**
-   * Two-discriminator extension: human-readable `(kind, action)` for a member op
-   * (the inverse of `resolveOp`), used to build that op's deprecation note. The
-   * `kind` field-collision is resolved here (see `gateFieldRemap`).
-   */
-  describeOp?: (opName: string) => { kind: string; action: string } | undefined;
   /**
    * Field-name remap applied to the composite's advertised schema and undone at
    * dispatch. Resolves a collision between a discriminator name and a member-op
@@ -131,7 +125,7 @@ function resolveGateOp(input: { kind: string; action: string }): string | undefi
   return undefined;
 }
 
-/** The 9 gate ops, in (kind, action) order — single source for memberOps + describeOp. */
+/** The 9 gate ops, in (kind, action) order — single source for memberOps. */
 const GATE_OPS: Array<{ op: string; kind: string; action: string }> = GATE_KINDS.flatMap((kind) =>
   GATE_ACTIONS.map((action) => {
     const op = resolveGateOp({ kind, action });
@@ -143,11 +137,6 @@ const GATE_OPS: Array<{ op: string; kind: string; action: string }> = GATE_KINDS
   }),
 );
 
-function describeGateOp(opName: string): { kind: string; action: string } | undefined {
-  const match = GATE_OPS.find((entry) => entry.op === opName);
-  return match ? { kind: match.kind, action: match.action } : undefined;
-}
-
 export const compositeToolDefinitions: CompositeToolDefinition[] = [
   {
     toolName: 'canvas_node',
@@ -289,7 +278,6 @@ export const compositeToolDefinitions: CompositeToolDefinition[] = [
     },
     memberOps: GATE_OPS.map((entry) => entry.op),
     resolveOp: resolveGateOp,
-    describeOp: describeGateOp,
     // ax.approval.request defines its own optional `action` field (a
     // machine-readable identifier the gate guards) — it collides with the gate
     // lifecycle `action` discriminator. Namespace it to `approvalAction` in the

package/src/server/operations/invoker.ts

@@ -68,19 +68,26 @@ export class HttpOperationInvoker implements OperationInvoker {
     const response = await fetch(url, init);
     const text = await response.text();
     let parsed: unknown = null;
+    let parsedAsJson = false;
     if (text.length > 0) {
       try {
         parsed = JSON.parse(text) as unknown;
+        parsedAsJson = true;
       } catch {
         parsed = { error: text };
       }
     }
     if (!response.ok) {
-      if (route.errorBodyAsResult) return parsed;
+      // errorBodyAsResult carries the route's STRUCTURED partial-failure
+      // envelope (e.g. canvas_batch { ok:false, failedIndex, ... }) through as
+      // a result. A non-JSON error body (an HTML 502 from a proxy, a foreign
+      // service) is not that envelope — fall through to the throw path so the
+      // caller still fails loudly with a nonzero exit.
+      if (route.errorBodyAsResult && parsedAsJson) return parsed;
       const message =
-        parsed !== null && typeof parsed === 'object' && 'error' in parsed
+        parsedAsJson && parsed !== null && typeof parsed === 'object' && 'error' in parsed
           ? String((parsed as { error?: unknown }).error)
-          : `HTTP ${response.status}`;
+          : `HTTP ${response.status}${text.length > 0 ? `: ${text.slice(0, 200)}` : ''}`;
       throw new OperationError(message, toOperationErrorStatus(response.status));
     }
     return parsed;

package/src/server/operations/mcp.ts

@@ -11,7 +11,7 @@ import { z, type ZodRawShape, type ZodTypeAny } from 'zod';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { getOperation, listOperations } from './registry.js';
 import type { OperationInvoker } from './invoker.js';
-import { OperationError, type OperationMcpToolHost } from './types.js';
+import { OperationError, type Operation, type OperationMcpToolHost } from './types.js';
 import { compositeFoldedOpNames, compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
 
 export interface OperationToolHost extends OperationMcpToolHost {
@@ -176,6 +176,43 @@ function stripCompositeDiscriminators(
   return out;
 }
 
+/**
+ * Per-op cache of the MCP arg names its extraShape marks REQUIRED (a schema
+ * that rejects `undefined`). These are the standalone tools' old contracts,
+ * which buildCompositeShape flattens to all-optional — the composite handler
+ * re-enforces them at dispatch so a missing required field fails loudly and
+ * names the field, instead of failing deep in the handler or silently
+ * no-oping (the `q`-vs-`query` zero-results trap from the 0.3.1 test report).
+ */
+const requiredFieldsCache = new WeakMap<object, string[]>();
+
+// Advertised input aliases that satisfy a required extraShape field: the op's
+// handler accepts either name, so the pre-dispatch check must too. (The only
+// such collision across all 15 composites — edges.ts advertises `edge_id` as a
+// legacy alias for `id` and its handler reads `edge_id ?? id`.)
+const REQUIRED_FIELD_ALIASES: Record<string, Record<string, readonly string[]>> = {
+  'edge.remove': { id: ['edge_id'] },
+};
+
+function requiredFieldSatisfied(opName: string, field: string, rest: Record<string, unknown>): boolean {
+  if (rest[field] !== undefined) return true;
+  const aliases = REQUIRED_FIELD_ALIASES[opName]?.[field] ?? [];
+  return aliases.some((alias) => rest[alias] !== undefined);
+}
+
+function requiredMcpFields(op: Operation): string[] {
+  const tool = op.mcp;
+  if (!tool?.extraShape) return [];
+  let keys = requiredFieldsCache.get(tool);
+  if (!keys) {
+    keys = Object.entries(tool.extraShape)
+      .filter(([, schema]) => !(schema as ZodTypeAny).safeParse(undefined).success)
+      .map(([key]) => key);
+    requiredFieldsCache.set(tool, keys);
+  }
+  return keys;
+}
+
 /**
  * Register composite (action-discriminated) MCP tools (plan-006). Each action
  * dispatches to a registered operation, reusing that op's `mcp.buildInput` and
@@ -188,6 +225,12 @@ export function registerCompositeTools(
   definitions: CompositeToolDefinition[] = compositeToolDefinitions,
 ): void {
   for (const def of definitions) {
+    // Public composite name for each op field (inverse of fieldRemap), so
+    // required-field errors name the argument the agent actually sends.
+    const publicFieldName = new Map<string, string>();
+    for (const [publicKey, opField] of Object.entries(def.fieldRemap ?? {})) {
+      publicFieldName.set(opField, publicKey);
+    }
     server.tool(def.toolName, def.description, buildCompositeShape(def), async (input: Record<string, unknown>) => {
       try {
         const host = await getHost();
@@ -197,6 +240,13 @@ export function registerCompositeTools(
         // and undo any field remap; the rest is the op's raw MCP args — the same
         // value the standalone tool would receive.
         const rest = stripCompositeDiscriminators(def, input);
+        const missing = requiredMcpFields(op).filter((field) => !requiredFieldSatisfied(opName, field, rest));
+        if (missing.length > 0) {
+          const named = missing.map((field) => `"${publicFieldName.get(field) ?? field}"`).join(', ');
+          throw new OperationError(
+            `${def.toolName} action "${String(input.action)}" requires ${named}. Unknown parameters are ignored — check the argument names.`,
+          );
+        }
         const opInput = op.mcp?.buildInput ? op.mcp.buildInput(rest) : rest;
         const result = await host.invoker().invoke(opName, opInput);
         if (op.mcp?.formatResult) {

package/src/server/operations/ops/app.ts

@@ -405,6 +405,11 @@ const webArtifactOperation = defineOperation<z.infer<typeof webArtifactSchema>,
   http: {
     method: 'POST',
     path: '/api/canvas/web-artifact',
+    // Build failures throw OperationError, served as { ok:false, error }. The
+    // CLI prints that failure envelope on STDOUT and exits 1
+    // (cli-node.test.ts:2502-2548 pins it), so the HTTP invoker must return
+    // the non-2xx body instead of throwing — mirrors canvas.batch/webview.start.
+    errorBodyAsResult: true,
   },
   mcp: {
     toolName: 'canvas_build_web_artifact',

package/src/server/server.ts

@@ -61,6 +61,7 @@ import { resolveNodeAxCapabilities } from './ax-interaction.js';
 import { normalizeCanvasTheme, type CanvasTheme } from './canvas-db.js';
 import { validateLocalImageFile } from './image-source.js';
 import {
+  cancelCodeGraphRecompute,
   primeCanvasRuntimeBackends,
   setCanvasLayoutUpdateEmitter,
   syncCanvasRuntimeBackends,
@@ -1120,6 +1121,44 @@ function handleFrameDocument(pathname: string): Response {
   });
 }
 
+// ── Ext-app recovery diagnostics (0.3.2 report Finding N) ──────
+//
+// The WebKit black-tile recovery trail is otherwise trapped inside host panels
+// without devtools (the Copilot WKWebView). Clients mirror their bounded
+// recovery log here; agents/testers read it back over HTTP. In-memory only,
+// diagnostics-grade: no persistence, no snapshots.
+const EXT_APP_RECOVERY_LOG_MAX = 500;
+const EXT_APP_RECOVERY_FIELD_MAX = 300;
+const extAppRecoveryEntries: Array<Record<string, unknown>> = [];
+
+/**
+ * Clamp a reported entry to the known trail shape ({ t, nodeId, event,
+ * visibility }) with bounded string lengths. The count trim below caps the
+ * number of entries; this caps bytes per entry, so the in-memory log stays
+ * diagnostics-sized no matter what a client posts.
+ */
+function clampExtAppRecoveryEntry(entry: Record<string, unknown>): Record<string, unknown> {
+  const clamped: Record<string, unknown> = {};
+  if (typeof entry.t === 'number' && Number.isFinite(entry.t)) clamped.t = entry.t;
+  for (const key of ['nodeId', 'event', 'visibility'] as const) {
+    const value = entry[key];
+    if (typeof value === 'string') clamped[key] = value.slice(0, EXT_APP_RECOVERY_FIELD_MAX);
+  }
+  return clamped;
+}
+
+function handleExtAppRecoveryReport(entries: unknown): Response {
+  if (!Array.isArray(entries)) return responseJson({ ok: false, error: 'entries must be an array' }, 400);
+  for (const entry of entries.slice(0, 100)) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+    extAppRecoveryEntries.push(clampExtAppRecoveryEntry(entry as Record<string, unknown>));
+  }
+  if (extAppRecoveryEntries.length > EXT_APP_RECOVERY_LOG_MAX) {
+    extAppRecoveryEntries.splice(0, extAppRecoveryEntries.length - EXT_APP_RECOVERY_LOG_MAX);
+  }
+  return responseJson({ ok: true, total: extAppRecoveryEntries.length });
+}
+
 // ── Node surfaces ("Open as site") ─────────────────────────────
 //
 // One stable, node-addressable URL — /api/canvas/surface/:nodeId — that serves
@@ -2843,7 +2882,10 @@ export function startCanvasServer(options: CanvasServerOptions = {}): string | n
           const url = new URL(req.url);
 
           if (url.pathname === '/health') {
-            return responseJson({ ok: true, workspace: activeWorkspaceRoot });
+            // `pid` lets `serve status` report the ACTUAL serving process even
+            // when the pid file is stale (e.g. an adapter respawned the server
+            // outside `serve --daemon` — 0.3.2 report Finding P).
+            return responseJson({ ok: true, workspace: activeWorkspaceRoot, pid: process.pid });
           }
 
           if (url.pathname === '/favicon.ico' || url.pathname === '/favicon.svg') {
@@ -2854,10 +2896,25 @@ export function startCanvasServer(options: CanvasServerOptions = {}): string | n
             return handleArtifactView(url);
           }
 
-          if (url.pathname === '/api/canvas/json-render/view' && req.method === 'GET') {
+          // Standalone surfaces answer HEAD like GET (status + headers, no body):
+          // tooling probes these advertised URLs, and a HEAD 404 against a
+          // working GET reads as a broken surface (0.3.2 report Finding O).
+          // Bun.serve strips the body and keeps the true Content-Length on HEAD,
+          // so the GET handler's response is returned as-is.
+          if (url.pathname === '/api/canvas/json-render/view' && (req.method === 'GET' || req.method === 'HEAD')) {
             return handleJsonRenderView(url);
           }
 
+          if (url.pathname === '/api/canvas/debug/ext-app-recovery' && req.method === 'POST') {
+            const body = await readJson(req);
+            if (body === null) return malformedJsonResponse();
+            return handleExtAppRecoveryReport(body.entries);
+          }
+
+          if (url.pathname === '/api/canvas/debug/ext-app-recovery' && req.method === 'GET') {
+            return responseJson({ ok: true, entries: extAppRecoveryEntries });
+          }
+
           if (url.pathname === '/api/canvas/frame-documents' && req.method === 'POST') {
             return handleCreateFrameDocument(req);
           }
@@ -2866,7 +2923,7 @@ export function startCanvasServer(options: CanvasServerOptions = {}): string | n
             return handleFrameDocument(url.pathname);
           }
 
-          if (url.pathname.startsWith('/api/canvas/surface/') && req.method === 'GET') {
+          if (url.pathname.startsWith('/api/canvas/surface/') && (req.method === 'GET' || req.method === 'HEAD')) {
             return handleNodeSurface(url.pathname, url);
           }
 
@@ -2959,6 +3016,7 @@ export function stopCanvasServer(): void {
   intentRegistry.reset();
   canvasState.close();
   closeAllMcpAppSessions();
+  cancelCodeGraphRecompute();
   setCanvasLayoutUpdateEmitter(null);
   void closeCanvasAutomationWebViewInternal().catch((error) => {
     logWorkbenchWarning('stopCanvasServer closeCanvasAutomationWebViewInternal', error);

package/src/shared/ax-surface-protocol.ts

@@ -0,0 +1,22 @@
+/**
+ * Wire-protocol source tags for sandboxed-surface ↔ canvas postMessage traffic
+ * (plan-009 M2): one module owns the strings that used to be spread across the
+ * client node components, the server-side surface script generators, the
+ * ext-app script builders, and the json-render viewer. These are the trust
+ * boundary between opaque-origin iframes and the canvas — a typo'd tag fails
+ * SILENTLY (the listener just ignores the message), so single-siting them is a
+ * correctness measure, not cosmetics. The values are a persisted wire contract
+ * with already-generated surface documents: never change them.
+ */
+
+/** A sandboxed surface emitting an AX interaction to the parent canvas. */
+export const AX_SURFACE_EMIT_SOURCE = 'pmx-canvas-ax';
+
+/** The parent canvas acking an AX interaction back to the emitting surface (#55). */
+export const AX_SURFACE_ACK_SOURCE = 'pmx-canvas-ax-ack';
+
+/** Parent→surface pushes (theme updates, live AX state) into html/viewer iframes. */
+export const HTML_SURFACE_PUSH_SOURCE = 'pmx-canvas-html-node';
+
+/** Ext-app boot beacon: the iframe's scripts executed (WebKit watchdog liveness). */
+export const EXT_APP_BOOT_BEACON_SOURCE = 'pmx-canvas-ext-app-alive';

package/dist/types/client/canvas/ContextPinHud.d.ts

@@ -1 +0,0 @@
-export declare function ContextPinHud(): import("preact/src").JSX.Element | null;

package/src/client/canvas/ContextPinHud.tsx

@@ -1,17 +0,0 @@
-import { clearContextPins, contextPinnedNodeIds } from '../state/canvas-store';
-
-export function ContextPinHud() {
-  const count = contextPinnedNodeIds.value.size;
-  if (count === 0) return null;
-
-  return (
-    <div class="context-pin-hud">
-      <span class="context-pin-hud-label">
-        {'\u2726'} {count} in context
-      </span>
-      <button type="button" class="context-pin-hud-clear" onClick={clearContextPins} title="Clear all context pins">
-        ×
-      </button>
-    </div>
-  );
-}