@intx/db 0.2.2 → 0.4.0

package/dist/signal-correlation-store.d.ts

@@ -0,0 +1,36 @@
+import type { DB, DBExecutor } from "./client.js";
+import { signalCorrelation } from "./schema/signal-correlations.js";
+import { parseSignalCorrelationRow } from "./parse-row.js";
+type DBHandle = DB["db"];
+type SignalCorrelationInsert = typeof signalCorrelation.$inferInsert;
+type ParsedSignalCorrelation = ReturnType<typeof parseSignalCorrelationRow>;
+/**
+ * Store for the `signal_correlation` table, which maps an in-flight signal
+ * (correlation id) to the run and address that must be resumed when the signal
+ * resolves. Each method accepts an optional transaction handle so the resolver
+ * can claim the correlation and flip its approval atomically.
+ */
+export declare function createSignalCorrelationStore(db: DBHandle): {
+    register(row: SignalCorrelationInsert, tx?: DBExecutor): Promise<ParsedSignalCorrelation>;
+    /**
+     * Idempotent variant of `register`. On a `correlationId` primary-key
+     * conflict the insert is a no-op and this returns `null` rather than
+     * throwing, so a redelivered register frame (sidecar reconnect,
+     * workflow-log replay, supervisor restart re-emitting) does not fail the
+     * co-write. Returns the parsed row only when this call performed the
+     * insert.
+     */
+    registerIfAbsent(row: SignalCorrelationInsert, tx?: DBExecutor): Promise<ParsedSignalCorrelation | null>;
+    resolveRoute(correlationId: string, tx?: DBExecutor): Promise<ParsedSignalCorrelation | null>;
+    /**
+     * Atomically claim a correlation for terminal delivery. The
+     * `resolved_at IS NULL` guard makes the claim single-shot: the first caller
+     * stamps `resolvedAt` and gets the row back; any second caller matches no
+     * row and receives null, so a redelivered signal is not delivered twice.
+     * When `signalId` is provided it is persisted on the same update, recording
+     * which signal instance won the claim for redelivery idempotency.
+     */
+    claimTerminal(correlationId: string, resolvedAt: Date, signalId: string | null, tx?: DBExecutor): Promise<ParsedSignalCorrelation | null>;
+};
+export type SignalCorrelationStore = ReturnType<typeof createSignalCorrelationStore>;
+export {};

package/dist/signal-correlation-store.js

@@ -0,0 +1,63 @@
+import { and, eq, isNull } from "drizzle-orm";
+import { signalCorrelation } from "./schema/signal-correlations.js";
+import { parseSignalCorrelationRow } from "./parse-row.js";
+/**
+ * Store for the `signal_correlation` table, which maps an in-flight signal
+ * (correlation id) to the run and address that must be resumed when the signal
+ * resolves. Each method accepts an optional transaction handle so the resolver
+ * can claim the correlation and flip its approval atomically.
+ */
+export function createSignalCorrelationStore(db) {
+    return {
+        async register(row, tx) {
+            const [inserted] = await (tx ?? db)
+                .insert(signalCorrelation)
+                .values(row)
+                .returning();
+            if (inserted === undefined) {
+                throw new Error(`signalCorrelationStore.register: insert returned no row for ${row.correlationId}`);
+            }
+            return parseSignalCorrelationRow(inserted);
+        },
+        /**
+         * Idempotent variant of `register`. On a `correlationId` primary-key
+         * conflict the insert is a no-op and this returns `null` rather than
+         * throwing, so a redelivered register frame (sidecar reconnect,
+         * workflow-log replay, supervisor restart re-emitting) does not fail the
+         * co-write. Returns the parsed row only when this call performed the
+         * insert.
+         */
+        async registerIfAbsent(row, tx) {
+            const [inserted] = await (tx ?? db)
+                .insert(signalCorrelation)
+                .values(row)
+                .onConflictDoNothing({ target: signalCorrelation.correlationId })
+                .returning();
+            return inserted === undefined
+                ? null
+                : parseSignalCorrelationRow(inserted);
+        },
+        async resolveRoute(correlationId, tx) {
+            const row = await (tx ?? db).query.signalCorrelation.findFirst({
+                where: eq(signalCorrelation.correlationId, correlationId),
+            });
+            return row === undefined ? null : parseSignalCorrelationRow(row);
+        },
+        /**
+         * Atomically claim a correlation for terminal delivery. The
+         * `resolved_at IS NULL` guard makes the claim single-shot: the first caller
+         * stamps `resolvedAt` and gets the row back; any second caller matches no
+         * row and receives null, so a redelivered signal is not delivered twice.
+         * When `signalId` is provided it is persisted on the same update, recording
+         * which signal instance won the claim for redelivery idempotency.
+         */
+        async claimTerminal(correlationId, resolvedAt, signalId, tx) {
+            const [claimed] = await (tx ?? db)
+                .update(signalCorrelation)
+                .set({ resolvedAt, signalId })
+                .where(and(eq(signalCorrelation.correlationId, correlationId), isNull(signalCorrelation.resolvedAt)))
+                .returning();
+            return claimed === undefined ? null : parseSignalCorrelationRow(claimed);
+        },
+    };
+}

package/dist/signer-identity.d.ts

@@ -0,0 +1,12 @@
+import type { LocalPrincipalSigner } from "@intx/types";
+import type { DBExecutor } from "./client.js";
+import type { PrincipalKeyStore } from "./principal-key-store.js";
+/**
+ * Resolve a principal's trusted signer identity from the hub's own key store.
+ *
+ * The returned `publicKey` is the principal's active key as the hub holds it, so
+ * a verifier can check a signature against it without trusting any key on the
+ * wire. Throws when the principal has no active key -- an unresolvable signer
+ * must fail loudly rather than default.
+ */
+export declare function lookupLocalPrincipalSigner(principalKeyStore: PrincipalKeyStore, principalId: string, tx?: DBExecutor): Promise<LocalPrincipalSigner>;

package/dist/signer-identity.js

@@ -0,0 +1,15 @@
+/**
+ * Resolve a principal's trusted signer identity from the hub's own key store.
+ *
+ * The returned `publicKey` is the principal's active key as the hub holds it, so
+ * a verifier can check a signature against it without trusting any key on the
+ * wire. Throws when the principal has no active key -- an unresolvable signer
+ * must fail loudly rather than default.
+ */
+export async function lookupLocalPrincipalSigner(principalKeyStore, principalId, tx) {
+    return {
+        kind: "local-principal",
+        principalId,
+        publicKey: await principalKeyStore.getPublicKey(principalId, tx),
+    };
+}

package/dist/tenant-hierarchy.d.ts

@@ -1,11 +1,14 @@
+import { type TenantSidecarCapabilityPolicy } from "@intx/types";
 import type { DB } from "./client.js";
 /**
  * Walks the tenant parentId chain from the given tenant up to the root.
  * Returns an ordered array of tenant IDs: [tenantId, parentId, grandparentId, ...rootId].
  *
- * Protects against cycles with a depth limit.
+ * Throws if the hierarchy contains a cycle instead of returning a partial
+ * chain that could omit inherited policy or configuration.
  */
 export declare function getAncestorChain(db: DB["db"], tenantId: string): Promise<string[]>;
+export declare function resolveTenantSidecarCapabilityPolicies(db: DB["db"], tenantId: string): Promise<readonly TenantSidecarCapabilityPolicy[]>;
 /**
  * Returns the tenant and every distinct tenant in its subtree (children,
  * their children, and so on), discovered breadth-first. Used to find every

package/dist/tenant-hierarchy.js

@@ -1,27 +1,59 @@
+import { type } from "arktype";
 import { eq, inArray } from "drizzle-orm";
+import { TenantConfig } from "@intx/types";
 import { tenant } from "./schema/tenants.js";
-const MAX_DEPTH = 20;
 /**
  * Walks the tenant parentId chain from the given tenant up to the root.
  * Returns an ordered array of tenant IDs: [tenantId, parentId, grandparentId, ...rootId].
  *
- * Protects against cycles with a depth limit.
+ * Throws if the hierarchy contains a cycle instead of returning a partial
+ * chain that could omit inherited policy or configuration.
  */
 export async function getAncestorChain(db, tenantId) {
-    const chain = [tenantId];
+    const chain = [];
+    const visited = new Set();
     let currentId = tenantId;
-    for (let depth = 0; depth < MAX_DEPTH; depth++) {
+    while (true) {
+        if (visited.has(currentId)) {
+            throw new Error(`Tenant hierarchy contains a cycle at tenant ${currentId}`);
+        }
+        visited.add(currentId);
+        chain.push(currentId);
         const row = await db.query.tenant.findFirst({
             where: eq(tenant.id, currentId),
             columns: { parentId: true },
         });
         if (!row?.parentId)
             break;
-        chain.push(row.parentId);
         currentId = row.parentId;
     }
     return chain;
 }
+export async function resolveTenantSidecarCapabilityPolicies(db, tenantId) {
+    const chain = await getAncestorChain(db, tenantId);
+    const rows = await db.query.tenant.findMany({
+        where: inArray(tenant.id, chain),
+        columns: { id: true, config: true },
+    });
+    const rowsById = new Map(rows.map((row) => [row.id, row]));
+    const policies = [];
+    for (const ancestorId of chain) {
+        const row = rowsById.get(ancestorId);
+        if (row === undefined)
+            continue;
+        if (row.config === null)
+            continue;
+        const config = TenantConfig(row.config);
+        if (config instanceof type.errors) {
+            throw new Error(`Tenant ${row.id} has invalid configuration: ${config.summary}`);
+        }
+        const rules = config.sidecarPlacement?.capabilities;
+        if (rules !== undefined && rules.length > 0) {
+            policies.push({ tenantId: row.id, rules });
+        }
+    }
+    return policies;
+}
 /**
  * Returns the tenant and every distinct tenant in its subtree (children,
  * their children, and so on), discovered breadth-first. Used to find every

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

@@ -0,0 +1,55 @@
+import { GrantWalkSnapshot } from "@intx/types";
+import type { DB, DBExecutor } from "./client.js";
+import { parseWorkflowDefinitionRow } from "./parse-row.js";
+type DBHandle = DB["db"];
+type ParsedWorkflowDefinition = ReturnType<typeof parseWorkflowDefinitionRow>;
+/**
+ * The selector that keys a workflow definition's identity: the asset it
+ * projects and the content hash of its wire projection. A single asset backs
+ * many definitions distinguished by their wire hash, so both fields are
+ * required to name exactly one definition.
+ */
+export type WorkflowDefinitionSelector = {
+    assetId: string;
+    wireHash: string;
+};
+/**
+ * The definition a selector names, or null when no definition has been folded
+ * for that `(assetId, wireHash)` pair. This is the single expression of the
+ * deployment -> definition mapping (a deployment names its asset and wire hash);
+ * the run backfill and the native-run insert sites both resolve through it.
+ * Null on a miss is deliberate, not an error: a deployment whose selector the
+ * run-once fold never covered has no definition yet, and its runs anchor on
+ * `runId` until that gap closes.
+ */
+export declare function resolveDefinitionIdForAsset(db: DBExecutor, selector: WorkflowDefinitionSelector): Promise<string | null>;
+/**
+ * Read the deploy-approved grant-walk snapshot frozen onto a definition's
+ * version row, validated as a `GrantWalkSnapshot` at this boundary. Returns
+ * `null` when the version row is absent or its `grantSnapshot` column is still
+ * `null` -- the "not yet approved" state, mirroring `approvedWireHash`. The
+ * caller fails closed on `null`; it never substitutes an empty grant set.
+ */
+export declare function loadFrozenGrantSnapshot(db: DBExecutor, definitionId: string): Promise<GrantWalkSnapshot | null>;
+export type WorkflowDefinitionRollbackResult = {
+    ok: true;
+    definition: ParsedWorkflowDefinition;
+} | {
+    ok: false;
+    reason: "definition_not_found" | "version_not_found";
+};
+/**
+ * Store for the first-class `workflow_definition` and its version history.
+ */
+export declare function createWorkflowDefinitionStore(db: DBHandle): {
+    /**
+     * Roll a definition back to a prior version: deactivate the current
+     * version, activate the target, and repoint `currentVersion` in one
+     * transaction, so a reader never sees two active versions or a
+     * `currentVersion` that names an inactive row. Returns a discriminated
+     * result rather than throwing for the not-found cases the route reports as
+     * 404 / 400.
+     */
+    rollback(tenantId: string, definitionId: string, targetVersion: string): Promise<WorkflowDefinitionRollbackResult>;
+};
+export {};

package/dist/workflow-definition-store.js

@@ -0,0 +1,93 @@
+import { and, eq } from "drizzle-orm";
+import { GrantWalkSnapshot } from "@intx/types";
+import { workflowDefinition, workflowDefinitionVersion, } from "./schema/workflow-definitions.js";
+import { parseWorkflowDefinitionRow } from "./parse-row.js";
+// The version `ensureWorkflowDefinitionForAsset` projects for a fresh
+// definition, and therefore the row the approval freeze stamps the grant
+// snapshot onto. Hand-coupled to the ensure helper's initial version; if that
+// helper ever projects a different version this must follow.
+const FROZEN_VERSION = "1";
+/**
+ * The definition a selector names, or null when no definition has been folded
+ * for that `(assetId, wireHash)` pair. This is the single expression of the
+ * deployment -> definition mapping (a deployment names its asset and wire hash);
+ * the run backfill and the native-run insert sites both resolve through it.
+ * Null on a miss is deliberate, not an error: a deployment whose selector the
+ * run-once fold never covered has no definition yet, and its runs anchor on
+ * `runId` until that gap closes.
+ */
+export async function resolveDefinitionIdForAsset(db, selector) {
+    const row = await db
+        .select({ id: workflowDefinition.id })
+        .from(workflowDefinition)
+        .where(and(eq(workflowDefinition.assetId, selector.assetId), eq(workflowDefinition.wireHash, selector.wireHash)))
+        .limit(1)
+        .then((rows) => rows[0]);
+    return row?.id ?? null;
+}
+/**
+ * Read the deploy-approved grant-walk snapshot frozen onto a definition's
+ * version row, validated as a `GrantWalkSnapshot` at this boundary. Returns
+ * `null` when the version row is absent or its `grantSnapshot` column is still
+ * `null` -- the "not yet approved" state, mirroring `approvedWireHash`. The
+ * caller fails closed on `null`; it never substitutes an empty grant set.
+ */
+export async function loadFrozenGrantSnapshot(db, definitionId) {
+    const row = await db
+        .select({ grantSnapshot: workflowDefinitionVersion.grantSnapshot })
+        .from(workflowDefinitionVersion)
+        .where(and(eq(workflowDefinitionVersion.definitionId, definitionId), eq(workflowDefinitionVersion.version, FROZEN_VERSION)))
+        .limit(1)
+        .then((rows) => rows[0]);
+    if (row === undefined || row.grantSnapshot === null)
+        return null;
+    return GrantWalkSnapshot.assert(row.grantSnapshot);
+}
+/**
+ * Store for the first-class `workflow_definition` and its version history.
+ */
+export function createWorkflowDefinitionStore(db) {
+    return {
+        /**
+         * Roll a definition back to a prior version: deactivate the current
+         * version, activate the target, and repoint `currentVersion` in one
+         * transaction, so a reader never sees two active versions or a
+         * `currentVersion` that names an inactive row. Returns a discriminated
+         * result rather than throwing for the not-found cases the route reports as
+         * 404 / 400.
+         */
+        async rollback(tenantId, definitionId, targetVersion) {
+            return db.transaction(async (tx) => {
+                const existing = await tx.query.workflowDefinition.findFirst({
+                    where: and(eq(workflowDefinition.id, definitionId), eq(workflowDefinition.tenantId, tenantId)),
+                });
+                if (existing === undefined) {
+                    return { ok: false, reason: "definition_not_found" };
+                }
+                const target = await tx.query.workflowDefinitionVersion.findFirst({
+                    where: and(eq(workflowDefinitionVersion.definitionId, definitionId), eq(workflowDefinitionVersion.version, targetVersion)),
+                });
+                if (target === undefined) {
+                    return { ok: false, reason: "version_not_found" };
+                }
+                await tx
+                    .update(workflowDefinitionVersion)
+                    .set({ status: "inactive" })
+                    .where(and(eq(workflowDefinitionVersion.definitionId, definitionId), eq(workflowDefinitionVersion.version, existing.currentVersion)));
+                await tx
+                    .update(workflowDefinitionVersion)
+                    .set({ status: "active" })
+                    .where(and(eq(workflowDefinitionVersion.definitionId, definitionId), eq(workflowDefinitionVersion.version, targetVersion)));
+                const [updated] = await tx
+                    .update(workflowDefinition)
+                    .set({ currentVersion: targetVersion, updatedAt: new Date() })
+                    .where(eq(workflowDefinition.id, definitionId))
+                    .returning();
+                if (updated === undefined) {
+                    throw new Error(`workflowDefinitionStore.rollback: update returned no row for ${definitionId}`);
+                }
+                return { ok: true, definition: parseWorkflowDefinitionRow(updated) };
+            });
+        },
+    };
+}

package/dist/workflow-probe-store.d.ts

@@ -0,0 +1,47 @@
+import type { WorkflowProbeResultFrame } from "@intx/types/sidecar";
+import type { WorkflowDefinitionSource } from "@intx/types/workflow-sources";
+import type { DB, DBExecutor } from "./client.js";
+import { workflowProbe, type WorkflowProbeStatus } from "./schema/index.js";
+type DBHandle = DB["db"];
+type WorkflowProbeResult = Omit<WorkflowProbeResultFrame, "type" | "requestId">;
+type WorkflowProbeRow = typeof workflowProbe.$inferSelect;
+export type WorkflowProbe = WorkflowProbeRow;
+export type CreateWorkflowProbeArgs = {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly definitionAssetId: string;
+    readonly source: WorkflowDefinitionSource;
+    readonly entry: string;
+    readonly pin?: string;
+    readonly provisionerId: string;
+    readonly provisionerApiVersion: 1;
+    readonly provisionerBindingFingerprint: string;
+    readonly now?: Date;
+};
+export type BindWorkflowProbeSidecarArgs = {
+    readonly probeId: string;
+    readonly sidecarId: string;
+    readonly tokenHashSha256: Uint8Array;
+    readonly now?: Date;
+};
+export declare function createWorkflowProbeStore(db: DBHandle): {
+    create(args: CreateWorkflowProbeArgs, tx?: DBExecutor): Promise<WorkflowProbe>;
+    bindSidecar(args: BindWorkflowProbeSidecarArgs, tx?: DBExecutor): Promise<WorkflowProbe | null>;
+    markProbing(args: {
+        probeId: string;
+        externalRef?: string;
+        now?: Date;
+    }): Promise<WorkflowProbe | null>;
+    recordResult(probeId: string, result: WorkflowProbeResult, now?: Date): Promise<WorkflowProbe | null>;
+    transition(probeId: string, from: readonly WorkflowProbeStatus[], to: WorkflowProbeStatus, opts?: {
+        failureCode?: string;
+        failureMessage?: string;
+        now?: Date;
+        tx?: DBExecutor;
+    }): Promise<WorkflowProbe | null>;
+    get(probeId: string): Promise<WorkflowProbe | null>;
+    listActive(): Promise<WorkflowProbe[]>;
+    listReleasing(): Promise<WorkflowProbe[]>;
+};
+export type WorkflowProbeStore = ReturnType<typeof createWorkflowProbeStore>;
+export {};

package/dist/workflow-probe-store.js

@@ -0,0 +1,124 @@
+import { and, eq, inArray, sql } from "drizzle-orm";
+import { sidecar, workflowProbe } from "./schema/index.js";
+const activeStatuses = [
+    "pending",
+    "provisioning",
+    "probing",
+    "releasing",
+];
+function timestamp(now) {
+    return now ?? sql `now()`;
+}
+export function createWorkflowProbeStore(db) {
+    return {
+        async create(args, tx) {
+            const createdAt = timestamp(args.now);
+            const [created] = await (tx ?? db)
+                .insert(workflowProbe)
+                .values({
+                id: args.id,
+                tenantId: args.tenantId,
+                definitionAssetId: args.definitionAssetId,
+                source: args.source,
+                entry: args.entry,
+                ...(args.pin !== undefined ? { pin: args.pin } : {}),
+                provisionerId: args.provisionerId,
+                provisionerApiVersion: args.provisionerApiVersion,
+                provisionerBindingFingerprint: args.provisionerBindingFingerprint,
+                createdAt,
+                updatedAt: createdAt,
+            })
+                .returning();
+            if (created === undefined) {
+                throw new Error(`Failed to create workflow probe ${args.id}`);
+            }
+            return created;
+        },
+        async bindSidecar(args, tx) {
+            const bind = async (executor) => {
+                const updatedAt = timestamp(args.now);
+                const [probe] = await executor
+                    .select({ status: workflowProbe.status })
+                    .from(workflowProbe)
+                    .where(eq(workflowProbe.id, args.probeId))
+                    .limit(1)
+                    .for("update");
+                if (probe?.status !== "pending")
+                    return null;
+                await executor.insert(sidecar).values({
+                    id: args.sidecarId,
+                    url: null,
+                    tokenHashSha256: args.tokenHashSha256,
+                    status: "offline",
+                    createdAt: updatedAt,
+                    updatedAt,
+                });
+                const [updated] = await executor
+                    .update(workflowProbe)
+                    .set({
+                    sidecarId: args.sidecarId,
+                    status: "provisioning",
+                    updatedAt,
+                })
+                    .where(eq(workflowProbe.id, args.probeId))
+                    .returning();
+                return updated ?? null;
+            };
+            return tx === undefined ? db.transaction(bind) : bind(tx);
+        },
+        async markProbing(args) {
+            const [updated] = await db
+                .update(workflowProbe)
+                .set({
+                status: "probing",
+                ...(args.externalRef !== undefined
+                    ? { externalRef: args.externalRef }
+                    : {}),
+                updatedAt: timestamp(args.now),
+            })
+                .where(and(eq(workflowProbe.id, args.probeId), eq(workflowProbe.status, "provisioning")))
+                .returning();
+            return updated ?? null;
+        },
+        async recordResult(probeId, result, now) {
+            const [updated] = await db
+                .update(workflowProbe)
+                .set({ result, updatedAt: timestamp(now) })
+                .where(and(eq(workflowProbe.id, probeId), eq(workflowProbe.status, "probing")))
+                .returning();
+            return updated ?? null;
+        },
+        async transition(probeId, from, to, opts) {
+            const [updated] = await (opts?.tx ?? db)
+                .update(workflowProbe)
+                .set({
+                status: to,
+                ...(opts?.failureCode !== undefined
+                    ? { failureCode: opts.failureCode }
+                    : {}),
+                ...(opts?.failureMessage !== undefined
+                    ? { failureMessage: opts.failureMessage }
+                    : {}),
+                updatedAt: timestamp(opts?.now),
+            })
+                .where(and(eq(workflowProbe.id, probeId), inArray(workflowProbe.status, [...from])))
+                .returning();
+            return updated ?? null;
+        },
+        async get(probeId) {
+            return ((await db.query.workflowProbe.findFirst({
+                where: eq(workflowProbe.id, probeId),
+            })) ?? null);
+        },
+        async listActive() {
+            return db.query.workflowProbe.findMany({
+                where: inArray(workflowProbe.status, [...activeStatuses]),
+            });
+        },
+        async listReleasing() {
+            return db.query.workflowProbe.findMany({
+                where: eq(workflowProbe.status, "releasing"),
+            });
+        },
+    };
+}

package/dist/workflow-run-dispatch-store.d.ts

@@ -0,0 +1,83 @@
+import { type SQL } from "drizzle-orm";
+import { type RunGrantsFrame as RunGrantsFrameType, type SignalDeliverFrame as SignalDeliverFrameType } from "@intx/types/sidecar";
+import type { DB, DBExecutor } from "./client.js";
+import { parseWorkflowRunDispatchRow } from "./parse-row.js";
+type DBHandle = DB["db"];
+type ParsedDispatch = ReturnType<typeof parseWorkflowRunDispatchRow>;
+export type EnqueueWorkflowRunDispatchArgs = {
+    readonly id: string;
+    readonly anchorRunId: string;
+    readonly messageId: string;
+    readonly senderAddress: string;
+    readonly rawMessage: Uint8Array;
+    readonly stepGrants: RunGrantsFrameType["stepGrants"];
+    readonly now?: Date;
+};
+export type EnqueueWorkflowSignalDispatchArgs = {
+    readonly id: string;
+    readonly anchorRunId: string;
+    readonly signal: Omit<SignalDeliverFrameType, "type">;
+    readonly now?: Date;
+};
+export type EnqueueWorkflowRunDispatchResult = {
+    readonly dispatch: ParsedDispatch;
+    readonly created: boolean;
+};
+type InsertOrReconcileDispatchArgs = {
+    readonly operation: "enqueue" | "enqueueSignal";
+    readonly id: string;
+    readonly anchorRunId: string;
+    readonly messageId: string;
+    readonly kind: ParsedDispatch["kind"];
+    readonly senderAddress: string | null;
+    readonly rawMessage: Uint8Array;
+    readonly stepGrants: RunGrantsFrameType["stepGrants"];
+    readonly now?: Date;
+};
+export declare class WorkflowRunDispatchPayloadConflictError extends Error {
+    readonly messageId: string;
+    readonly payloadKind: "message" | "signal";
+    constructor(messageId: string, payloadKind: "message" | "signal", operation: InsertOrReconcileDispatchArgs["operation"]);
+}
+export type ClaimWorkflowRunDispatchArgs = {
+    readonly excludedDispatchIds?: readonly string[];
+    readonly leaseId: string;
+    readonly leaseDurationMs: number;
+};
+export type AcknowledgeWorkflowRunDispatchArgs = {
+    readonly allocationId: string;
+    readonly anchorRunId: string;
+    readonly messageId: string;
+    readonly generation: number;
+    readonly now?: Date;
+};
+export type RetryWorkflowRunDispatchArgs = {
+    readonly dispatchId: string;
+    readonly nextAttemptAt: Date;
+    readonly code: string;
+    readonly message: string;
+    readonly expectedLeaseId?: string;
+    readonly now?: Date;
+};
+export type FailWorkflowRunDispatchArgs = {
+    readonly anchorRunId: string;
+    readonly messageId: string;
+    readonly code: string;
+    readonly message: string;
+    readonly now?: Date;
+};
+export declare function createWorkflowRunDispatchStore(db: DBHandle): {
+    enqueue(args: EnqueueWorkflowRunDispatchArgs, tx?: DBExecutor): Promise<EnqueueWorkflowRunDispatchResult>;
+    enqueueSignal(args: EnqueueWorkflowSignalDispatchArgs, tx?: DBExecutor): Promise<EnqueueWorkflowRunDispatchResult>;
+    claimNextPending(args: ClaimWorkflowRunDispatchArgs): Promise<ParsedDispatch | null>;
+    acknowledge(args: AcknowledgeWorkflowRunDispatchArgs): Promise<ParsedDispatch | null>;
+    scheduleRetry(args: RetryWorkflowRunDispatchArgs): Promise<ParsedDispatch | null>;
+    settle(anchorRunId: string, messageId: string, now?: Date): Promise<ParsedDispatch | null>;
+    fail(args: FailWorkflowRunDispatchArgs): Promise<ParsedDispatch | null>;
+    failUnsettled(anchorRunId: string, code: string, message: string, now?: Date | SQL, tx?: DBExecutor): Promise<number>;
+    requeueUnsettled(anchorRunId: string): Promise<number>;
+    findById(id: string): Promise<ParsedDispatch | null>;
+    listUnsettled(anchorRunId: string): Promise<ParsedDispatch[]>;
+};
+export type WorkflowRunDispatchStore = ReturnType<typeof createWorkflowRunDispatchStore>;
+export {};