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

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

@@ -1,208 +0,0 @@
-import { type ConfiguredDbosDurability, configureDbosDurableBackend, type DbosDurableBackend } from "./dbos-backend.js";
-import {
-	provisionResolvedLocalDbos,
-	resolveDbosSystemDatabaseUrl,
-	shouldProvisionLocalDbos,
-	shutdownResolvedLocalDbos,
-} from "./dbos-local-postgres.js";
-import { getDbosProcessOwner, resetDbosProcessOwner } from "./dbos-process-owner.js";
-import { classifyDbosDurabilityFailure, readDbosFailureDetail } from "./dbos-registration-diagnostics.js";
-
-export type DbosLifecycleState =
-	| "uninitialized"
-	| "configured"
-	| "launching"
-	| "ready"
-	| "failed"
-	| "shutting_down"
-	| "shut_down";
-
-export class DbosDurabilityError extends Error {
-	constructor(message: string, options?: ErrorOptions) {
-		super(message, options);
-		this.name = "DbosDurabilityError";
-	}
-}
-
-export class DbosNotReadyError extends DbosDurabilityError {
-	constructor() {
-		super("DBOS workflow durability is not ready. Await initializeDurableBackend() before accessing workflows.");
-		this.name = "DbosNotReadyError";
-	}
-}
-
-export class DbosShutdownError extends DbosDurabilityError {
-	constructor() {
-		super(
-			"DBOS workflow durability has been shut down in this process. " +
-				"Durable workflows can no longer start; restart Atomic to restore durability.",
-		);
-		this.name = "DbosShutdownError";
-	}
-}
-type DbosConfigurator = () => Promise<ConfiguredDbosDurability>;
-type LocalDbosProvisioner = () => Promise<void>;
-type LocalDbosShutdowner = () => Promise<void>;
-
-/**
- * Default path: resolve the local database first (explicit env URL, embedded
- * Postgres, or the Docker fallback), then configure DBOS against it.
- */
-const defaultConfigurator: DbosConfigurator = async () => {
-	const systemDatabaseUrl = await resolveDbosSystemDatabaseUrl();
-	return await configureDbosDurableBackend(systemDatabaseUrl === undefined ? undefined : { systemDatabaseUrl });
-};
-
-let configureDurability: DbosConfigurator = defaultConfigurator;
-let provisionLocalDbos: LocalDbosProvisioner = provisionResolvedLocalDbos;
-let shutdownLocalDbos: LocalDbosShutdowner = shutdownResolvedLocalDbos;
-
-function owner(): ReturnType<typeof getDbosProcessOwner> {
-	return getDbosProcessOwner();
-}
-
-async function durabilityFailure(action: string, error: unknown): Promise<DbosDurabilityError> {
-	const detail = readDbosFailureDetail(error);
-	const kind = await classifyDbosDurabilityFailure(error);
-	const guidance =
-		kind === "duplicate_registration"
-			? "A duplicate DBOS operation registration caused this failure; changing the database URL will not resolve it."
-			: "Set DBOS_SYSTEM_DATABASE_URL to an existing Postgres when local provisioning is unavailable.";
-	const cause = error instanceof Error ? { cause: error } : undefined;
-	return new DbosDurabilityError(`DBOS workflow durability ${action} failed: ${detail}. ${guidance}`, cause);
-}
-
-function combinedShutdownFailure(errors: readonly unknown[]): unknown {
-	if (errors.length === 1) return errors[0];
-	return new AggregateError(errors, errors.map((error) => readDbosFailureDetail(error)).join("; "));
-}
-
-export async function configureDbosOnce(): Promise<ConfiguredDbosDurability> {
-	const slot = owner();
-	if (slot.failure !== undefined) throw slot.failure;
-	slot.configured ??= configureDurability()
-		.then((value) => {
-			slot.active = value;
-			slot.state = "configured";
-			return value;
-		})
-		.catch(async (error: unknown) => {
-			slot.failure = await durabilityFailure("configuration", error);
-			slot.state = "failed";
-			throw slot.failure;
-		});
-	return await slot.configured;
-}
-
-export async function launchDbosOnce(): Promise<void> {
-	const slot = owner();
-	if (slot.failure !== undefined) throw slot.failure;
-	// The executor is process-scoped and stops exactly once, at process exit.
-	// Post-shutdown launches must fail loudly instead of returning a backend
-	// whose SDK launched marker has been cleared.
-	if (slot.state === "shutting_down" || slot.state === "shut_down") throw new DbosShutdownError();
-	const durability = await configureDbosOnce();
-	slot.launchPromise ??= (async () => {
-		slot.state = "launching";
-		try {
-			await durability.launch();
-			slot.state = "ready";
-		} catch (error) {
-			if (shouldProvisionLocalDbos(error)) {
-				try {
-					// DBOS creates an executor before testing connectivity. Tear down the
-					// failed executor so retry does not leak a pool or hang shutdown.
-					await durability.shutdown();
-					await provisionLocalDbos();
-					await durability.launch();
-					slot.state = "ready";
-					return;
-				} catch (provisionError) {
-					slot.failure = await durabilityFailure("local Postgres startup", provisionError);
-				}
-			} else {
-				slot.failure = await durabilityFailure("launch", error);
-			}
-			slot.state = "failed";
-			throw slot.failure;
-		}
-	})();
-	await slot.launchPromise;
-}
-
-export async function getReadyDbosBackend(): Promise<DbosDurableBackend> {
-	await launchDbosOnce();
-	const slot = owner();
-	if (slot.state !== "ready" || slot.active === undefined) throw slot.failure ?? new DbosNotReadyError();
-	return slot.active.backend;
-}
-
-export function getReadyDbosBackendSync(): DbosDurableBackend | undefined {
-	const slot = owner();
-	return slot.state === "ready" ? slot.active?.backend : undefined;
-}
-
-export async function shutdownDbos(): Promise<void> {
-	const slot = owner();
-	if (slot.shutdownPromise !== undefined) return await slot.shutdownPromise;
-	const configuredPromise = slot.configured;
-	if (configuredPromise === undefined) return;
-	slot.shutdownPromise = (async () => {
-		// Configuration and launch failures are intentionally not rethrown during
-		// session disposal, but local provisioning may already have started an
-		// owned cluster. Always attempt that cleanup exactly once.
-		const durability = await configuredPromise.catch(() => undefined);
-		if (durability === undefined) {
-			await shutdownLocalDbos();
-			return;
-		}
-		if (slot.launchPromise !== undefined) await slot.launchPromise.catch(() => undefined);
-		if (slot.state !== "ready") {
-			await shutdownLocalDbos();
-			return;
-		}
-		slot.state = "shutting_down";
-		const errors: unknown[] = [];
-		for (const shutdown of [() => durability.backend.flush(), () => durability.shutdown(), shutdownLocalDbos]) {
-			try {
-				await shutdown();
-			} catch (error) {
-				errors.push(error);
-			}
-		}
-		if (errors.length > 0) throw combinedShutdownFailure(errors);
-		slot.state = "shut_down";
-	})().catch(async (error: unknown) => {
-		slot.failure = await durabilityFailure("shutdown", error);
-		slot.state = "failed";
-		throw slot.failure;
-	});
-	await slot.shutdownPromise;
-}
-
-/**
- * Flush queued durable writes without stopping the process-scoped executor.
- * Used at process-preserving host-session boundaries (`/new`, `/resume`,
- * `/fork`, `/reload`) where the DBOS executor must stay launched.
- */
-export async function flushDbos(): Promise<void> {
-	const slot = owner();
-	if (slot.state !== "ready" || slot.active === undefined) return;
-	await slot.active.backend.flush();
-}
-
-export function dbosLifecycleState(): DbosLifecycleState {
-	return owner().state;
-}
-
-/** Reset the process singleton with an explicit configurator for unit tests. */
-export function resetDbosLifecycleForTests(
-	configurator: DbosConfigurator = defaultConfigurator,
-	provisioner: LocalDbosProvisioner = provisionResolvedLocalDbos,
-	shutdowner: LocalDbosShutdowner = shutdownResolvedLocalDbos,
-): void {
-	resetDbosProcessOwner();
-	configureDurability = configurator;
-	provisionLocalDbos = provisioner;
-	shutdownLocalDbos = shutdowner;
-}

package/dist/builtin/workflows/src/durable/dbos-local-postgres.ts

@@ -1,166 +0,0 @@
-/**
- * Local DBOS database resolution.
- *
- * Without `DBOS_SYSTEM_DATABASE_URL`, Atomic never guesses at a user-managed
- * Postgres (a reachable 5432 with foreign credentials is indistinguishable
- * from a misconfiguration). The order is deterministic:
- *
- *   1. `DBOS_SYSTEM_DATABASE_URL` — the user's explicit database.
- *   2. Atomic's embedded Postgres (npm-distributed binaries, no Docker).
- *   3. DBOS's reusable `dbos-db` Docker container, only after embedded
- *      provisioning fails without leaving retained-process cleanup pending.
- */
-
-import {
-	EMBEDDED_DBOS_SYSTEM_DATABASE_URL,
-	EmbeddedPostgresCleanupPendingError,
-	ensureEmbeddedDbosPostgres,
-	shutdownEmbeddedDbosPostgres,
-} from "./dbos-embedded-postgres.js";
-import { commandFailureDetail, delay, runLocalCommand, tcpReachable } from "./local-command.js";
-
-const DOCKER_CONTAINER = "dbos-db";
-const DOCKER_IMAGE = "pgvector/pgvector:pg16";
-const DOCKER_READY_ATTEMPTS = 60;
-const DOCKER_READY_DELAY_MS = 500;
-
-type LocalDbosProvider = () => Promise<void>;
-type LocalDbosShutdowner = () => Promise<void>;
-
-let resolution: Promise<string | undefined> | undefined;
-let resolvedProvider: LocalDbosProvider | undefined;
-let embeddedProvider: LocalDbosProvider = ensureEmbeddedDbosPostgres;
-let dockerProvider: LocalDbosProvider = ensureDockerDbosPostgres;
-let shutdownEmbeddedProvider: LocalDbosShutdowner = shutdownEmbeddedDbosPostgres;
-let embeddedShutdown: Promise<void> | undefined;
-
-/**
- * Resolve the system database URL for this process and make its database
- * reachable. `undefined` defers to the environment/DBOS defaults (explicit
- * user URL or the Docker container that matches them).
- */
-export function resolveDbosSystemDatabaseUrl(): Promise<string | undefined> {
-	resolution ??= resolve().catch((error: unknown) => {
-		resolution = undefined;
-		throw error;
-	});
-	return resolution;
-}
-
-/** Re-ensure the previously resolved local database (launch-retry safety net). */
-export async function provisionResolvedLocalDbos(): Promise<void> {
-	await (resolvedProvider ?? embeddedProvider)();
-}
-
-/** Stop the local database only when the resolved provider was embedded. */
-export function shutdownResolvedLocalDbos(): Promise<void> {
-	if (resolvedProvider !== embeddedProvider) return Promise.resolve();
-	embeddedShutdown ??= shutdownEmbeddedProvider().then(
-		() => {
-			resolvedProvider = undefined;
-			embeddedShutdown = undefined;
-		},
-		(error: unknown) => {
-			embeddedShutdown = undefined;
-			throw error;
-		},
-	);
-	return embeddedShutdown;
-}
-
-export function shouldProvisionLocalDbos(error: unknown): boolean {
-	if (process.env.DBOS_SYSTEM_DATABASE_URL?.trim()) return false;
-	const message = error instanceof Error ? `${error.message}\n${error.cause ?? ""}` : String(error);
-	return /ECONNREFUSED|server not reachable|connect failed|connection refused|unable to connect to system database/i.test(
-		message,
-	);
-}
-
-async function resolve(): Promise<string | undefined> {
-	const explicit = process.env.DBOS_SYSTEM_DATABASE_URL?.trim();
-	if (explicit) return undefined;
-
-	try {
-		await embeddedProvider();
-		resolvedProvider = embeddedProvider;
-		return EMBEDDED_DBOS_SYSTEM_DATABASE_URL;
-	} catch (embeddedError) {
-		if (embeddedError instanceof EmbeddedPostgresCleanupPendingError) {
-			// A second database must not hide the exact child lease whose startup
-			// rollback timed out. Keep teardown routed to that embedded owner.
-			resolvedProvider = embeddedProvider;
-			throw embeddedError;
-		}
-		try {
-			await dockerProvider();
-			resolvedProvider = dockerProvider;
-			// The container matches DBOS's documented default URL; defer to it.
-			return undefined;
-		} catch (dockerError) {
-			const embeddedDetail = embeddedError instanceof Error ? embeddedError.message : String(embeddedError);
-			const dockerDetail = dockerError instanceof Error ? dockerError.message : String(dockerError);
-			throw new Error(
-				`No usable Postgres for workflow durability. Embedded Postgres: ${embeddedDetail} Docker fallback: ${dockerDetail} ` +
-					"Set DBOS_SYSTEM_DATABASE_URL to an existing Postgres to proceed.",
-			);
-		}
-	}
-}
-
-/** Start DBOS's canonical reusable local Postgres container. */
-async function ensureDockerDbosPostgres(): Promise<void> {
-	const docker = await runLocalCommand("docker", ["version", "--format", "{{.Server.Version}}"]).catch(
-		() => undefined,
-	);
-	if (docker === undefined || docker.exitCode !== 0) {
-		throw new Error("Docker is unavailable.");
-	}
-
-	const inspection = await runLocalCommand("docker", ["inspect", "--format", "{{.State.Running}}", DOCKER_CONTAINER]);
-	if (inspection.exitCode === 0) {
-		if (inspection.stdout.trim() !== "true") {
-			await requireDockerSuccess("start existing DBOS Postgres", ["start", DOCKER_CONTAINER]);
-		}
-	} else {
-		await requireDockerSuccess("create DBOS Postgres", [
-			"run",
-			"-d",
-			"--name",
-			DOCKER_CONTAINER,
-			"-e",
-			"POSTGRES_PASSWORD=dbos",
-			"-e",
-			"PGDATA=/var/lib/postgresql/data",
-			"-p",
-			"127.0.0.1:5432:5432",
-			"-v",
-			"dbos-db-data:/var/lib/postgresql/data",
-			DOCKER_IMAGE,
-		]);
-	}
-
-	for (let attempt = 0; attempt < DOCKER_READY_ATTEMPTS; attempt += 1) {
-		if (await tcpReachable("127.0.0.1", 5432)) return;
-		await delay(DOCKER_READY_DELAY_MS);
-	}
-	throw new Error("The DBOS Postgres container started but did not become ready within 30 seconds.");
-}
-
-async function requireDockerSuccess(action: string, args: string[]): Promise<void> {
-	const result = await runLocalCommand("docker", args);
-	if (result.exitCode === 0) return;
-	throw new Error(`Could not ${action}: ${commandFailureDetail(result)}`);
-}
-
-export function resetLocalDbosProvisioningForTests(
-	embedded: LocalDbosProvider = ensureEmbeddedDbosPostgres,
-	docker: LocalDbosProvider = ensureDockerDbosPostgres,
-	shutdownEmbedded: LocalDbosShutdowner = shutdownEmbeddedDbosPostgres,
-): void {
-	resolution = undefined;
-	resolvedProvider = undefined;
-	embeddedShutdown = undefined;
-	embeddedProvider = embedded;
-	dockerProvider = docker;
-	shutdownEmbeddedProvider = shutdownEmbedded;
-}

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

@@ -1,196 +0,0 @@
-import type { WorkflowActor } from "../shared/store-types.js";
-import type { WorkflowSerializableValue } from "../shared/types.js";
-import {
-	isWorkflowFailureCode,
-	isWorkflowFailureDisposition,
-	isWorkflowFailureKind,
-	isWorkflowFailureRecoverability,
-} from "../shared/workflow-failures.js";
-import type { DbosStepRecord } from "./dbos-backend.js";
-import { DURABLE_FORMAT_VERSION, isCurrentDurableFormat } from "./format-version.js";
-import type { DurableWorkflowMetadata, DurableWorkflowStatus } from "./types.js";
-import { isAbsorbingDurableStatus } from "./workflow-status-transition.js";
-
-const METADATA_STEP_PREFIX = "__atomic_metadata";
-
-export type DbosMetadataClassification =
-	| { readonly kind: "current"; readonly metadata: DurableWorkflowMetadata; readonly generation: number }
-	| { readonly kind: "unknown" }
-	| { readonly kind: "unavailable" };
-
-export function metadataStepName(ts: number): string {
-	return `${METADATA_STEP_PREFIX}:${ts}:${crypto.randomUUID()}`;
-}
-
-/** Deterministic first-writer-wins claim id for one observed generation. */
-export function claimMetadataStepName(generation: number): string {
-	return `${METADATA_STEP_PREFIX}:${generation + 1}:claim`;
-}
-
-export function isMetadataStep(stepName: string): boolean {
-	return stepName === METADATA_STEP_PREFIX || stepName.startsWith(`${METADATA_STEP_PREFIX}:`);
-}
-
-/** Parse one metadata step record, returning current-format metadata only. */
-export function parseCurrentMetadataRecord(
-	record: DbosStepRecord,
-	workflowId: string,
-): DurableWorkflowMetadata | undefined {
-	const classified = classifyMetadataRecord(record, workflowId);
-	return classified.kind === "current" ? classified.metadata : undefined;
-}
-
-export function encodeMetadata(metadata: DurableWorkflowMetadata): WorkflowSerializableValue {
-	return {
-		__atomicDurableMetadata: true,
-		version: DURABLE_FORMAT_VERSION,
-		metadata: {
-			workflowId: metadata.workflowId,
-			name: metadata.name,
-			inputs: metadata.inputs,
-			status: metadata.status,
-			createdAt: metadata.createdAt,
-			completedCheckpoints: metadata.completedCheckpoints,
-			pendingPrompts: metadata.pendingPrompts,
-			promptReservationEpoch: metadata.promptReservationEpoch,
-			...(metadata.ownerExecutorId !== undefined ? { ownerExecutorId: metadata.ownerExecutorId } : {}),
-			...(metadata.transitionClaimId !== undefined ? { transitionClaimId: metadata.transitionClaimId } : {}),
-			...(metadata.sessionFile !== undefined ? { sessionFile: metadata.sessionFile } : {}),
-			...(metadata.label !== undefined ? { label: metadata.label } : {}),
-			...(metadata.rootWorkflowId !== undefined ? { rootWorkflowId: metadata.rootWorkflowId } : {}),
-			...(metadata.resumable !== undefined ? { resumable: metadata.resumable } : {}),
-			...(metadata.exited !== undefined ? { exited: metadata.exited } : {}),
-			...(metadata.exitReason !== undefined ? { exitReason: metadata.exitReason } : {}),
-			...(metadata.error !== undefined ? { error: metadata.error } : {}),
-			...(metadata.failureKind !== undefined ? { failureKind: metadata.failureKind } : {}),
-			...(metadata.failureCode !== undefined ? { failureCode: metadata.failureCode } : {}),
-			...(metadata.failureRecoverability !== undefined
-				? { failureRecoverability: metadata.failureRecoverability }
-				: {}),
-			...(metadata.failureDisposition !== undefined ? { failureDisposition: metadata.failureDisposition } : {}),
-			...(metadata.failedToolNodeId !== undefined ? { failedToolNodeId: metadata.failedToolNodeId } : {}),
-			...(metadata.origin !== undefined ? { origin: metadata.origin } : {}),
-			...(metadata.invocationCwd !== undefined ? { invocationCwd: metadata.invocationCwd } : {}),
-			...(metadata.workflowCwd !== undefined ? { workflowCwd: metadata.workflowCwd } : {}),
-			...(metadata.repositoryRoot !== undefined ? { repositoryRoot: metadata.repositoryRoot } : {}),
-			...(metadata.gitWorktreeRoot !== undefined ? { gitWorktreeRoot: metadata.gitWorktreeRoot } : {}),
-			updatedAt: metadata.updatedAt,
-		},
-	};
-}
-
-export function classifyLatestMetadata(
-	records: readonly DbosStepRecord[],
-	workflowId: string,
-): DbosMetadataClassification {
-	const metadataRecords = records.filter((record) => isMetadataStep(record.stepName));
-	if (metadataRecords.length === 0) return { kind: "unavailable" };
-	const latest = metadataRecords.reduce((selected, record) =>
-		metadataTimestamp(record) >= metadataTimestamp(selected) ? record : selected,
-	);
-	const latestClassification = classifyMetadataRecord(latest, workflowId);
-	if (latestClassification.kind !== "current") return latestClassification;
-	const terminals = metadataRecords
-		.map((record) => ({ record, classified: classifyMetadataRecord(record, workflowId) }))
-		.filter(
-			(
-				candidate,
-			): candidate is {
-				record: DbosStepRecord;
-				classified: { kind: "current"; metadata: DurableWorkflowMetadata };
-			} =>
-				candidate.classified.kind === "current" &&
-				isAbsorbingDurableStatus(candidate.classified.metadata.status, candidate.classified.metadata.resumable),
-		);
-	if (terminals.length === 0) {
-		return { ...latestClassification, generation: metadataTimestamp(latest) };
-	}
-	const terminal = terminals.reduce((selected, candidate) =>
-		metadataTimestamp(candidate.record) >= metadataTimestamp(selected.record) ? candidate : selected,
-	);
-	return { ...terminal.classified, generation: metadataTimestamp(terminal.record) };
-}
-
-function classifyMetadataRecord(
-	record: DbosStepRecord,
-	workflowId: string,
-): { readonly kind: "current"; readonly metadata: DurableWorkflowMetadata } | { readonly kind: "unknown" } {
-	if (typeof record.output !== "object" || record.output === null || Array.isArray(record.output)) {
-		return { kind: "unknown" };
-	}
-	const raw = record.output as Record<string, WorkflowSerializableValue>;
-	if (raw.__atomicDurableMetadata !== true || !isCurrentDurableFormat(raw.version)) {
-		return { kind: "unknown" };
-	}
-	const metadata = parseDurableWorkflowMetadata(raw.metadata, workflowId);
-	return metadata === undefined ? { kind: "unknown" } : { kind: "current", metadata };
-}
-
-function metadataTimestamp(record: DbosStepRecord): number {
-	const segment = record.stepName.split(":")[1];
-	const fromName = segment === undefined ? Number.NaN : Number(segment);
-	return Number.isFinite(fromName) ? fromName : (record.completedAt ?? 0);
-}
-
-function parseDurableWorkflowMetadata(
-	value: WorkflowSerializableValue | undefined,
-	workflowId: string,
-): DurableWorkflowMetadata | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-	const metadata = value as Partial<DurableWorkflowMetadata>;
-	if (
-		metadata.workflowId !== workflowId ||
-		typeof metadata.workflowId !== "string" ||
-		typeof metadata.name !== "string" ||
-		typeof metadata.inputs !== "object" ||
-		metadata.inputs === null ||
-		Array.isArray(metadata.inputs) ||
-		typeof metadata.status !== "string" ||
-		!isDurableWorkflowStatus(metadata.status) ||
-		typeof metadata.completedCheckpoints !== "number" ||
-		typeof metadata.createdAt !== "number" ||
-		typeof metadata.pendingPrompts !== "number" ||
-		typeof metadata.promptReservationEpoch !== "string" ||
-		typeof metadata.updatedAt !== "number" ||
-		(metadata.ownerExecutorId !== undefined && typeof metadata.ownerExecutorId !== "string") ||
-		(metadata.transitionClaimId !== undefined && typeof metadata.transitionClaimId !== "string") ||
-		(metadata.sessionFile !== undefined && typeof metadata.sessionFile !== "string") ||
-		(metadata.label !== undefined && typeof metadata.label !== "string") ||
-		(metadata.rootWorkflowId !== undefined && typeof metadata.rootWorkflowId !== "string") ||
-		(metadata.resumable !== undefined && typeof metadata.resumable !== "boolean") ||
-		(metadata.exited !== undefined && typeof metadata.exited !== "boolean") ||
-		(metadata.exitReason !== undefined && typeof metadata.exitReason !== "string") ||
-		(metadata.error !== undefined && typeof metadata.error !== "string") ||
-		(metadata.failureKind !== undefined && !isWorkflowFailureKind(metadata.failureKind)) ||
-		(metadata.failureCode !== undefined && !isWorkflowFailureCode(metadata.failureCode)) ||
-		(metadata.failureRecoverability !== undefined &&
-			!isWorkflowFailureRecoverability(metadata.failureRecoverability)) ||
-		(metadata.failureDisposition !== undefined && !isWorkflowFailureDisposition(metadata.failureDisposition)) ||
-		(metadata.failedToolNodeId !== undefined && typeof metadata.failedToolNodeId !== "string") ||
-		(metadata.invocationCwd !== undefined && typeof metadata.invocationCwd !== "string") ||
-		(metadata.workflowCwd !== undefined && typeof metadata.workflowCwd !== "string") ||
-		(metadata.repositoryRoot !== undefined && typeof metadata.repositoryRoot !== "string") ||
-		(metadata.gitWorktreeRoot !== undefined && typeof metadata.gitWorktreeRoot !== "string")
-	)
-		return undefined;
-	const { origin, ...metadataWithoutOrigin } = metadata;
-	return {
-		...metadataWithoutOrigin,
-		...(isWorkflowActor(origin) ? { origin } : {}),
-	} as DurableWorkflowMetadata;
-}
-
-function isWorkflowActor(value: WorkflowSerializableValue | undefined): value is WorkflowActor {
-	return value === "user" || value === "agent";
-}
-
-function isDurableWorkflowStatus(value: string): value is DurableWorkflowStatus {
-	return (
-		value === "running" ||
-		value === "paused" ||
-		value === "completed" ||
-		value === "failed" ||
-		value === "cancelled" ||
-		value === "blocked"
-	);
-}

package/dist/builtin/workflows/src/durable/dbos-process-owner.ts

@@ -1,87 +0,0 @@
-/**
- * Process-global owner for DBOS lifecycle state and registered wrappers.
- *
- * `@dbos-inc/dbos-sdk` keeps a process-global operation registry that #1958
- * leaves alive across session replacement. The workflows bundle is re-evaluated
- * on `/reload` and the other process-preserving boundaries, so module-local
- * variables restart at `uninitialized` and `configureDbosDurableBackend` would
- * register `atomicWorkflowHandle` / `atomicWorkflowCheckpoint` a second time.
- * The second registration throws and the replacement session degrades to
- * `InMemoryDurableBackend` (#2022).
- *
- * Session scope is the wrong lifetime: the SDK registry is process-global, so
- * a session-scoped owner would re-register per session and reproduce the bug.
- * This slot lives on `globalThis` under `Symbol.for` so every load generation
- * of the bundle — and a second copy of the module reached through a different
- * specifier — shares one owner.
- *
- * The `@1` suffix is the shape version. Bump it when these fields change so a
- * new generation declines an incompatible predecessor instead of reading it.
- */
-
-import type { WorkflowSerializableValue } from "../shared/types.js";
-import type { ConfiguredDbosDurability } from "./dbos-backend.js";
-import type { DbosDurabilityError, DbosLifecycleState } from "./dbos-lifecycle.js";
-
-export const DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
-
-export interface DbosRegisteredWrappers {
-	readonly mainWorkflow: (
-		name: string,
-		inputs: Record<string, WorkflowSerializableValue>,
-	) => Promise<WorkflowSerializableValue>;
-	readonly checkpointWorkflow: (
-		workflowId: string,
-		stepName: string,
-		output: WorkflowSerializableValue,
-	) => Promise<WorkflowSerializableValue>;
-}
-
-export interface DbosProcessOwner {
-	readonly version: 1;
-	state: DbosLifecycleState;
-	configured: Promise<ConfiguredDbosDurability> | undefined;
-	active: ConfiguredDbosDurability | undefined;
-	launchPromise: Promise<void> | undefined;
-	shutdownPromise: Promise<void> | undefined;
-	failure: DbosDurabilityError | undefined;
-	wrappers: DbosRegisteredWrappers | undefined;
-}
-
-function emptyOwner(): DbosProcessOwner {
-	return {
-		version: 1,
-		state: "uninitialized",
-		configured: undefined,
-		active: undefined,
-		launchPromise: undefined,
-		shutdownPromise: undefined,
-		failure: undefined,
-		wrappers: undefined,
-	};
-}
-
-function ownerBag(): Record<symbol, DbosProcessOwner | undefined> {
-	return globalThis as typeof globalThis & Record<symbol, DbosProcessOwner | undefined>;
-}
-
-export function getDbosProcessOwner(): DbosProcessOwner {
-	const bag = ownerBag();
-	const existing = bag[DBOS_PROCESS_OWNER_KEY];
-	if (existing !== undefined && existing.version === 1) return existing;
-	const created = emptyOwner();
-	bag[DBOS_PROCESS_OWNER_KEY] = created;
-	return created;
-}
-
-/** Reset every field on the process-global slot. Used by durability tests. */
-export function resetDbosProcessOwner(): void {
-	const owner = getDbosProcessOwner();
-	owner.state = "uninitialized";
-	owner.configured = undefined;
-	owner.active = undefined;
-	owner.launchPromise = undefined;
-	owner.shutdownPromise = undefined;
-	owner.failure = undefined;
-	owner.wrappers = undefined;
-}