@sentropic/artifacts 0.1.3 → 0.2.0

package/dist/server/service.d.ts

@@ -1,11 +1,18 @@
 import type { ServerPorts } from './ports.js';
+import { type CompiledArtifactsProfile } from '../profile/index.js';
+import { type ArtifactKeyDerivationBinding } from './command-identity.js';
+import type { ArtifactInvocationContext, ArtifactCommitCoordinator, FinalizeTxClient, InternalIdempotencyKey } from './commit/types.js';
+import type { ArtifactOutcome } from './failures.js';
 export interface EnsurePrivateViewInput {
     actorUserId: string;
     ownerId: string;
     storageScopeId: string;
     bindingName: string;
     idempotencyKey: string;
-    paramsHash: string;
+    /** @deprecated Ignored; the service computes its own hash. */
+    paramsHash?: string;
+    /** Validated provider parameters supplied by the application layer. */
+    parameters?: Record<string, string | number | boolean | null>;
 }
 export interface EnsurePrivateViewResult {
     artifactId: string;
@@ -17,3 +24,59 @@ export interface ArtifactService {
 }
 /** Create the artifact service over explicit injected ports (no defaults). */
 export declare function createArtifactService(ports: ServerPorts): ArtifactService;
+/**
+ * L5 (immo #861) — coordinator-bound ensure (spec r2 §§3.1 A1-A8, 3.2).
+ *
+ * The legacy split finalizer above stays intact for the L6-owned HTTP and
+ * MCP consumers; L6 removes it during transport wiring. This composition is
+ * the only guarded ensure path: closed profile validation, server-derived
+ * command identity (never a caller hash or scope), request-bound guard
+ * invoked after all waits inside one atomic unit, typed outcomes shared
+ * with the failure projection. Unknown legacy codecs propagate as
+ * quarantine for the L6 migration projection.
+ */
+export interface GuardedEnsureArgs {
+    readonly bindingName: string;
+    readonly parameters?: Record<string, string | number | boolean | null>;
+    readonly idempotencyKey: string;
+    readonly envelopeKey?: string;
+}
+export interface GuardedEnsureResult {
+    readonly artifactId: string;
+    readonly created: boolean;
+    readonly replayed: boolean;
+}
+/** Binding identity resolved inside the finalization unit. */
+export interface EnsureBindingInput {
+    readonly ownerId: string;
+    readonly storageScopeId: string;
+    readonly bindingName: string;
+    readonly attemptId: string;
+}
+export interface EnsureBindingReceipt {
+    readonly artifactId: string;
+    readonly created: boolean;
+}
+/** Host-owned ensure effects inside the coordinator transaction. */
+export interface GuardedEnsureHost {
+    lockBinding(client: FinalizeTxClient, binding: EnsureBindingInput): Promise<void>;
+    resolveBinding(client: FinalizeTxClient, binding: EnsureBindingInput): Promise<EnsureBindingReceipt>;
+    abandonAttempt(attemptId: string): Promise<void>;
+    readPolicyRevision(): Promise<string>;
+}
+export interface GuardedEnsureDeps {
+    readonly profile: CompiledArtifactsProfile;
+    readonly coordinator: ArtifactCommitCoordinator;
+    readonly derivation: ArtifactKeyDerivationBinding;
+    readonly host: GuardedEnsureHost;
+}
+export interface GuardedReplayArgs {
+    readonly internalKey: InternalIdempotencyKey;
+    readonly commandHash: string;
+    readonly binding?: EnsureBindingInput;
+}
+export interface GuardedEnsureService {
+    ensure(invocation: ArtifactInvocationContext, args: GuardedEnsureArgs): Promise<ArtifactOutcome<GuardedEnsureResult>>;
+    replay(invocation: ArtifactInvocationContext, args: GuardedReplayArgs): Promise<ArtifactOutcome<GuardedEnsureResult>>;
+}
+export declare function createGuardedEnsureService(deps: GuardedEnsureDeps): GuardedEnsureService;

package/dist/server/service.js

@@ -10,6 +10,10 @@
 import { assertArtifactAccess } from './authorization.js';
 import { createBindingService } from './bindings.js';
 import { createIdempotencyStore } from './idempotency.js';
+import { manifestDigest } from '../codecs.js';
+import { ArtifactProfileInputError } from '../profile/index.js';
+import { createArtifactCommand, } from './command-identity.js';
+import { projectEnsureReceipt, replayEnsureGuarded, } from './authorized-replay.js';
 /** Create the artifact service over explicit injected ports (no defaults). */
 export function createArtifactService(ports) {
     const bindings = createBindingService(ports.kv, ports.uuid);
@@ -21,7 +25,11 @@ export function createArtifactService(ports) {
                 artifactOwnerId: input.ownerId,
                 action: 'mutate',
             });
-            const { result, replayed } = await idempotent.execute(input.idempotencyKey, input.paramsHash, () => bindings.ensure({
+            const { result, replayed } = await idempotent.execute(JSON.stringify(['ensure', input.actorUserId, input.idempotencyKey]), manifestDigest({
+                schemaVersion: 'artifacts/v1', ownerId: input.ownerId,
+                storageScopeId: input.storageScopeId, bindingName: input.bindingName,
+                parameters: input.parameters ?? {},
+            }), () => bindings.ensure({
                 ownerId: input.ownerId,
                 storageScopeId: input.storageScopeId,
                 bindingName: input.bindingName,
@@ -30,3 +38,181 @@ export function createArtifactService(ports) {
         },
     };
 }
+/** Private causes stay on the failure object but never serialize: projection picks fields. */
+const conceal = (failure) => {
+    Object.defineProperty(failure, 'cause', { value: failure.cause, enumerable: false });
+    return Object.freeze(failure);
+};
+const profileEntryFailure = (error, invocationId) => {
+    if (error.kind === 'operational') {
+        return conceal({
+            kind: 'operational', category: 'capability_unselected', variant: error.variant,
+            httpStatus: error.httpStatus, publicCode: error.publicCode, retriable: false,
+            invocationId, operation: 'ensure', phase: error.phase, commitState: 'not_committed', cause: error,
+        });
+    }
+    return conceal({
+        kind: 'ordinary', category: 'invalid_request',
+        httpStatus: error.httpStatus, publicCode: error.publicCode, retriable: false,
+        invocationId, operation: 'ensure', phase: error.phase, commitState: 'not_committed', cause: error,
+    });
+};
+const internalFailure = (invocationId, phase, cause) => conceal({
+    kind: 'operational', category: 'provider_error', variant: 'unclassified',
+    httpStatus: 500, publicCode: 'internal_error', retriable: false,
+    invocationId, operation: 'ensure', phase, commitState: 'not_committed', cause,
+});
+const unavailableFailure = (invocationId, phase, cause) => conceal({
+    kind: 'operational', category: 'provider_unavailable', variant: 'dispatch_failure',
+    httpStatus: 503, publicCode: 'capability_unavailable', retriable: true,
+    invocationId, operation: 'ensure', phase, commitState: 'not_committed', cause,
+});
+const anonymousFailure = (invocation) => conceal({
+    kind: 'admission', category: 'anonymous',
+    httpStatus: 401, publicCode: 'anonymous', retriable: false,
+    invocationId: invocation.invocationId, operation: 'ensure', phase: 'admit',
+    commitState: 'not_committed', cause: { invocation: invocation.invocationId },
+});
+const coordinatorFailure = (failure) => conceal({
+    kind: 'operational', category: failure.category, variant: failure.variant,
+    httpStatus: failure.httpStatus, publicCode: failure.publicCode, retriable: failure.retriable,
+    invocationId: failure.invocationId, operation: failure.operation, phase: failure.phase,
+    commitState: failure.commitState, cause: failure.cause,
+});
+const ensureResult = (receipt, replayed, invocationId) => ({
+    ok: true,
+    result: { artifactId: receipt.artifactId, created: receipt.created, replayed },
+    invocationId,
+    commitState: 'committed',
+    replayed,
+});
+export function createGuardedEnsureService(deps) {
+    const finalizeRequest = (invocation, command, policyRevision) => {
+        const binding = {
+            ownerId: invocation.actorId,
+            storageScopeId: invocation.storageScopeId,
+            bindingName: command.payload.bindingName,
+            attemptId: invocation.invocationId,
+        };
+        const captured = {};
+        const request = {
+            scopeId: invocation.storageScopeId,
+            internalKey: command.identity.internalKey,
+            commandHash: command.identity.commandHash,
+            codecVersion: command.identity.codecVersion,
+            invocationId: invocation.invocationId,
+            actorId: invocation.actorId,
+            operation: 'ensure',
+            get artifactId() { return captured.artifactId ?? null; },
+            bindingName: binding.bindingName,
+            policyRevision,
+            locks: { 'binding-identity': [async (client) => {
+                        await deps.host.lockBinding(client, binding);
+                        const receipt = await deps.host.resolveBinding(client, binding);
+                        captured.artifactId = receipt.artifactId;
+                        captured.created = receipt.created;
+                    }] },
+            validateReplayReceipt: (receipt) => captured.created === false &&
+                projectEnsureReceipt(receipt).artifactId === captured.artifactId,
+            noteAbandonedAttempt: (attemptId) => deps.host.abandonAttempt(attemptId),
+            attemptId: invocation.invocationId,
+            guard: invocation.authorizeCommit,
+            receiptData: captured,
+        };
+        return { request, captured };
+    };
+    return {
+        async ensure(invocation, args) {
+            if (invocation.actorId.length === 0 || invocation.storageScopeId.length === 0) {
+                return { ok: false, failure: anonymousFailure(invocation) };
+            }
+            let command;
+            try {
+                const { envelopeKey, ...commandArgs } = args;
+                command = createArtifactCommand(deps.profile, 'artifacts_ensure', commandArgs, { storageScopeId: invocation.storageScopeId, actorId: invocation.actorId }, deps.derivation, envelopeKey);
+            }
+            catch (error) {
+                if (error instanceof ArtifactProfileInputError) {
+                    return { ok: false, failure: profileEntryFailure(error, invocation.invocationId) };
+                }
+                return { ok: false, failure: internalFailure(invocation.invocationId, 'entry', error) };
+            }
+            let policyRevision;
+            try {
+                policyRevision = await deps.host.readPolicyRevision();
+            }
+            catch (error) {
+                return { ok: false, failure: unavailableFailure(invocation.invocationId, 'acquire', error) };
+            }
+            const { request } = finalizeRequest(invocation, command, policyRevision);
+            const outcome = await deps.coordinator.finalizePrepared(request);
+            if (!outcome.ok)
+                return { ok: false, failure: coordinatorFailure(outcome.failure) };
+            let receipt;
+            try {
+                receipt = projectEnsureReceipt(outcome.result);
+            }
+            catch (error) {
+                return { ok: false, failure: internalFailure(invocation.invocationId, 'resolve', error) };
+            }
+            return ensureResult(receipt, outcome.replayed, outcome.invocationId);
+        },
+        async replay(invocation, args) {
+            if (invocation.actorId.length === 0 || invocation.storageScopeId.length === 0) {
+                return { ok: false, failure: anonymousFailure(invocation) };
+            }
+            try {
+                deps.profile.assertSelected('artifacts_ensure');
+                if (!args.binding || args.binding.ownerId !== invocation.actorId ||
+                    args.binding.storageScopeId !== invocation.storageScopeId || !args.binding.bindingName) {
+                    throw new ArtifactProfileInputError();
+                }
+            }
+            catch (error) {
+                if (error instanceof ArtifactProfileInputError) {
+                    return { ok: false, failure: profileEntryFailure(error, invocation.invocationId) };
+                }
+                return { ok: false, failure: internalFailure(invocation.invocationId, 'entry', error) };
+            }
+            let policyRevision;
+            try {
+                policyRevision = await deps.host.readPolicyRevision();
+            }
+            catch (error) {
+                return { ok: false, failure: unavailableFailure(invocation.invocationId, 'acquire', error) };
+            }
+            let artifactId;
+            let missingTarget = false;
+            const binding = args.binding;
+            const outcome = await replayEnsureGuarded(deps.coordinator, {
+                invocation,
+                internalKey: args.internalKey,
+                commandHash: args.commandHash,
+                policyRevision,
+                get artifactId() { return artifactId; },
+                bindingName: binding?.bindingName,
+                validateReplayReceipt: (receipt) => !missingTarget &&
+                    projectEnsureReceipt(receipt).artifactId === artifactId,
+                noteAbandonedAttempt: (attemptId) => deps.host.abandonAttempt(attemptId),
+                locks: binding === undefined ? undefined : {
+                    'binding-identity': [async (client) => {
+                            await deps.host.lockBinding(client, binding);
+                            const target = await deps.host.resolveBinding(client, binding);
+                            missingTarget = target.created;
+                            artifactId = target.artifactId;
+                        }],
+                },
+            });
+            if (!outcome.ok)
+                return { ok: false, failure: coordinatorFailure(outcome.failure) };
+            let receipt;
+            try {
+                receipt = projectEnsureReceipt(outcome.result);
+            }
+            catch (error) {
+                return { ok: false, failure: internalFailure(invocation.invocationId, 'resolve', error) };
+            }
+            return ensureResult(receipt, outcome.replayed, outcome.invocationId);
+        },
+    };
+}

package/dist/server/uploads.d.ts

@@ -20,10 +20,13 @@ export interface UploadService {
     begin(input: BeginUploadInput): Promise<{
         uploadId: string;
     }>;
+    /** Check that the session is open and optionally validate its sequential offset before decoding. */
+    remainingBytes(uploadId: string, offset?: number): number;
     append(uploadId: string, offset: number, chunk: Uint8Array): Promise<{
         size: number;
     }>;
-    commit(uploadId: string, expected: BlobRef): Promise<BlobRef>;
+    /** Validate the commit snapshot before consuming the session; rejected validation remains retryable. */
+    commit(uploadId: string, expected: BlobRef, validate?: (bytes: Uint8Array) => void): Promise<BlobRef>;
 }
 /** Create an upload service over an injected staging store (no S3 imports). */
 export declare function createUploadService(staging: StagingStore, options: UploadServiceOptions, ids?: () => string): UploadService;

package/dist/server/uploads.js

@@ -33,54 +33,82 @@ export function createMemoryStaging() {
 }
 /** Create an upload service over an injected staging store (no S3 imports). */
 export function createUploadService(staging, options, ids = () => crypto.randomUUID()) {
+    if (!Number.isSafeInteger(options.maxUploadBytes) || options.maxUploadBytes < 1) {
+        throw new Error('invalid upload byte budget');
+    }
     const sessions = new Map();
+    function openSession(uploadId) {
+        const session = sessions.get(uploadId);
+        if (session === undefined)
+            throw new Error(`unknown upload: ${uploadId}`);
+        if (session.committed)
+            throw new Error(`upload already committed: ${uploadId}`);
+        if (session.busy)
+            throw new Error(`upload conflict: operation in progress for ${uploadId}`);
+        return session;
+    }
+    async function exclusive(uploadId, run) {
+        const session = openSession(uploadId);
+        session.busy = true;
+        try {
+            return await run(session);
+        }
+        finally {
+            session.busy = false;
+        }
+    }
+    function remainingBytes(uploadId, offset) {
+        const session = openSession(uploadId);
+        if (offset !== undefined && (!Number.isSafeInteger(offset) || offset !== session.size)) {
+            throw new Error(`upload offset mismatch for ${uploadId}: expected ${session.size}, got ${offset}`);
+        }
+        return session.maxSize - session.size;
+    }
     return {
+        remainingBytes,
         async begin(input) {
+            if (input.maxSize !== undefined && (!Number.isSafeInteger(input.maxSize) || input.maxSize < 1)) {
+                throw new Error('invalid upload byte budget');
+            }
             const uploadId = ids();
             sessions.set(uploadId, {
                 committed: false,
-                maxSize: input.maxSize ?? options.maxUploadBytes,
+                busy: false,
+                maxSize: Math.min(input.maxSize ?? options.maxUploadBytes, options.maxUploadBytes),
                 size: 0,
             });
             await staging.write(uploadId, new Uint8Array(0));
             return { uploadId };
         },
         async append(uploadId, offset, chunk) {
-            const session = sessions.get(uploadId);
-            if (session === undefined)
-                throw new Error(`unknown upload: ${uploadId}`);
-            if (session.committed)
-                throw new Error(`upload already committed: ${uploadId}`);
-            if (offset !== session.size) {
-                throw new Error(`upload offset mismatch for ${uploadId}: expected ${session.size}, got ${offset}`);
-            }
-            if (session.size + chunk.length > session.maxSize) {
-                throw new Error(`upload budget exceeded for ${uploadId}: max ${session.maxSize} bytes`);
-            }
-            const current = await staging.read(uploadId);
-            const next = new Uint8Array(current.length + chunk.length);
-            next.set(current, 0);
-            next.set(chunk, current.length);
-            await staging.write(uploadId, next);
-            session.size = next.length;
-            return { size: session.size };
+            const remaining = remainingBytes(uploadId, offset);
+            return exclusive(uploadId, async (session) => {
+                if (chunk.length > remaining) {
+                    throw new Error(`upload budget exceeded for ${uploadId}: max ${session.maxSize} bytes`);
+                }
+                const current = await staging.read(uploadId);
+                const next = new Uint8Array(current.length + chunk.length);
+                next.set(current, 0);
+                next.set(chunk, current.length);
+                await staging.write(uploadId, next);
+                session.size = next.length;
+                return { size: session.size };
+            });
         },
-        async commit(uploadId, expected) {
-            const session = sessions.get(uploadId);
-            if (session === undefined)
-                throw new Error(`unknown upload: ${uploadId}`);
-            if (session.committed)
-                throw new Error(`upload already committed: ${uploadId}`);
-            const bytes = await staging.read(uploadId);
-            if (bytes.length !== expected.size) {
-                throw new Error(`upload size mismatch for ${uploadId}: staged ${bytes.length}, declared ${expected.size}`);
-            }
-            const actual = `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
-            if (actual !== expected.digest) {
-                throw new Error(`upload digest mismatch for ${uploadId}: staged ${actual}`);
-            }
-            session.committed = true;
-            return { digest: actual, size: bytes.length };
+        async commit(uploadId, expected, validate) {
+            return exclusive(uploadId, async (session) => {
+                const bytes = new Uint8Array(await staging.read(uploadId));
+                validate?.(bytes);
+                if (bytes.length !== expected.size) {
+                    throw new Error(`upload size mismatch for ${uploadId}: staged ${bytes.length}, declared ${expected.size}`);
+                }
+                const actual = `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+                if (actual !== expected.digest) {
+                    throw new Error(`upload digest mismatch for ${uploadId}: staged ${actual}`);
+                }
+                session.committed = true;
+                return { digest: actual, size: bytes.length };
+            });
         },
     };
 }

package/dist/testing.d.ts

@@ -0,0 +1,50 @@
+/**
+ * L3 (immo #861) — test-only commit barrier (spec r2 §3.2).
+ *
+ * Test seam for pausing finalization at deterministic points with
+ * invocation correlation. `waitUntilReached` resolves after arrival;
+ * `release` resumes only that invocation/point pair. The coordinator
+ * rechecks authority after a resumed barrier; a barrier can never mark
+ * an operation authorized or successful.
+ *
+ * Pass `observer` as the coordinator `testObserver`. Register a wait before
+ * starting the operation to pause that invocation/point; other arrivals
+ * are observed without blocking. The three preparation points are fired by L4
+ * preparation adapters holding this same observer, never by the
+ * coordinator (arming one throws at construction).
+ */
+import type { InspectableDeletionClaimStore } from './server/gc.js';
+import type { PublicationBlobStore } from './server/publication.js';
+export declare const COMMIT_BARRIER_POINTS: readonly ["before_connection_acquire", "before_key_lock", "before_blob_put", "after_blob_put_before_verify", "before_blob_readback", "before_finalization_row_lock", "after_finalization_locks_before_guard", "after_replay_lookup_before_guard", "before_commit"];
+export type CommitBarrierPoint = (typeof COMMIT_BARRIER_POINTS)[number];
+export type CommitBarrierObserver = (point: CommitBarrierPoint, invocationId: string) => Promise<void>;
+export interface CommitArrivalObserver {
+    arrive(point: CommitBarrierPoint, invocationId: string): void;
+}
+/** Explicit host binding: purge must use the supplied deletion adapter for this call only. */
+export interface PurgeTestHost {
+    readonly claims: InspectableDeletionClaimStore;
+    readonly storageScopeId: string;
+    readonly blobs: PublicationBlobStore;
+    purge(artifactId: string, deleting: PublicationBlobStore): Promise<void>;
+}
+export declare function inspectDeletionClaims(host: Pick<PurgeTestHost, 'claims' | 'storageScopeId'>): Promise<Array<{
+    claimId: string;
+    state: string;
+    blobKeys: string[];
+}>>;
+/** Start one correlated purge and pause immediately before its first external DELETE. */
+export declare function pausePurgeBeforeDelete(host: PurgeTestHost, artifactId: string): Promise<{
+    claimId: string;
+    blobKeys: string[];
+    release(): void;
+    finished: Promise<void>;
+}>;
+/** Create a correlated test barrier for one finalization run. */
+export declare function createArtifactCommitBarrier(options?: {
+    readonly points: readonly CommitBarrierPoint[];
+}): {
+    observer: CommitBarrierObserver & CommitArrivalObserver;
+    waitUntilReached(point: CommitBarrierPoint, invocationId: string): Promise<void>;
+    release(point: CommitBarrierPoint, invocationId: string): void;
+};

package/dist/testing.js

@@ -0,0 +1,86 @@
+export const COMMIT_BARRIER_POINTS = [
+    'before_connection_acquire',
+    'before_key_lock',
+    'before_blob_put',
+    'after_blob_put_before_verify',
+    'before_blob_readback',
+    'before_finalization_row_lock',
+    'after_finalization_locks_before_guard',
+    'after_replay_lookup_before_guard',
+    'before_commit',
+];
+export async function inspectDeletionClaims(host) {
+    return (await host.claims.listClaims()).map((claim) => ({ claimId: claim.claimId, state: claim.state,
+        blobKeys: [`artifacts/${host.storageScopeId}/blobs/sha256/${claim.digest.slice(7)}`] }));
+}
+/** Start one correlated purge and pause immediately before its first external DELETE. */
+export async function pausePurgeBeforeDelete(host, artifactId) {
+    let release;
+    const gate = new Promise((resolve) => { release = resolve; });
+    let reached;
+    let fail;
+    const arrival = new Promise((resolve, reject) => {
+        reached = resolve;
+        fail = reject;
+    });
+    const deleting = { ...host.blobs,
+        putBlob: (key, bytes) => host.blobs.putBlob(key, bytes),
+        getBlob: (key) => host.blobs.getBlob(key), listKeys: (prefix) => host.blobs.listKeys(prefix),
+        async deleteBlob(key) {
+            const claims = (await host.claims.listClaims()).filter((claim) => claim.holder === `purge:${artifactId}` && claim.state === 'pending');
+            const matching = claims.find((claim) => key.endsWith(`/sha256/${claim.digest.slice(7)}`));
+            if (matching === undefined)
+                return host.blobs.deleteBlob(key);
+            reached({ claimId: matching.claimId,
+                blobKeys: claims.map((claim) => `artifacts/${host.storageScopeId}/blobs/sha256/${claim.digest.slice(7)}`) });
+            await gate;
+            await host.blobs.deleteBlob(key);
+        },
+    };
+    const finished = host.purge(artifactId, deleting);
+    void finished.then(() => fail(new Error('purge finished without external DELETE')), fail);
+    return { ...await arrival, release, finished };
+}
+/** Create a correlated test barrier for one finalization run. */
+export function createArtifactCommitBarrier(options) {
+    const gates = new Map();
+    const gateFor = (point, invocationId) => {
+        const key = `${point}:${invocationId}`;
+        const existing = gates.get(key);
+        if (existing !== undefined)
+            return existing;
+        const created = { arrivals: 0, armed: options?.points.includes(point) ?? false, waiters: [], releases: [] };
+        gates.set(key, created);
+        return created;
+    };
+    const arrive = (point, invocationId) => {
+        const gate = gateFor(point, invocationId);
+        gate.arrivals += 1;
+        for (const waiter of gate.waiters.splice(0))
+            waiter();
+        if (!gate.armed)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            gate.releases.push(resolve);
+        });
+    };
+    return {
+        observer: Object.assign(arrive, { arrive }),
+        waitUntilReached: (point, invocationId) => {
+            const gate = gateFor(point, invocationId);
+            if (gate.arrivals > 0)
+                return Promise.resolve();
+            gate.armed = true;
+            return new Promise((resolve) => {
+                gate.waiters.push(resolve);
+            });
+        },
+        release: (point, invocationId) => {
+            const gate = gateFor(point, invocationId);
+            const resume = gate.releases.shift();
+            if (resume === undefined)
+                throw new Error(`no paused barrier at ${point} for ${invocationId}`);
+            resume();
+        },
+    };
+}