@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

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

@@ -1,377 +0,0 @@
-import type { WorkflowSerializableValue } from "../shared/types.js";
-import type { DbosStepRecord } from "./dbos-backend.js";
-import { DURABLE_FORMAT_VERSION } from "./format-version.js";
-import { type PromptReservationToken, promptReservationToken } from "./prompt-reservation-state.js";
-import type { DurableWorkflowMetadata } from "./types.js";
-
-const RESERVATION_PREFIX = "__atomic_prompt_reservation";
-
-export interface DbosActivePromptReservation {
-	readonly generation: number;
-	readonly tokenId: string;
-}
-
-export interface DbosPromptReservationState {
-	readonly active: Map<string, DbosActivePromptReservation>;
-	readonly maxGeneration: Map<string, number>;
-	readonly releasedGeneration: Map<string, number>;
-	readonly availableTokens: Set<string>;
-	readonly consumedTokens: Set<string>;
-	readonly baseline: number;
-	readonly epoch: string;
-	hasEvents: boolean;
-}
-
-export function emptyDbosPromptReservationState(
-	baseline = 0,
-	epoch: string = crypto.randomUUID(),
-): DbosPromptReservationState {
-	const normalized = Math.max(0, Math.trunc(baseline));
-	const availableTokens = new Set<string>();
-	for (let index = 0; index < normalized; index++) availableTokens.add(`baseline:${epoch}:${index}`);
-	return {
-		active: new Map(),
-		maxGeneration: new Map(),
-		releasedGeneration: new Map(),
-		availableTokens,
-		consumedTokens: new Set(),
-		baseline: normalized,
-		epoch,
-		hasEvents: false,
-	};
-}
-
-export function promptReservationStepName(
-	reservationId: string,
-	generation: number,
-	operation: "reserve" | "release",
-	epoch: string,
-): string {
-	return `${RESERVATION_PREFIX}:${operation}:${reservationId}:${generation}:${epoch}`;
-}
-
-export function encodePromptReservationEvent(input: {
-	readonly reservationId: string;
-	readonly generation: number;
-	readonly operation: "reserve" | "release";
-	readonly tokenId: string;
-	readonly epoch: string;
-}): WorkflowSerializableValue {
-	return {
-		__atomicPromptReservation: true,
-		version: DURABLE_FORMAT_VERSION,
-		reservationId: input.reservationId,
-		generation: input.generation,
-		operation: input.operation,
-		tokenId: input.tokenId,
-		epoch: input.epoch,
-	};
-}
-
-export function isDbosPromptStateStep(stepName: string): boolean {
-	return stepName.startsWith(`${RESERVATION_PREFIX}:`);
-}
-
-interface ParsedReservation {
-	readonly reservationId: string;
-	readonly generation: number;
-	readonly operation: "reserve" | "release";
-	readonly tokenId: string;
-	readonly epoch: string;
-}
-
-interface ReservationGeneration {
-	tokenId: string;
-	reserved: boolean;
-	released: boolean;
-}
-
-export function classifyDbosPromptReservationState(
-	records: readonly DbosStepRecord[],
-	baseline = 0,
-	epoch: string = crypto.randomUUID(),
-): DbosPromptReservationState {
-	const state = emptyDbosPromptReservationState(baseline, epoch);
-	const generations = new Map<string, Map<number, ReservationGeneration>>();
-	for (const record of records) {
-		if (!isDbosPromptStateStep(record.stepName)) continue;
-		const event = parseReservation(record.output);
-		if (event === undefined || event.epoch !== epoch) continue;
-		state.hasEvents = true;
-		let byGeneration = generations.get(event.reservationId);
-		if (byGeneration === undefined) {
-			byGeneration = new Map();
-			generations.set(event.reservationId, byGeneration);
-		}
-		const entry = byGeneration.get(event.generation) ?? {
-			tokenId: event.tokenId,
-			reserved: false,
-			released: false,
-		};
-		if (entry.tokenId !== event.tokenId) continue;
-		if (event.operation === "reserve") entry.reserved = true;
-		else entry.released = true;
-		byGeneration.set(event.generation, entry);
-	}
-
-	for (const [reservationId, byGeneration] of generations) {
-		const maxGeneration = Math.max(...byGeneration.keys());
-		state.maxGeneration.set(reservationId, maxGeneration);
-		for (const [generation, entry] of [...byGeneration].sort(([a], [b]) => a - b)) {
-			if (entry.released) {
-				state.releasedGeneration.set(
-					reservationId,
-					Math.max(state.releasedGeneration.get(reservationId) ?? 0, generation),
-				);
-				consumeToken(state, entry.tokenId);
-			}
-			if (
-				generation === maxGeneration &&
-				entry.reserved &&
-				!entry.released &&
-				!state.consumedTokens.has(entry.tokenId)
-			) {
-				state.active.set(reservationId, { generation, tokenId: entry.tokenId });
-				state.availableTokens.add(entry.tokenId);
-			}
-		}
-	}
-	return state;
-}
-
-export function promptReservationAdjustment(state: DbosPromptReservationState): number {
-	return state.availableTokens.size - state.baseline;
-}
-
-function parseReservation(output: WorkflowSerializableValue): ParsedReservation | undefined {
-	if (
-		!isRecord(output) ||
-		output.__atomicPromptReservation !== true ||
-		output.version !== DURABLE_FORMAT_VERSION ||
-		typeof output.reservationId !== "string" ||
-		typeof output.generation !== "number" ||
-		!Number.isInteger(output.generation) ||
-		output.generation < 1 ||
-		(output.operation !== "reserve" && output.operation !== "release") ||
-		typeof output.tokenId !== "string" ||
-		typeof output.epoch !== "string"
-	)
-		return undefined;
-	return {
-		reservationId: output.reservationId,
-		generation: output.generation,
-		operation: output.operation,
-		tokenId: output.tokenId,
-		epoch: output.epoch,
-	};
-}
-
-function isRecord(value: WorkflowSerializableValue): value is Record<string, WorkflowSerializableValue> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-interface DbosPromptReservationHost {
-	readonly pendingPrompts: (workflowId: string) => number;
-	readonly adjustPendingPrompts: (workflowId: string, delta: number) => void;
-	readonly persist: (workflowId: string, stepName: string, output: WorkflowSerializableValue) => void;
-}
-
-export class DbosPromptReservationTracker {
-	private readonly baselines = new Map<string, number>();
-	private readonly states = new Map<string, DbosPromptReservationState>();
-
-	constructor(private readonly host: DbosPromptReservationHost) {}
-
-	registerWorkflow(workflowId: string, pending: number | undefined, existingPending: number): number {
-		if (pending === undefined) return this.register(workflowId, existingPending);
-		return this.states.has(workflowId) ? this.setBaseline(workflowId, pending) : this.register(workflowId, pending);
-	}
-
-	register(workflowId: string, pending: number): number {
-		const existing = this.states.get(workflowId);
-		if (existing !== undefined) return pendingPrompts(existing);
-		const normalized = Math.max(0, Math.trunc(pending));
-		this.baselines.set(workflowId, normalized);
-		this.states.set(workflowId, emptyDbosPromptReservationState(normalized));
-		return normalized;
-	}
-
-	setBaseline(workflowId: string, pending: number): number {
-		const normalized = Math.max(0, Math.trunc(pending));
-		this.baselines.set(workflowId, normalized);
-		this.states.set(workflowId, emptyDbosPromptReservationState(normalized));
-		return normalized;
-	}
-
-	delete(workflowId: string): void {
-		this.baselines.delete(workflowId);
-		this.states.delete(workflowId);
-	}
-	clear(): void {
-		this.baselines.clear();
-		this.states.clear();
-	}
-
-	metadata(
-		workflowId: string,
-		value: Omit<DurableWorkflowMetadata, "promptReservationEpoch">,
-	): DurableWorkflowMetadata {
-		const state = this.state(workflowId);
-		return {
-			...value,
-			pendingPrompts: this.baselines.get(workflowId) ?? value.pendingPrompts,
-			promptReservationEpoch: state.epoch,
-		};
-	}
-
-	hydrate(workflowId: string, baseline: number, records: readonly DbosStepRecord[], epoch?: string): number {
-		if (epoch === undefined) return 0;
-		const state = classifyDbosPromptReservationState(records, baseline, epoch);
-		this.baselines.set(workflowId, baseline);
-		this.states.set(workflowId, state);
-		return pendingPrompts(state);
-	}
-
-	adjust(workflowId: string, delta: number): void {
-		const state = this.state(workflowId);
-		const count = Math.max(0, Math.trunc(Math.abs(delta)));
-		for (let index = 0; index < count; index++) {
-			if (delta > 0) this.reserveScalar(workflowId, state);
-			else if (delta < 0) {
-				const tokenId = state.availableTokens.values().next().value as string | undefined;
-				if (tokenId === undefined) break;
-				const owner = [...state.active].find(([, reservation]) => reservation.tokenId === tokenId);
-				if (owner !== undefined) this.releaseGeneration(workflowId, state, owner[0], owner[1]);
-				else this.releaseUnownedToken(workflowId, state, tokenId);
-			}
-		}
-		this.syncPending(workflowId, state);
-	}
-
-	token(workflowId: string, reservationId: string): PromptReservationToken | undefined {
-		const reservation = this.state(workflowId).active.get(reservationId);
-		return reservation === undefined ? undefined : tokenFor(reservationId, reservation);
-	}
-
-	reserve(workflowId: string, reservationId: string): PromptReservationToken {
-		const state = this.state(workflowId);
-		const current = state.active.get(reservationId);
-		if (current !== undefined) return tokenFor(reservationId, current);
-		const generation = (state.maxGeneration.get(reservationId) ?? 0) + 1;
-		const reservation = {
-			generation,
-			tokenId: `prompt:${state.epoch}:${encodeURIComponent(reservationId)}:${generation}`,
-		};
-		applyReserve(state, reservationId, reservation);
-		this.syncPending(workflowId, state);
-		this.persistReservation(workflowId, state, reservationId, reservation, "reserve");
-		return tokenFor(reservationId, reservation);
-	}
-
-	release(workflowId: string, reservationId: string, token: PromptReservationToken): void {
-		const state = this.state(workflowId);
-		const reservation = state.active.get(reservationId);
-		if (
-			reservation === undefined ||
-			token.reservationId !== reservationId ||
-			token.generation !== reservation.generation ||
-			token.tokenId !== reservation.tokenId
-		)
-			return;
-		this.releaseGeneration(workflowId, state, reservationId, reservation);
-		this.syncPending(workflowId, state);
-	}
-
-	private reserveScalar(workflowId: string, state: DbosPromptReservationState): void {
-		const id = crypto.randomUUID();
-		const reservation = { generation: 1, tokenId: `scalar:${state.epoch}:${id}` };
-		applyReserve(state, `__scalar:${id}`, reservation);
-		this.persistReservation(workflowId, state, `__scalar:${id}`, reservation, "reserve");
-	}
-
-	private releaseUnownedToken(workflowId: string, state: DbosPromptReservationState, tokenId: string): void {
-		const reservationId = `__token_release:${crypto.randomUUID()}`;
-		const reservation = { generation: 1, tokenId };
-		state.maxGeneration.set(reservationId, 1);
-		state.releasedGeneration.set(reservationId, 1);
-		consumeToken(state, tokenId);
-		state.hasEvents = true;
-		this.persistReservation(workflowId, state, reservationId, reservation, "release");
-	}
-
-	private releaseGeneration(
-		workflowId: string,
-		state: DbosPromptReservationState,
-		reservationId: string,
-		reservation: DbosActivePromptReservation,
-	): void {
-		applyRelease(state, reservationId, reservation);
-		this.persistReservation(workflowId, state, reservationId, reservation, "release");
-	}
-
-	private state(workflowId: string): DbosPromptReservationState {
-		let state = this.states.get(workflowId);
-		if (state === undefined) {
-			state = emptyDbosPromptReservationState(this.baselines.get(workflowId) ?? 0);
-			this.states.set(workflowId, state);
-		}
-		return state;
-	}
-
-	private syncPending(workflowId: string, state: DbosPromptReservationState): void {
-		const delta = pendingPrompts(state) - this.host.pendingPrompts(workflowId);
-		if (delta !== 0) this.host.adjustPendingPrompts(workflowId, delta);
-	}
-
-	private persistReservation(
-		workflowId: string,
-		state: DbosPromptReservationState,
-		reservationId: string,
-		reservation: DbosActivePromptReservation,
-		operation: "reserve" | "release",
-	): void {
-		this.host.persist(
-			workflowId,
-			promptReservationStepName(reservationId, reservation.generation, operation, state.epoch),
-			encodePromptReservationEvent({ reservationId, operation, ...reservation, epoch: state.epoch }),
-		);
-	}
-}
-
-function tokenFor(reservationId: string, reservation: DbosActivePromptReservation): PromptReservationToken {
-	return promptReservationToken({ reservationId, generation: reservation.generation, tokenId: reservation.tokenId });
-}
-
-function pendingPrompts(state: DbosPromptReservationState): number {
-	return state.availableTokens.size;
-}
-
-function applyReserve(
-	state: DbosPromptReservationState,
-	reservationId: string,
-	reservation: DbosActivePromptReservation,
-): void {
-	state.maxGeneration.set(reservationId, reservation.generation);
-	state.active.set(reservationId, reservation);
-	if (!state.consumedTokens.has(reservation.tokenId)) state.availableTokens.add(reservation.tokenId);
-	state.hasEvents = true;
-}
-
-function applyRelease(
-	state: DbosPromptReservationState,
-	reservationId: string,
-	reservation: DbosActivePromptReservation,
-): void {
-	state.active.delete(reservationId);
-	state.releasedGeneration.set(
-		reservationId,
-		Math.max(state.releasedGeneration.get(reservationId) ?? 0, reservation.generation),
-	);
-	consumeToken(state, reservation.tokenId);
-	state.hasEvents = true;
-}
-
-function consumeToken(state: DbosPromptReservationState, tokenId: string): void {
-	state.availableTokens.delete(tokenId);
-	state.consumedTokens.add(tokenId);
-}

package/dist/builtin/workflows/src/durable/dbos-registration-diagnostics.ts

@@ -1,113 +0,0 @@
-/**
- * Classify DBOS durability failures so a duplicate operation registration
- * is not described as a Postgres provisioning problem (#2022 / #2462).
- *
- * Uses the SDK `Error` namespace (`DBOSConflictingRegistrationError` and
- * `getDBOSErrorCode`). The SDK is loaded lazily so this module never
- * statically imports `@dbos-inc/dbos-sdk`. `instanceof` is not used: two
- * resolved copies of the SDK would make it fail.
- */
-
-export type DbosDurabilityFailureKind = "duplicate_registration" | "other";
-
-interface DbosSdkErrorModule {
-	readonly DBOSConflictingRegistrationError?: new (msg: string) => object;
-	readonly getDBOSErrorCode?: (error: Error) => number | undefined;
-}
-
-let cachedErrorModule: DbosSdkErrorModule | undefined;
-let errorModuleLoad: Promise<DbosSdkErrorModule | undefined> | undefined;
-
-async function loadDbosErrorModule(): Promise<DbosSdkErrorModule | undefined> {
-	if (cachedErrorModule !== undefined) return cachedErrorModule;
-	errorModuleLoad ??= (async () => {
-		const spec = "@dbos-inc/dbos-sdk";
-		try {
-			const mod = (await import(spec)) as { readonly Error?: DbosSdkErrorModule };
-			cachedErrorModule = mod.Error;
-			return cachedErrorModule;
-		} catch {
-			return undefined;
-		}
-	})();
-	return await errorModuleLoad;
-}
-
-function conflictingRegistrationCode(errors: DbosSdkErrorModule | undefined): number | undefined {
-	const ctor = errors?.DBOSConflictingRegistrationError;
-	if (ctor === undefined) return undefined;
-	try {
-		const code = Reflect.get(new ctor(""), "dbosErrorCode");
-		return typeof code === "number" ? code : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function isDuplicateRegistration(value: object, errors: DbosSdkErrorModule | undefined): boolean {
-	const expected = conflictingRegistrationCode(errors);
-	const code = readOwn(value, "dbosErrorCode");
-	if (typeof code === "number" && typeof expected === "number" && code === expected) return true;
-	if (errors?.getDBOSErrorCode !== undefined && value instanceof Error) {
-		try {
-			if (errors.getDBOSErrorCode(value) === expected) return true;
-		} catch {
-			/* keep walking */
-		}
-	}
-	const name = readOwn(value, "name");
-	const className = errors?.DBOSConflictingRegistrationError?.name;
-	return typeof name === "string" && typeof className === "string" && name === className;
-}
-
-function classifyWith(error: unknown, errors: DbosSdkErrorModule | undefined): DbosDurabilityFailureKind {
-	try {
-		const seen = new Set<object>();
-		let current: unknown = error;
-		while (current !== undefined && current !== null) {
-			if (typeof current !== "object") return "other";
-			if (seen.has(current)) return "other";
-			seen.add(current);
-			if (isDuplicateRegistration(current, errors)) return "duplicate_registration";
-			current = readOwn(current, "cause");
-		}
-	} catch {
-		return "other";
-	}
-	return "other";
-}
-
-/**
- * Async classification used at the durability boundary so the first failure
- * can load the SDK error classes before deciding. Subsequent sync callers
- * reuse the cached module.
- */
-export async function classifyDbosDurabilityFailure(error: unknown): Promise<DbosDurabilityFailureKind> {
-	const errors = await loadDbosErrorModule();
-	return classifyWith(error, errors);
-}
-
-/**
- * Read an error's display detail without letting a throwing `message` getter
- * escape the durability wrapper. `String(error)` is the last-resort fallback
- * and is itself guarded: some `toString` implementations also throw.
- */
-export function readDbosFailureDetail(error: unknown): string {
-	if (typeof error === "object" && error !== null) {
-		const message = readOwn(error, "message");
-		if (typeof message === "string" && message !== "") return message;
-	}
-	try {
-		return String(error);
-	} catch {
-		return "unknown error";
-	}
-}
-
-function readOwn(value: object, key: string): unknown {
-	try {
-		return Reflect.get(value, key);
-	} catch {
-		return undefined;
-	}
-}

package/dist/builtin/workflows/src/durable/dbos-sdk-handle.ts

@@ -1,182 +0,0 @@
-/**
- * Real `@dbos-inc/dbos-sdk` handle factory.
- *
- * Wraps the DBOS static executor into the {@link DbosSdkHandle} seam used by
- * {@link DbosDurableBackend}. Kept separate from the backend adapter so both
- * files stay focused.
- */
-
-import type { WorkflowSerializableValue } from "../shared/types.js";
-import type { DbosSdkHandle, DbosStepRecord, DbosWorkflowInfo } from "./dbos-backend.js";
-
-interface DbosWorkflowHandle {
-	readonly workflowID?: string;
-	getStatus(): Promise<DbosStatus | null>;
-	getResult(): Promise<WorkflowSerializableValue>;
-}
-
-interface DbosStatus {
-	readonly workflowID?: string;
-	readonly workflowId?: string;
-	readonly workflowName?: string;
-	readonly name?: string;
-	readonly status?: string;
-	readonly createdAt?: number;
-	readonly input?: readonly WorkflowSerializableValue[];
-}
-
-/**
- * Unique executor identity for this Atomic process. Multiple concurrent Atomic
- * sessions share one DBOS database; a per-process id keeps DBOS-level recovery
- * and workflow ownership scoped to the process that actually runs the work.
- */
-const ATOMIC_EXECUTOR_ID = `atomic-${process.pid.toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
-
-export function getAtomicExecutorId(): string {
-	return ATOMIC_EXECUTOR_ID;
-}
-
-export interface DbosLogger {
-	info(value: unknown, metadata?: object): void;
-	debug(value: unknown, metadata?: object): void;
-	warn(value: unknown, metadata?: object): void;
-	error(value: unknown, metadata?: object): void;
-}
-
-export interface DbosConfiguration {
-	readonly name: string;
-	readonly systemDatabaseUrl?: string;
-	readonly runAdminServer: boolean;
-	readonly executorID: string;
-	readonly logger: DbosLogger;
-}
-
-export interface DbosStatic {
-	setConfig(config: DbosConfiguration): void;
-	launch(): Promise<void>;
-	shutdown(): Promise<void>;
-	registerWorkflow<Args extends readonly WorkflowSerializableValue[]>(
-		fn: (...args: Args) => Promise<WorkflowSerializableValue>,
-		config?: { readonly name?: string },
-	): (...args: Args) => Promise<WorkflowSerializableValue>;
-	startWorkflow<Args extends readonly WorkflowSerializableValue[]>(
-		target: (...args: Args) => Promise<WorkflowSerializableValue>,
-		params?: { readonly workflowID?: string },
-	): (...args: Args) => Promise<DbosWorkflowHandle>;
-	retrieveWorkflow(workflowId: string): DbosWorkflowHandle;
-	resumeWorkflow(workflowId: string): Promise<DbosWorkflowHandle>;
-	cancelWorkflow(workflowId: string, options?: { readonly cancelChildren?: boolean }): Promise<void>;
-	listWorkflows(input: Record<string, WorkflowSerializableValue>): Promise<readonly DbosStatus[]>;
-	deleteWorkflows(workflowIds: string[], deleteChildren?: boolean): Promise<void>;
-}
-
-export function createRealDbosHandle(
-	dbos: DbosStatic,
-	mainWorkflow: (
-		name: string,
-		inputs: Record<string, WorkflowSerializableValue>,
-	) => Promise<WorkflowSerializableValue>,
-	checkpointWorkflow: (
-		workflowId: string,
-		stepName: string,
-		output: WorkflowSerializableValue,
-	) => Promise<WorkflowSerializableValue>,
-): DbosSdkHandle {
-	const checkpointId = (workflowId: string, stepName: string): string => `${workflowId}:checkpoint:${stepName}`;
-	return {
-		launch: () => dbos.launch(),
-		shutdown: () => dbos.shutdown(),
-		async startWorkflow(workflowId, name, inputs) {
-			try {
-				await dbos.startWorkflow(mainWorkflow, { workflowID: workflowId })(name, { ...inputs });
-			} catch (err) {
-				if (!isDbosDuplicateWorkflowError(err)) throw err;
-			}
-		},
-		async retrieveWorkflow(workflowId) {
-			const statuses = await dbos.listWorkflows({ workflowIDs: [workflowId], loadInput: true, limit: 1 });
-			const status = statuses[0];
-			if (status === undefined) return undefined;
-			return statusToInfo(status, workflowId);
-		},
-		async cancelWorkflow(workflowId) {
-			await dbos.cancelWorkflow(workflowId, { cancelChildren: true });
-		},
-		async resumeWorkflow(workflowId) {
-			await dbos.resumeWorkflow(workflowId);
-		},
-		async listAllWorkflows() {
-			const statuses = await dbos.listWorkflows({
-				workflowName: "atomicWorkflowHandle",
-				loadInput: true,
-				sortDesc: true,
-			});
-			return statuses.map((s) => statusToInfo(s, s.workflowID ?? s.workflowId ?? ""));
-		},
-		async listStepRecords(workflowId) {
-			const prefix = `${workflowId}:checkpoint:`;
-			const statuses = await dbos.listWorkflows({ workflow_id_prefix: prefix, loadOutput: true, sortDesc: false });
-			const records: DbosStepRecord[] = [];
-			for (const s of statuses) {
-				if (s.status !== "SUCCESS") continue;
-				const wid = s.workflowID ?? s.workflowId ?? "";
-				const stepName = wid.slice(prefix.length);
-				if (stepName.length === 0) continue;
-				const handle = dbos.retrieveWorkflow(wid);
-				const output = await handle.getResult();
-				records.push({ stepName, output, completedAt: s.createdAt });
-			}
-			return records;
-		},
-		async recordStepOutput(workflowId, stepName, output) {
-			let handle: DbosWorkflowHandle;
-			try {
-				handle = await dbos.startWorkflow(checkpointWorkflow, { workflowID: checkpointId(workflowId, stepName) })(
-					workflowId,
-					stepName,
-					output,
-				);
-			} catch (err) {
-				if (!isDbosDuplicateWorkflowError(err)) throw err;
-				handle = dbos.retrieveWorkflow(checkpointId(workflowId, stepName));
-			}
-			// Await completion so the record is durable and readable before the
-			// caller's flush boundary; duplicates resolve to the first stored output.
-			await handle.getResult();
-		},
-		async deleteWorkflowData(workflowId) {
-			const prefix = `${workflowId}:checkpoint:`;
-			const checkpointIds: string[] = [];
-			const pageSize = 1_000;
-			for (let offset = 0; ; offset += pageSize) {
-				const page = await dbos.listWorkflows({ workflow_id_prefix: prefix, limit: pageSize, offset });
-				checkpointIds.push(
-					...page.map((status) => status.workflowID ?? status.workflowId ?? "").filter((id) => id.length > 0),
-				);
-				if (page.length < pageSize) break;
-			}
-			await dbos.deleteWorkflows([...new Set([workflowId, ...checkpointIds])], true);
-		},
-	};
-}
-
-function isDbosDuplicateWorkflowError(err: unknown): boolean {
-	const msg = err instanceof Error ? err.message : String(err);
-	return /duplicate|conflict|already/i.test(msg);
-}
-
-function statusToInfo(status: DbosStatus, fallbackId: string): DbosWorkflowInfo {
-	const info: DbosWorkflowInfo = {
-		workflowId: status.workflowID ?? status.workflowId ?? fallbackId,
-		name: status.workflowName ?? status.name ?? "atomicWorkflowHandle",
-		status: status.status ?? "PENDING",
-		createdAt: status.createdAt ?? Date.now(),
-	};
-	if (status.input !== undefined && status.input.length >= 2) {
-		const inputs = status.input[1];
-		if (typeof inputs === "object" && inputs !== null && !Array.isArray(inputs)) {
-			return { ...info, inputs: inputs as import("./types.js").WorkflowSerializableObject };
-		}
-	}
-	return info;
-}