@intx/db 0.3.0 → 0.4.0

package/dist/sidecar-allocation-store.js

@@ -1,6 +1,6 @@
 import { type } from "arktype";
-import { and, asc, eq, inArray, isNull, lte, or, sql } from "drizzle-orm";
-import { SidecarPlacementRequirement, sidecarAllocationStatuses, } from "@intx/types";
+import { and, asc, eq, gt, inArray, isNull, lte, notInArray, or, sql, } from "drizzle-orm";
+import { sidecarAllocationStatuses, } from "@intx/types";
 import { createWorkflowRunDispatchStore } from "./workflow-run-dispatch-store.js";
 import { isLiveWorkflowRunStatus, liveWorkflowRunStatuses, principal, sidecar, sidecarAllocation, workflowRun, workflowRunLaunchSpec, } from "./schema/index.js";
 const SidecarAllocationStatusValidator = type.enumerated(...sidecarAllocationStatuses);
@@ -13,10 +13,6 @@ const activeStatuses = [
     "releasing",
 ];
 function parseSidecarAllocationRow(row) {
-    const placement = SidecarPlacementRequirement.assert({
-        sharing: row.placementSharing,
-        reuse: row.sidecarReuse,
-    });
     return {
         id: row.id,
         anchorRunId: row.anchorRunId,
@@ -25,7 +21,6 @@ function parseSidecarAllocationRow(row) {
         provisionerApiVersion: SidecarProvisionerApiVersion.assert(row.provisionerApiVersion),
         provisionerBindingFingerprint: row.provisionerBindingFingerprint,
         ...(row.sidecarId !== null ? { sidecarId: row.sidecarId } : {}),
-        placement,
         status: SidecarAllocationStatusValidator.assert(row.status),
         generation: row.generation,
         ...(row.ensureAcceptedGeneration !== null
@@ -39,6 +34,9 @@ function parseSidecarAllocationRow(row) {
         ...(row.reconciliationLeaseExpiresAt !== null
             ? { reconciliationLeaseExpiresAt: row.reconciliationLeaseExpiresAt }
             : {}),
+        ...(row.initializationLeaseId !== null
+            ? { initializationLeaseId: row.initializationLeaseId }
+            : {}),
         ensureAttempts: row.ensureAttempts,
         destroyAttempts: row.destroyAttempts,
         ...(row.connectDeadline !== null
@@ -58,16 +56,92 @@ function databaseTimestamp(override) {
 function leaseCondition(expectedLeaseId) {
     return expectedLeaseId === undefined
         ? []
-        : [eq(sidecarAllocation.reconciliationLeaseId, expectedLeaseId)];
+        : [
+            eq(sidecarAllocation.reconciliationLeaseId, expectedLeaseId),
+            gt(sidecarAllocation.reconciliationLeaseExpiresAt, sql `clock_timestamp()`),
+        ];
 }
 export function createSidecarAllocationStore(db) {
     const workflowRunDispatchStore = createWorkflowRunDispatchStore(db);
+    function initializationConditions(args, expectedMarker, { requireCurrentLease = true } = {}) {
+        return and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.anchorRunId, args.anchorRunId), eq(sidecarAllocation.tenantId, args.tenantId), eq(sidecarAllocation.status, "allocated"), eq(sidecarAllocation.generation, args.generation), eq(sidecarAllocation.ensureAcceptedGeneration, args.generation), ...(requireCurrentLease ? leaseCondition(args.leaseId) : []), expectedMarker === null
+            ? isNull(sidecarAllocation.initializationLeaseId)
+            : eq(sidecarAllocation.initializationLeaseId, expectedMarker));
+    }
+    async function writeInitialization(args, completion) {
+        args.signal.throwIfAborted();
+        return db.transaction(async (tx) => {
+            const condition = initializationConditions(args, completion === undefined ? null : args.leaseId);
+            const [allocation] = await tx
+                .select({ id: sidecarAllocation.id })
+                .from(sidecarAllocation)
+                .where(condition)
+                .for("update");
+            args.signal.throwIfAborted();
+            if (allocation === undefined)
+                return null;
+            let previousPublicKey = null;
+            if (completion === undefined) {
+                const [previous] = await tx
+                    .select({ publicKey: workflowRun.publicKey })
+                    .from(workflowRun)
+                    .where(and(eq(workflowRun.id, args.anchorRunId), eq(workflowRun.anchorRunId, args.anchorRunId), eq(workflowRun.tenantId, args.tenantId)))
+                    .for("update");
+                if (previous === undefined)
+                    throw new Error("Initialization anchor is missing");
+                previousPublicKey = previous.publicKey;
+            }
+            const [anchor] = await tx
+                .update(workflowRun)
+                .set({
+                publicKey: completion?.publicKey ?? null,
+                ...(completion?.credentialRefs !== undefined
+                    ? { credentialRefs: completion.credentialRefs }
+                    : {}),
+            })
+                .where(and(eq(workflowRun.id, args.anchorRunId), eq(workflowRun.anchorRunId, args.anchorRunId), eq(workflowRun.tenantId, args.tenantId)))
+                .returning({ id: workflowRun.id });
+            if (anchor === undefined)
+                throw new Error("Initialization anchor is missing");
+            // Check the lease again after waiting on the anchor row. Both writes roll
+            // back if ownership expired while the transaction held the allocation lock.
+            const [updated] = await tx
+                .update(sidecarAllocation)
+                .set({
+                initializationLeaseId: completion === undefined ? args.leaseId : null,
+            })
+                .where(condition)
+                .returning({ id: sidecarAllocation.id });
+            args.signal.throwIfAborted();
+            if (updated === undefined)
+                throw new Error("Initialization lease expired");
+            return { previousPublicKey };
+        });
+    }
+    async function initializationCompleted(tx, args) {
+        const [allocation] = await tx
+            .select({
+            anchorRunId: sidecarAllocation.anchorRunId,
+            initializationLeaseId: sidecarAllocation.initializationLeaseId,
+        })
+            .from(sidecarAllocation)
+            .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.generation, args.expectedGeneration), ...leaseCondition(args.expectedLeaseId)))
+            .for("update");
+        if (allocation === undefined || allocation.initializationLeaseId !== null)
+            return false;
+        // Read the key after acquiring the allocation lock, so a completion that
+        // committed while we waited is visible even if its response was lost.
+        const [anchor] = await tx
+            .select({ publicKey: workflowRun.publicKey })
+            .from(workflowRun)
+            .where(eq(workflowRun.id, allocation.anchorRunId));
+        return anchor !== undefined && anchor.publicKey !== null;
+    }
     async function insertSidecarIdentity(tx, args) {
         await tx.insert(sidecar).values({
             id: args.sidecarId,
             url: null,
             tokenHashSha256: args.tokenHashSha256,
-            credentialScope: "allocated",
             status: "offline",
             createdAt: args.now,
             updatedAt: args.now,
@@ -96,6 +170,7 @@ export function createSidecarAllocationStore(db) {
             .set({
             status: "releasing",
             generation: args.expectedGeneration + 1,
+            initializationLeaseId: null,
             nextAttemptAt: now,
             reconciliationLeaseId: null,
             reconciliationLeaseExpiresAt: null,
@@ -108,11 +183,59 @@ export function createSidecarAllocationStore(db) {
                 : {}),
             updatedAt: now,
         })
-            .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.status, args.expectedStatus), eq(sidecarAllocation.generation, args.expectedGeneration), ...leaseCondition(args.expectedLeaseId)))
+            .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.status, args.expectedStatus), eq(sidecarAllocation.generation, args.expectedGeneration), ...leaseCondition(args.expectedLeaseId), ...(args.expectedInitializationLeaseId !== undefined
+            ? [
+                eq(sidecarAllocation.initializationLeaseId, args.expectedInitializationLeaseId),
+            ]
+            : [])))
             .returning();
         return updated === undefined ? null : parseSidecarAllocationRow(updated);
     }
     return {
+        beginInitialization(args) {
+            return writeInitialization(args);
+        },
+        async completeInitialization(args) {
+            return (await writeInitialization(args, args)) !== null;
+        },
+        async clearUnsentInitialization(args) {
+            // No signal gate: the sole caller invokes this only for a proven-unsent
+            // frame, which is reachable precisely when the attempt was cancelled.
+            // The WHERE clause is the guard. Marker equality proves no newer
+            // attempt began, and generation/status equality proves the allocation
+            // did not move on. The reconciliation lease is deliberately not
+            // required: a disconnect nulls the lease while leaving this attempt's
+            // marker behind, and only this attempt's own clear may remove it. Restore
+            // its previous key in the same transaction so absence of the marker cannot
+            // expose a live workflow as keyless or certify a different attempt.
+            return db.transaction(async (tx) => {
+                const condition = initializationConditions(args, args.leaseId, {
+                    requireCurrentLease: false,
+                });
+                const [allocation] = await tx
+                    .select({ id: sidecarAllocation.id })
+                    .from(sidecarAllocation)
+                    .where(condition)
+                    .for("update");
+                if (allocation === undefined)
+                    return false;
+                const [anchor] = await tx
+                    .update(workflowRun)
+                    .set({ publicKey: args.previousPublicKey })
+                    .where(and(eq(workflowRun.id, args.anchorRunId), eq(workflowRun.anchorRunId, args.anchorRunId), eq(workflowRun.tenantId, args.tenantId)))
+                    .returning({ id: workflowRun.id });
+                if (anchor === undefined)
+                    throw new Error("Initialization anchor is missing");
+                const [updated] = await tx
+                    .update(sidecarAllocation)
+                    .set({ initializationLeaseId: null })
+                    .where(condition)
+                    .returning({ id: sidecarAllocation.id });
+                if (updated === undefined)
+                    throw new Error("Initialization attempt changed before rollback");
+                return true;
+            });
+        },
         async createPending(args, tx) {
             const executor = tx ?? db;
             const [anchor] = await executor
@@ -144,7 +267,6 @@ export function createSidecarAllocationStore(db) {
             if (args.provisionerApiVersion !== 1) {
                 throw new Error("sidecarAllocationStore.createPending: unsupported API version");
             }
-            const placement = SidecarPlacementRequirement.assert(args.placement ?? { sharing: "exclusive", reuse: "never" });
             const now = databaseTimestamp(args.now);
             const [inserted] = await executor
                 .insert(sidecarAllocation)
@@ -155,8 +277,6 @@ export function createSidecarAllocationStore(db) {
                 provisionerId: args.provisionerId,
                 provisionerApiVersion: args.provisionerApiVersion,
                 provisionerBindingFingerprint: args.provisionerBindingFingerprint,
-                placementSharing: placement.sharing,
-                sidecarReuse: placement.reuse ?? "never",
                 status: "pending",
                 generation: 0,
                 nextAttemptAt: now,
@@ -169,12 +289,41 @@ export function createSidecarAllocationStore(db) {
             }
             return parseSidecarAllocationRow(inserted);
         },
+        async createAdopted(args, tx) {
+            const createdAt = databaseTimestamp(args.now);
+            const [inserted] = await (tx ?? db)
+                .insert(sidecarAllocation)
+                .values({
+                id: args.id,
+                anchorRunId: args.anchorRunId,
+                tenantId: args.tenantId,
+                provisionerId: args.provisionerId,
+                provisionerApiVersion: args.provisionerApiVersion,
+                provisionerBindingFingerprint: args.provisionerBindingFingerprint,
+                sidecarId: args.sidecarId,
+                status: "allocated",
+                generation: args.generation,
+                ensureAcceptedGeneration: args.generation,
+                ...(args.externalRef !== undefined
+                    ? { externalRef: args.externalRef }
+                    : {}),
+                connectDeadline: args.connectDeadline,
+                nextAttemptAt: createdAt,
+                createdAt,
+                updatedAt: createdAt,
+            })
+                .returning();
+            if (inserted === undefined) {
+                throw new Error(`sidecarAllocationStore.createAdopted: insert returned no row for ${args.id}`);
+            }
+            return parseSidecarAllocationRow(inserted);
+        },
         async bindInitialSidecar(args) {
             return db.transaction(async (tx) => {
                 const [allocation] = await tx
                     .select()
                     .from(sidecarAllocation)
-                    .where(eq(sidecarAllocation.id, args.allocationId))
+                    .where(and(eq(sidecarAllocation.id, args.allocationId), ...leaseCondition(args.expectedLeaseId)))
                     .limit(1)
                     .for("update");
                 if (allocation === undefined ||
@@ -217,7 +366,7 @@ export function createSidecarAllocationStore(db) {
                 const [allocation] = await tx
                     .select()
                     .from(sidecarAllocation)
-                    .where(eq(sidecarAllocation.id, args.allocationId))
+                    .where(and(eq(sidecarAllocation.id, args.allocationId), ...leaseCondition(args.expectedLeaseId)))
                     .limit(1)
                     .for("update");
                 if (allocation === undefined ||
@@ -300,11 +449,15 @@ export function createSidecarAllocationStore(db) {
         async beginReplacement(args) {
             const now = databaseTimestamp(args.now);
             return db.transaction(async (tx) => {
+                if (args.onlyIfInitializationIncomplete &&
+                    (await initializationCompleted(tx, args)))
+                    return null;
                 const [updated] = await tx
                     .update(sidecarAllocation)
                     .set({
                     status: "replacing",
                     generation: args.expectedGeneration + 1,
+                    initializationLeaseId: null,
                     ensureAcceptedGeneration: null,
                     nextAttemptAt: args.nextAttemptAt,
                     reconciliationLeaseId: null,
@@ -314,7 +467,11 @@ export function createSidecarAllocationStore(db) {
                     failureMessage: args.failureMessage,
                     updatedAt: now,
                 })
-                    .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.status, args.expectedStatus), eq(sidecarAllocation.generation, args.expectedGeneration), ...leaseCondition(args.expectedLeaseId)))
+                    .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.status, args.expectedStatus), eq(sidecarAllocation.generation, args.expectedGeneration), ...leaseCondition(args.expectedLeaseId), ...(args.expectedInitializationLeaseId !== undefined
+                    ? [
+                        eq(sidecarAllocation.initializationLeaseId, args.expectedInitializationLeaseId),
+                    ]
+                    : [])))
                     .returning();
                 if (updated === undefined)
                     return null;
@@ -333,6 +490,9 @@ export function createSidecarAllocationStore(db) {
         async beginUnrecoverableRelease(args) {
             const now = databaseTimestamp(args.now);
             return db.transaction(async (tx) => {
+                if (args.onlyIfInitializationIncomplete &&
+                    (await initializationCompleted(tx, args)))
+                    return null;
                 const releasing = await beginRelease({
                     ...args,
                     expectedStatus: "allocated",
@@ -360,6 +520,31 @@ export function createSidecarAllocationStore(db) {
                 .returning();
             return updated === undefined ? null : parseSidecarAllocationRow(updated);
         },
+        async markDestroyFailed(args) {
+            const now = databaseTimestamp(args.now);
+            return db.transaction(async (tx) => {
+                const [updated] = await tx
+                    .update(sidecarAllocation)
+                    .set({
+                    status: "destroy_failed",
+                    failureCode: args.code,
+                    failureMessage: args.message,
+                    nextAttemptAt: null,
+                    reconciliationLeaseId: null,
+                    reconciliationLeaseExpiresAt: null,
+                    connectDeadline: null,
+                    destroyAttempts: sql `${sidecarAllocation.destroyAttempts} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(eq(sidecarAllocation.id, args.allocationId), inArray(sidecarAllocation.status, ["replacing", "releasing"]), eq(sidecarAllocation.generation, args.expectedGeneration), ...leaseCondition(args.expectedLeaseId)))
+                    .returning();
+                if (updated === undefined)
+                    return null;
+                await failRunningRuns(tx, updated.anchorRunId, now);
+                await workflowRunDispatchStore.failUnsettled(updated.anchorRunId, args.code, args.message, now, tx);
+                return parseSidecarAllocationRow(updated);
+            });
+        },
         async failWithoutInfrastructure(args, tx) {
             const now = databaseTimestamp(args.now);
             const fail = async (executor) => {
@@ -402,7 +587,14 @@ export function createSidecarAllocationStore(db) {
                 const [candidate] = await tx
                     .select({ id: sidecarAllocation.id })
                     .from(sidecarAllocation)
-                    .where(and(inArray(sidecarAllocation.status, activeStatuses), lte(sidecarAllocation.nextAttemptAt, sql `now()`), or(isNull(sidecarAllocation.reconciliationLeaseExpiresAt), lte(sidecarAllocation.reconciliationLeaseExpiresAt, sql `now()`))))
+                    .where(and(inArray(sidecarAllocation.status, activeStatuses), lte(sidecarAllocation.nextAttemptAt, sql `now()`), ...(args.excludedAllocationIds !== undefined &&
+                    args.excludedAllocationIds.length > 0
+                    ? [
+                        notInArray(sidecarAllocation.id, [
+                            ...args.excludedAllocationIds,
+                        ]),
+                    ]
+                    : []), or(isNull(sidecarAllocation.reconciliationLeaseExpiresAt), lte(sidecarAllocation.reconciliationLeaseExpiresAt, sql `now()`))))
                     .orderBy(asc(sidecarAllocation.nextAttemptAt), asc(sidecarAllocation.createdAt))
                     .limit(1)
                     .for("update", { skipLocked: true });
@@ -425,12 +617,20 @@ export function createSidecarAllocationStore(db) {
             const [updated] = await db
                 .update(sidecarAllocation)
                 .set({
-                reconciliationLeaseExpiresAt: sql `now() + (${leaseDurationMs} * interval '1 millisecond')`,
+                reconciliationLeaseExpiresAt: sql `clock_timestamp() + (${leaseDurationMs} * interval '1 millisecond')`,
             })
-                .where(and(eq(sidecarAllocation.id, allocationId), eq(sidecarAllocation.reconciliationLeaseId, leaseId)))
+                .where(and(eq(sidecarAllocation.id, allocationId), ...leaseCondition(leaseId)))
                 .returning({ id: sidecarAllocation.id });
             return updated !== undefined;
         },
+        async isReconciliationLeaseCurrent(allocationId, generation, leaseId) {
+            const [allocation] = await db
+                .select({ id: sidecarAllocation.id })
+                .from(sidecarAllocation)
+                .where(and(eq(sidecarAllocation.id, allocationId), eq(sidecarAllocation.generation, generation), ...leaseCondition(leaseId)))
+                .limit(1);
+            return allocation !== undefined;
+        },
         async markConnectionReady(args) {
             const [updated] = await db
                 .update(sidecarAllocation)
@@ -443,7 +643,7 @@ export function createSidecarAllocationStore(db) {
                 failureMessage: null,
                 updatedAt: databaseTimestamp(args.now),
             })
-                .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.status, "allocated"), eq(sidecarAllocation.generation, args.generation), eq(sidecarAllocation.ensureAcceptedGeneration, args.generation), ...leaseCondition(args.expectedLeaseId)))
+                .where(and(eq(sidecarAllocation.id, args.allocationId), eq(sidecarAllocation.status, "allocated"), eq(sidecarAllocation.generation, args.generation), eq(sidecarAllocation.ensureAcceptedGeneration, args.generation), isNull(sidecarAllocation.initializationLeaseId), ...leaseCondition(args.expectedLeaseId)))
                 .returning();
             return updated === undefined ? null : parseSidecarAllocationRow(updated);
         },
@@ -489,14 +689,16 @@ export function createSidecarAllocationStore(db) {
                 reconciliationLeaseId: null,
                 reconciliationLeaseExpiresAt: null,
             })
-                .where(and(eq(sidecarAllocation.id, allocationId), eq(sidecarAllocation.reconciliationLeaseId, leaseId)))
+                .where(and(eq(sidecarAllocation.id, allocationId), ...leaseCondition(leaseId)))
                 .returning({ id: sidecarAllocation.id });
             return updated !== undefined;
         },
         async wakeReconciliation(allocationId, generation) {
             const [updated] = await db
                 .update(sidecarAllocation)
-                .set({ nextAttemptAt: sql `now()` })
+                .set({
+                nextAttemptAt: sql `now()`,
+            })
                 .where(and(eq(sidecarAllocation.id, allocationId), eq(sidecarAllocation.generation, generation), inArray(sidecarAllocation.status, activeStatuses)))
                 .returning({ id: sidecarAllocation.id });
             return updated !== undefined;

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,3 +1,4 @@
+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.
@@ -7,6 +8,7 @@ import type { DB } from "./client.js";
  * 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,4 +1,6 @@
+import { type } from "arktype";
 import { eq, inArray } from "drizzle-orm";
+import { TenantConfig } from "@intx/types";
 import { tenant } from "./schema/tenants.js";
 /**
  * Walks the tenant parentId chain from the given tenant up to the root.
@@ -27,6 +29,31 @@ export async function getAncestorChain(db, tenantId) {
     }
     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-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"),
+            });
+        },
+    };
+}