yaml-flow 8.6.4 → 8.7.1

package/examples/board-firestore/server/adapters/firestore-lock.js

@@ -0,0 +1,62 @@
+/**
+ * firestore-lock.js
+ *
+ * AsyncAtomicRelayLock backed by a Firestore document + runTransaction.
+ *
+ * Document shape: { held, holderId, expiresAt, acquiredAt }
+ * Guarantees at-most-one holder via Firestore transaction atomicity.
+ *
+ * @param {import('@google-cloud/firestore').DocumentReference} lockDoc
+ * @param {{ holderId?: string, ttlMs?: number }} [options]
+ * @returns {import('yaml-flow/cloud-storage').AsyncAtomicRelayLock}
+ */
+
+import { randomUUID } from 'node:crypto';
+
+export function createFirestoreLock(lockDoc, options = {}) {
+  const holderId = options.holderId ?? randomUUID();
+  const ttlMs = options.ttlMs ?? 30_000;
+
+  return {
+    async tryAcquire() {
+      let released = false;
+
+      try {
+        await lockDoc.firestore.runTransaction(async (tx) => {
+          const snap = await tx.get(lockDoc);
+          const now = new Date();
+          if (snap.exists) {
+            const d = snap.data();
+            if (d.held && d.expiresAt > now.toISOString()) {
+              throw Object.assign(new Error('locked'), { code: 'locked' });
+            }
+          }
+          tx.set(lockDoc, {
+            held: true,
+            holderId,
+            expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+            acquiredAt: now.toISOString(),
+          });
+        });
+      } catch (err) {
+        if (err?.code === 'locked') return null;
+        throw err;
+      }
+
+      return async () => {
+        if (released) return;
+        released = true;
+        try {
+          await lockDoc.firestore.runTransaction(async (tx) => {
+            const snap = await tx.get(lockDoc);
+            if (snap.exists && snap.data().holderId === holderId) {
+              tx.update(lockDoc, { held: false, holderId: null });
+            }
+          });
+        } catch {
+          // Best-effort release — lock will expire via TTL
+        }
+      };
+    },
+  };
+}

package/examples/board-firestore/server/adapters/firestore-queue-storage.js

@@ -0,0 +1,186 @@
+/**
+ * firestore-queue-storage.js
+ *
+ * AsyncQueueStorage backed by Firestore with visibility-timeout leasing.
+ *
+ * Document shape:
+ *   { id, body, enqueuedAt, attempt, visibleAfter, leaseToken, leaseExpiresAt,
+ *     dead, deadReason, dedupKey? }
+ *
+ * Leasing is done via Firestore transactions: find visible messages,
+ * then atomically claim each one (optimistic concurrency — skip on race).
+ *
+ * Required Firestore composite index for the lease query:
+ *   Collection group: <your collection>
+ *   Fields: dead ASC, visibleAfter ASC
+ *
+ * @param {import('@google-cloud/firestore').CollectionReference} col
+ * @param {{ defaultVisibilityMs?: number }} [options]
+ * @returns {import('yaml-flow/cloud-storage').AsyncQueueStorage}
+ */
+
+import { randomUUID } from 'node:crypto';
+
+function lexicalId() {
+  const ts = String(Date.now()).padStart(13, '0');
+  const rand = Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+  return `${ts}-${rand}`;
+}
+
+export function createFirestoreQueueStorage(col, options = {}) {
+  const defaultVisibilityMs = options.defaultVisibilityMs ?? 30_000;
+
+  return {
+    async enqueue(body) {
+      const id = lexicalId();
+      const now = new Date().toISOString();
+      await col.doc(id).set({
+        id,
+        body,
+        enqueuedAt: now,
+        attempt: 0,
+        visibleAfter: now,
+        leaseToken: null,
+        leaseExpiresAt: null,
+        dead: false,
+        deadReason: null,
+      });
+      return { id, body, enqueuedAt: now };
+    },
+
+    async enqueueIfAbsent(body, dedupKey) {
+      const existing = await col
+        .where('dedupKey', '==', dedupKey)
+        .where('dead', '==', false)
+        .limit(1)
+        .get();
+      if (!existing.empty) return null;
+      const id = lexicalId();
+      const now = new Date().toISOString();
+      await col.doc(id).set({
+        id,
+        body,
+        enqueuedAt: now,
+        attempt: 0,
+        visibleAfter: now,
+        leaseToken: null,
+        leaseExpiresAt: null,
+        dead: false,
+        deadReason: null,
+        dedupKey,
+      });
+      return { id, body, enqueuedAt: now };
+    },
+
+    async lease(opts = {}) {
+      const max = opts.max ?? 1;
+      const visibilityMs = opts.visibilityMs ?? defaultVisibilityMs;
+      const nowIso = new Date().toISOString();
+
+      // Find visible, non-dead messages — fetch extra to tolerate races
+      const snap = await col
+        .where('dead', '==', false)
+        .where('visibleAfter', '<=', nowIso)
+        .orderBy('visibleAfter')
+        .limit(max * 4)
+        .get();
+
+      const leased = [];
+      for (const doc of snap.docs) {
+        if (leased.length >= max) break;
+
+        const data = doc.data();
+        // Skip if currently leased and lease hasn't expired
+        if (data.leaseToken && data.leaseExpiresAt > nowIso) continue;
+
+        const leaseToken = randomUUID();
+        const leaseExpiresAt = new Date(Date.now() + visibilityMs).toISOString();
+
+        try {
+          let claimedAttempt = 0;
+          await col.firestore.runTransaction(async (tx) => {
+            const fresh = await tx.get(doc.ref);
+            if (!fresh.exists) throw Object.assign(new Error('gone'), { code: 'gone' });
+            const d = fresh.data();
+            if (d.dead) throw Object.assign(new Error('dead'), { code: 'dead' });
+            if (d.leaseToken && d.leaseExpiresAt > new Date().toISOString()) {
+              throw Object.assign(new Error('taken'), { code: 'taken' });
+            }
+            claimedAttempt = (d.attempt ?? 0) + 1;
+            tx.update(doc.ref, { leaseToken, leaseExpiresAt, attempt: claimedAttempt });
+          });
+          leased.push({
+            id: data.id,
+            body: data.body,
+            enqueuedAt: data.enqueuedAt,
+            attempt: claimedAttempt,
+            leaseToken,
+            leaseExpiresAt,
+          });
+        } catch {
+          // Race condition — skip this message
+        }
+      }
+      return leased;
+    },
+
+    async ack(messageId, leaseToken) {
+      try {
+        await col.firestore.runTransaction(async (tx) => {
+          const ref = col.doc(messageId);
+          const snap = await tx.get(ref);
+          if (!snap.exists) return;
+          if (snap.data().leaseToken !== leaseToken) throw new Error('token mismatch');
+          tx.delete(ref);
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    async nack(messageId, leaseToken, opts = {}) {
+      try {
+        await col.firestore.runTransaction(async (tx) => {
+          const ref = col.doc(messageId);
+          const snap = await tx.get(ref);
+          if (!snap.exists) return;
+          if (snap.data().leaseToken !== leaseToken) throw new Error('token mismatch');
+          if (opts.dead) {
+            tx.update(ref, {
+              dead: true,
+              deadReason: opts.reason ?? 'nacked',
+              leaseToken: null,
+              leaseExpiresAt: null,
+            });
+          } else {
+            tx.update(ref, {
+              leaseToken: null,
+              leaseExpiresAt: null,
+              visibleAfter: new Date().toISOString(),
+            });
+          }
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    async peekActive(prefix) {
+      const snap = await col.where('dead', '==', false).orderBy('enqueuedAt').get();
+      return snap.docs
+        .map((d) => d.data())
+        .filter((d) => !prefix || String(d.id).startsWith(prefix))
+        .map((d) => ({ id: d.id, body: d.body, enqueuedAt: d.enqueuedAt }));
+    },
+
+    async peekDeadLetter(prefix) {
+      const snap = await col.where('dead', '==', true).orderBy('enqueuedAt').get();
+      return snap.docs
+        .map((d) => d.data())
+        .filter((d) => !prefix || String(d.id).startsWith(prefix))
+        .map((d) => ({ id: d.id, body: d.body, enqueuedAt: d.enqueuedAt, reason: d.deadReason }));
+    },
+  };
+}

package/examples/board-firestore/server/adapters/firestore-scratch-storage.js

@@ -0,0 +1,50 @@
+/**
+ * firestore-scratch-storage.js
+ *
+ * AsyncScratchStorage backed by Firestore.
+ * Extends AsyncBlobStorage with ephemeral-key creation and a config sub-map.
+ *
+ * @param {import('@google-cloud/firestore').CollectionReference} col
+ * @returns {import('yaml-flow/cloud-storage').AsyncScratchStorage}
+ */
+
+import { createFirestoreBlobStorage } from './firestore-blob-storage.js';
+
+function lexicalId() {
+  const ts = String(Date.now()).padStart(13, '0');
+  const rand = Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+  return `${ts}-${rand}`;
+}
+
+export function createFirestoreScratchStorage(col) {
+  const blob = createFirestoreBlobStorage(col);
+
+  return {
+    ...blob,
+
+    async getUniqueKey(prefix = 'scratch-', suffix = '') {
+      return `${prefix}${lexicalId()}${suffix}`;
+    },
+
+    async create(data, prefix = 'scratch-', suffix = '') {
+      const key = `${prefix}${lexicalId()}${suffix}`;
+      await blob.write(key, data);
+      return key;
+    },
+
+    keyRef(key) {
+      return { kind: 'firestore-blob', value: `${col.path}/${Buffer.from(key).toString('base64url')}` };
+    },
+
+    config: {
+      async get(k) {
+        const content = await blob.read(`__config__/${k}`);
+        if (content == null) return null;
+        try { return JSON.parse(content); } catch { return content; }
+      },
+      async set(k, v) {
+        await blob.write(`__config__/${k}`, JSON.stringify(v));
+      },
+    },
+  };
+}

package/examples/board-firestore/server/worker.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * board-firestore/server/worker.js
+ *
+ * Long-running worker server for the Firestore-backed board.
+ * Runs three things in one Node.js process:
+ *
+ *   1. Queue lane runners — drain worker-queue, chat-queue, process-queue
+ *   2. Board control-plane HTTP — GET/POST /api/board/* for browser SPA
+ *   3. Callback endpoint — POST /api/board/callback/* for execution webhooks
+ *
+ * Environment variables:
+ *   GOOGLE_APPLICATION_CREDENTIALS  Path to Firebase service account JSON key
+ *   FIREBASE_PROJECT_ID             Firebase project ID
+ *   BOARD_ID                        Firestore board document ID (default: "default")
+ *   WORKER_PORT                     HTTP listen port (default: 7900)
+ */
+
+import http from 'node:http';
+import { Buffer } from 'node:buffer';
+import { createSingleBoardServerRuntime } from 'yaml-flow/board-live-cards-server-runtime';
+import { createHostedBoardQueueLaneRegistry } from 'yaml-flow/server-jobs-queue-runner';
+import { startQueueLaneRunners } from 'yaml-flow/board-live-cards-node';
+import { initializeApp, cert, getApps } from 'firebase-admin/app';
+import { getFirestore } from 'firebase-admin/firestore';
+import { createFirestoreBoardAdapter } from './adapters/firestore-board-adapter.js';
+
+// ── Firebase Admin SDK init ────────────────────────────────────────────────────
+if (getApps().length === 0) {
+  initializeApp({
+    credential: cert(process.env.GOOGLE_APPLICATION_CREDENTIALS ?? './service-account.json'),
+    projectId: process.env.FIREBASE_PROJECT_ID,
+  });
+}
+
+const db = getFirestore();
+
+// ── Config ─────────────────────────────────────────────────────────────────────
+const BOARD_ID = process.env.BOARD_ID ?? 'default';
+const PORT = Number(process.env.WORKER_PORT ?? 7900);
+
+// ── Helper: build a b64 ref string (matches serializeRef in yaml-flow) ──────────
+function makeRef(kind, value) {
+  return `b64:${Buffer.from(JSON.stringify({ kind, value })).toString('base64url')}`;
+}
+
+// ── Firestore board adapter ────────────────────────────────────────────────────
+const boardAdapter = createFirestoreBoardAdapter(db, BOARD_ID);
+
+// ── Single-board runtime ───────────────────────────────────────────────────────
+const runtime = createSingleBoardServerRuntime({
+  boardId: BOARD_ID,
+  boards: [
+    {
+      label: `Board — ${BOARD_ID}`,
+      boardAdapter,
+      baseRef: { kind: 'firestore', value: `boards/${BOARD_ID}` },
+      cardStoreRef: makeRef('firestore', `boards/${BOARD_ID}/cards`),
+      outputsStoreRef: makeRef('firestore', `boards/${BOARD_ID}/runtime-out`),
+    },
+  ],
+  invocationAdapter: {
+    /**
+     * Route execution requests to the appropriate handler.
+     * For worker queue dispatch, yaml-flow uses boardAdapter.dispatchExecution internally.
+     * This adapter is the last-resort fallback for refs not handled by boardAdapter.
+     */
+    async invoke(ref, _args) {
+      return { dispatched: false, error: `No invocation handler for ${ref?.howToRun ?? '?'}` };
+    },
+  },
+  logger: {
+    info: (msg, ...args) => console.log(`[worker:${BOARD_ID}] ${msg}`, ...args),
+    warn: (msg, ...args) => console.warn(`[worker:${BOARD_ID}] ${msg}`, ...args),
+    error: (msg, ...args) => console.error(`[worker:${BOARD_ID}] ${msg}`, ...args),
+  },
+});
+
+// ── Queue lane runners ─────────────────────────────────────────────────────────
+const stopRunners = startQueueLaneRunners(
+  createHostedBoardQueueLaneRegistry({
+    boardId: BOARD_ID,
+    runtime,
+    boardAdapter,
+    logger: {
+      info: (msg, ...args) => console.log(`[queue:${BOARD_ID}] ${msg}`, ...args),
+      warn: (msg, ...args) => console.warn(`[queue:${BOARD_ID}] ${msg}`, ...args),
+      error: (msg, ...args) => console.error(`[queue:${BOARD_ID}] ${msg}`, ...args),
+    },
+  }),
+);
+
+// ── HTTP server ────────────────────────────────────────────────────────────────
+function sendJson(res, status, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(body),
+    'Access-Control-Allow-Origin': '*',
+  });
+  res.end(body);
+}
+
+const server = http.createServer(async (req, res) => {
+  // Handle CORS preflight
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    });
+    res.end();
+    return;
+  }
+
+  const url = new URL(req.url ?? '/', `http://localhost:${PORT}`);
+
+  try {
+    const handled = await runtime.handleRuntimeApi(req, res, url);
+    if (!handled) sendJson(res, 404, { error: 'not found', path: url.pathname });
+  } catch (err) {
+    console.error(`[worker:${BOARD_ID}] unhandled error for ${req.method} ${req.url}:`, err);
+    if (!res.headersSent) sendJson(res, 500, { error: 'internal error' });
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`[board-firestore/worker] Listening on http://localhost:${PORT}`);
+  console.log(`[board-firestore/worker] Board ID : ${BOARD_ID}`);
+  console.log(`[board-firestore/worker] Firebase project: ${process.env.FIREBASE_PROJECT_ID ?? '(auto-detect)'}`);
+});
+
+// ── Graceful shutdown ───────────────────────────────────────────────────────────
+function shutdown() {
+  console.log('[board-firestore/worker] Shutting down...');
+  stopRunners();
+  server.close(() => {
+    console.log('[board-firestore/worker] HTTP server closed.');
+    process.exit(0);
+  });
+  // Force exit after 10 s if connections linger
+  setTimeout(() => process.exit(0), 10_000).unref();
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);

package/lib/{artifacts-store-lib-BR-Samty.d.cts → artifacts-store-lib-D9nMkVcE.d.cts}

@@ -58,4 +58,4 @@ declare function createArtifactsStore(blob: BlobStorage): ArtifactsStore;
 declare function createFileArtifactsStore(store: ArtifactsStore): FileArtifactsStore;
 declare function createCardFileMetadataStore(): CardFileMetadataStore;
 
-export { type ArtifactInfo as A, type ArtifactsStore as a, createCardFileMetadataStore as b, createArtifactsStore as c, createFileArtifactsStore as d };
+export { type ArtifactInfo as A, type CardFileMetadataStore as C, type ArtifactsStore as a, createCardFileMetadataStore as b, createArtifactsStore as c, createFileArtifactsStore as d };

package/lib/{artifacts-store-lib-DT7XlWUL.d.ts → artifacts-store-lib-DSSMqVL2.d.ts}

@@ -58,4 +58,4 @@ declare function createArtifactsStore(blob: BlobStorage): ArtifactsStore;
 declare function createFileArtifactsStore(store: ArtifactsStore): FileArtifactsStore;
 declare function createCardFileMetadataStore(): CardFileMetadataStore;
 
-export { type ArtifactInfo as A, type ArtifactsStore as a, createCardFileMetadataStore as b, createArtifactsStore as c, createFileArtifactsStore as d };
+export { type ArtifactInfo as A, type CardFileMetadataStore as C, type ArtifactsStore as a, createCardFileMetadataStore as b, createArtifactsStore as c, createFileArtifactsStore as d };

package/lib/artifacts-store-public.d.cts

@@ -1,5 +1,5 @@
-import { a as CommandInput, C as CommandResult } from './board-live-cards-public-wkNmBIRC.cjs';
-import { A as ArtifactInfo, a as ArtifactsStore } from './artifacts-store-lib-BR-Samty.cjs';
+import { C as CommandInput, a as CommandResult } from './board-live-cards-public-LlVUQPL2.cjs';
+import { A as ArtifactInfo, a as ArtifactsStore } from './artifacts-store-lib-D9nMkVcE.cjs';
 import './storage-interface-BFiD3kyB.cjs';
 import './execution-refs.cjs';
 import './types-BBhqYGhE.cjs';

package/lib/artifacts-store-public.d.ts

@@ -1,5 +1,5 @@
-import { a as CommandInput, C as CommandResult } from './board-live-cards-public-BMUIPOrc.js';
-import { A as ArtifactInfo, a as ArtifactsStore } from './artifacts-store-lib-DT7XlWUL.js';
+import { C as CommandInput, a as CommandResult } from './board-live-cards-public-JNRKfBZy.js';
+import { A as ArtifactInfo, a as ArtifactsStore } from './artifacts-store-lib-DSSMqVL2.js';
 import './storage-interface-BFiD3kyB.js';
 import './execution-refs.js';
 import './types-BBhqYGhE.js';

package/lib/board-live-cards-mcp.cjs

@@ -1,2 +1,2 @@
-'use strict';var chunkYEB5QHGE_cjs=require('./chunk-YEB5QHGE.cjs');require('./chunk-IXZG74EW.cjs'),require('./chunk-NMZ6XNLB.cjs'),require('./chunk-UJ7ZTV4J.cjs'),require('./chunk-GNFE24S7.cjs');Object.defineProperty(exports,"createBoardLiveCardsMcp",{enumerable:true,get:function(){return chunkYEB5QHGE_cjs.a}});//# sourceMappingURL=board-live-cards-mcp.cjs.map
+'use strict';var chunkPBOQ4HYB_cjs=require('./chunk-PBOQ4HYB.cjs');require('./chunk-IXZG74EW.cjs'),require('./chunk-HWYMZK3N.cjs'),require('./chunk-UJ7ZTV4J.cjs'),require('./chunk-GNFE24S7.cjs');Object.defineProperty(exports,"createBoardLiveCardsMcp",{enumerable:true,get:function(){return chunkPBOQ4HYB_cjs.a}});//# sourceMappingURL=board-live-cards-mcp.cjs.map
 //# sourceMappingURL=board-live-cards-mcp.cjs.map

package/lib/board-live-cards-mcp.d.cts

@@ -1,6 +1,6 @@
-import { C as CommandResult, L as LiveCard } from './board-live-cards-public-wkNmBIRC.cjs';
+import { L as LiveCard, a as CommandResult } from './board-live-cards-public-LlVUQPL2.cjs';
 import { ChatStorePublic } from './chat-store-public.cjs';
-import { C as ChatRecord } from './chat-storage-lib-BIUbE-fM.cjs';
+import { a as ChatRecord } from './chat-storage-lib-B9Q34Dyv.cjs';
 import './storage-interface-BFiD3kyB.cjs';
 import './execution-refs.cjs';
 import './types-BBhqYGhE.cjs';
@@ -114,6 +114,14 @@ interface BoardLiveCardsMcpManageAddChatEntryAndAnyAttachmentsResult {
         files: Array<Record<string, unknown>>;
     };
 }
+interface BoardLiveCardsMcpManageAddChatAttachmentResult {
+    status: 'success';
+    data: {
+        cardId: string;
+        turn: string;
+        files: Array<Record<string, unknown>>;
+    };
+}
 interface BoardLiveCardsMcpPreflightRunOneCycleResult {
     status: 'success';
     data: {
@@ -242,11 +250,21 @@ interface BoardLiveCardsMcpDeps {
     nonCore: BoardLiveCardsMcpNonCoreDeps;
     cardStore: BoardLiveCardsMcpCardStoreDeps;
     chatStore: ChatStorePublic;
+    processAccumulated?: () => Awaitable<CommandResult>;
+    sourceFetchDone?: (args: {
+        token: string;
+        ref: string;
+    }) => Awaitable<CommandResult>;
+    sourceFetchFailed?: (args: {
+        token: string;
+        reason: string;
+    }) => Awaitable<CommandResult>;
     uploadCardFile(args: {
         cardId: string;
         fileName: string;
         contentType: string;
         bytes: Uint8Array;
+        suppressChatRecordWrite?: boolean;
     }): Awaitable<{
         ok: true;
         file: Record<string, unknown>;
@@ -263,6 +281,7 @@ interface BoardLiveCardsMcpDeps {
     }): unknown | null;
 }
 interface BoardLiveCardsMcp {
+    listRuntimeCards(): Promise<LiveCard[]>;
     discoverSourceKinds(): Promise<BoardLiveCardsMcpDiscoverSourceKindsResult>;
     inspectBoardRuntimeStatus(): Promise<BoardLiveCardsMcpBoardStatusResult>;
     inspectCardDefinitionAndRuntime(args: {
@@ -310,6 +329,12 @@ interface BoardLiveCardsMcp {
     manageReadCard(args: {
         cardId: string;
     }): Promise<LiveCard[]>;
+    manageAddChatAttachment(args: {
+        cardId: string;
+        role?: string;
+        turn?: string;
+        files?: unknown[];
+    }): Promise<BoardLiveCardsMcpManageAddChatAttachmentResult>;
     manageAddChatEntryAndAnyAttachments(args: {
         cardId: string;
         role: string;
@@ -317,6 +342,10 @@ interface BoardLiveCardsMcp {
         turn?: string;
         files?: unknown[];
     }): Promise<BoardLiveCardsMcpManageAddChatEntryAndAnyAttachmentsResult>;
+    managePatchCard(args: {
+        cardId: string;
+        patch: UnknownRecord;
+    }): Promise<BoardLiveCardsMcpManageUpsertCardResult>;
     manageUpsertCard(args: {
         cardId: string;
         candidateCardContent: UnknownRecord;
@@ -344,7 +373,26 @@ interface BoardLiveCardsMcp {
         cardId: string;
         active: boolean;
     };
+    webhookProcessAccumulated(): Promise<CommandResult<{
+        runtime_result: unknown;
+    }>>;
+    webhookSourceFetchDone(args: {
+        token: string;
+        ref: string;
+    }): Promise<CommandResult<{
+        token: string;
+        ref: string;
+        runtime_result: unknown;
+    }>>;
+    webhookSourceFetchFailed(args: {
+        token: string;
+        reason: string;
+    }): Promise<CommandResult<{
+        token: string;
+        reason: string;
+        runtime_result: unknown;
+    }>>;
 }
 declare function createBoardLiveCardsMcp(deps: BoardLiveCardsMcpDeps): BoardLiveCardsMcp;
 
-export { type BoardLiveCardsMcp, type BoardLiveCardsMcpBoardDeps, type BoardLiveCardsMcpBoardStatusCard, type BoardLiveCardsMcpBoardStatusResult, type BoardLiveCardsMcpCardStoreDeps, type BoardLiveCardsMcpDeps, type BoardLiveCardsMcpDiscoverSourceKindsResult, type BoardLiveCardsMcpFileDownloadDescriptor, type BoardLiveCardsMcpInspectCardDefinitionAndRuntimeResult, type BoardLiveCardsMcpInspectChatMessagesResult, type BoardLiveCardsMcpManageAddChatEntryAndAnyAttachmentsResult, type BoardLiveCardsMcpManageUpsertCardFailureResult, type BoardLiveCardsMcpManageUpsertCardResult, type BoardLiveCardsMcpManageUpsertCardSuccessResult, type BoardLiveCardsMcpNonCoreDeps, type BoardLiveCardsMcpPreflightMaterializeResult, type BoardLiveCardsMcpPreflightRunOneCycleResult, type BoardLiveCardsMcpRenderedView, type BoardLiveCardsMcpRenderedViewElement, createBoardLiveCardsMcp };
+export { type BoardLiveCardsMcp, type BoardLiveCardsMcpBoardDeps, type BoardLiveCardsMcpBoardStatusCard, type BoardLiveCardsMcpBoardStatusResult, type BoardLiveCardsMcpCardStoreDeps, type BoardLiveCardsMcpDeps, type BoardLiveCardsMcpDiscoverSourceKindsResult, type BoardLiveCardsMcpFileDownloadDescriptor, type BoardLiveCardsMcpInspectCardDefinitionAndRuntimeResult, type BoardLiveCardsMcpInspectChatMessagesResult, type BoardLiveCardsMcpManageAddChatAttachmentResult, type BoardLiveCardsMcpManageAddChatEntryAndAnyAttachmentsResult, type BoardLiveCardsMcpManageUpsertCardFailureResult, type BoardLiveCardsMcpManageUpsertCardResult, type BoardLiveCardsMcpManageUpsertCardSuccessResult, type BoardLiveCardsMcpNonCoreDeps, type BoardLiveCardsMcpPreflightMaterializeResult, type BoardLiveCardsMcpPreflightRunOneCycleResult, type BoardLiveCardsMcpRenderedView, type BoardLiveCardsMcpRenderedViewElement, createBoardLiveCardsMcp };