@intx/hub-sessions 0.1.2 → 0.3.0

package/dist/workflow-closure-resolution.d.ts

@@ -0,0 +1,106 @@
+import { type PackumentFetcher, type RegistryConfig } from "@intx/tool-packaging";
+import type { WorkflowSourceAssetMount } from "@intx/types/sidecar";
+import type { ToolPackageManifest } from "@intx/types/tool-packages";
+import type { WorkflowDefinitionAssetSource, WorkflowDefinitionRegistrySource } from "@intx/types/workflow-sources";
+import { type SourceTreeReads } from "./workflow-source-closure.js";
+/**
+ * Resolve a workflow definition's dependency closure against the npm registry
+ * the source names.
+ */
+export type ResolveWorkflowClosureRegistryArgs = {
+    readonly source: WorkflowDefinitionRegistrySource;
+    /** A `name@range` spec for the workflow definition package. */
+    readonly pin: string;
+    /** URL and credentials for the registry named by `source.registry`. */
+    readonly registryConfig: RegistryConfig;
+    /**
+     * Test seam for packument fetches. Omitted in production, where the
+     * default `npm-registry-fetch` wrapper reaches the configured URL.
+     */
+    readonly fetchPackument?: PackumentFetcher;
+};
+/**
+ * Resolve a workflow definition's dependency closure against a single hub
+ * `package-registry` asset.
+ *
+ * The resolver is single-source by design: the asset is the sole and default
+ * registry, so a self-contained definition (its `@intx/*` imports bundled at
+ * author time) resolves to one `kind:"asset"` entry. A specifier the asset does
+ * not publish fails loud from `AssetRegistrySource` -- there is no silent
+ * fallback to npm. A definition that genuinely needs external npm dependencies
+ * would resolve through the mixed `AssetRegistrySource` + `HttpRegistrySource`
+ * map `session-service` already builds for tool packages; that path is not
+ * threaded here.
+ */
+export type ResolveWorkflowClosureAssetTarballArgs = {
+    /** An asset source whose `package.format` is `"tarball"`. */
+    readonly source: WorkflowDefinitionAssetSource;
+    /** A `name@range` spec for the workflow definition package. */
+    readonly pin: string;
+    /** Reads a blob at `path` from the asset the definition is sourced from. */
+    readonly readBlob: (path: string) => Promise<Uint8Array>;
+    /** Lists the blob names directly under `dir` in that asset. */
+    readonly listBlobs: (dir: string) => Promise<string[]>;
+};
+/**
+ * Resolve a source-format workflow definition's dependency closure from the
+ * asset's git tree at the pinned commit. The workspace-local members become
+ * `format:"source"` entries and the external npm deps resolve through the
+ * npm registry the caller supplies; there is no `name@range` pin (the member
+ * is selected from `source.package.packageName`).
+ */
+export type ResolveWorkflowClosureAssetSourceArgs = {
+    /** An asset source whose `package.format` is `"source"`. */
+    readonly source: WorkflowDefinitionAssetSource;
+    /** Git-tree reads pinned to `source.package.commitSha`. */
+    readonly reads: SourceTreeReads;
+    /**
+     * The registry name external deps are stamped with in the frozen closure.
+     * Must be a name the sidecar's registry map is keyed by (its npm registry),
+     * since the sidecar resolves each external entry's `source.registry` against
+     * that map at materialization.
+     */
+    readonly registryName: string;
+    /** URL and credentials for the npm registry external deps resolve against. */
+    readonly registryConfig: RegistryConfig;
+    /**
+     * Test seam for packument fetches. Omitted in production, where the
+     * default `npm-registry-fetch` wrapper reaches the configured URL.
+     */
+    readonly fetchPackument?: PackumentFetcher;
+};
+export type ResolveWorkflowClosureArgs = ResolveWorkflowClosureRegistryArgs | ResolveWorkflowClosureAssetTarballArgs | ResolveWorkflowClosureAssetSourceArgs;
+/**
+ * Resolve a workflow definition's dependency closure to concrete versions
+ * and integrity SRIs, reusing the tool-packaging closure resolver.
+ *
+ * @returns the frozen closure: a `ToolPackageManifest` whose `topLevel`
+ *   pins the definition package and whose `entries` carry the concrete
+ *   version and integrity SRI of every transitive dependency.
+ */
+export declare function resolveWorkflowClosure(args: ResolveWorkflowClosureArgs): Promise<ToolPackageManifest>;
+/**
+ * The workspace-relative mount path a workflow definition's source asset is
+ * delivered under, keyed by asset id. Both the probe (inline delivery) and the
+ * deploy (streamed fan-out) build their `assetId -> mountPath` maps through
+ * this one helper, so the same asset lands at the same path on both paths.
+ */
+export declare function workflowSourceAssetMountPath(assetId: string): string;
+/**
+ * Resolves an asset (by id) to the git pack a source-ref frame delivers for it.
+ * The caller binds the ref: an asset source binds the asset's default ref, so
+ * the install/deploy glue stays ref-agnostic.
+ */
+export type ResolveAssetAttachmentFn = (assetId: string) => Promise<{
+    pack: Uint8Array;
+    ref: string;
+    commitSha: string;
+}>;
+/**
+ * Build the inline asset mounts a source-ref frame delivers for an asset-sourced
+ * closure: one per distinct asset the closure's `kind:"asset"` entries name (so
+ * a multi-asset closure delivers every backing asset, not just the source), each
+ * carrying the git pack the caller resolves for that asset. `mountPath` is
+ * derived through the shared helper so probe and deploy agree on it.
+ */
+export declare function buildSourceAssetMounts(closure: ToolPackageManifest, resolveAttachment: ResolveAssetAttachmentFn): Promise<WorkflowSourceAssetMount[]>;

package/dist/workflow-closure-resolution.js

@@ -0,0 +1,123 @@
+// Hub-side dependency-closure resolution for a code-sourced workflow
+// definition.
+//
+// Given a `WorkflowDefinitionSource` and a pin, walk the full dependency
+// closure to concrete versions plus integrity SRIs, reusing the tool-packaging
+// closure resolver. This is the "what exactly would we install" step: packument
+// and package.json metadata reads only, no code execution. The returned
+// `ToolPackageManifest` is the frozen closure the deploy path later ships by
+// source-ref.
+//
+// There are three arms, one per `(source.kind, package.format)`:
+//   - `registry` names an npm registry; its URL and credentials are supplied by
+//     the caller as a `RegistryConfig`, since the caller owns the registry
+//     configuration.
+//   - `asset` + `tarball` names a hub asset that publishes the definition
+//     package as a tarball; the caller supplies bound `readBlob`/`listBlobs`
+//     closures over that asset (the same shape `session-service` mints for
+//     `AssetRegistrySource`).
+//   - `asset` + `source` names a hub asset whose definition package lives as a
+//     git subtree at a pinned commit; the caller supplies a `SourceTreeReads`
+//     pinned to that commit plus a `RegistryConfig` for the external npm deps.
+//     This arm delegates to `resolveSourceWorkflowClosure`, which reads the
+//     tree directly and needs no `name@range` pin (it selects the member from
+//     the source's `packageName`).
+// Every arm takes pre-bound read capabilities, keeping this module free of any
+// asset-service or repo-store dependency.
+import { base64Encode } from "@intx/types";
+import { AssetRegistrySource, HttpRegistrySource, createClosureResolver, parsePin, } from "@intx/tool-packaging";
+import { resolveSourceWorkflowClosure, } from "./workflow-source-closure.js";
+// Both asset arms carry an identical `source` field type, so narrow on the
+// source's own `package.format` discriminant rather than adding a redundant
+// discriminant to the args.
+function isAssetSourceArgs(args) {
+    return (args.source.kind === "asset" && args.source.package.format === "source");
+}
+function isAssetTarballArgs(args) {
+    return (args.source.kind === "asset" && args.source.package.format === "tarball");
+}
+/**
+ * Resolve a workflow definition's dependency closure to concrete versions
+ * and integrity SRIs, reusing the tool-packaging closure resolver.
+ *
+ * @returns the frozen closure: a `ToolPackageManifest` whose `topLevel`
+ *   pins the definition package and whose `entries` carry the concrete
+ *   version and integrity SRI of every transitive dependency.
+ */
+export async function resolveWorkflowClosure(args) {
+    if (isAssetSourceArgs(args)) {
+        return resolveSourceWorkflowClosure({
+            source: args.source,
+            reads: args.reads,
+            registryName: args.registryName,
+            registryConfig: args.registryConfig,
+            ...(args.fetchPackument !== undefined
+                ? { fetchPackument: args.fetchPackument }
+                : {}),
+        });
+    }
+    if (isAssetTarballArgs(args)) {
+        // The assetId is the source name so every walker resolution error is
+        // traceable to the exact asset; it is the sole and default source.
+        const name = args.source.assetId;
+        const assetSource = new AssetRegistrySource({
+            name,
+            assetId: args.source.assetId,
+            readBlob: args.readBlob,
+            listBlobs: args.listBlobs,
+        });
+        const resolver = createClosureResolver({
+            registries: new Map([[name, assetSource]]),
+            defaultRegistry: name,
+        });
+        return resolver.resolveClosure([parsePin(args.pin)]);
+    }
+    const registrySource = new HttpRegistrySource({
+        name: args.source.registry,
+        config: args.registryConfig,
+        ...(args.fetchPackument !== undefined
+            ? { fetchPackument: args.fetchPackument }
+            : {}),
+    });
+    const resolver = createClosureResolver({
+        registries: new Map([[registrySource.name, registrySource]]),
+        defaultRegistry: registrySource.name,
+    });
+    return resolver.resolveClosure([parsePin(args.pin)]);
+}
+/**
+ * The workspace-relative mount path a workflow definition's source asset is
+ * delivered under, keyed by asset id. Both the probe (inline delivery) and the
+ * deploy (streamed fan-out) build their `assetId -> mountPath` maps through
+ * this one helper, so the same asset lands at the same path on both paths.
+ */
+export function workflowSourceAssetMountPath(assetId) {
+    return `source-assets/${assetId}/`;
+}
+/**
+ * Build the inline asset mounts a source-ref frame delivers for an asset-sourced
+ * closure: one per distinct asset the closure's `kind:"asset"` entries name (so
+ * a multi-asset closure delivers every backing asset, not just the source), each
+ * carrying the git pack the caller resolves for that asset. `mountPath` is
+ * derived through the shared helper so probe and deploy agree on it.
+ */
+export async function buildSourceAssetMounts(closure, resolveAttachment) {
+    const assetIds = new Set();
+    for (const entry of closure.entries) {
+        if (entry.source.kind === "asset") {
+            assetIds.add(entry.source.assetId);
+        }
+    }
+    const mounts = [];
+    for (const assetId of assetIds) {
+        const attachment = await resolveAttachment(assetId);
+        mounts.push({
+            assetId,
+            mountPath: workflowSourceAssetMountPath(assetId),
+            pack: base64Encode(attachment.pack),
+            ref: attachment.ref,
+            commitSha: attachment.commitSha,
+        });
+    }
+    return mounts;
+}

package/dist/workflow-definition-ensure.d.ts

@@ -0,0 +1,24 @@
+import { type DBExecutor, type WorkflowDefinitionSelector } from "@intx/db";
+/**
+ * The first-class `workflow_definition` a selector names, created if absent. A
+ * native workflow carries its body in the asset it points at, so this only
+ * projects a definition row -- plus its version "1" -- over that asset, keyed
+ * by the selector's wire hash, so a run can anchor on a first-class definition.
+ * A single asset backs many definitions distinguished by their wire hash, so
+ * distinct hashes over one asset yield distinct definitions.
+ * `currentVersion`/`status` are left to the table defaults; the definition
+ * carries no `modelRequirements` manifest, so it deploys as a workflow rather
+ * than launching as an instance.
+ *
+ * Idempotent and concurrency-safe: the definition insert conflicts on the
+ * unique `(assetId, wireHash)` and the version on `(definitionId, version)`, so
+ * two concurrent deploys of the same selector still yield exactly one
+ * definition and one version. The returned id is read back after the conflict
+ * -- the winner's id, not a locally-minted one -- so a losing insert anchors
+ * its version on the real row. `created` distinguishes a fresh projection from
+ * a pre-existing one for callers that report fold counts.
+ */
+export declare function ensureWorkflowDefinitionForAsset(db: DBExecutor, selector: WorkflowDefinitionSelector): Promise<{
+    definitionId: string;
+    created: boolean;
+}>;

package/dist/workflow-definition-ensure.js

@@ -0,0 +1,75 @@
+import { eq } from "drizzle-orm";
+import { resolveDefinitionIdForAsset, } from "@intx/db";
+import { asset, workflowDefinition, workflowDefinitionVersion, } from "@intx/db/schema";
+import { generateId } from "@intx/hub-common";
+/**
+ * The first-class `workflow_definition` a selector names, created if absent. A
+ * native workflow carries its body in the asset it points at, so this only
+ * projects a definition row -- plus its version "1" -- over that asset, keyed
+ * by the selector's wire hash, so a run can anchor on a first-class definition.
+ * A single asset backs many definitions distinguished by their wire hash, so
+ * distinct hashes over one asset yield distinct definitions.
+ * `currentVersion`/`status` are left to the table defaults; the definition
+ * carries no `modelRequirements` manifest, so it deploys as a workflow rather
+ * than launching as an instance.
+ *
+ * Idempotent and concurrency-safe: the definition insert conflicts on the
+ * unique `(assetId, wireHash)` and the version on `(definitionId, version)`, so
+ * two concurrent deploys of the same selector still yield exactly one
+ * definition and one version. The returned id is read back after the conflict
+ * -- the winner's id, not a locally-minted one -- so a losing insert anchors
+ * its version on the real row. `created` distinguishes a fresh projection from
+ * a pre-existing one for callers that report fold counts.
+ */
+export async function ensureWorkflowDefinitionForAsset(db, selector) {
+    const { assetId, wireHash } = selector;
+    const assetRow = await db
+        .select({
+        tenantId: asset.tenantId,
+        creatorPrincipalId: asset.creatorPrincipalId,
+        name: asset.name,
+        displayName: asset.displayName,
+    })
+        .from(asset)
+        .where(eq(asset.id, assetId))
+        .limit(1)
+        .then((rows) => rows[0]);
+    if (assetRow === undefined) {
+        throw new Error(`ensureWorkflowDefinitionForAsset: no asset found for id "${assetId}"`);
+    }
+    const inserted = await db
+        .insert(workflowDefinition)
+        .values({
+        id: generateId("workflowDefinition"),
+        tenantId: assetRow.tenantId,
+        creatorPrincipalId: assetRow.creatorPrincipalId,
+        assetId,
+        wireHash,
+        name: assetRow.name,
+        description: assetRow.displayName,
+    })
+        .onConflictDoNothing({
+        target: [workflowDefinition.assetId, workflowDefinition.wireHash],
+    })
+        .returning({ id: workflowDefinition.id });
+    const created = inserted.length > 0;
+    const insertedId = inserted[0]?.id;
+    const definitionId = insertedId ?? (await resolveDefinitionIdForAsset(db, selector));
+    if (definitionId === null || definitionId === undefined) {
+        throw new Error(`ensureWorkflowDefinitionForAsset: definition for asset "${assetId}" (wire hash "${wireHash}") missing after insert`);
+    }
+    await db
+        .insert(workflowDefinitionVersion)
+        .values({
+        id: generateId("workflowDefinitionVersion"),
+        definitionId,
+        version: "1",
+    })
+        .onConflictDoNothing({
+        target: [
+            workflowDefinitionVersion.definitionId,
+            workflowDefinitionVersion.version,
+        ],
+    });
+    return { definitionId, created };
+}

package/dist/workflow-dispatch-service.d.ts

@@ -0,0 +1,40 @@
+import type { DBExecutor, EnqueueWorkflowRunDispatchArgs, EnqueueWorkflowRunDispatchResult, EnqueueWorkflowSignalDispatchArgs, SidecarAllocationStore, WorkflowRunDispatchStore } from "@intx/db";
+import type { SidecarAllocationRouter } from "./ws/sidecar-handler.js";
+type DispatchStore = Pick<WorkflowRunDispatchStore, "acknowledge" | "claimNextPending" | "enqueue" | "enqueueSignal" | "requeueUnsettled" | "scheduleRetry" | "settle">;
+type AllocationStore = Pick<SidecarAllocationStore, "findByAnchorRunId">;
+type DispatchRouter = Pick<SidecarAllocationRouter, "sendSignalDeliverToAllocation" | "sendWorkflowRunDispatchToAllocation">;
+export type WorkflowDispatchAcknowledgement = {
+    readonly allocationId: string;
+    readonly anchorRunId: string;
+    readonly generation: number;
+    readonly messageId: string;
+};
+export type WorkflowDispatchService = {
+    enqueue(args: EnqueueWorkflowRunDispatchArgs, tx?: DBExecutor): Promise<EnqueueWorkflowRunDispatchResult>;
+    enqueueSignal(args: EnqueueWorkflowSignalDispatchArgs, tx?: DBExecutor): Promise<EnqueueWorkflowRunDispatchResult>;
+    acknowledge(args: WorkflowDispatchAcknowledgement): Promise<void>;
+    settle(anchorRunId: string, messageId: string): Promise<void>;
+    requeueForReadyAllocation(anchorRunId: string): Promise<number>;
+    reconcileNext(): Promise<boolean>;
+    reconcileUntilIdle(maxIterations?: number): Promise<number>;
+    wake(): void;
+};
+export type WorkflowDispatchServiceDeps = {
+    readonly dispatchStore: DispatchStore;
+    readonly allocationStore: AllocationStore;
+    readonly router: DispatchRouter;
+    /** Resolve the deployment anchor's durable routing address. */
+    readonly resolveAnchorAddress: (anchorRunId: string) => Promise<string | null>;
+    readonly leaseDurationMs?: number;
+    readonly retryDelayMs?: (attempt: number) => number;
+    readonly now?: () => Date;
+    readonly createLeaseId?: () => string;
+};
+/**
+ * Drives Hub-owned workflow triggers onto exclusive sidecars. The database
+ * row is the delivery authority: websocket acceptance never deletes the raw
+ * payload, and a generation replacement requeues every row that has not been
+ * settled by the workflow-run Git claim-check.
+ */
+export declare function createWorkflowDispatchService({ dispatchStore, allocationStore, router, resolveAnchorAddress, leaseDurationMs, retryDelayMs, now, createLeaseId, }: WorkflowDispatchServiceDeps): WorkflowDispatchService;
+export {};

package/dist/workflow-dispatch-service.js

@@ -0,0 +1,146 @@
+import { getLogger } from "@intx/log";
+import { base64Encode, hexEncode } from "@intx/types";
+import { SignalDeliverFrame } from "@intx/types/sidecar";
+const logger = getLogger(["hub", "workflow-dispatch"]);
+const DEFAULT_LEASE_DURATION_MS = 30_000;
+function defaultRetryDelay(attempt) {
+    return Math.min(500 * 2 ** Math.min(attempt, 6), 30_000);
+}
+function randomLeaseId() {
+    return `dispatch_lease_${hexEncode(crypto.getRandomValues(new Uint8Array(16)))}`;
+}
+function targetForReadyAllocation(allocation) {
+    if (allocation.status !== "allocated" ||
+        allocation.ensureAcceptedGeneration !== allocation.generation ||
+        allocation.connectDeadline !== undefined) {
+        return null;
+    }
+    return {
+        allocationId: allocation.id,
+        generation: allocation.generation,
+    };
+}
+/**
+ * Drives Hub-owned workflow triggers onto exclusive sidecars. The database
+ * row is the delivery authority: websocket acceptance never deletes the raw
+ * payload, and a generation replacement requeues every row that has not been
+ * settled by the workflow-run Git claim-check.
+ */
+export function createWorkflowDispatchService({ dispatchStore, allocationStore, router, resolveAnchorAddress, leaseDurationMs = DEFAULT_LEASE_DURATION_MS, retryDelayMs = defaultRetryDelay, now = () => new Date(), createLeaseId = randomLeaseId, }) {
+    if (leaseDurationMs <= 0) {
+        throw new Error("leaseDurationMs must be positive");
+    }
+    let drainPromise = null;
+    function retryAt(attempt) {
+        return new Date(now().getTime() + retryDelayMs(attempt));
+    }
+    async function retry(dispatch, leaseId, code, message) {
+        await dispatchStore.scheduleRetry({
+            dispatchId: dispatch.id,
+            nextAttemptAt: retryAt(dispatch.attemptCount),
+            code,
+            message,
+            expectedLeaseId: leaseId,
+            now: now(),
+        });
+    }
+    async function reconcileNext() {
+        const leaseId = createLeaseId();
+        const dispatch = await dispatchStore.claimNextPending({
+            leaseId,
+            leaseDurationMs,
+        });
+        if (dispatch === null)
+            return false;
+        const allocation = await allocationStore.findByAnchorRunId(dispatch.anchorRunId);
+        if (allocation === null) {
+            await retry(dispatch, leaseId, "allocation_missing", `No sidecar allocation exists for workflow anchor ${dispatch.anchorRunId}`);
+            return true;
+        }
+        const target = targetForReadyAllocation(allocation);
+        if (target === null) {
+            await retry(dispatch, leaseId, "allocation_not_ready", `Sidecar allocation ${allocation.id} is not ready for delivery`);
+            return true;
+        }
+        const agentAddress = await resolveAnchorAddress(dispatch.anchorRunId);
+        if (agentAddress === null) {
+            await retry(dispatch, leaseId, "anchor_address_missing", `Workflow anchor ${dispatch.anchorRunId} has no routing address`);
+            return true;
+        }
+        try {
+            if (dispatch.kind === "signal") {
+                const signal = SignalDeliverFrame.assert(JSON.parse(new TextDecoder().decode(dispatch.rawMessage)));
+                await router.sendSignalDeliverToAllocation(target, {
+                    agentAddress: signal.agentAddress,
+                    runId: signal.runId,
+                    signalName: signal.signalName,
+                    signalId: signal.signalId,
+                    payload: signal.payload,
+                });
+            }
+            else {
+                await router.sendWorkflowRunDispatchToAllocation(target, agentAddress, 
+                // Every trigger of a deployment uses its stable mail address as the
+                // supervisor run id.
+                agentAddress, dispatch.stepGrants, base64Encode(dispatch.rawMessage), dispatch.messageId);
+            }
+            // Keep the delivery lease until the sidecar acknowledges its durable
+            // inbox write. If that ack never arrives, lease expiry makes the same
+            // immutable payload claimable again.
+        }
+        catch (error) {
+            await retry(dispatch, leaseId, "dispatch_unroutable", error instanceof Error ? error.message : String(error));
+        }
+        return true;
+    }
+    async function reconcileUntilIdle(maxIterations = 100) {
+        let reconciled = 0;
+        while (reconciled < maxIterations && (await reconcileNext())) {
+            reconciled += 1;
+        }
+        return reconciled;
+    }
+    function wake() {
+        if (drainPromise !== null)
+            return;
+        drainPromise = Promise.resolve()
+            .then(async () => {
+            await reconcileUntilIdle();
+        })
+            .catch((error) => {
+            logger.error `Workflow dispatch reconciliation failed: ${error instanceof Error ? error.message : String(error)}`;
+        })
+            .finally(() => {
+            drainPromise = null;
+        });
+    }
+    return {
+        async enqueue(args, tx) {
+            const result = await dispatchStore.enqueue(args, tx);
+            wake();
+            return result;
+        },
+        async enqueueSignal(args, tx) {
+            const result = await dispatchStore.enqueueSignal(args, tx);
+            wake();
+            return result;
+        },
+        async acknowledge(args) {
+            await dispatchStore.acknowledge({
+                ...args,
+                now: now(),
+            });
+        },
+        async settle(anchorRunId, messageId) {
+            await dispatchStore.settle(anchorRunId, messageId, now());
+        },
+        async requeueForReadyAllocation(anchorRunId) {
+            const count = await dispatchStore.requeueUnsettled(anchorRunId);
+            wake();
+            return count;
+        },
+        reconcileNext,
+        reconcileUntilIdle,
+        wake,
+    };
+}

package/dist/workflow-dispatch-settlement.d.ts

@@ -0,0 +1,29 @@
+import type { CommittedReads } from "./repo-store/index.js";
+export type ConsumedWorkflowDispatch = {
+    readonly messageId: string;
+    readonly address: string;
+    readonly rejection?: {
+        readonly code: string;
+        readonly message: string;
+    };
+};
+export type ReceivedWorkflowSignal = {
+    readonly runId: string;
+    readonly signalId: string;
+};
+export type AcceptedWorkflowDispatch = {
+    readonly runId: string;
+    readonly messageId: string;
+    readonly kind: "mail" | "signal";
+};
+/** Enumerate dispatches durably accepted by one live or sealed run log. */
+export declare function listAcceptedWorkflowDispatches(reads: CommittedReads, runId: string, targetMessageIds?: ReadonlySet<string>): Promise<AcceptedWorkflowDispatch[]>;
+/** Enumerate durable SignalReceived ids from one live or sealed run log. */
+export declare function listReceivedWorkflowSignals(reads: CommittedReads, runId: string): Promise<ReceivedWorkflowSignal[]>;
+/**
+ * Enumerate the workflow-run claim-check's retained consumed index. The kind
+ * validator guarantees this tree shape before the ref advances; the runtime
+ * validator here keeps the Git-to-database projection fail-closed if that
+ * invariant is ever violated.
+ */
+export declare function listConsumedWorkflowDispatches(reads: CommittedReads): Promise<ConsumedWorkflowDispatch[]>;