yaml-flow 8.6.4 → 8.7.1

package/lib/server-runtime-agentface/index.d.ts

@@ -0,0 +1,53 @@
+import { f as RuntimeRequest, g as RuntimeResponse } from '../types-SO5OZm4s.js';
+import { T as ToolRegistry } from '../mcp-tool-registries-BBObLYga.js';
+import '../artifacts-store-lib-DSSMqVL2.js';
+import '../storage-interface-BFiD3kyB.js';
+import '../board-live-cards-public-JNRKfBZy.js';
+import '../execution-refs.js';
+import '../types-BBhqYGhE.js';
+import '../board-platform-adapter-async-DYahVzIK.js';
+import '../storage-async-interface-DhlOVPSp.js';
+import '../board-live-cards-public-async-fwd1QI82.js';
+import '../chat-storage-lib-DB9iSai2.js';
+import '../board-live-cards-mcp.js';
+import '../chat-store-public.js';
+
+/**
+ * server-runtime/routes-agentface.ts
+ *
+ * Agent-facing MCP routes extracted from createSingleBoardServerRuntime.
+ *   POST /mcp      — general MCP tool dispatch (read-only, stateless)
+ *   POST /mcp-raw  — raw file-content streaming (inspect.file-contents only)
+ */
+
+interface McpFacadeLike {
+    inspectFileContents: (args: {
+        cardId: string;
+        fileIdx: number;
+    }) => unknown;
+}
+interface CardFileRecord {
+    name?: unknown;
+    stored_name?: unknown;
+    mime_type?: unknown;
+}
+interface RoutesAgentfaceDeps {
+    apiBasePath: string;
+    json: (res: RuntimeResponse, status: number, payload: unknown) => void;
+    readJsonBody: (req: RuntimeRequest) => Promise<Record<string, unknown>>;
+    bootstrapBoard: () => Promise<void>;
+    createMcpFacade: () => McpFacadeLike;
+    createMcpToolRegistry: (mcp: McpFacadeLike) => ToolRegistry;
+    resolveCardFileDownloadPayload: (cardId: string, idx: number, expectedStoredName: string | null) => Promise<{
+        fileRecord: CardFileRecord;
+        bytes: Uint8Array;
+    }>;
+    isLikelyTextMimeType: (mimeType: string) => boolean;
+    sliceTextByLines: (text: string, mode: 'head' | 'tail', count: number) => string;
+}
+interface RoutesAgentface {
+    handleAgentfaceApi: (req: RuntimeRequest, res: RuntimeResponse, parsedUrl: URL) => Promise<boolean>;
+}
+declare function createRoutesAgentface(deps: RoutesAgentfaceDeps): RoutesAgentface;
+
+export { type RoutesAgentface, type RoutesAgentfaceDeps, createRoutesAgentface };

package/lib/server-runtime-agentface/index.js

@@ -0,0 +1,2 @@
+export{a as createRoutesAgentface}from'../chunk-NTICU4OK.js';import'../chunk-O7NOHKVR.js';import'../chunk-ZJ5M5COT.js';import'../chunk-FW4363Y4.js';//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/server-runtime-controlface/index.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkASR44K7H_cjs=require('../chunk-ASR44K7H.cjs');require('../chunk-EZENHAVZ.cjs'),require('../chunk-7FGPOGRV.cjs'),require('../chunk-LPXVVMQT.cjs'),require('../chunk-7ICPAABP.cjs'),require('../chunk-KAWQPLIE.cjs'),require('../chunk-NM6O35RY.cjs'),require('../chunk-272IYUKT.cjs'),require('../chunk-CPAXTVBQ.cjs'),require('../chunk-NJJ7WEDT.cjs'),require('../chunk-GL2OHR2E.cjs'),require('../chunk-J6EGN6S4.cjs'),require('../chunk-PBCDDO4V.cjs'),require('../chunk-JJL5VOQZ.cjs'),require('../chunk-U2N6MCD5.cjs'),require('../chunk-SFVO2LB2.cjs'),require('../chunk-G4XXRHL2.cjs'),require('../chunk-LODXIALE.cjs'),require('../chunk-PBOQ4HYB.cjs'),require('../chunk-IXZG74EW.cjs'),require('../chunk-HWYMZK3N.cjs'),require('../chunk-UJ7ZTV4J.cjs'),require('../chunk-YMEIPKLW.cjs'),require('../chunk-GYQXDNNI.cjs'),require('../chunk-GNFE24S7.cjs');var a=["/mcp","/mcp-raw","/mcp-controlplane","/mcp-webhooks"];function l(n,e){return a.some(r=>e===`${n}${r}`)}function s(n,e){return a.some(r=>{let i=`${r}`;if(!e.startsWith(`${n}/`)||!e.endsWith(i))return  false;let t=e.slice(n.length+1,e.length-i.length);return t.length>0&&!t.includes("/")})}function d(n){let e=chunkASR44K7H_cjs.a(n);return {...e,async handleRuntimeApi(r,i,t){return l(e.apiBasePath,t.pathname)?e.handleRuntimeApi(r,i,t):false}}}function c(n){let e=chunkASR44K7H_cjs.b(n);return {...e,async handleApi(r,i,t){return s(e.apiBasePath,t.pathname)?e.handleApi(r,i,t):false}}}exports.createMultiBoardServerRuntime=c;exports.createSingleBoardServerRuntime=d;//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/lib/server-runtime-controlface/index.d.cts

@@ -0,0 +1,29 @@
+import { M as MultiBoardRuntimeOptions, a as MultiBoardRuntime, S as SingleBoardRuntimeOptions, b as SingleBoardRuntime } from '../types-Ba8H5_Wo.cjs';
+import '../artifacts-store-lib-D9nMkVcE.cjs';
+import '../storage-interface-BFiD3kyB.cjs';
+import '../board-live-cards-public-LlVUQPL2.cjs';
+import '../execution-refs.cjs';
+import '../types-BBhqYGhE.cjs';
+import '../board-platform-adapter-async-BfHmHdx2.cjs';
+import '../storage-async-interface-BRR4eBjx.cjs';
+import '../board-live-cards-public-async-Di9QB141.cjs';
+import '../chat-storage-lib-B9Q34Dyv.cjs';
+
+/**
+ * server-runtime-controlface
+ *
+ * MCP-only server runtime surface.
+ *   POST /mcp
+ *   POST /mcp-raw
+ *   POST /mcp-controlplane
+ *   POST /mcp-webhooks
+ *
+ * This package intentionally does not expose /init-board, /board-status,
+ * /cards/*, or /sse watcher routes. Browser builds keep the full dispatcher
+ * through a dedicated browser entrypoint.
+ */
+
+declare function createSingleBoardServerRuntime(options: SingleBoardRuntimeOptions): SingleBoardRuntime;
+declare function createMultiBoardServerRuntime(options: MultiBoardRuntimeOptions): MultiBoardRuntime;
+
+export { MultiBoardRuntime, MultiBoardRuntimeOptions, SingleBoardRuntime, SingleBoardRuntimeOptions, createMultiBoardServerRuntime, createSingleBoardServerRuntime };

package/lib/server-runtime-controlface/index.d.ts

@@ -0,0 +1,29 @@
+import { M as MultiBoardRuntimeOptions, a as MultiBoardRuntime, S as SingleBoardRuntimeOptions, b as SingleBoardRuntime } from '../types-SO5OZm4s.js';
+import '../artifacts-store-lib-DSSMqVL2.js';
+import '../storage-interface-BFiD3kyB.js';
+import '../board-live-cards-public-JNRKfBZy.js';
+import '../execution-refs.js';
+import '../types-BBhqYGhE.js';
+import '../board-platform-adapter-async-DYahVzIK.js';
+import '../storage-async-interface-DhlOVPSp.js';
+import '../board-live-cards-public-async-fwd1QI82.js';
+import '../chat-storage-lib-DB9iSai2.js';
+
+/**
+ * server-runtime-controlface
+ *
+ * MCP-only server runtime surface.
+ *   POST /mcp
+ *   POST /mcp-raw
+ *   POST /mcp-controlplane
+ *   POST /mcp-webhooks
+ *
+ * This package intentionally does not expose /init-board, /board-status,
+ * /cards/*, or /sse watcher routes. Browser builds keep the full dispatcher
+ * through a dedicated browser entrypoint.
+ */
+
+declare function createSingleBoardServerRuntime(options: SingleBoardRuntimeOptions): SingleBoardRuntime;
+declare function createMultiBoardServerRuntime(options: MultiBoardRuntimeOptions): MultiBoardRuntime;
+
+export { MultiBoardRuntime, MultiBoardRuntimeOptions, SingleBoardRuntime, SingleBoardRuntimeOptions, createMultiBoardServerRuntime, createSingleBoardServerRuntime };

package/lib/server-runtime-controlface/index.js

@@ -0,0 +1,2 @@
+import {a as a$1,b}from'../chunk-76C7N4YT.js';import'../chunk-QJVR3FWQ.js';import'../chunk-NTICU4OK.js';import'../chunk-O7NOHKVR.js';import'../chunk-WHDEBJLT.js';import'../chunk-SGV7PU4H.js';import'../chunk-XYN5D3GL.js';import'../chunk-ZJ5M5COT.js';import'../chunk-YGALANRO.js';import'../chunk-6APH25VI.js';import'../chunk-VXJHBWK3.js';import'../chunk-PRKRXAVN.js';import'../chunk-HEEDJEKM.js';import'../chunk-JH37NJGP.js';import'../chunk-XQRNDX4Q.js';import'../chunk-BQS3EIEK.js';import'../chunk-VGT3TRQG.js';import'../chunk-WDPOGXTY.js';import'../chunk-ZCNN6XPV.js';import'../chunk-JMDHDY6M.js';import'../chunk-3KC6LBOG.js';import'../chunk-MNEOJWPS.js';import'../chunk-KBELAKIY.js';import'../chunk-76ON3V7R.js';import'../chunk-FW4363Y4.js';var a=["/mcp","/mcp-raw","/mcp-controlplane","/mcp-webhooks"];function l(n,e){return a.some(r=>e===`${n}${r}`)}function s(n,e){return a.some(r=>{let i=`${r}`;if(!e.startsWith(`${n}/`)||!e.endsWith(i))return  false;let t=e.slice(n.length+1,e.length-i.length);return t.length>0&&!t.includes("/")})}function d(n){let e=a$1(n);return {...e,async handleRuntimeApi(r,i,t){return l(e.apiBasePath,t.pathname)?e.handleRuntimeApi(r,i,t):false}}}function c(n){let e=b(n);return {...e,async handleApi(r,i,t){return s(e.apiBasePath,t.pathname)?e.handleApi(r,i,t):false}}}export{c as createMultiBoardServerRuntime,d as createSingleBoardServerRuntime};//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/server-runtime-core/index.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkEZENHAVZ_cjs=require('../chunk-EZENHAVZ.cjs'),chunkLPXVVMQT_cjs=require('../chunk-LPXVVMQT.cjs'),chunkKAWQPLIE_cjs=require('../chunk-KAWQPLIE.cjs'),chunk272IYUKT_cjs=require('../chunk-272IYUKT.cjs'),chunkCPAXTVBQ_cjs=require('../chunk-CPAXTVBQ.cjs');require('../chunk-GL2OHR2E.cjs'),require('../chunk-SFVO2LB2.cjs'),require('../chunk-PBOQ4HYB.cjs'),require('../chunk-IXZG74EW.cjs'),require('../chunk-HWYMZK3N.cjs'),require('../chunk-UJ7ZTV4J.cjs'),require('../chunk-GNFE24S7.cjs');Object.defineProperty(exports,"appendNotification",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.c}});Object.defineProperty(exports,"createCardFileOps",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.j}});Object.defineProperty(exports,"createControlplaneToolHandlers",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.h}});Object.defineProperty(exports,"createMcpControlplaneToolRegistry",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.m}});Object.defineProperty(exports,"createMcpFacadeModule",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.n}});Object.defineProperty(exports,"createMcpToolRegistry",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.k}});Object.defineProperty(exports,"createMcpWebhookToolRegistry",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.l}});Object.defineProperty(exports,"createRuntimePayloadModule",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.i}});Object.defineProperty(exports,"expectControlplaneSuccess",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.d}});Object.defineProperty(exports,"expectControlplaneSuccessAsync",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.e}});Object.defineProperty(exports,"getCardMetaKey",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.f}});Object.defineProperty(exports,"hasNonEmptyCardCountStatus",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.b}});Object.defineProperty(exports,"makeNotificationState",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.a}});Object.defineProperty(exports,"readCardMetaValue",{enumerable:true,get:function(){return chunkEZENHAVZ_cjs.g}});Object.defineProperty(exports,"getMcpArgNumber",{enumerable:true,get:function(){return chunkLPXVVMQT_cjs.b}});Object.defineProperty(exports,"getMcpArgRecord",{enumerable:true,get:function(){return chunkLPXVVMQT_cjs.c}});Object.defineProperty(exports,"getMcpArgString",{enumerable:true,get:function(){return chunkLPXVVMQT_cjs.a}});Object.defineProperty(exports,"getRequiredMcpArgNumber",{enumerable:true,get:function(){return chunkLPXVVMQT_cjs.e}});Object.defineProperty(exports,"getRequiredMcpArgRecord",{enumerable:true,get:function(){return chunkLPXVVMQT_cjs.d}});Object.defineProperty(exports,"parseMcpUploadBytes",{enumerable:true,get:function(){return chunkLPXVVMQT_cjs.f}});Object.defineProperty(exports,"concatUint8Arrays",{enumerable:true,get:function(){return chunkKAWQPLIE_cjs.d}});Object.defineProperty(exports,"escapeRegExp",{enumerable:true,get:function(){return chunkKAWQPLIE_cjs.c}});Object.defineProperty(exports,"executionWhatToRunValue",{enumerable:true,get:function(){return chunkKAWQPLIE_cjs.b}});Object.defineProperty(exports,"isAsyncBoardPlatformAdapter",{enumerable:true,get:function(){return chunkKAWQPLIE_cjs.a}});Object.defineProperty(exports,"extractMcpFailureMessage",{enumerable:true,get:function(){return chunk272IYUKT_cjs.b}});Object.defineProperty(exports,"invokeMcpTool",{enumerable:true,get:function(){return chunk272IYUKT_cjs.a}});Object.defineProperty(exports,"createHostedBoardQueueLaneRegistry",{enumerable:true,get:function(){return chunkCPAXTVBQ_cjs.a}});//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/lib/server-runtime-core/index.d.cts

@@ -0,0 +1,378 @@
+import { d as BoardRuntimePlatformAdapter } from '../types-Ba8H5_Wo.cjs';
+export { A as Awaitable, B as BoardContextConfig, c as BoardRuntimeNonCorePublic, e as BoardRuntimePublic, C as ChatHandlerFlowRunner, D as DescribeEnvelope, H as HostedBoardQueueLaneTuning, I as InvocationAdapter, a as MultiBoardRuntime, M as MultiBoardRuntimeOptions, N as NotificationTransport, Q as QueueLaneRuntimeTuning, R as RuntimeLogger, f as RuntimeRequest, g as RuntimeResponse, b as SingleBoardRuntime, S as SingleBoardRuntimeOptions } from '../types-Ba8H5_Wo.cjs';
+export { HostedBoardQueueLaneRegistryOptions, createHostedBoardQueueLaneRegistry } from '../server-jobs-queue-runner/index.cjs';
+export { M as McpControlplaneRegistryDeps, a as McpFacadeForRegistry, b as McpWebhookFacadeForRegistry, T as ToolRegistry, c as createMcpControlplaneToolRegistry, d as createMcpToolRegistry, e as createMcpWebhookToolRegistry } from '../mcp-tool-registries-W3TRj6O5.cjs';
+import { createBoardLiveCardsMcp, BoardLiveCardsMcpBoardDeps, BoardLiveCardsMcpNonCoreDeps, BoardLiveCardsMcpCardStoreDeps, BoardLiveCardsMcp } from '../board-live-cards-mcp.cjs';
+import { a as CommandResult } from '../board-live-cards-public-LlVUQPL2.cjs';
+export { B as BoardChangeNotification, c as BoardLiveCardsPublic, d as BoardNonCorePlatformAdapter, e as BoardPlatformAdapter, f as BoardWorkerRequest, C as CommandInput } from '../board-live-cards-public-LlVUQPL2.cjs';
+import { C as CardFileMetadataStore } from '../artifacts-store-lib-D9nMkVcE.cjs';
+import { A as AsyncBoardPlatformAdapter } from '../board-platform-adapter-async-BfHmHdx2.cjs';
+import { ExecutionRef } from '../execution-refs.cjs';
+export { A as AsyncBoardLiveCardsPublic } from '../board-live-cards-public-async-Di9QB141.cjs';
+export { B as BlobStorage, K as KVStorage, a as KindValueRef } from '../storage-interface-BFiD3kyB.cjs';
+export { C as ChatStorage } from '../chat-storage-lib-B9Q34Dyv.cjs';
+import '../queue-lane-registry-PaZuFpwp.cjs';
+import '../chat-store-public.cjs';
+import '../types-BBhqYGhE.cjs';
+import '../storage-async-interface-BRR4eBjx.cjs';
+
+/**
+ * server-runtime/notifications.ts
+ *
+ * Per-board notification accumulator state and the small set of pure helpers
+ * that fold incoming runtime events into that state. Owned by the runtime
+ * closure; no I/O.
+ */
+interface NotificationState {
+    status: unknown;
+    computedValues: Record<string, unknown>;
+    dataObjects: Record<string, unknown>;
+    cards: Record<string, unknown>;
+}
+declare function makeNotificationState(): NotificationState;
+declare function hasNonEmptyCardCountStatus(status: unknown): boolean;
+declare function appendNotification(state: NotificationState, event: unknown): void;
+
+/**
+ * server-runtime/mcp-invoker.ts
+ *
+ * Pure helpers for invoking MCP tools through a registry and turning a tool
+ * result into a human-readable error message. Both helpers are platform-free
+ * and depend only on plain values — no closure state.
+ */
+type McpToolHandler = (args: Record<string, unknown>) => unknown | Promise<unknown>;
+type McpToolRegistry = Record<string, McpToolHandler>;
+/**
+ * Look up `tool` in `registry` and invoke it with `args`. Normalises the
+ * returned shape so callers always see `{ status, data? }` (or an explicit
+ * `fail` / `error` envelope). Throws an Error tagged with `statusCode: 400`
+ * if the tool is unknown.
+ */
+declare function invokeMcpTool(tool: string, args: Record<string, unknown>, registry: McpToolRegistry): Promise<unknown>;
+/**
+ * Extract a single human-readable failure message from an MCP tool result,
+ * looking through validation envelopes for the first useful issue string.
+ * Returns `fallback` when nothing better can be found.
+ */
+declare function extractMcpFailureMessage(result: unknown, fallback: string): string;
+
+/**
+ * server-runtime/mcp-args.ts
+ *
+ * Pure MCP tool argument parsers. These read from the args record and do not
+ * touch runtime state. Kept here so the index closure does not redefine them.
+ */
+declare function getMcpArgString(args: Record<string, unknown>, ...keys: string[]): string;
+declare function getMcpArgNumber(args: Record<string, unknown>, ...keys: string[]): number | undefined;
+declare function getMcpArgRecord(args: Record<string, unknown>, ...keys: string[]): Record<string, unknown>;
+declare function getRequiredMcpArgRecord(args: Record<string, unknown>, errorKey: string, ...keys: string[]): Record<string, unknown>;
+declare function getRequiredMcpArgNumber(args: Record<string, unknown>, errorKey: string, ...keys: string[]): number;
+declare function parseMcpUploadBytes(args: Record<string, unknown>): Uint8Array | null;
+
+/**
+ * server-runtime/mcp-facade.ts
+ *
+ * MCP facade wiring extracted from createSingleBoardServerRuntime.
+ * Builds the four facade pieces used by the per-board MCP entry point:
+ * - mcpBoardFacade        (board command surface used by MCP)
+ * - mcpNonCoreFacade      (preflight / discovery surface)
+ * - mcpCardStoreFacade    (card-store CRUD surface)
+ * - createMcpFacade       (composes the above into BoardLiveCardsMcp)
+ *
+ * The facade reaches into many runtime closures (status snapshots,
+ * data-object reads, card-store reads, lane drains, etc.). Those are
+ * passed in as narrow callbacks so this module stays portable.
+ */
+
+/** Subset of BoardContext consumed by the facade. */
+interface McpFacadeBoardContextLike {
+    boardAdapter: unknown;
+    boardOps: {
+        getOutputsFetchedSources: (input: {
+            params: {
+                key: string;
+            };
+        }) => Promise<CommandResult>;
+        removeCard: (input: {
+            params: {
+                id: string;
+            };
+        }) => Promise<CommandResult>;
+        cardRefreshedNotify: (input: {
+            params: {
+                cardId: string;
+            };
+        }) => Promise<CommandResult>;
+        upsertCard: (input: {
+            params: {
+                cardId: string;
+                restart: boolean;
+            };
+        }) => Promise<CommandResult>;
+    };
+    cardStoreOps: {
+        set: (input: {
+            body: unknown;
+        }) => Promise<CommandResult>;
+        del: (input: {
+            params: {
+                id: string;
+            };
+        }) => Promise<CommandResult>;
+        patch: (input: {
+            params?: {
+                id?: string;
+                path?: string;
+            };
+            body?: unknown;
+        }) => Promise<CommandResult>;
+        appendFiles: (input: {
+            params?: {
+                id?: string;
+            };
+            body?: unknown;
+        }) => Promise<CommandResult>;
+    };
+    nonCore: {
+        describeTaskExecutorCapabilities: (input: unknown) => unknown;
+        validateCardPreflight: (input: unknown) => unknown;
+        evalCardCompute: (input: unknown) => unknown;
+        probeSourcePreflight: (input: unknown) => unknown;
+        runSourcePreflight: (input: unknown) => unknown;
+        simulateCardCycle: (input: unknown) => unknown;
+    } | null;
+}
+interface McpFacadeDeps {
+    boardContexts: ReadonlyArray<McpFacadeBoardContextLike>;
+    cardOwnerIndex: Map<string, number>;
+    cardContextForCard: (cardId: string) => McpFacadeBoardContextLike | null;
+    readStatusSnapshot: () => Promise<unknown>;
+    readDataObjectsByToken: () => Promise<Record<string, unknown>>;
+    readCardRuntimeArtifacts: () => Promise<Record<string, unknown>>;
+    readCardFromStore: (cardId: string) => Promise<Record<string, unknown> | null>;
+    readCardDefinitions: () => Promise<unknown[]>;
+    processAccumulatedLaneInternal: (skipInit?: boolean) => Promise<CommandResult>;
+    reportSourceFetched: (token: string, ref: string) => Promise<CommandResult>;
+    reportSourceFetchFailure: (token: string, reason: string) => Promise<CommandResult>;
+    uploadCardFile: (cardId: string, fileName: string, contentType: string, bytes: Uint8Array, opts?: {
+        inChat?: boolean;
+        suppressChatRecordWrite?: boolean;
+    }) => unknown | Promise<unknown>;
+    chatStorePublic: Parameters<typeof createBoardLiveCardsMcp>[0]['chatStore'];
+    serverUrl: string | null;
+    apiBasePath: string;
+}
+interface McpFacadeModule {
+    mcpBoardFacade: () => BoardLiveCardsMcpBoardDeps;
+    mcpNonCoreFacade: () => BoardLiveCardsMcpNonCoreDeps;
+    mcpCardStoreFacade: () => BoardLiveCardsMcpCardStoreDeps;
+    createMcpFacade: () => BoardLiveCardsMcp;
+}
+declare function createMcpFacadeModule(deps: McpFacadeDeps): McpFacadeModule;
+
+/**
+ * server-runtime/runtime-payload.ts
+ *
+ * Read-only aggregation of the per-runtime "published" payload that SSE
+ * snapshots and the /board-status endpoint return. Pulled out of
+ * createSingleBoardServerRuntime so the closure no longer has to host the
+ * three readers (status, computed-values, data-objects) plus the published
+ * payload assembler.
+ *
+ * Uses a structural board-context type with only the fields the readers need,
+ * so this module doesn't pull in the heavy BoardContext interface from
+ * index.ts.
+ */
+
+/** Minimum surface of the kv-storage handle used to read persisted status. */
+interface KvStorageReader {
+    read(key: string): unknown | Promise<unknown>;
+}
+/** Minimum surface of the board-platform adapter consumed by readStatusSnapshot. */
+interface BoardAdapterForPayload {
+    kvStorageForRef(ref: string): KvStorageReader;
+}
+/** Minimum surface of the board-ops handle consumed by payload readers. */
+interface BoardOpsForPayload {
+    getAllOutputsComputedValues(input: Record<string, unknown>): {
+        status: string;
+        data?: unknown;
+    } | Promise<{
+        status: string;
+        data?: unknown;
+    }>;
+    getAllOutputsDataObjects(input: Record<string, unknown>): {
+        status: string;
+        data?: unknown;
+    } | Promise<{
+        status: string;
+        data?: unknown;
+    }>;
+}
+/** Subset of BoardContext consumed by runtime-payload readers. */
+interface RuntimePayloadBoardContext {
+    boardOps: BoardOpsForPayload;
+    boardAdapter: BoardAdapterForPayload;
+    outputsStoreRef: string;
+    notification: NotificationState;
+}
+interface RuntimePayloadDeps {
+    boardId: string;
+    /** Live reference to the runtime's board-contexts array (read on each call). */
+    boardContexts: ReadonlyArray<RuntimePayloadBoardContext>;
+    readCardDefinitions: () => Promise<Array<Record<string, unknown>>>;
+    readChatRecords: (cardId: string) => Array<Record<string, unknown>>;
+    getChatProcessing: (cardId: string) => boolean;
+}
+interface RuntimePayloadModule {
+    readStatusSnapshot: () => Promise<unknown>;
+    readCardRuntimeArtifacts: () => Promise<Record<string, unknown>>;
+    readDataObjectsByToken: () => Promise<Record<string, unknown>>;
+    buildPublishedRuntimePayload: () => Promise<unknown>;
+}
+declare function createRuntimePayloadModule(deps: RuntimePayloadDeps): RuntimePayloadModule;
+
+/**
+ * server-runtime/controlplane-tool-handlers.ts
+ *
+ * Handlers for the small "controlplane" MCP tools that read/write chat
+ * processing state and per-card meta. Each handler validates `board_id`
+ * against the runtime's own boardId, requires `card_id`, then delegates to
+ * the MCP facade or card-store facade supplied by the host runtime.
+ *
+ * The handlers are factored out of createSingleBoardServerRuntime so that
+ * createMcpControlplaneToolRegistry in index.ts can simply wire them up,
+ * keeping the closure free of repetitive arg-validation noise.
+ */
+
+interface ControlplaneToolHandlersDeps {
+    boardId: string;
+    /** Returns the live MCP facade (chat processing getters/setters). */
+    getMcpFacade: () => {
+        setChatProcessing: (args: {
+            cardId: string;
+            active: boolean;
+        }) => unknown;
+        getChatProcessing: (args: {
+            cardId: string;
+        }) => {
+            active: boolean;
+        };
+    };
+    /** Returns the card-store facade used for meta reads/writes. */
+    getMcpCardStoreFacade: () => BoardLiveCardsMcpCardStoreDeps;
+}
+interface ControlplaneToolHandlers {
+    requireCardArgs: (args: Record<string, unknown>) => {
+        cardId: string;
+    };
+    setChatProcessing: (args: Record<string, unknown>, active: boolean) => {
+        status: 'success';
+        data: {
+            boardId: string;
+            cardId: string;
+            active: boolean;
+        };
+    };
+    getChatProcessing: (args: Record<string, unknown>) => {
+        status: 'success';
+        data: {
+            boardId: string;
+            cardId: string;
+            active: boolean;
+        };
+    };
+    setCardMeta: (args: Record<string, unknown>) => Promise<{
+        status: 'success';
+        data: {
+            boardId: string;
+            cardId: string;
+            key: string;
+        };
+    }>;
+    getCardMeta: (args: Record<string, unknown>) => Promise<{
+        status: 'success';
+        data: {
+            boardId: string;
+            cardId: string;
+            key: string;
+            exists: boolean;
+            value: unknown;
+        };
+    }>;
+}
+declare function createControlplaneToolHandlers(deps: ControlplaneToolHandlersDeps): ControlplaneToolHandlers;
+
+/**
+ * server-runtime/controlplane-helpers.ts
+ *
+ * Pure helpers used by the runtime's controlplane MCP handlers. The handlers
+ * themselves still live in index.ts because they capture closure state; these
+ * utilities are stateless.
+ */
+
+declare function expectControlplaneSuccess<T>(result: CommandResult<T>, commandName: string): T;
+declare function expectControlplaneSuccessAsync<T>(result: CommandResult<T> | Promise<CommandResult<T>>, commandName: string): Promise<T>;
+declare function getCardMetaKey(args: Record<string, unknown>): string;
+declare function readCardMetaValue(card: Record<string, unknown>, key: string): {
+    exists: boolean;
+    value: unknown;
+};
+
+/**
+ * server-runtime/card-file-ops.ts
+ *
+ * Per-card file upload / metadata-merge orchestration extracted from
+ * createSingleBoardServerRuntime. The factory takes narrow callbacks for
+ * the small handful of closure-owned helpers (card-store reads,
+ * card-data writes, chat-record writes, artifact stores, file-metadata
+ * normaliser) and exposes the upload entry point plus its read helper.
+ */
+
+/** Subset of the per-card files artifact store consumed by file-ops. */
+interface FilesArtifactsStoreLike {
+    putBytes(key: string, content: Uint8Array, contentType?: string): unknown | Promise<unknown>;
+}
+interface CardFileOpsDeps {
+    /** Sanitised card-id suitable for use as a storage prefix. */
+    safeCardId: (cardId: string) => string;
+    /** Returns the per-card artifact stores; `files` is the bytes sink. */
+    artifactsStores: (cardId: string) => {
+        files: FilesArtifactsStoreLike | null;
+    };
+    /** Card-file-metadata store wired against the runtime's persistence layer. */
+    cardFileMetadataStore: () => CardFileMetadataStore;
+    /** Read the persisted card from the store (used to count existing files). */
+    readCardFromStore: (cardId: string) => Promise<Record<string, unknown> | null>;
+    /** Apply a local-only update to a card; same shape as updateCardLocalOnly. */
+    updateCardLocalOnly: (cardId: string, updateFn: (card: Record<string, unknown>) => Record<string, unknown> | void) => Promise<void>;
+    /** Append a chat record (used for in-chat upload announcements). */
+    writeChatRecord: (cardId: string, role: string, text: string, files: unknown[], turnId: string) => unknown;
+}
+interface CardFileOps {
+    uploadCardFile: (cardId: string, requestedName: string, contentType: string, buffer: Uint8Array, opts?: {
+        inChat?: boolean;
+        turnId?: string;
+        suppressChatRecordWrite?: boolean;
+    }) => Promise<{
+        ok: true;
+        file: Record<string, unknown>;
+    }>;
+    readCardStoredFileNames: (cardId: string) => Promise<string[]>;
+}
+declare function createCardFileOps(deps: CardFileOpsDeps): CardFileOps;
+
+/**
+ * server-runtime/internal-helpers.ts
+ *
+ * Small, pure helpers shared across the server-runtime slices. No closure
+ * state, no I/O. Anything that depends on runtime state belongs in a slice
+ * module, not here.
+ */
+
+declare function isAsyncBoardPlatformAdapter(adapter: BoardRuntimePlatformAdapter): adapter is AsyncBoardPlatformAdapter;
+declare function executionWhatToRunValue(ref: ExecutionRef): string;
+declare function escapeRegExp(str: string): string;
+declare function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array;
+
+export { AsyncBoardPlatformAdapter, BoardRuntimePlatformAdapter, CommandResult, ExecutionRef, type McpFacadeBoardContextLike, type McpFacadeDeps, type McpFacadeModule, type McpToolHandler, type McpToolRegistry, type NotificationState, type RuntimePayloadBoardContext, type RuntimePayloadDeps, type RuntimePayloadModule, appendNotification, concatUint8Arrays, createCardFileOps, createControlplaneToolHandlers, createMcpFacadeModule, createRuntimePayloadModule, escapeRegExp, executionWhatToRunValue, expectControlplaneSuccess, expectControlplaneSuccessAsync, extractMcpFailureMessage, getCardMetaKey, getMcpArgNumber, getMcpArgRecord, getMcpArgString, getRequiredMcpArgNumber, getRequiredMcpArgRecord, hasNonEmptyCardCountStatus, invokeMcpTool, isAsyncBoardPlatformAdapter, makeNotificationState, parseMcpUploadBytes, readCardMetaValue };