@makaio/storage-pg 1.0.0-dev-1789178780636 → 1.0.0-dev-1789234461336

package/dist/execution-attempt-cancellation-read.d.ts

@@ -0,0 +1,13 @@
+/** Cancellation read operations for PostgreSQL execution attempts. */
+import type { ExecutionAttemptRepository } from '@makaio/framework/workflow-engine';
+import type { ExecutionAttemptRows } from './execution-attempt-rows.js';
+import type { ExecutionAttemptTransaction } from './execution-attempt-transaction.js';
+type CancellationReadOperations = Pick<Required<ExecutionAttemptRepository<never>>, 'readCancellation' | 'readAttemptCancellationControl'>;
+/**
+ * Create cancellation state read operations.
+ * @param rows - Attempt and control-state row accessors.
+ * @param transact - Transaction boundary for consistent cancellation reads.
+ * @returns Cancellation state read methods.
+ */
+export declare function createCancellationReadOperations(rows: Pick<ExecutionAttemptRows, 'readAttemptRow' | 'readCancellationInSession' | 'readControlEvidenceInSession'>, transact: ExecutionAttemptTransaction['transact']): CancellationReadOperations;
+export {};

package/dist/execution-attempt-control.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Cancellation, control-evidence, active-attempt, and outcome transitions.
+ *
+ * This private module keeps the repository's owner-fenced control plane
+ * separate from provisioning and runtime-operation transitions. Its context
+ * is concrete: callers supply the one session transaction boundary, row
+ * accessors, settlement CAS, and injected outcome codec used by every method.
+ */
+import { type SQL } from 'drizzle-orm';
+import type { RawSqlSession } from '@makaio/framework/storage/drizzle';
+import type { ExecutionAttemptRepository, OutcomeCodec } from '@makaio/framework/workflow-engine';
+import type { ExecutionAttemptRows } from './execution-attempt-rows.js';
+import type { ExecutionAttemptTransaction } from './execution-attempt-transaction.js';
+type ControlMethods<TOutcome> = Pick<Required<ExecutionAttemptRepository<TOutcome>>, 'requestAttemptCancellation' | 'requestCancellation' | 'readCancellation' | 'readAttemptCancellationControl' | 'recordAttemptControlReceipt' | 'reportAttemptControl' | 'getActiveAttempt' | 'canonicalizeOutcome' | 'decodeOutcome' | 'commitOutcome' | 'abandonPendingAttempt'>;
+/** Dependencies shared by the control-plane repository methods. */
+export interface ExecutionAttemptControlContext<TOutcome> {
+    readonly codec: OutcomeCodec<TOutcome>;
+    readonly transaction: ExecutionAttemptTransaction;
+    readonly rows: ExecutionAttemptRows;
+    readonly settleAttempt: (session: RawSqlSession, executionAttemptId: string, settlementKind: 'outcome' | 'abandoned', guard: SQL) => Promise<{
+        readonly rowsAffected: number;
+    }>;
+}
+/**
+ * Create the control-plane portion of the PostgreSQL attempt repository.
+ * @param context - Codec, transaction, rows, and settlement dependencies.
+ * @returns Cancellation, evidence, active-attempt, and outcome methods.
+ */
+export declare function createExecutionAttemptControlOperations<TOutcome>(context: ExecutionAttemptControlContext<TOutcome>): ControlMethods<TOutcome>;
+export {};

package/dist/execution-attempt-core.d.ts

@@ -0,0 +1,33 @@
+/** Core creation, replay, allocation, and recovery operations for PostgreSQL attempts. */
+import { type SQL } from 'drizzle-orm';
+import type { BoundedRecoveryEvidence } from '@makaio/framework/contracts';
+import type { RawSqlSession } from '@makaio/framework/storage/drizzle';
+import type { AllocationRecordingDecision, ExecutionAttemptRecoveryOperations, ExecutionAttemptRepository, ExecutionAttemptSettlementKind, OutcomeCodec, ProviderOperationClaim, RecordAllocationInput } from '@makaio/framework/workflow-engine';
+import { type ExecutionAttemptRows } from './execution-attempt-rows.js';
+import { type ExecutionAttemptTransaction } from './execution-attempt-transaction.js';
+export interface ExecutionAttemptCoreOperations<TOutcome> {
+    readonly methods: Pick<Required<ExecutionAttemptRepository<TOutcome>>, 'createAttempt' | 'ensureAttempt' | 'readAttemptSettlement' | 'readBootstrapStartState'>;
+    readonly recovery: ExecutionAttemptRecoveryOperations;
+    readonly applyAllocation: ApplyAllocation;
+    readonly settleAttempt: SettleAttempt;
+    readonly settleAndCompletePreallocationOperation: SettleAndCompletePreallocationOperation;
+}
+interface ExecutionAttemptCoreContext<TOutcome> {
+    readonly codec: OutcomeCodec<TOutcome>;
+    readonly transaction: ExecutionAttemptTransaction;
+    readonly rows: ExecutionAttemptRows;
+}
+type ApplyAllocation = (input: RecordAllocationInput, bootstrapClaimable: boolean) => Promise<AllocationRecordingDecision>;
+type SettleAttempt = (session: RawSqlSession, executionAttemptId: string, settlementKind: NonNullable<ExecutionAttemptSettlementKind>, guard: SQL) => Promise<{
+    readonly rowsAffected: number;
+}>;
+type SettleAndCompletePreallocationOperation = (session: RawSqlSession, executionAttemptId: string, claim: ProviderOperationClaim, guard: SQL, evidence: BoundedRecoveryEvidence, alreadySettled: boolean) => Promise<{
+    readonly rowsAffected: number;
+}>;
+/**
+ * Create core attempt persistence, allocation, and recovery operations.
+ * @param options - Codec, transaction boundary, and row accessors to compose.
+ * @returns Core repository members and provider-transition dependencies.
+ */
+export declare function createExecutionAttemptCore<TOutcome>(options: ExecutionAttemptCoreContext<TOutcome>): ExecutionAttemptCoreOperations<TOutcome>;
+export {};

package/dist/execution-attempt-provider-claim.d.ts

@@ -0,0 +1,15 @@
+import { type ExecutionAttemptRepository } from '@makaio/framework/workflow-engine';
+import type { ExecutionAttemptRows } from './execution-attempt-rows.js';
+import type { ExecutionAttemptTransaction } from './execution-attempt-transaction.js';
+type ProviderClaimOperations = Pick<Required<ExecutionAttemptRepository<never>>, 'takeOverProviderOperation' | 'handoffProviderOperation' | 'recordProviderOperationUncertainty'>;
+interface ProviderClaimContext {
+    readonly transaction: Pick<ExecutionAttemptTransaction, 'transact'>;
+    readonly rows: Pick<ExecutionAttemptRows, 'readAttemptRow' | 'readOperationRow' | 'refuseUnauthorized'>;
+}
+/**
+ * Create the claim transition members of the provider-operation repository surface.
+ * @param context - Transaction and row access dependencies for claim-fenced changes.
+ * @returns Claim takeover, handoff, and uncertainty methods.
+ */
+export declare function createProviderClaimOperations(context: ProviderClaimContext): ProviderClaimOperations;
+export {};

package/dist/execution-attempt-provider.d.ts

@@ -0,0 +1,27 @@
+/** Provider provisioning and allocation transitions for PostgreSQL attempts. */
+import { type SQL } from 'drizzle-orm';
+import { type BoundedRecoveryEvidence } from '@makaio/framework/contracts';
+import { type AllocationRecordingDecision, type ExecutionAttemptRepository, type ProviderOperationClaim, type RecordAllocationInput } from '@makaio/framework/workflow-engine';
+import type { RawSqlSession } from '@makaio/framework/storage/drizzle';
+import type { ExecutionAttemptRows } from './execution-attempt-rows.js';
+import type { ExecutionAttemptTransaction } from './execution-attempt-transaction.js';
+/** Concrete dependencies shared by the provider-operation method group. */
+export interface ProviderMethodContext {
+    readonly transaction: Pick<ExecutionAttemptTransaction, 'transact'>;
+    readonly rows: Pick<ExecutionAttemptRows, 'authorize' | 'readActiveAttemptId' | 'readAttemptRow' | 'readOperationRow' | 'refuseUnauthorized'>;
+    readonly applyAllocation: (input: RecordAllocationInput, bootstrapClaimable: boolean) => Promise<AllocationRecordingDecision>;
+    readonly settleAttempt: (session: RawSqlSession, executionAttemptId: string, settlementKind: 'abandoned' | 'infrastructure-failure', guard: SQL) => Promise<{
+        readonly rowsAffected: number;
+    }>;
+    readonly settleAndCompletePreallocationOperation: (session: RawSqlSession, executionAttemptId: string, claim: ProviderOperationClaim, guard: SQL, evidence: BoundedRecoveryEvidence, alreadySettled: boolean) => Promise<{
+        readonly rowsAffected: number;
+    }>;
+}
+type ProviderMethods = Pick<Required<ExecutionAttemptRepository<never>>, 'beginProvisioning' | 'getProviderOperation' | 'renewProviderOperationClaim' | 'takeOverProviderOperation' | 'handoffProviderOperation' | 'recordProviderOperationUncertainty' | 'completeProviderOperation' | 'recordAllocation' | 'recordProvisioningAbsent' | 'recordProvisionerIncarnationLost' | 'recordAllocationTerminated' | 'recordInfrastructureFailure'>;
+/**
+ * Create the provider-operation methods of an execution-attempt repository.
+ * @param context - Transaction, row, allocation, and settlement dependencies.
+ * @returns Provider-operation members of the complete repository port.
+ */
+export declare function createProviderMethods(context: ProviderMethodContext): ProviderMethods;
+export {};

package/dist/execution-attempt-repository.d.ts

@@ -0,0 +1,13 @@
+/** Transactional PostgreSQL realization of the execution-attempt repository. */
+import type { MakaioDatabase } from '@makaio/framework/storage/drizzle';
+import type { ExecutionAttemptRepository, OutcomeCodec } from '@makaio/framework/workflow-engine';
+/**
+ * Create a full, owner-fenced PostgreSQL execution-attempt repository.
+ *
+ * The constructor accepts the branded database supplied by the storage layer;
+ * it never creates a pool or permits an unpinned transaction connection.
+ * @param db - Branded PostgreSQL database handle.
+ * @param codec - Owner-supplied canonical outcome codec.
+ * @returns The complete execution-attempt repository port.
+ */
+export declare function createPostgresExecutionAttemptRepository<TOutcome>(db: MakaioDatabase, codec: OutcomeCodec<TOutcome>): Promise<Required<ExecutionAttemptRepository<TOutcome>>>;

package/dist/execution-attempt-rows.d.ts

@@ -0,0 +1,42 @@
+import type { RawSqlSession } from '@makaio/framework/storage/drizzle';
+import type { AttemptControlEvidence, AttemptReachabilityDecision, ExecutionAttemptCancellationIntent, ExecutionAttemptRecord, ProviderOperationClaim } from '@makaio/framework/workflow-engine';
+import { type AttemptRow, type OperationRow } from './execution-attempt-types.js';
+export { toAttemptRecord, toOperationRecord, type AttemptRow, type OperationRow } from './execution-attempt-types.js';
+export type ClaimAuthorization = {
+    readonly kind: 'authorized';
+    readonly attempt: ExecutionAttemptRecord;
+    readonly attemptRow: AttemptRow;
+    readonly operation: OperationRow;
+} | {
+    readonly kind: 'stale';
+    readonly attempt: ExecutionAttemptRecord;
+} | {
+    readonly kind: 'resolved';
+    readonly attempt: ExecutionAttemptRecord;
+} | {
+    readonly kind: 'not-found';
+};
+export type ClaimRefusal = {
+    readonly kind: 'stale' | 'resolved' | 'not-found';
+};
+export interface ExecutionAttemptRows {
+    readonly readCancellationInSession: (session: RawSqlSession, executionAttemptId: string) => Promise<ExecutionAttemptCancellationIntent | null>;
+    readonly readControlEvidenceInSession: (session: RawSqlSession, executionAttemptId: string) => Promise<AttemptControlEvidence[]>;
+    readonly writeCancellationInSession: (session: RawSqlSession, executionAttemptId: string, intent: ExecutionAttemptCancellationIntent) => Promise<void>;
+    readonly readAttemptRow: (session: RawSqlSession, executionAttemptId: string) => Promise<AttemptRow | undefined>;
+    readonly readOperationRow: (session: RawSqlSession, executionAttemptId: string) => Promise<OperationRow | undefined>;
+    readonly allocationTerminated: (session: RawSqlSession, executionAttemptId: string) => Promise<boolean>;
+    readonly readActiveAttemptId: (session: RawSqlSession, executionId: string) => Promise<string | null>;
+    readonly runtimeReachability: (session: RawSqlSession, row: AttemptRow) => Promise<AttemptReachabilityDecision | null>;
+    readonly authorize: (session: RawSqlSession, claim: ProviderOperationClaim) => Promise<ClaimAuthorization>;
+    readonly refuseUnauthorized: (session: RawSqlSession, claim: ProviderOperationClaim) => Promise<ClaimRefusal | undefined>;
+}
+interface ExecutionAttemptRowsContext {
+    readonly lockOwner: (session: RawSqlSession, executionId: string) => Promise<void>;
+}
+/**
+ * Create row operations bound to the transaction's execution-owner lock.
+ * @param context - Owner-lock operation shared by all row reads.
+ * @returns Session-local attempt, operation, and control-evidence accessors.
+ */
+export declare function createExecutionAttemptRows(context: ExecutionAttemptRowsContext): ExecutionAttemptRows;

package/dist/execution-attempt-runtime.d.ts

@@ -0,0 +1,29 @@
+import type { ExecutionAttemptInstruction } from '@makaio/framework/contracts';
+import { type AdmitOperationInput, type AttemptControlState, type CompleteOperationInput, type GetInstructionInput, type MarkRuntimeReadyInput, type OperationAdmissionDecision, type OperationCompletionDecision, type OperationReportDecision, type RegisterRuntimeInput, type ReportOperationInput, type RuntimeReadinessDecision, type RuntimeRegistrationDecision } from '@makaio/framework/workflow-engine';
+import { type ExecutionAttemptRows } from './execution-attempt-rows.js';
+import { decideByWrite, type ExecutionAttemptTransaction } from './execution-attempt-transaction.js';
+/** Dependencies shared by the runtime method group. */
+export interface ExecutionAttemptRuntimeContext {
+    readonly transact: ExecutionAttemptTransaction['transact'];
+    readonly decideByWrite: typeof decideByWrite;
+    readonly readAttemptRow: ExecutionAttemptRows['readAttemptRow'];
+    readonly readActiveAttemptId: ExecutionAttemptRows['readActiveAttemptId'];
+    readonly allocationTerminated: ExecutionAttemptRows['allocationTerminated'];
+    readonly runtimeReachability: ExecutionAttemptRows['runtimeReachability'];
+}
+/** Runtime/workflow-operation members of the execution-attempt repository. */
+export interface ExecutionAttemptRuntimeMethods {
+    readonly registerRuntime: (input: RegisterRuntimeInput) => Promise<RuntimeRegistrationDecision>;
+    readonly admitOperation: (input: AdmitOperationInput) => Promise<OperationAdmissionDecision>;
+    readonly getInstruction: (input: GetInstructionInput) => Promise<ExecutionAttemptInstruction | null>;
+    readonly reportOperation: (input: ReportOperationInput) => Promise<OperationReportDecision>;
+    readonly completeOperation: (input: CompleteOperationInput) => Promise<OperationCompletionDecision>;
+    readonly markRuntimeReady: (input: MarkRuntimeReadyInput) => Promise<RuntimeReadinessDecision>;
+    readonly getAttemptControlState: (executionAttemptId: string) => Promise<AttemptControlState | null>;
+}
+/**
+ * Create the runtime and workflow-operation repository methods.
+ * @param context - Transaction and row operations shared by runtime transitions.
+ * @returns Runtime and workflow-operation repository methods.
+ */
+export declare function createRuntimeMethods(context: ExecutionAttemptRuntimeContext): ExecutionAttemptRuntimeMethods;

package/dist/execution-attempt-transaction.d.ts

@@ -0,0 +1,79 @@
+/**
+ * PostgreSQL transaction and compare-and-set primitives for execution attempts.
+ *
+ * This module owns the adapter's connection-scoped atomicity, owner fencing,
+ * and correlated write predicates. Repository operations compose these helpers
+ * with their port-specific reads and evaluators.
+ */
+import { type SQL } from 'drizzle-orm';
+import { type MakaioDatabase, type RawSqlSession } from '@makaio/framework/storage/drizzle';
+import type { ProviderOperationClaim } from '@makaio/framework/workflow-engine';
+/** A write that reports whether its complete durable guard still held. */
+export type GuardedWrite = () => Promise<{
+    readonly rowsAffected: number;
+}>;
+/**
+ * The connection-scoped operations used by execution-attempt transitions.
+ *
+ * `transact` is intentionally the only entry point that issues PostgreSQL
+ * transaction control statements. `lockOwner` is parameterized through the
+ * shared advisory-lock expression factory and must run inside `transact`.
+ */
+export interface ExecutionAttemptTransaction {
+    readonly transact: <TResult>(work: (session: RawSqlSession) => Promise<TResult>) => Promise<TResult>;
+    readonly lockOwner: (session: RawSqlSession, executionId: string) => Promise<void>;
+}
+/**
+ * Validate the database handle and create the execution-attempt transaction
+ * boundary.
+ *
+ * All control statements execute only while `withSession` has checked out one
+ * PostgreSQL connection. When rollback itself fails, both the original and
+ * rollback errors remain observable so the driver can discard the poisoned
+ * connection.
+ * @param db - Branded database handle to bind to one PostgreSQL session per transition.
+ * @returns Connection-pinned transaction and owner-lock operations.
+ */
+export declare function createExecutionAttemptTransaction(db: MakaioDatabase): ExecutionAttemptTransaction;
+/**
+ * Decide a transition from the row count of a write that repeats its guards.
+ *
+ * A zero-row write is re-evaluated. If durable state still permits the write,
+ * the stored row changed without producing a refusal and the caller has found
+ * a violated compare-and-set invariant.
+ * @param read - Re-evaluates durable state and returns either a refusal or guarded write.
+ * @param accepted - Decision to return after the guarded write succeeds.
+ * @returns The durable refusal or accepted transition decision.
+ */
+export declare function decideByWrite<TDecision extends {
+    readonly kind: string;
+}>(read: () => Promise<TDecision | GuardedWrite>, accepted: TDecision | (() => TDecision)): Promise<TDecision>;
+/**
+ * Predicate asserting that a provider-operation claim still matches durable ownership.
+ * @param claim - Provider-operation ownership claim to match.
+ * @returns SQL predicate that verifies the exact stored claim.
+ */
+export declare function claimHolds(claim: ProviderOperationClaim): SQL;
+/**
+ * Predicate asserting that provider completion and attempt settlement have both converged.
+ * @param executionAttemptId - Attempt whose provider operation is inspected.
+ * @returns SQL predicate that permits unfinished provider convergence.
+ */
+export declare function operationIsUnresolved(executionAttemptId: string): SQL;
+/**
+ * Predicate asserting that an unresolved operation still authorizes its current claim holder.
+ * @param claim - Provider-operation ownership claim to authorize.
+ * @returns SQL predicate for an unresolved operation owned by the claim.
+ */
+export declare function claimAuthorizes(claim: ProviderOperationClaim): SQL;
+/**
+ * Predicate asserting that a provider operation still owes terminal convergence.
+ * @param executionAttemptId - Attempt whose operation obligation is inspected.
+ * @returns SQL predicate for a terminal-convergence obligation.
+ */
+export declare function operationOwesTerminalConvergence(executionAttemptId: string): SQL;
+/**
+ * Predicate asserting that the `execution_attempt` row being written remains active.
+ * @returns SQL predicate correlated to the row being updated.
+ */
+export declare function isActiveAttemptRow(): SQL;

package/dist/execution-attempt-types.d.ts

@@ -0,0 +1,164 @@
+import type { ExecutionAttemptInstruction, ProviderAllocationRef } from '@makaio/framework/contracts';
+import { type AllocationRefEvolution, type AttemptControlState, type AttemptOutcomeControlObservation, type ExecutionAttemptRecord, type ProviderOperationOwnershipRecord, type RecoverableAttemptRecord } from '@makaio/framework/workflow-engine';
+export declare const INITIAL_ATTEMPT_CONTROL_STATE: AttemptControlState;
+export declare const instantOf: (value: string) => number;
+export declare const normalizeInstant: (value: string) => string;
+export declare const createAttemptTiming: (bootstrapTimeoutMs: number) => {
+    createdAt: string;
+    bootstrapDeadlineAt: string;
+};
+export declare const parseInstruction: (value: ExecutionAttemptInstruction) => {
+    id: string;
+    revision: string;
+    workload: {
+        kind: string;
+        version: string;
+        input: import("@makaio/framework/contracts").JsonValue;
+    };
+    workspace?: {
+        provisioning: "bind" | "create";
+        custody: "disposable" | "external";
+        sourceRoots: {
+            id: string;
+            path: string;
+            source?: {
+                kind: string;
+                input: import("@makaio/framework/contracts").JsonValue;
+            } | undefined;
+        }[];
+        setup: {
+            command: string;
+            args: string[];
+            env: Record<string, string>;
+            timeoutMs: number;
+        }[];
+    } | undefined;
+    preservation: {
+        required: ("diagnostics" | "live-state" | "source-state" | "workspace-state")[];
+    };
+};
+export declare const parsePreparationResult: (value: unknown) => {
+    kind: "workspace-prepared";
+    binding: {
+        workspaceRoot: string;
+        sourceRoots: {
+            id: string;
+            path: string;
+        }[];
+    };
+};
+export declare const parsePreparationReceipts: (value: unknown) => {
+    operationId: string;
+    runtimeGeneration: number;
+    result: {
+        kind: "workspace-prepared";
+        binding: {
+            workspaceRoot: string;
+            sourceRoots: {
+                id: string;
+                path: string;
+            }[];
+        };
+    };
+}[];
+export declare const parseAllocationRef: (value: ProviderAllocationRef) => {
+    version: 1;
+    providerId: string;
+    providerData: Record<string, unknown>;
+};
+export declare const parseAllocationLifetime: (value: unknown) => "provider-managed" | "provisioner-process-bound";
+export declare const parseAllocationRefEvolution: (input: AllocationRefEvolution) => {
+    currentRef: {
+        version: 1;
+        providerId: string;
+        providerData: Record<string, unknown>;
+    };
+    nextRef: {
+        version: 1;
+        providerId: string;
+        providerData: Record<string, unknown>;
+    };
+};
+export declare const requireAllocationRefProvider: (attempt: ExecutionAttemptRecord, allocationRef: ProviderAllocationRef) => void;
+export declare const toRecoverableAttempt: (record: ExecutionAttemptRecord) => RecoverableAttemptRecord;
+export interface AttemptRow extends Record<string, unknown> {
+    readonly execution_attempt_id: string;
+    readonly execution_id: string;
+    readonly instruction: string;
+    readonly preparation_receipts: string;
+    readonly status: string;
+    readonly provider_id: string | null;
+    readonly allocation_lifetime: string | null;
+    readonly provisioner_incarnation_id: string | null;
+    readonly allocation_ref: string | null;
+    readonly settlement_kind: string | null;
+    readonly outcome_text: string | null;
+    readonly outcome_control_observation: string | null;
+    readonly claimable: number;
+    readonly claim_expires_at: string | null;
+    readonly created_at: string;
+    readonly bootstrap_deadline_at: string | null;
+    readonly runtime_generation: number;
+    readonly runtime_incarnation_id: string | null;
+    readonly runtime_ready_at: string | null;
+    readonly operation_start_gate: string;
+    readonly active_operation_id: string | null;
+    readonly active_operation_kind: string | null;
+    readonly active_operation_key: string | null;
+    readonly active_operation_generation: number | null;
+    readonly active_operation_admitted_at: string | null;
+    readonly last_completed_operation_id: string | null;
+}
+export interface OperationRow extends Record<string, unknown> {
+    readonly execution_attempt_id: string;
+    readonly generation: number;
+    readonly owner_id: string | null;
+    readonly token: string | null;
+    readonly lease_expires_at: string | null;
+    readonly obligation: string;
+    readonly failure_count: number;
+    readonly last_failure: string | null;
+    readonly completion_evidence: string | null;
+}
+export interface ActiveAttemptRow extends Record<string, unknown> {
+    readonly execution_attempt_id: string;
+}
+/**
+ * Parse a stored enum member against the port-owned vocabulary.
+ * @param members - Allowed members in the port vocabulary.
+ * @param value - Stored database value to validate.
+ * @param column - Database column reported for an invalid value.
+ * @returns The validated vocabulary member.
+ */
+export declare function parseMember<TMember extends string>(members: readonly TMember[], value: string, column: string): TMember;
+/**
+ * Decode an optional JSON column through its value schema.
+ * @param json - Serialized column value, or null when absent.
+ * @param parse - Schema parser for the decoded JSON value.
+ * @returns The parsed value, or null when the column is null.
+ */
+export declare function parseJsonColumn<TValue>(json: string | null, parse: (value: unknown) => TValue): TValue | null;
+/**
+ * Decode the immutable cancellation observation stored with an outcome.
+ * @param json - Serialized control observation, or null when no outcome was committed.
+ * @returns The validated control observation, or null when absent.
+ */
+export declare function decodeOutcomeControl(json: string | null): AttemptOutcomeControlObservation | null;
+/**
+ * Decode the runtime and active-operation columns of an attempt row.
+ * @param row - Database attempt row to decode.
+ * @returns The port control-state projection.
+ */
+export declare function decodeAttemptControlState(row: AttemptRow): AttemptControlState;
+/**
+ * Decode a database attempt row into its public repository record.
+ * @param row - Database attempt row to decode.
+ * @returns Validated immutable execution-attempt record.
+ */
+export declare function toAttemptRecord(row: AttemptRow): ExecutionAttemptRecord;
+/**
+ * Decode a database provider-operation row into its public ownership record.
+ * @param row - Database operation row to decode.
+ * @returns Validated provider-operation ownership record.
+ */
+export declare function toOperationRecord(row: OperationRow): ProviderOperationOwnershipRecord;

package/dist/index.d.ts

@@ -14,6 +14,7 @@
 export { postgresStorageEngine } from './engine.js';
 export { isPostgresDuplicateObjectError, isPostgresUniqueViolationError } from './errors.js';
 export { postgresFtsSearchStrategy } from './fts-strategy.js';
+export { createPostgresExecutionAttemptRepository } from './execution-attempt-repository.js';
 export { buildPostgresLedgerDdl, migrationAdvisoryLockKey, POSTGRES_MIGRATION_BEGIN } from './migrations.js';
 export { postgresTransactionLockExpressions, postgresTransactionLockKey, postgresTransactionLocks, } from './transaction-locks.js';
 /**