@lostgradient/weft 0.23.1 → 0.24.1

package/dist/core/events/catalog-events.d.ts

@@ -0,0 +1,117 @@
+import type { WorkflowCompatibilityReason } from '../contract/compatibility.ts';
+/**
+ * Fired on the {@link Engine} when a `(name, revision)` is durably installed
+ * into the workflow catalog for the first time. Never fired for a
+ * byte-identical reinstall of an already-installed revision. Read
+ * `e.workflowType` and `e.revision` directly off the event.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowRevisionInstalledEvent, workflow } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowRevisionInstalledEvent.type, (event) => {
+ *   console.log('installed:', event.workflowType, event.revision);
+ * });
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ * ```
+ */
+export declare class WorkflowRevisionInstalledEvent extends Event {
+    static readonly type: "catalog:revision-installed";
+    readonly workflowType: string;
+    readonly revision: string;
+    constructor(workflowType: string, revision: string);
+}
+/**
+ * Fired on the {@link Engine} when a `(name, revision)` becomes the active
+ * revision for its name — bumping the catalog's per-name `generation`
+ * counter. `previousRevision` is `undefined` on a name's first-ever
+ * activation, and set to the revision this activation replaced otherwise.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowRevisionActivatedEvent, workflow } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowRevisionActivatedEvent.type, (event) => {
+ *   console.log('activated:', event.workflowType, event.revision, 'gen', event.generation);
+ * });
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ * ```
+ */
+export declare class WorkflowRevisionActivatedEvent extends Event {
+    static readonly type: "catalog:revision-activated";
+    readonly workflowType: string;
+    readonly revision: string;
+    readonly generation: number;
+    readonly previousRevision: string | undefined;
+    constructor(workflowType: string, revision: string, generation: number, previousRevision: string | undefined);
+}
+/**
+ * Fired on the {@link Engine} when a candidate activation
+ * (`activateCatalogRevisionCandidate`, the guarded primitive) is refused.
+ * `reason` is a closed, low-cardinality union safe to use as a metric label;
+ * `incompatibilityReasons` is populated only when `reason === 'incompatible'`,
+ * carrying every applicable {@link WorkflowCompatibilityReason} — never the
+ * full compatibility verdict object.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowRevisionActivationRejectedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowRevisionActivationRejectedEvent.type, (event) => {
+ *   console.log('rejected:', event.workflowType, event.candidateRevision, event.reason);
+ * });
+ * ```
+ */
+export declare class WorkflowRevisionActivationRejectedEvent extends Event {
+    static readonly type: "catalog:activation-rejected";
+    readonly workflowType: string;
+    readonly candidateRevision: string;
+    readonly reason: 'incompatible' | 'stale-generation' | 'conflict' | 'expected-generation-required';
+    readonly incompatibilityReasons: readonly WorkflowCompatibilityReason[] | undefined;
+    constructor(workflowType: string, candidateRevision: string, reason: 'incompatible' | 'stale-generation' | 'conflict' | 'expected-generation-required', incompatibilityReasons?: readonly WorkflowCompatibilityReason[]);
+}
+/**
+ * Fired on the {@link Engine} alongside {@link WorkflowRevisionActivatedEvent}
+ * when activating a new revision displaces a previously active one for the
+ * same name. Never fired on a name's first-ever activation (there is
+ * nothing to drain).
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowRevisionDrainingEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowRevisionDrainingEvent.type, (event) => {
+ *   console.log('draining:', event.workflowType, event.revision);
+ * });
+ * ```
+ */
+export declare class WorkflowRevisionDrainingEvent extends Event {
+    static readonly type: "catalog:revision-draining";
+    readonly workflowType: string;
+    readonly revision: string;
+    constructor(workflowType: string, revision: string);
+}
+/**
+ * Fired on the {@link Engine} when a `(name, revision)` is durably removed
+ * from the workflow catalog via `removeWorkflowRevision`.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowRevisionRemovedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowRevisionRemovedEvent.type, (event) => {
+ *   console.log('removed:', event.workflowType, event.revision);
+ * });
+ * ```
+ */
+export declare class WorkflowRevisionRemovedEvent extends Event {
+    static readonly type: "catalog:revision-removed";
+    readonly workflowType: string;
+    readonly revision: string;
+    constructor(workflowType: string, revision: string);
+}

package/dist/core/events/catalog-events.js

@@ -0,0 +1,62 @@
+export class WorkflowRevisionInstalledEvent extends Event {
+  static type = "catalog:revision-installed";
+  workflowType;
+  revision;
+  constructor(workflowType, revision) {
+    super(WorkflowRevisionInstalledEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+  }
+}
+
+export class WorkflowRevisionActivatedEvent extends Event {
+  static type = "catalog:revision-activated";
+  workflowType;
+  revision;
+  generation;
+  previousRevision;
+  constructor(workflowType, revision, generation, previousRevision) {
+    super(WorkflowRevisionActivatedEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+    this.generation = generation;
+    this.previousRevision = previousRevision;
+  }
+}
+
+export class WorkflowRevisionActivationRejectedEvent extends Event {
+  static type = "catalog:activation-rejected";
+  workflowType;
+  candidateRevision;
+  reason;
+  incompatibilityReasons;
+  constructor(workflowType, candidateRevision, reason, incompatibilityReasons) {
+    super(WorkflowRevisionActivationRejectedEvent.type);
+    this.workflowType = workflowType;
+    this.candidateRevision = candidateRevision;
+    this.reason = reason;
+    this.incompatibilityReasons = incompatibilityReasons;
+  }
+}
+
+export class WorkflowRevisionDrainingEvent extends Event {
+  static type = "catalog:revision-draining";
+  workflowType;
+  revision;
+  constructor(workflowType, revision) {
+    super(WorkflowRevisionDrainingEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+  }
+}
+
+export class WorkflowRevisionRemovedEvent extends Event {
+  static type = "catalog:revision-removed";
+  workflowType;
+  revision;
+  constructor(workflowType, revision) {
+    super(WorkflowRevisionRemovedEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+  }
+}

package/dist/core/events/event-map.d.ts

@@ -1,11 +1,13 @@
 import type { ReviewCompletedEvent, ReviewRequestedEvent } from '../review/events.ts';
 import type { ActivityAsyncPendingEvent, ActivityCompletedEvent, ActivityFailedEvent, ActivityStartedEvent, TaskResultDeadLetteredEvent } from './activity-events.ts';
 import type { AttributesChangedEvent } from './attribute-events.ts';
+import type { WorkflowRevisionActivatedEvent, WorkflowRevisionActivationRejectedEvent, WorkflowRevisionDrainingEvent, WorkflowRevisionInstalledEvent, WorkflowRevisionRemovedEvent } from './catalog-events.ts';
 import type { ScheduleFiredEvent, ScheduleMissedFireEvent } from './schedule-events.ts';
 import type { SignalDeliveredEvent, SignalReceivedEvent } from './signal-events.ts';
 import type { AlertFiredEvent, AlertResolvedEvent, CheckpointSizeWarningEvent, CleanupWarningEvent, ConstraintViolatedEvent, DevelopmentWarningEvent, StorageSizeReportedEvent, WorkerConnectedEvent, WorkerDisconnectedEvent } from './system-events.ts';
 import type { UpdateCompletedEvent, UpdateReceivedEvent } from './update-events.ts';
 import type { WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowDefinitionRegisteredEvent, WorkflowFailedEvent, WorkflowRecoverySkippedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowSuspendedEvent, WorkflowTeardownEvent, WorkflowTimedOutEvent } from './workflow-events.ts';
+import type { WorkflowSourceLoadCancelledEvent, WorkflowSourceLoadFailedEvent, WorkflowSourceLoadReadyEvent, WorkflowSourceLoadStartedEvent } from './workflow-source-events.ts';
 /**
  * Record mapping each event-name string the {@link Engine} dispatches to its
  * corresponding typed `Event` subclass.
@@ -57,6 +59,15 @@ export type WeftEventMap = {
     'alert:fired': AlertFiredEvent;
     'alert:resolved': AlertResolvedEvent;
     'constraint:violated': ConstraintViolatedEvent;
+    'catalog:revision-installed': WorkflowRevisionInstalledEvent;
+    'catalog:revision-activated': WorkflowRevisionActivatedEvent;
+    'catalog:activation-rejected': WorkflowRevisionActivationRejectedEvent;
+    'catalog:revision-draining': WorkflowRevisionDrainingEvent;
+    'catalog:revision-removed': WorkflowRevisionRemovedEvent;
+    'workflow-source:load-started': WorkflowSourceLoadStartedEvent;
+    'workflow-source:load-ready': WorkflowSourceLoadReadyEvent;
+    'workflow-source:load-failed': WorkflowSourceLoadFailedEvent;
+    'workflow-source:load-cancelled': WorkflowSourceLoadCancelledEvent;
 };
 /**
  * Typed version of the `EventTarget` interface that constrains

package/dist/core/events/index.d.ts

@@ -1,8 +1,10 @@
 export * from './activity-events.ts';
 export * from './attribute-events.ts';
+export * from './catalog-events.ts';
 export * from './event-map.ts';
 export * from './schedule-events.ts';
 export * from './signal-events.ts';
 export * from './system-events.ts';
 export * from './update-events.ts';
 export * from './workflow-events.ts';
+export * from './workflow-source-events.ts';

package/dist/core/events/index.js

@@ -1,8 +1,10 @@
 export * from "./activity-events.js";
 export * from "./attribute-events.js";
+export * from "./catalog-events.js";
 export * from "./event-map.js";
 export * from "./schedule-events.js";
 export * from "./signal-events.js";
 export * from "./system-events.js";
 export * from "./update-events.js";
 export * from "./workflow-events.js";
+export * from "./workflow-source-events.js";

package/dist/core/events/workflow-source-events.d.ts

@@ -0,0 +1,102 @@
+import type { FailureCategory } from '../types/identity.ts';
+type WorkflowSourceKind = import('../source/index.ts').WorkflowSourceKind;
+/**
+ * Fired on the {@link Engine} when a dynamic workflow source's single-flight
+ * load for `(workflowType, revision)` starts — the loader is about to be
+ * invoked. Never fired for a cache hit (an already-installed revision
+ * `resolveWorkflowSource()` returns without invoking the loader).
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowSourceLoadStartedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowSourceLoadStartedEvent.type, (event) => {
+ *   console.log('loading:', event.workflowType, event.revision);
+ * });
+ * ```
+ */
+export declare class WorkflowSourceLoadStartedEvent extends Event {
+    static readonly type: "workflow-source:load-started";
+    readonly workflowType: string;
+    readonly revision: string;
+    readonly kind: WorkflowSourceKind;
+    constructor(workflowType: string, revision: string, kind: WorkflowSourceKind);
+}
+/**
+ * Fired on the {@link Engine} when a dynamic workflow source's load for
+ * `(workflowType, revision)` completes successfully — the loader ran,
+ * validation passed, and the manifest is durably installed.
+ * `loadDurationMs` is measured via the engine's own injected clock.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowSourceLoadReadyEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowSourceLoadReadyEvent.type, (event) => {
+ *   console.log('ready:', event.workflowType, event.revision, event.loadDurationMs);
+ * });
+ * ```
+ */
+export declare class WorkflowSourceLoadReadyEvent extends Event {
+    static readonly type: "workflow-source:load-ready";
+    readonly workflowType: string;
+    readonly revision: string;
+    readonly kind: WorkflowSourceKind;
+    readonly loadDurationMs: number;
+    constructor(workflowType: string, revision: string, kind: WorkflowSourceKind, loadDurationMs: number);
+}
+/**
+ * Fired on the {@link Engine} when a dynamic workflow source's load for
+ * `(workflowType, revision)` fails — the loader threw, validation rejected
+ * the loaded module, or the durable install failed. `failureCategory` is
+ * the closed, low-cardinality {@link FailureCategory} classification, safe
+ * to use as a metric label; the underlying error itself is never included.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowSourceLoadFailedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowSourceLoadFailedEvent.type, (event) => {
+ *   console.log('failed:', event.workflowType, event.revision, event.failureCategory);
+ * });
+ * ```
+ */
+export declare class WorkflowSourceLoadFailedEvent extends Event {
+    static readonly type: "workflow-source:load-failed";
+    readonly workflowType: string;
+    readonly revision: string;
+    readonly kind: WorkflowSourceKind;
+    readonly loadDurationMs: number;
+    readonly failureCategory: FailureCategory;
+    constructor(workflowType: string, revision: string, kind: WorkflowSourceKind, loadDurationMs: number, failureCategory: FailureCategory);
+}
+/**
+ * Fired on the {@link Engine} when the LAST outstanding
+ * `resolveWorkflowSource()` waiter for `(workflowType, revision)` releases
+ * (its own abort, or engine disposal) while the shared load is still
+ * unsettled. The shared load itself is never aborted — a fresh caller
+ * starting a new attempt for the same key re-fires
+ * {@link WorkflowSourceLoadStartedEvent}, not this event again for the
+ * orphaned attempt.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowSourceLoadCancelledEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowSourceLoadCancelledEvent.type, (event) => {
+ *   console.log('cancelled:', event.workflowType, event.revision);
+ * });
+ * ```
+ */
+export declare class WorkflowSourceLoadCancelledEvent extends Event {
+    static readonly type: "workflow-source:load-cancelled";
+    readonly workflowType: string;
+    readonly revision: string;
+    readonly kind: WorkflowSourceKind;
+    constructor(workflowType: string, revision: string, kind: WorkflowSourceKind);
+}
+export {};

package/dist/core/events/workflow-source-events.js

@@ -0,0 +1,57 @@
+export class WorkflowSourceLoadStartedEvent extends Event {
+  static type = "workflow-source:load-started";
+  workflowType;
+  revision;
+  kind;
+  constructor(workflowType, revision, kind) {
+    super(WorkflowSourceLoadStartedEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+    this.kind = kind;
+  }
+}
+
+export class WorkflowSourceLoadReadyEvent extends Event {
+  static type = "workflow-source:load-ready";
+  workflowType;
+  revision;
+  kind;
+  loadDurationMs;
+  constructor(workflowType, revision, kind, loadDurationMs) {
+    super(WorkflowSourceLoadReadyEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+    this.kind = kind;
+    this.loadDurationMs = loadDurationMs;
+  }
+}
+
+export class WorkflowSourceLoadFailedEvent extends Event {
+  static type = "workflow-source:load-failed";
+  workflowType;
+  revision;
+  kind;
+  loadDurationMs;
+  failureCategory;
+  constructor(workflowType, revision, kind, loadDurationMs, failureCategory) {
+    super(WorkflowSourceLoadFailedEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+    this.kind = kind;
+    this.loadDurationMs = loadDurationMs;
+    this.failureCategory = failureCategory;
+  }
+}
+
+export class WorkflowSourceLoadCancelledEvent extends Event {
+  static type = "workflow-source:load-cancelled";
+  workflowType;
+  revision;
+  kind;
+  constructor(workflowType, revision, kind) {
+    super(WorkflowSourceLoadCancelledEvent.type);
+    this.workflowType = workflowType;
+    this.revision = revision;
+    this.kind = kind;
+  }
+}

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

@@ -85,6 +85,13 @@ export interface ExecutionStrategy extends Disposable, AsyncDisposable {
     startWorkflow(parameters: {
         workflowId: string;
         workflowExecutionToken?: string;
+        /**
+         * The starting run's persisted `WorkflowState.revision` (WFT-20). Threaded
+         * through to the worker strategy's outbound echo/validation; an inline
+         * strategy accepts and ignores it — inline execution crosses no trust
+         * boundary this field needs to police.
+         */
+        revision?: string;
         workflowType: string;
         input: unknown;
         checkpoint: ArrayBuffer | Uint8Array;

package/dist/core/inline-execution-strategy.context-options.d.ts

@@ -11,7 +11,7 @@ import type { SearchAttributeSchema, WorkflowFunction } from './types.ts';
 import type { WorkflowLogRecord } from './types/workflow-log.ts';
 /** Capabilities the engine injects into the inline strategy at construction. */
 export interface InlineExecutionDependencies {
-    getRegistration: (workflowType: string) => {
+    getRegistration: (workflowType: string, workflowId: string) => {
         handler: WorkflowFunction;
         version: string;
         searchAttributes?: SearchAttributeSchema;

package/dist/core/inline-execution-strategy.js

@@ -30,7 +30,7 @@ export class InlineExecutionStrategy {
     this.#messageHandler = handler;
   }
   startWorkflow(parameters) {
-    const registration = this.#dependencies.getRegistration(parameters.workflowType);
+    const registration = this.#dependencies.getRegistration(parameters.workflowType, parameters.workflowId);
     if (!registration) {
       this.#emit({
         type: "failed",

package/dist/core/mailbox-admission.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Admission for the application command mailbox (WFT-84): validating an offered
+ * command, resolving its idempotency identity, enforcing backlog capacity, and
+ * committing the record with its indexes and fleet event.
+ *
+ * Admission is the one transition that also allocates: it advances the mailbox
+ * header's FIFO sequence and open count in the same conditional batch as the
+ * record itself, so backlog accounting can never drift from the records it
+ * describes.
+ *
+ * @module core/mailbox-admission
+ */
+import type { ApplicationCommandAdmission, ApplicationCommandInput, MailboxCapacity } from './mailbox-contract.ts';
+import { type MailboxRuntime } from './mailbox-internals.ts';
+/** Backlog accounting, shared by admission rejection and the public `capacity()`. */
+export declare function capacityOf(runtime: MailboxRuntime, open: number, admitted: number): MailboxCapacity;
+/**
+ * Offer a command to the mailbox.
+ *
+ * An exact retry of the same idempotency identity returns the original
+ * receipt without creating a second command. Reusing the key with a different
+ * caller, target, kind, or payload digest returns a conflict and leaves the
+ * original command untouched. A full backlog is rejected before anything is
+ * persisted.
+ */
+export declare function admitCommand(runtime: MailboxRuntime, command: ApplicationCommandInput): Promise<ApplicationCommandAdmission>;

package/dist/core/mailbox-admission.js

@@ -0,0 +1,130 @@
+import { computeIdentityDigest } from "./application-payload-digest.js";
+import {
+  encodeApplicationCommandIdempotencyRecord,
+  encodeApplicationReadyEntry
+} from "./mailbox-index-codec.js";
+import {
+  describeCommandTransition,
+  MailboxContentionError,
+  MAX_MAILBOX_TRANSITION_ATTEMPTS,
+  toApplicationCommandReceipt
+} from "./mailbox-internals.js";
+import {
+  commitMailboxTransition,
+  headerOperation,
+  loadCommand,
+  loadIdempotencyBinding,
+  loadMailboxHeader,
+  planCommandTransition
+} from "./mailbox-storage.js";
+import { createAdmittedCommandRecord } from "./mailbox-transitions.js";
+import { MAILBOX_RECORD_VERSION } from "./mailbox-types.js";
+import {
+  ApplicationCommandValidationError,
+  requireGeneratedIdentifier,
+  validateCommandInput
+} from "./mailbox-validation.js";
+import { PersistedDataCorruptError } from "./persisted-data-incompatible-error.js";
+export function capacityOf(runtime, open, admitted) {
+  const limit = runtime.policy.maxBacklog;
+  return Object.freeze({ open, limit, remaining: Math.max(0, limit - open), admitted });
+}
+export async function admitCommand(runtime, command) {
+  const input = await validateCommandInput(command, runtime.policy), identityDigest = await computeIdentityDigest([
+    input.caller,
+    input.target,
+    input.kind,
+    input.payloadDigest
+  ]);
+  for (let attempt = 1;attempt <= MAX_MAILBOX_TRANSITION_ATTEMPTS; attempt += 1) {
+    let expectedBinding = null;
+    if (input.idempotencyKey !== void 0) {
+      const resolved = await resolveIdempotency(runtime, input.idempotencyKey, identityDigest);
+      if (resolved.admission !== null)
+        return resolved.admission;
+      expectedBinding = resolved.staleBindingBytes;
+    }
+    const header = await loadMailboxHeader(runtime.storage, runtime.keys, runtime.policy.namespace, runtime.policy.resourceId);
+    if (header.record.openCount >= runtime.policy.maxBacklog)
+      return {
+        status: "rejected",
+        reason: "backlog-full",
+        capacity: capacityOf(runtime, header.record.openCount, header.record.admittedCount)
+      };
+    if (header.record.nextSequence >= Number.MAX_SAFE_INTEGER)
+      throw new ApplicationCommandValidationError("This mailbox has exhausted its FIFO sequence allocator; no further commands can be admitted under this namespace and resource id.");
+    const now = runtime.now(), record = createAdmittedCommandRecord(input, {
+      namespace: runtime.policy.namespace,
+      resourceId: runtime.policy.resourceId,
+      commandId: requireGeneratedIdentifier(runtime.generateId(), "commandId"),
+      sequence: header.record.nextSequence,
+      now
+    });
+    if (!await commitMailboxTransition(runtime.storage, runtime.events, planCommandTransition(runtime.keys, {
+      previous: null,
+      expectedBytes: null,
+      next: record,
+      event: describeCommandTransition(null, record),
+      now,
+      extraConditions: [
+        { key: runtime.keys.header, expectedValue: header.bytes },
+        ...input.idempotencyKey === void 0 ? [] : [
+          {
+            key: runtime.keys.idempotency(input.idempotencyKey),
+            expectedValue: expectedBinding
+          }
+        ]
+      ],
+      extraOperations: [
+        {
+          type: "put",
+          key: runtime.keys.bySequence(record.sequence),
+          value: encodeApplicationReadyEntry(record.commandId)
+        },
+        headerOperation(runtime.keys, {
+          ...header.record,
+          nextSequence: header.record.nextSequence + 1,
+          openCount: header.record.openCount + 1,
+          admittedCount: header.record.admittedCount + 1
+        }),
+        ...input.idempotencyKey === void 0 ? [] : [
+          {
+            type: "put",
+            key: runtime.keys.idempotency(input.idempotencyKey),
+            value: encodeApplicationCommandIdempotencyRecord({
+              recordVersion: MAILBOX_RECORD_VERSION,
+              commandId: record.commandId,
+              identityDigest
+            })
+          }
+        ]
+      ]
+    })))
+      continue;
+    return { status: "admitted", receipt: toApplicationCommandReceipt(record) };
+  }
+  throw new MailboxContentionError("admit", null);
+}
+async function resolveIdempotency(runtime, idempotencyKey, identityDigest) {
+  const binding = await loadIdempotencyBinding(runtime.storage, runtime.keys, idempotencyKey);
+  if (binding === null)
+    return { admission: null, staleBindingBytes: null };
+  const loaded = await loadCommand(runtime.storage, runtime.keys, binding.record.commandId);
+  if (loaded === null)
+    return { admission: null, staleBindingBytes: binding.bytes };
+  const ownDigest = await computeIdentityDigest([
+    loaded.record.caller,
+    loaded.record.target,
+    loaded.record.kind,
+    loaded.record.payloadDigest
+  ]);
+  if (loaded.record.idempotencyKey !== idempotencyKey || ownDigest !== binding.record.identityDigest)
+    throw new PersistedDataCorruptError(runtime.keys.idempotency(idempotencyKey));
+  const receipt = toApplicationCommandReceipt(loaded.record);
+  if (binding.record.identityDigest !== identityDigest)
+    return {
+      admission: { status: "conflict", receipt, reason: "idempotency-identity-mismatch" },
+      staleBindingBytes: null
+    };
+  return { admission: { status: "duplicate", receipt }, staleBindingBytes: null };
+}