yaml-flow 8.5.3 → 8.6.2

package/lib/{board-live-cards-public-BGS22cMb.d.ts → board-live-cards-public-BMUIPOrc.d.ts}

@@ -1,4 +1,4 @@
-import { K as KVStorage, B as BlobStorage, S as ScratchStorage, A as ArchiveFactory, b as AtomicRelayLock, a as KindValueRef } from './storage-interface-B2WD9D5n.js';
+import { g as QueueStorage, K as KVStorage, B as BlobStorage, S as ScratchStorage, A as ArchiveFactory, h as AtomicRelayLock, a as KindValueRef } from './storage-interface-BFiD3kyB.js';
 import { ExecutionRef } from './execution-refs.js';
 import { f as GraphEvent, G as GraphConfig } from './types-BBhqYGhE.js';
 
@@ -71,6 +71,10 @@ interface JournalStorageAdapter {
 }
 declare const SNAPSHOT_SCHEMA_VERSION_V1 = "v1";
 declare const BOARD_GRAPH_KEY = "board/graph";
+interface StateSnapshotReadView {
+    version: string | null;
+    values: Record<string, unknown>;
+}
 type OutputStoreEvent = {
     kind: 'computed_values';
     cardId: string;
@@ -136,6 +140,52 @@ interface BoardStatusObject {
 }
 declare const EMPTY_CONFIG: GraphConfig;
 
+interface BoardTaskCallback {
+    token: string;
+    via: ExecutionRef;
+}
+interface BoardCallbackTransport {
+    createCallback(token: string): BoardTaskCallback;
+}
+declare function createHttpBoardCallbackTransport(baseUrl: string): BoardCallbackTransport;
+declare function createInProcessBoardCallbackTransport(handlerKey: string): BoardCallbackTransport;
+declare function createLocalNodeBoardCallbackTransport(notifyChannel?: string): BoardCallbackTransport;
+
+interface BoardWorkerRequest {
+    boardId?: string;
+    ref: ExecutionRef;
+    args: Record<string, unknown>;
+}
+interface BoardWorkerQueuedRequest {
+    messageId: string;
+    enqueuedAt: string;
+    attempt: number;
+    request: BoardWorkerRequest;
+}
+interface BoardWorkerLeasedRequest extends BoardWorkerQueuedRequest {
+    leaseToken: string;
+    leaseExpiresAt: string;
+}
+interface BoardWorkerDeadLetterRequest extends BoardWorkerQueuedRequest {
+    reason?: string;
+}
+interface BoardWorkerStore {
+    enqueueRequest(request: BoardWorkerRequest): string;
+    enqueueRequestIfAbsent?(request: BoardWorkerRequest, dedupKey: string): string | null;
+    leaseRequests(opts?: {
+        max?: number;
+        visibilityMs?: number;
+    }): BoardWorkerLeasedRequest[];
+    ackRequest(messageId: string, leaseToken: string): boolean;
+    nackRequest(messageId: string, leaseToken: string, opts?: {
+        dead?: boolean;
+        reason?: string;
+    }): boolean;
+    peekActive(): BoardWorkerQueuedRequest[];
+    peekDeadLetter(): BoardWorkerDeadLetterRequest[];
+}
+declare function createBoardWorkerStore(queue: QueueStorage): BoardWorkerStore;
+
 /**
  * board-live-cards-public.ts
  *
@@ -233,6 +283,22 @@ interface BoardPlatformAdapter {
      * One journal per board — no namespace parameter needed.
      */
     journalAdapter(): JournalStorageAdapter;
+    /**
+     * Semantic board-worker queue for hosted task execution.
+     * Implementations may back this with QueueStorage, Service Bus, Pub/Sub, etc.
+     */
+    boardWorkerStore(): BoardWorkerStore;
+    /**
+     * Semantic queue for chat-agent dispatch requests.
+     * Kept separate from task execution so chat work can be drained independently.
+     */
+    chatAgentStore(): BoardWorkerStore;
+    /**
+     * Queue of board wake-up requests for processAccumulatedEvents scheduling.
+     * Implementations should use enqueueIfAbsent when they want single-pending
+     * drain semantics.
+     */
+    processAccumulatedStore(): QueueStorage;
     /**
      * AtomicRelayLock — non-blocking try-acquire with relay-on-busy semantics.
      * Guards processAccumulatedEvents drain cycle.
@@ -242,17 +308,15 @@ interface BoardPlatformAdapter {
      */
     lock: AtomicRelayLock;
     /**
-     * Self-identity ExecutionRef — how to invoke THIS board instance.
-     * Embedded in source callback tokens so executors know where to report back.
-    *   Node/FS:  { howToRun: 'local-node', whatToRun: 'b64:<base64url({"kind":"yaml-flow-cli","value":"board-live-cards-cli.js"})>' }
-    *   Azure Fn: { howToRun: 'http:post',  whatToRun: 'b64:<base64url({"kind":"http-url","value":"https://…/api/board"})>' }
+     * Adapter-owned callback transport used to build worker callback payloads.
+     * The board core treats callback delivery as a platform concern.
      */
-    selfRef: ExecutionRef;
+    callbackTransport?: BoardCallbackTransport;
     /**
      * Generic execution dispatch — platform adapts ExecutionRef → actual transport.
      * Public layer constructs fully-formed semantic args (source def, base_ref,
      * callback token with selfRef baked in). Platform handles transport:
-     *   Node: writes args to temp file, spawns detached process
+      *   Node host adapter: may write args to temp file and may spawn a detached process
      *   Azure: HTTP POST args as JSON body
      *   Firebase: publishes args as pubsub message
      */
@@ -260,6 +324,12 @@ interface BoardPlatformAdapter {
         dispatched: boolean;
         error?: string;
     }>;
+    /**
+     * Whether dispatchExecution can accept a board-owned staged source output ref
+     * for this executor. When false/absent, the adapter keeps its legacy staging
+     * protocol such as scratch in/out refs for local process launch.
+     */
+    supportsDirectSourceOutput?(ref: ExecutionRef): boolean;
     /**
      * Resolve a blob ref to its string contents.
      * The adapter handles the platform-specific lookup (e.g. absolute FS path vs board-relative key).
@@ -355,13 +425,13 @@ type BoardChangeNotification = OutputStoreEvent | {
 declare function createBoardLiveCardsPublic(baseRef: KindValueRef, adapter: BoardPlatformAdapter): BoardLiveCardsPublic;
 interface BoardNonCorePlatformAdapter extends BoardPlatformAdapter {
     /**
-     * Synchronously invoke a task executor subcommand and return stdout.
-     * Throws on non-zero exit or timeout.
+     * Invoke a task executor subcommand and return stdout.
+     * Throws on transport failure, non-zero exit, or timeout.
      */
-    invokeExecutorSync(ref: ExecutionRef, subcommand: string, args: string[], opts?: {
+    invokeExecutor(ref: ExecutionRef, subcommand: string, opts?: {
         timeout?: number;
         input?: string;
-    }): string;
+    }): Promise<string>;
     /** Schema-only card validator (no executor invocation). */
     validateSchema(card: Record<string, unknown>): {
         ok: boolean;
@@ -370,7 +440,7 @@ interface BoardNonCorePlatformAdapter extends BoardPlatformAdapter {
     /** Absolute-path blob I/O for resolving arbitrary KindValueRef blobs. */
     absoluteBlob: BlobStorage;
     /**
-     * Default timeouts (ms) for synchronous executor invocations.
+    * Default timeouts (ms) for executor request/response calls.
      * Each field can also be overridden per-source via source_def.timeout.
      *
      *   validationMs — validate-source-def, validate-card-preflight (structural, fast). Default: 10_000.
@@ -386,31 +456,21 @@ interface BoardNonCorePlatformAdapter extends BoardPlatformAdapter {
     };
 }
 interface BoardLiveCardsNonCorePublic {
-    /** params: cardId? or all?; returns array even for single card */
-    validateCard(input: CommandInput): CommandResult<Array<{
-        cardId: string;
-        isValid: boolean;
-        issues: string[];
-    }>>;
     /** body: { "card-content": <card> } — card JSON arrives via stdin; validates schema + JSONata + provides refs + source_defs (executor, if configured) */
-    validateCardPreflight(input: CommandInput): CommandResult<{
+    validateCardPreflight(input: CommandInput): Promise<CommandResult<{
         cardId: string;
         isValid: boolean;
         issues: string[];
-    }>;
-    /** params: cardId, sourceIdx, outRef?; body — mockProjections object */
-    probeSource(input: CommandInput): CommandResult;
-    /** body: { sourceDef, mockProjections }; params: outRef? */
-    probeTmpSource(input: CommandInput): CommandResult;
+    }>>;
     /** body: { "card-content": <card>, "mock-projections"?: {} }; params: sourceIdx, outRef? — card JSON arrives via stdin; no board state needed */
-    probeSourcePreflight(input: CommandInput): CommandResult;
+    probeSourcePreflight(input: CommandInput): Promise<CommandResult>;
     /** body: { "card-content": <card>, "mock-projections"?: {} }; params: sourceIdx, outRef? — runs the real source fetch flow as a preflight */
-    runSourcePreflight(input: CommandInput): CommandResult<{
+    runSourcePreflight(input: CommandInput): Promise<CommandResult<{
         bindTo: string;
         ok: boolean;
         result: unknown;
         issues: string[];
-    }>;
+    }>>;
     /** body: { "card-content": <card>, "mock-fetched-sources"?: {}, "mock-requires"?: {} } — evaluates compute expressions with supplied data; no board state needed */
     evalCardCompute(input: CommandInput): CommandResult<{
         cardId: string;
@@ -422,9 +482,9 @@ interface BoardLiveCardsNonCorePublic {
         }>;
     }>;
     /** body: { "card-content": <card>, "mock-fetched-sources"?: {}, "mock-requires"?: {} } — full cycle: validate → resolve projections → probe sources → compute */
-    simulateCardCycle(input: CommandInput): CommandResult;
+    simulateCardCycle(input: CommandInput): Promise<CommandResult>;
     /** no params needed */
-    describeTaskExecutorCapabilities(input: CommandInput): CommandResult;
+    describeTaskExecutorCapabilities(input: CommandInput): Promise<CommandResult>;
     /**
      * Write/update cards in the configured card store.
      * body: { ops: Array<{ op: 'update', id: string, 'card-content': LiveCard }> }
@@ -443,4 +503,4 @@ interface BoardLiveCardsNonCorePublic {
 }
 declare function createBoardLiveCardsNonCorePublic(baseRef: KindValueRef, adapter: BoardNonCorePlatformAdapter): BoardLiveCardsNonCorePublic;
 
-export { type BoardChangeNotification as B, type CommandResult as C, EMPTY_CONFIG as E, type LiveCard as L, SNAPSHOT_SCHEMA_VERSION_V1 as S, type CommandInput as a, type CardAdminStore as b, type BoardLiveCardsPublic as c, type BoardNonCorePlatformAdapter as d, type BoardPlatformAdapter as e, BOARD_GRAPH_KEY as f, type BoardLiveCardsNonCorePublic as g, createBoardLiveCardsNonCorePublic as h, createBoardLiveCardsPublic as i, createCardStore as j };
+export { type BoardWorkerRequest as B, type CommandResult as C, EMPTY_CONFIG as E, type LiveCard as L, type StateSnapshotReadView as S, type CommandInput as a, type CardAdminStore as b, type BoardChangeNotification as c, type BoardLiveCardsPublic as d, type BoardNonCorePlatformAdapter as e, type BoardPlatformAdapter as f, type BoardCallbackTransport as g, type BoardStatusObject as h, type CardChecksumIndex as i, type CardUpsertValidation as j, type CardIndex as k, type BoardWorkerStore as l, BOARD_GRAPH_KEY as m, type BoardLiveCardsNonCorePublic as n, type BoardWorkerDeadLetterRequest as o, type BoardWorkerLeasedRequest as p, type BoardWorkerQueuedRequest as q, SNAPSHOT_SCHEMA_VERSION_V1 as r, createBoardLiveCardsNonCorePublic as s, createBoardLiveCardsPublic as t, createBoardWorkerStore as u, createCardStore as v, createHttpBoardCallbackTransport as w, createInProcessBoardCallbackTransport as x, createLocalNodeBoardCallbackTransport as y };

package/lib/board-live-cards-public-async-DKZqbJVU.d.ts

@@ -0,0 +1,256 @@
+import { b as BlobStat, a as KindValueRef, c as JournalEntry, d as JournalReadResult, Q as QueueMessage, e as QueueLeasedMessage, f as QueueDeadLetterMessage } from './storage-interface-BFiD3kyB.js';
+import { g as BoardCallbackTransport, c as BoardChangeNotification, a as CommandInput, C as CommandResult, h as BoardStatusObject } from './board-live-cards-public-BMUIPOrc.js';
+import { ExecutionRef } from './execution-refs.js';
+
+interface AsyncBlobStorage {
+    read(key: string): Promise<string | null>;
+    write(key: string, content: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    remove(key: string): Promise<void>;
+    readBytes?(key: string): Promise<Uint8Array | null>;
+    writeBytes?(key: string, content: Uint8Array): Promise<void>;
+    listKeys(prefix?: string): Promise<string[]>;
+    stat?(key: string): Promise<BlobStat | null>;
+    keyRef?(key: string): Promise<KindValueRef> | KindValueRef;
+}
+interface AsyncJournalStorage {
+    append(payload: unknown): Promise<JournalEntry>;
+    readAll(): Promise<JournalEntry[]>;
+    readAfter(cursor: string | null): Promise<JournalReadResult>;
+    clear?(): Promise<void>;
+}
+interface AsyncQueueStorage {
+    enqueue<T>(body: T): Promise<QueueMessage<T>>;
+    /** See QueueStorage.enqueueIfAbsent. Optional on adapters that cannot cheaply dedup. */
+    enqueueIfAbsent?<T>(body: T, dedupKey: string): Promise<QueueMessage<T> | null>;
+    lease<T>(opts?: {
+        max?: number;
+        visibilityMs?: number;
+    }): Promise<QueueLeasedMessage<T>[]>;
+    ack(messageId: string, leaseToken: string): Promise<boolean>;
+    nack(messageId: string, leaseToken: string, opts?: {
+        dead?: boolean;
+        reason?: string;
+    }): Promise<boolean>;
+    peekActive<T>(prefix?: string): Promise<QueueMessage<T>[]>;
+    peekDeadLetter<T>(prefix?: string): Promise<QueueDeadLetterMessage<T>[]>;
+}
+interface AsyncKVStorage {
+    read(key: string): Promise<unknown | null>;
+    write(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    listKeys(prefix?: string): Promise<string[]>;
+}
+interface AsyncJSONStorage {
+    read(key: string): Promise<unknown | null>;
+    get(key: string, jsonPath: string): Promise<unknown | null>;
+    write(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    listKeys(prefix?: string): Promise<string[]>;
+    shallowMerge(key: string, patch: Record<string, unknown>): Promise<void>;
+    deepMerge(key: string, patch: Record<string, unknown>): Promise<void>;
+    patch(key: string, jsonPath: string, value: unknown): Promise<void>;
+}
+interface AsyncScratchStorage extends AsyncBlobStorage {
+    getUniqueKey(prefix?: string, suffix?: string): Promise<string>;
+    create(data: string, prefix?: string, suffix?: string): Promise<string>;
+    keyRef(key: string): Promise<KindValueRef> | KindValueRef;
+    config: {
+        get(k: string): Promise<unknown> | unknown;
+        set(k: string, v: unknown): Promise<void> | void;
+    };
+}
+interface AsyncArchiveFactory {
+    stream(name: string): AsyncJournalStorage;
+    blob(name: string): AsyncBlobStorage;
+    listStreams(prefix?: string): Promise<string[]>;
+    listBlobs(prefix?: string): Promise<string[]>;
+    config: {
+        get(k: string): Promise<unknown> | unknown;
+        set(k: string, v: unknown): Promise<void> | void;
+    };
+}
+interface AsyncStorageProvider {
+    blob: AsyncBlobStorage;
+    journal: AsyncJournalStorage;
+    kv: AsyncKVStorage;
+}
+interface AsyncAtomicRelayLock {
+    tryAcquire(): Promise<(() => Promise<void> | void) | null>;
+}
+declare function withAsyncRelayLock(lock: AsyncAtomicRelayLock, work: () => Promise<void>, continuation?: () => Promise<void> | void): Promise<boolean>;
+
+interface AsyncBoardWorkerRequest {
+    boardId?: string;
+    ref: ExecutionRef;
+    args: Record<string, unknown>;
+}
+interface AsyncBoardWorkerQueuedRequest {
+    messageId: string;
+    enqueuedAt: string;
+    attempt: number;
+    request: AsyncBoardWorkerRequest;
+}
+interface AsyncBoardWorkerLeasedRequest extends AsyncBoardWorkerQueuedRequest {
+    leaseToken: string;
+    leaseExpiresAt: string;
+}
+interface AsyncBoardWorkerDeadLetterRequest extends AsyncBoardWorkerQueuedRequest {
+    reason?: string;
+}
+interface AsyncBoardWorkerStore {
+    enqueueRequest(request: AsyncBoardWorkerRequest): Promise<string>;
+    leaseRequests(opts?: {
+        max?: number;
+        visibilityMs?: number;
+    }): Promise<AsyncBoardWorkerLeasedRequest[]>;
+    ackRequest(messageId: string, leaseToken: string): Promise<boolean>;
+    nackRequest(messageId: string, leaseToken: string, opts?: {
+        dead?: boolean;
+        reason?: string;
+    }): Promise<boolean>;
+    peekActive(): Promise<AsyncBoardWorkerQueuedRequest[]>;
+    peekDeadLetter(): Promise<AsyncBoardWorkerDeadLetterRequest[]>;
+}
+interface AsyncBoardConfigStore {
+    readTaskExecutorRef(): Promise<ExecutionRef | undefined>;
+    writeTaskExecutorRef(ref: ExecutionRef): Promise<void>;
+    readChatHandlerFlow(): Promise<unknown>;
+    writeChatHandlerFlow(flow: unknown): Promise<void>;
+    readCardStoreRef(): Promise<string | null>;
+    writeCardStoreRef(ref: string): Promise<void>;
+    readOutputsStoreRef(): Promise<string | null>;
+    writeOutputsStoreRef(ref: string): Promise<void>;
+    readScratchStoreRef(): Promise<string | null>;
+    writeScratchStoreRef(ref: string): Promise<void>;
+    readArchiveStoreRef(): Promise<string | null>;
+    writeArchiveStoreRef(ref: string): Promise<void>;
+    readChatStoreRef(): Promise<string | null>;
+    writeChatStoreRef(ref: string): Promise<void>;
+    readArtifactsStoreRef(): Promise<string | null>;
+    writeArtifactsStoreRef(ref: string): Promise<void>;
+}
+interface AsyncBoardPlatformAdapter {
+    kvStorage(namespace: string): AsyncKVStorage;
+    kvStorageForRef(ref: string): AsyncKVStorage;
+    blobStorage(namespace: string): AsyncBlobStorage;
+    scratchStorage(): AsyncScratchStorage;
+    scratchStorageForRef(ref: string): AsyncScratchStorage;
+    archiveFactory(): AsyncArchiveFactory;
+    archiveFactoryForRef(ref: string): AsyncArchiveFactory;
+    journalStorage(): AsyncJournalStorage;
+    boardWorkerStore(): AsyncBoardWorkerStore;
+    chatAgentStore(): AsyncBoardWorkerStore;
+    processAccumulatedStore(): AsyncQueueStorage;
+    lock: AsyncAtomicRelayLock;
+    callbackTransport?: BoardCallbackTransport;
+    dispatchExecution(ref: ExecutionRef, args: Record<string, unknown>): Promise<{
+        dispatched: boolean;
+        error?: string;
+    }>;
+    supportsDirectSourceOutput?(ref: ExecutionRef): boolean;
+    resolveBlob(ref: KindValueRef): Promise<string>;
+    hashFn(value: unknown): string;
+    genId(): string;
+    requestProcessAccumulated?(): void | Promise<void>;
+    publishBoardChangeNotifications?(notifications: BoardChangeNotification[]): void | Promise<void>;
+    warn?: (msg: string) => void;
+}
+interface HostedFetchResponseLike {
+    ok: boolean;
+    status: number;
+    text(): Promise<string>;
+}
+interface HostedFetchLike {
+    (input: string, init: {
+        method: string;
+        headers: Record<string, string>;
+        body: string;
+    }): Promise<HostedFetchResponseLike>;
+}
+interface HostedAsyncBoardPlatformAdapterOptions {
+    boardId?: string;
+    kvStorage(namespace: string): AsyncKVStorage;
+    kvStorageForRef(ref: string): AsyncKVStorage;
+    blobStorage(namespace: string): AsyncBlobStorage;
+    scratchStorage(): AsyncScratchStorage;
+    scratchStorageForRef(ref: string): AsyncScratchStorage;
+    archiveFactory(): AsyncArchiveFactory;
+    archiveFactoryForRef(ref: string): AsyncArchiveFactory;
+    journalStorage(): AsyncJournalStorage;
+    queueStorage?: AsyncQueueStorage;
+    boardWorkerStore?: AsyncBoardWorkerStore;
+    chatAgentQueueStorage?: AsyncQueueStorage;
+    chatAgentStore?: AsyncBoardWorkerStore;
+    processAccumulatedQueueStorage?: AsyncQueueStorage;
+    processAccumulatedStore?: AsyncQueueStorage;
+    lock: AsyncAtomicRelayLock;
+    callbackTransport?: BoardCallbackTransport;
+    fetch?: HostedFetchLike;
+    dispatchExecution?: (ref: ExecutionRef, args: Record<string, unknown>) => Promise<{
+        dispatched: boolean;
+        error?: string;
+    }>;
+    supportsDirectSourceOutput?: (ref: ExecutionRef) => boolean;
+    resolveBlob?: (ref: KindValueRef) => Promise<string>;
+    hashFn: (value: unknown) => string;
+    genId: () => string;
+    requestProcessAccumulated?: () => void | Promise<void>;
+    publishBoardChangeNotifications?: (notifications: BoardChangeNotification[]) => void | Promise<void>;
+    onWarn?: (msg: string) => void;
+}
+declare function createAsyncBoardWorkerStore(queue: AsyncQueueStorage): AsyncBoardWorkerStore;
+declare function createAsyncBoardConfigStore(kv: AsyncKVStorage): AsyncBoardConfigStore;
+declare function createHostedAsyncBoardPlatformAdapter(options: HostedAsyncBoardPlatformAdapterOptions): AsyncBoardPlatformAdapter;
+
+interface AsyncBoardLiveCardsPublic {
+    init(input: CommandInput): Promise<CommandResult>;
+    status(input: CommandInput): Promise<CommandResult<BoardStatusObject>>;
+    getCardStoreRef(input: CommandInput): Promise<CommandResult<{
+        storeRef: string;
+    }>>;
+    getOutputsStoreRef(input: CommandInput): Promise<CommandResult<{
+        storeRef: string;
+    }>>;
+    getScratchStoreRef(input: CommandInput): Promise<CommandResult<{
+        storeRef: string | null;
+    }>>;
+    getArchiveStoreRef(input: CommandInput): Promise<CommandResult<{
+        storeRef: string | null;
+    }>>;
+    getChatStoreRef(input: CommandInput): Promise<CommandResult<{
+        storeRef: string | null;
+    }>>;
+    getArtifactsStoreRef(input: CommandInput): Promise<CommandResult<{
+        storeRef: string | null;
+    }>>;
+    getConfig(input: CommandInput): Promise<CommandResult<{
+        value: unknown;
+    }>>;
+    getOutputsDataObject(input: CommandInput): Promise<CommandResult>;
+    getAllOutputsDataObjects(input: CommandInput): Promise<CommandResult<Record<string, unknown>>>;
+    getOutputsComputedValues(input: CommandInput): Promise<CommandResult>;
+    getAllOutputsComputedValues(input: CommandInput): Promise<CommandResult<Record<string, unknown>>>;
+    getOutputsFetchedSources(input: CommandInput): Promise<CommandResult<Record<string, string>>>;
+    getAllOutputsFetchedSources(input: CommandInput): Promise<CommandResult<Record<string, Record<string, string>>>>;
+    addCardFiles(input: CommandInput): Promise<CommandResult<{
+        cardId: string;
+        files_added: Array<{
+            idx: number;
+            entry: unknown;
+        }>;
+        notified: true;
+    }>>;
+    cardRefreshedNotify(input: CommandInput): Promise<CommandResult>;
+    removeCard(input: CommandInput): Promise<CommandResult>;
+    retrigger(input: CommandInput): Promise<CommandResult>;
+    upsertCard(input: CommandInput): Promise<CommandResult>;
+    processAccumulatedEvents(input: CommandInput): Promise<CommandResult>;
+    taskFailed(input: CommandInput): Promise<CommandResult>;
+    taskProgress(input: CommandInput): Promise<CommandResult>;
+    sourceDataFetched(input: CommandInput): Promise<CommandResult>;
+    sourceDataFetchFailure(input: CommandInput): Promise<CommandResult>;
+}
+declare function createAsyncBoardLiveCardsPublic(baseRef: KindValueRef, adapter: AsyncBoardPlatformAdapter): AsyncBoardLiveCardsPublic;
+
+export { type AsyncBoardLiveCardsPublic as A, type HostedAsyncBoardPlatformAdapterOptions as H, type AsyncBoardPlatformAdapter as a, type AsyncJSONStorage as b, type AsyncKVStorage as c, type AsyncBlobStorage as d, type AsyncJournalStorage as e, type AsyncStorageProvider as f, type AsyncAtomicRelayLock as g, type AsyncQueueStorage as h, type AsyncBoardConfigStore as i, type AsyncBoardWorkerDeadLetterRequest as j, type AsyncBoardWorkerLeasedRequest as k, type AsyncBoardWorkerQueuedRequest as l, type AsyncBoardWorkerRequest as m, type AsyncBoardWorkerStore as n, type HostedFetchLike as o, type HostedFetchResponseLike as p, createAsyncBoardConfigStore as q, createAsyncBoardLiveCardsPublic as r, createAsyncBoardWorkerStore as s, createHostedAsyncBoardPlatformAdapter as t, withAsyncRelayLock as w };