@bastani/atomic 0.9.16-alpha.1 → 0.9.16-alpha.3

package/dist/builtin/workflows/src/durable/dbos-status-transition.ts

@@ -1,67 +0,0 @@
-import type { DbosMetadataClassification } from "./dbos-metadata.js";
-import type { DurableWorkflowHandle, DurableWorkflowMetadata, DurableWorkflowStatus } from "./types.js";
-import { isAbsorbingDurableStatus } from "./workflow-status-transition.js";
-
-interface DbosStatusTransitionInput {
-	readonly expectedStatuses: readonly DurableWorkflowStatus[];
-	readonly status: DurableWorkflowStatus;
-	readonly flush: () => Promise<void>;
-	readonly read: () => Promise<DbosMetadataClassification>;
-	readonly local: () => DurableWorkflowHandle | undefined;
-	readonly reconcile: (metadata: DurableWorkflowMetadata) => void;
-	/** Atomically claim this generation's transition against concurrent processes. */
-	readonly claim?: (authoritative: DurableWorkflowMetadata, generation: number) => Promise<boolean>;
-	readonly write: () => Promise<void>;
-}
-
-/**
- * Serialize local writes around authoritative generations and verify the
- * persisted result. DBOS metadata classification makes terminal generations
- * absorbing, so a stale nonterminal append cannot reopen a completed run.
- * The optional claim step makes the read→write window safe across processes:
- * every racer that observed the same generation competes for one durable
- * first-writer-wins record before it may write.
- */
-export async function transitionDbosWorkflowStatus(input: DbosStatusTransitionInput): Promise<boolean> {
-	await input.flush();
-	const authoritative = await input.read();
-	const local = input.local();
-	if (
-		local === undefined ||
-		authoritative.kind !== "current" ||
-		!input.expectedStatuses.includes(authoritative.metadata.status)
-	) {
-		if (authoritative.kind === "current") input.reconcile(authoritative.metadata);
-		return false;
-	}
-
-	if (input.claim !== undefined && !(await input.claim(authoritative.metadata, authoritative.generation))) {
-		const current = await input.read();
-		if (current.kind === "current") input.reconcile(current.metadata);
-		return false;
-	}
-
-	try {
-		await input.write();
-	} catch (error) {
-		const persisted = await input.read();
-		if (persisted.kind === "current" && persisted.metadata.status === input.status) {
-			input.reconcile(persisted.metadata);
-			return true;
-		}
-		if (
-			persisted.kind === "current" &&
-			isAbsorbingDurableStatus(persisted.metadata.status, persisted.metadata.resumable)
-		) {
-			input.reconcile(persisted.metadata);
-			return false;
-		}
-		throw error;
-	}
-	const persisted = await input.read();
-	if (persisted.kind !== "current" || persisted.metadata.status !== input.status) {
-		if (persisted.kind === "current") input.reconcile(persisted.metadata);
-		return false;
-	}
-	return true;
-}

package/dist/builtin/workflows/src/durable/dbos-tombstone.ts

@@ -1,27 +0,0 @@
-import type { WorkflowSerializableValue } from "../shared/types.js";
-import type { DbosStepRecord } from "./dbos-backend.js";
-import { DURABLE_FORMAT_VERSION, isCurrentDurableFormat } from "./format-version.js";
-
-export const DBOS_DELETION_STEP = "__atomic_deleted";
-
-export type DbosDeletionCompatibility = "current" | "unknown" | "absent";
-
-export function encodeDbosDeletionTombstone(workflowId: string): WorkflowSerializableValue {
-	return {
-		__atomicDurableDeleted: true,
-		version: DURABLE_FORMAT_VERSION,
-		workflowId,
-	};
-}
-
-export function classifyDbosDeletionTombstone(
-	records: readonly DbosStepRecord[],
-	workflowId: string,
-): DbosDeletionCompatibility {
-	const record = records.find((candidate) => candidate.stepName === DBOS_DELETION_STEP);
-	if (record === undefined) return "absent";
-	if (typeof record.output !== "object" || record.output === null || Array.isArray(record.output)) return "unknown";
-	const raw = record.output as Record<string, WorkflowSerializableValue>;
-	if (raw.__atomicDurableDeleted !== true || raw.workflowId !== workflowId) return "unknown";
-	return isCurrentDurableFormat(raw.version) ? "current" : "unknown";
-}

package/dist/builtin/workflows/src/durable/durable-hash.ts

@@ -1,18 +0,0 @@
-import { createHash } from "node:crypto";
-import type { WorkflowSerializableValue } from "../shared/types.js";
-import type { WorkflowSerializableObject } from "./types.js";
-
-/** Compute a collision-resistant digest over canonical JSON. */
-export function durableHash(value: WorkflowSerializableValue | WorkflowSerializableObject): string {
-	const canonical = canonicalJsonString(value);
-	const digest = createHash("sha256").update(canonical).digest("hex");
-	return `h${digest.slice(0, 32)}`;
-}
-
-function canonicalJsonString(value: WorkflowSerializableValue): string {
-	if (value === null || typeof value !== "object") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(canonicalJsonString).join(",")}]`;
-	const object = value as WorkflowSerializableObject;
-	const keys = Object.keys(object).sort();
-	return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJsonString(object[key]!)}`).join(",")}}`;
-}

package/dist/builtin/workflows/src/durable/factory.ts

@@ -1,93 +0,0 @@
-/** DBOS-first durable backend factory with a non-durable last-resort fallback. */
-
-import { type DurableWorkflowBackend, InMemoryDurableBackend } from "./backend.js";
-import {
-	DbosNotReadyError,
-	DbosShutdownError,
-	dbosLifecycleState,
-	getReadyDbosBackend,
-	getReadyDbosBackendSync,
-} from "./dbos-lifecycle.js";
-import { classifyDbosDurabilityFailure, readDbosFailureDetail } from "./dbos-registration-diagnostics.js";
-
-let injectedBackend: DurableWorkflowBackend | undefined;
-let initializedBackend: DurableWorkflowBackend | undefined;
-let initializing: Promise<DurableWorkflowBackend> | undefined;
-
-/**
- * A memoized backend is only reusable while its lifecycle generation is
- * healthy. The in-memory degraded backend has no external lifecycle; a
- * persistent (DBOS) backend is usable only while the process-scoped DBOS
- * executor is still `ready` — never after shutdown.
- */
-function isMemoizedBackendUsable(backend: DurableWorkflowBackend): boolean {
-	return !backend.persistent || dbosLifecycleState() === "ready";
-}
-
-/** Return the injected test backend or the process-wide initialized backend. */
-export function getDurableBackend(): DurableWorkflowBackend {
-	const memoized =
-		initializedBackend !== undefined && isMemoizedBackendUsable(initializedBackend) ? initializedBackend : undefined;
-	const backend = injectedBackend ?? memoized ?? getReadyDbosBackendSync();
-	if (backend === undefined) throw new DbosNotReadyError();
-	return backend;
-}
-
-/** Internal injection seam. Production initialization uses DBOS. */
-export function setDurableBackend(backend: DurableWorkflowBackend | undefined): void {
-	injectedBackend = backend;
-	if (backend === undefined) {
-		initializedBackend = undefined;
-		initializing = undefined;
-	}
-}
-
-/** Create an isolated current-interface backend for tests only. */
-export function createInMemoryTestBackend(): InMemoryDurableBackend {
-	return new InMemoryDurableBackend();
-}
-
-/**
- * Configure, register, launch, and install the DBOS backend.
- *
- * When no durable backend can be provisioned (no `DBOS_SYSTEM_DATABASE_URL`,
- * embedded Postgres unavailable — e.g. running as root without an
- * unprivileged account — and no Docker), workflows degrade to a process-local
- * in-memory backend with a loud warning instead of refusing to run at all.
- * Non-durable runs execute normally but do not survive the process:
- * `/workflow resume` after exit has nothing to restore.
- */
-export async function initializeDurableBackend(): Promise<DurableWorkflowBackend> {
-	if (injectedBackend !== undefined) return injectedBackend;
-	if (initializedBackend !== undefined) {
-		if (isMemoizedBackendUsable(initializedBackend)) return initializedBackend;
-		// Never hand out a backend from a stopped lifecycle generation.
-		initializedBackend = undefined;
-		initializing = undefined;
-	}
-	initializing ??= getReadyDbosBackend()
-		.catch(async (error: unknown) => {
-			if (error instanceof DbosShutdownError) throw error;
-			return await degradeToNonDurableBackend(error);
-		})
-		.then((backend) => {
-			initializedBackend = backend;
-			return backend;
-		});
-	return await initializing;
-}
-
-async function degradeToNonDurableBackend(error: unknown): Promise<DurableWorkflowBackend> {
-	const detail = readDbosFailureDetail(error);
-	const kind = await classifyDbosDurabilityFailure(error);
-	const restore =
-		kind === "duplicate_registration"
-			? `Restore durability by resolving the duplicate DBOS operation registration: ${detail}`
-			: `Restore durability by fixing Postgres provisioning: ${detail}`;
-	console.error(
-		"atomic-workflows: durable backend unavailable — continuing NON-DURABLY with an in-memory backend. " +
-			"Workflow runs will execute, but their state will not survive this process and `/workflow resume` " +
-			`after exit will not work. ${restore}`,
-	);
-	return new InMemoryDurableBackend();
-}

package/dist/builtin/workflows/src/durable/format-version.ts

@@ -1,6 +0,0 @@
-/** Single current schema version for DBOS workflow state and metadata. */
-export const DURABLE_FORMAT_VERSION = 3 as const;
-
-export function isCurrentDurableFormat(value: unknown): boolean {
-	return value === DURABLE_FORMAT_VERSION;
-}

package/dist/builtin/workflows/src/durable/index.ts

@@ -1,82 +0,0 @@
-/** DBOS-only durable workflow API. */
-
-export type { DurableWorkflowBackend, DurableWorkflowCatalogEntries } from "./backend.js";
-export { durableHash, InMemoryDurableBackend } from "./backend.js";
-export {
-	type CompletedWorkflowResolution,
-	completedWorkflowSnapshot,
-	listCompletedFromBackend,
-	listOpenableCompletedWorkflows,
-	resolveCompletedWorkflow,
-} from "./completed-catalog.js";
-export {
-	type OpenCompletedDurableDeps,
-	type OpenCompletedDurableResult,
-	openCompletedDurableWorkflow,
-} from "./completed-inspection.js";
-export {
-	type ConfiguredDbosDurability,
-	configureDbosDurableBackend,
-	DbosDurableBackend,
-	type DbosSdkHandle,
-	type DbosStepRecord,
-	type DbosWorkflowInfo,
-} from "./dbos-backend.js";
-export {
-	DBOS_ENVELOPE_VERSION,
-	type DbosCheckpointEnvelope,
-	decodeToCheckpoint,
-	encodeCheckpoint,
-	isCheckpointEnvelope,
-} from "./dbos-envelope.js";
-export {
-	configureDbosOnce,
-	DbosDurabilityError,
-	DbosNotReadyError,
-	DbosShutdownError,
-	flushDbos,
-	getReadyDbosBackend,
-	launchDbosOnce,
-	shutdownDbos,
-} from "./dbos-lifecycle.js";
-export {
-	createInMemoryTestBackend,
-	getDurableBackend,
-	initializeDurableBackend,
-	setDurableBackend,
-} from "./factory.js";
-export { formatResumableWorkflowList, listResumableFromBackend } from "./resume-catalog.js";
-export {
-	prepareDurableResume,
-	type ResumeDurableDeps,
-	type ResumeDurableResult,
-	resolveDurableEntry,
-	resumeDurableWorkflow,
-} from "./resume-runtime.js";
-export {
-	createDurableStagePrimitive,
-	createDurableTaskPrimitive,
-	createStageReplayKeyGenerator,
-	type DurableStageDeps,
-	recordStageCheckpoint,
-	stableCheckpointId,
-} from "./stage-primitive.js";
-export {
-	createCheckpointIdGenerator,
-	createToolPrimitive,
-	type WorkflowToolOptions,
-	type WorkflowToolPrimitive,
-} from "./tool-primitive.js";
-export type {
-	DurableCheckpoint,
-	DurableStageCheckpoint,
-	DurableToolCheckpoint,
-	DurableUiCheckpoint,
-	DurableWorkflowHandle,
-	DurableWorkflowMetadata,
-	DurableWorkflowStatus,
-	ResumableWorkflowEntry,
-	UiPromptKind,
-	WorkflowSerializableObject,
-} from "./types.js";
-export { type DurableUiDeps, wrapUiWithDurable } from "./ui-primitive.js";

package/dist/builtin/workflows/src/durable/local-command.ts

@@ -1,135 +0,0 @@
-/** Minimal subprocess and TCP helpers for local DBOS database provisioning. */
-
-import { spawn } from "node:child_process";
-import { connect } from "node:net";
-import { createChildProcessEnvironment } from "@bastani/atomic";
-
-export interface LocalCommandResult {
-	readonly exitCode: number;
-	readonly stdout: string;
-	readonly stderr: string;
-	/** True when bounded capture discarded the beginning of stdout. */
-	readonly stdoutTruncated?: true;
-	/** True when bounded capture discarded the beginning of stderr. */
-	readonly stderrTruncated?: true;
-}
-
-const OUTPUT_LIMIT_BYTES = 16_384;
-
-export interface LocalCommandOptions {
-	readonly env?: Readonly<Record<string, string>>;
-	/**
-	 * For daemon launchers whose successful descendants inherit stdio, settle
-	 * from a successful direct-child exit. Nonzero exits still drain through
-	 * `close`, preserving bounded failure diagnostics.
-	 */
-	readonly completion?: "successful-exit";
-	/** POSIX drop-privilege identity for the spawned process (root only). */
-	readonly uid?: number;
-	readonly gid?: number;
-}
-
-export function runLocalCommand(
-	command: string,
-	args: readonly string[],
-	options?: LocalCommandOptions,
-): Promise<LocalCommandResult> {
-	return new Promise((resolve, reject) => {
-		const child = spawn(command, [...args], {
-			stdio: ["ignore", "pipe", "pipe"],
-			windowsHide: true,
-			env: createChildProcessEnvironment(options?.env ? { ...options.env } : undefined),
-			...(options?.uid !== undefined ? { uid: options.uid } : {}),
-			...(options?.gid !== undefined ? { gid: options.gid } : {}),
-		});
-		let stdout = "";
-		let stderr = "";
-		let stdoutTruncated = false;
-		let stderrTruncated = false;
-		let settled = false;
-		let exitFallback: NodeJS.Immediate | undefined;
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		const onStdout = (chunk: string): void => {
-			const appended = boundedAppend(stdout, chunk);
-			stdout = appended.value;
-			stdoutTruncated ||= appended.truncated;
-		};
-		const onStderr = (chunk: string): void => {
-			const appended = boundedAppend(stderr, chunk);
-			stderr = appended.value;
-			stderrTruncated ||= appended.truncated;
-		};
-		const cleanup = (): void => {
-			if (exitFallback !== undefined) clearImmediate(exitFallback);
-			child.off("error", onError);
-			child.off("exit", onExit);
-			child.off("close", onClose);
-			child.stdout.off("data", onStdout);
-			child.stderr.off("data", onStderr);
-			child.stdout.destroy();
-			child.stderr.destroy();
-		};
-		const finish = (code: number | null): void => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve({
-				exitCode: code ?? 1,
-				stdout,
-				stderr,
-				...(stdoutTruncated ? { stdoutTruncated: true as const } : {}),
-				...(stderrTruncated ? { stderrTruncated: true as const } : {}),
-			});
-		};
-		const onError = (error: Error): void => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(error);
-		};
-		const onExit = (code: number | null): void => {
-			if (code !== 0) return;
-			// pg_ctl redirects server output with `-l`; only its successful child
-			// exit needs early settlement because Postgres can retain inherited EOF.
-			exitFallback = setImmediate(() => finish(code));
-		};
-		const onClose = (code: number | null): void => finish(code);
-		child.stdout.on("data", onStdout);
-		child.stderr.on("data", onStderr);
-		child.once("error", onError);
-		if (options?.completion === "successful-exit") child.once("exit", onExit);
-		child.once("close", onClose);
-	});
-}
-
-export function commandFailureDetail(result: LocalCommandResult): string {
-	return result.stderr.trim() || result.stdout.trim() || `exit ${result.exitCode}`;
-}
-
-export function delay(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/** True when a TCP listener accepts a connection on host:port within the timeout. */
-export function tcpReachable(host: string, port: number, timeoutMs = 1_000): Promise<boolean> {
-	return new Promise((resolve) => {
-		const socket = connect({ host, port });
-		const finish = (reachable: boolean) => {
-			socket.removeAllListeners();
-			socket.destroy();
-			resolve(reachable);
-		};
-		socket.setTimeout(timeoutMs);
-		socket.once("connect", () => finish(true));
-		socket.once("timeout", () => finish(false));
-		socket.once("error", () => finish(false));
-	});
-}
-
-function boundedAppend(current: string, chunk: string): { readonly value: string; readonly truncated: boolean } {
-	const next = current + chunk;
-	return next.length <= OUTPUT_LIMIT_BYTES
-		? { value: next, truncated: false }
-		: { value: next.slice(-OUTPUT_LIMIT_BYTES), truncated: true };
-}

package/dist/builtin/workflows/src/durable/prompt-reservation-state.ts

@@ -1,184 +0,0 @@
-export interface PromptReservationEntry {
-	readonly reservationId: string;
-	readonly generation: number;
-	readonly tokenId: string;
-}
-
-declare const promptReservationTokenBrand: unique symbol;
-
-/** Opaque ownership proof returned by reserve and required by release. */
-export interface PromptReservationToken extends PromptReservationEntry {
-	readonly [promptReservationTokenBrand]: true;
-}
-
-export interface PromptReservationSnapshot {
-	readonly active: readonly PromptReservationEntry[];
-	readonly released: readonly Omit<PromptReservationEntry, "tokenId">[];
-	readonly anonymousTokenIds: readonly string[];
-	readonly consumedTokenIds: readonly string[];
-}
-
-export function promptReservationToken(entry: PromptReservationEntry): PromptReservationToken {
-	return entry as PromptReservationToken;
-}
-
-export function inactivePromptReservationToken(reservationId: string): PromptReservationToken {
-	return promptReservationToken({ reservationId, generation: 1, tokenId: `inactive:${crypto.randomUUID()}` });
-}
-
-function nextPendingToken(existing: ReadonlySet<string>, index: number): string {
-	let candidate = `pending:${index}`;
-	while (existing.has(candidate)) candidate = `pending:${++index}`;
-	return candidate;
-}
-
-/** Identity-owned prompt tokens with generation tombstones for current backends. */
-export class PromptReservationState {
-	private readonly active = new Map<string, PromptReservationEntry>();
-	private readonly released = new Map<string, number>();
-	private readonly availableTokens = new Set<string>();
-	private readonly anonymousTokens = new Set<string>();
-	private readonly consumedTokens = new Set<string>();
-
-	constructor(pendingPrompts: number, snapshot?: PromptReservationSnapshot) {
-		for (const tokenId of snapshot?.consumedTokenIds ?? []) this.consumedTokens.add(tokenId);
-		for (const entry of snapshot?.active ?? []) {
-			if (this.consumedTokens.has(entry.tokenId)) continue;
-			const current = this.active.get(entry.reservationId);
-			if (current === undefined || entry.generation > current.generation) {
-				this.active.set(entry.reservationId, entry);
-			}
-			this.availableTokens.add(entry.tokenId);
-		}
-		for (const entry of snapshot?.released ?? []) {
-			const generation = Math.max(this.released.get(entry.reservationId) ?? 0, entry.generation);
-			this.released.set(entry.reservationId, generation);
-			const active = this.active.get(entry.reservationId);
-			if (active !== undefined && active.generation <= generation) {
-				this.active.delete(entry.reservationId);
-				this.availableTokens.delete(active.tokenId);
-				this.consumedTokens.add(active.tokenId);
-			}
-		}
-		for (const tokenId of snapshot?.anonymousTokenIds ?? []) {
-			if (this.consumedTokens.has(tokenId)) continue;
-			this.anonymousTokens.add(tokenId);
-			this.availableTokens.add(tokenId);
-		}
-		let index = 0;
-		while (this.availableTokens.size < Math.max(0, Math.trunc(pendingPrompts))) {
-			const tokenId = nextPendingToken(this.availableTokens, index++);
-			this.anonymousTokens.add(tokenId);
-			this.availableTokens.add(tokenId);
-		}
-	}
-
-	get pendingPrompts(): number {
-		return this.availableTokens.size;
-	}
-
-	activeToken(reservationId: string): PromptReservationToken | undefined {
-		const active = this.active.get(reservationId);
-		return active === undefined ? undefined : promptReservationToken(active);
-	}
-
-	claim(reservationId: string): PromptReservationToken | undefined {
-		return (
-			this.activeToken(reservationId) ?? (this.anonymousTokens.size > 0 ? this.reserve(reservationId) : undefined)
-		);
-	}
-
-	reserve(reservationId: string): PromptReservationToken {
-		const current = this.active.get(reservationId);
-		if (current !== undefined) return promptReservationToken(current);
-		const generation = Math.max(this.released.get(reservationId) ?? 0, 0) + 1;
-		const anonymous = this.released.has(reservationId)
-			? undefined
-			: (this.anonymousTokens.values().next().value as string | undefined);
-		const tokenId = anonymous ?? `reservation:${encodeURIComponent(reservationId)}:${generation}`;
-		if (anonymous !== undefined) this.anonymousTokens.delete(anonymous);
-		const entry = { reservationId, generation, tokenId };
-		this.active.set(reservationId, entry);
-		this.availableTokens.add(tokenId);
-		return promptReservationToken(entry);
-	}
-
-	release(reservationId: string, token: PromptReservationToken): void {
-		const active = this.active.get(reservationId);
-		if (
-			active === undefined ||
-			token === undefined ||
-			token.reservationId !== reservationId ||
-			active.generation !== token.generation ||
-			active.tokenId !== token.tokenId
-		)
-			return;
-		this.active.delete(reservationId);
-		this.consume(active.tokenId);
-		this.released.set(reservationId, active.generation);
-	}
-
-	adjust(delta: number): void {
-		const count = Math.max(0, Math.trunc(Math.abs(delta)));
-		for (let index = 0; index < count; index++) {
-			if (delta > 0) {
-				const tokenId = `scalar:${crypto.randomUUID()}`;
-				this.anonymousTokens.add(tokenId);
-				this.availableTokens.add(tokenId);
-			} else if (delta < 0) {
-				const anonymous = this.anonymousTokens.values().next().value as string | undefined;
-				if (anonymous !== undefined) {
-					this.consume(anonymous);
-					continue;
-				}
-				const active = this.active.values().next().value as PromptReservationEntry | undefined;
-				if (active === undefined) break;
-				this.active.delete(active.reservationId);
-				this.released.set(active.reservationId, active.generation);
-				this.consume(active.tokenId);
-			}
-		}
-	}
-
-	snapshot(): PromptReservationSnapshot {
-		return {
-			active: [...this.active.values()],
-			released: [...this.released].map(([reservationId, generation]) => ({ reservationId, generation })),
-			anonymousTokenIds: [...this.anonymousTokens],
-			consumedTokenIds: [...this.consumedTokens],
-		};
-	}
-
-	private consume(tokenId: string): void {
-		this.availableTokens.delete(tokenId);
-		this.anonymousTokens.delete(tokenId);
-		this.consumedTokens.add(tokenId);
-	}
-}
-
-export function mergePromptReservationSnapshots(
-	first: PromptReservationSnapshot | undefined,
-	second: PromptReservationSnapshot | undefined,
-	pendingPrompts: number,
-): PromptReservationSnapshot | undefined {
-	if (first === undefined && second === undefined) return undefined;
-	const consumed = new Set([...(first?.consumedTokenIds ?? []), ...(second?.consumedTokenIds ?? [])]);
-	const released = new Map<string, number>();
-	for (const entry of [...(first?.released ?? []), ...(second?.released ?? [])]) {
-		released.set(entry.reservationId, Math.max(released.get(entry.reservationId) ?? 0, entry.generation));
-	}
-	const active = new Map<string, PromptReservationEntry>();
-	for (const entry of [...(first?.active ?? []), ...(second?.active ?? [])]) {
-		if (consumed.has(entry.tokenId) || (released.get(entry.reservationId) ?? 0) >= entry.generation) continue;
-		const current = active.get(entry.reservationId);
-		if (current === undefined || entry.generation > current.generation) active.set(entry.reservationId, entry);
-	}
-	const anonymousTokenIds = new Set([...(first?.anonymousTokenIds ?? []), ...(second?.anonymousTokenIds ?? [])]);
-	for (const tokenId of consumed) anonymousTokenIds.delete(tokenId);
-	return new PromptReservationState(pendingPrompts, {
-		active: [...active.values()],
-		released: [...released].map(([reservationId, generation]) => ({ reservationId, generation })),
-		anonymousTokenIds: [...anonymousTokenIds],
-		consumedTokenIds: [...consumed],
-	}).snapshot();
-}

package/dist/builtin/workflows/src/durable/prompt-reservations.ts

@@ -1,36 +0,0 @@
-import type { DurableWorkflowBackend } from "./backend.js";
-import type { PromptReservationToken } from "./prompt-reservation-state.js";
-
-export function durablePromptScope(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-): { readonly rootWorkflowId: string; readonly scope: string } {
-	return backend.promptReservationScope(workflowId);
-}
-
-export function claimDurablePromptToken(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-	reservationId: string,
-): PromptReservationToken | undefined {
-	return backend.pendingPromptToken(workflowId, reservationId);
-}
-
-export function reserveDurablePrompt(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-	reservationId: string,
-): PromptReservationToken {
-	return backend.reservePendingPrompt(workflowId, reservationId);
-}
-
-export function releaseDurablePrompt(
-	backend: DurableWorkflowBackend,
-	workflowId: string,
-	reservationId: string,
-	token: PromptReservationToken,
-): void {
-	backend.releasePendingPrompt(workflowId, reservationId, token);
-}
-
-export type { PromptReservationToken } from "./prompt-reservation-state.js";

package/dist/builtin/workflows/src/durable/resume-catalog.ts

@@ -1,20 +0,0 @@
-import type { DurableWorkflowBackend } from "./backend.js";
-import type { ResumableWorkflowEntry } from "./types.js";
-
-/** List resumable workflows directly from the ready backend. */
-export function listResumableFromBackend(backend: DurableWorkflowBackend): readonly ResumableWorkflowEntry[] {
-	return backend.listResumableWorkflows();
-}
-
-export function formatResumableWorkflowList(entries: readonly ResumableWorkflowEntry[]): string {
-	if (entries.length === 0) return "No resumable or completed workflows found.";
-	const hasCompleted = entries.some((entry) => entry.status === "completed");
-	const lines = entries.map((entry, index) => {
-		const id = entry.workflowId;
-		const status = entry.status === "completed" ? "✓ completed" : entry.status.padEnd(8);
-		const checkpoints = `${entry.completedCheckpoints} checkpoint${entry.completedCheckpoints === 1 ? "" : "s"}`;
-		const label = entry.label ? ` "${entry.label}"` : "";
-		return `  ${index + 1}. ${id}  ${status}  ${entry.name}${label}  (${checkpoints})`;
-	});
-	return `${hasCompleted ? "Workflow resume targets" : "Resumable workflows"}:\n${lines.join("\n")}`;
-}