@bitfab/sdk 0.65.4 → 0.65.6

package/dist/registryCommand-Di8x0YoJ.js

@@ -0,0 +1,1111 @@
+import { register } from "tsx/esm/api";
+import "@opentelemetry/api";
+import "@opentelemetry/core";
+import "@opentelemetry/resources";
+import "@opentelemetry/sdk-trace-base";
+import "superjson";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/errors.ts
+var BitfabError = class extends Error {
+	constructor(message, url, status, retryAfterMs) {
+		super(message);
+		this.url = url;
+		this.status = status;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "BitfabError";
+	}
+};
+(typeof process !== "undefined" && process.versions?.node ? import(
+	/* webpackIgnore: true */
+	["node", "zlib"].join(":")
+).then(({ gzip }) => {}).catch(() => {}) : Promise.resolve()).then(() => {});
+//#endregion
+//#region src/asyncStorage.ts
+let AsyncLocalStorageClass = null;
+function registerAsyncLocalStorageClass(cls) {
+	if (!AsyncLocalStorageClass) AsyncLocalStorageClass = cls;
+}
+const asyncStorageReady = (typeof process !== "undefined" && process.versions?.node ? 
+// webpackIgnore tells webpack/turbopack to emit a native import()
+import(
+	/* webpackIgnore: true */
+	["node", "async_hooks"].join(":")
+).then((mod) => {
+	registerAsyncLocalStorageClass(mod.AsyncLocalStorage);
+}).catch(() => {}) : Promise.resolve()).then(() => {});
+function createAsyncLocalStorage() {
+	return AsyncLocalStorageClass ? new AsyncLocalStorageClass() : null;
+}
+const REPLAY_CONTEXT_STORAGE_SYMBOL = Symbol.for("bitfab.replayContextStorage");
+const replayContextReady = asyncStorageReady.then(() => {
+	const shared = globalThis;
+	if (shared[REPLAY_CONTEXT_STORAGE_SYMBOL]) return;
+	const created = createAsyncLocalStorage();
+	if (created) shared[REPLAY_CONTEXT_STORAGE_SYMBOL] = created;
+});
+//#endregion
+//#region src/captureSuppression.ts
+const suppressionGlobal = globalThis;
+suppressionGlobal.__bitfabCaptureSuppressionV1 = suppressionGlobal.__bitfabCaptureSuppressionV1 ?? { depth: 0 };
+typeof TextEncoder !== "undefined" && new TextEncoder();
+//#endregion
+//#region src/warnOnce.ts
+const warned = /* @__PURE__ */ new Set();
+function warn(message) {
+	try {
+		console.warn(`[bitfab] ${message}`);
+	} catch {}
+}
+function warnOnce(key, message) {
+	if (warned.has(key)) return;
+	warned.add(key);
+	warn(message);
+}
+function writeOnce(key, line, write = console.warn) {
+	if (warned.has(key)) return;
+	warned.add(key);
+	try {
+		write(line);
+	} catch {}
+}
+//#endregion
+//#region src/simulationPlan.ts
+const SIMULATION_PLAN_READ_TIMEOUT_MS = 5e3;
+function planWaitSliceMs(timeoutMs) {
+	return Math.min(SIMULATION_PLAN_READ_TIMEOUT_MS, Math.max(timeoutMs, 0) / 2);
+}
+//#endregion
+//#region src/unrefTimer.ts
+function unrefTimer(timer) {
+	const handle = timer;
+	if (typeof handle.unref === "function") handle.unref();
+}
+//#endregion
+//#region src/otel.ts
+const DEFAULT_LIFECYCLE_TIMEOUT_MS$1 = 3e4;
+const liveTransports = /* @__PURE__ */ new Set();
+async function forEachLiveTransport(timeoutMs, run) {
+	const deadline = Date.now() + Math.max(timeoutMs, 0);
+	let succeeded = true;
+	for (const transport of [...liveTransports]) succeeded = await run(transport, Math.max(0, deadline - Date.now())) && succeeded;
+	return succeeded;
+}
+function flushOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS$1) {
+	return forEachLiveTransport(timeoutMs, (transport, remaining) => transport.flush(remaining));
+}
+function shutdownOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS$1) {
+	return forEachLiveTransport(timeoutMs, (transport, remaining) => transport.shutdown(remaining));
+}
+//#endregion
+//#region src/transport.ts
+function flushTraceTransports(timeoutMs) {
+	return flushOtelTransports(timeoutMs);
+}
+function shutdownTraceTransports(timeoutMs) {
+	return shutdownOtelTransports(timeoutMs);
+}
+//#endregion
+//#region src/http.ts
+var http_exports = /* @__PURE__ */ __exportAll({
+	awaitPendingRequests: () => awaitPendingRequests,
+	flushTraces: () => flushTraces
+});
+const EXIT_FLUSH_TIMEOUT_MS = 5e3;
+const DEFAULT_LIFECYCLE_TIMEOUT_MS = 3e4;
+const pendingTracePromises = /* @__PURE__ */ new Set();
+const liveHttpClients = /* @__PURE__ */ new Set();
+async function releaseHeldExternalSpans(timeoutMs) {
+	const deadline = Date.now() + Math.max(timeoutMs, 0);
+	let released = true;
+	for (const client of [...liveHttpClients]) released = await client.releaseHeldExternalSpans?.(Math.max(0, deadline - Date.now())) !== false && released;
+	return released;
+}
+function stopSimulationPlans() {
+	for (const client of [...liveHttpClients]) client.stopSimulationPlan?.();
+}
+async function flushTraces(timeoutMs = 5e3) {
+	const deadline = Date.now() + Math.max(timeoutMs, 0);
+	const released = await releaseHeldExternalSpans(planWaitSliceMs(timeoutMs));
+	const requestsFlushed = await awaitPendingRequests(Math.max(0, deadline - Date.now()));
+	const releasedAfterDeferred = await releaseHeldExternalSpans(0);
+	const transportsFlushed = await flushTraceTransports(Math.max(0, deadline - Date.now()));
+	return released && releasedAfterDeferred && requestsFlushed && transportsFlushed;
+}
+async function awaitPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
+	await replayContextReady.catch(() => {});
+	return waitForPromises(Array.from(pendingTracePromises), timeoutMs);
+}
+async function waitForPromises(promises, timeoutMs) {
+	if (promises.length === 0) return true;
+	let timer;
+	try {
+		return await Promise.race([Promise.allSettled(promises).then(() => true), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(false), timeoutMs);
+			unrefTimer(timer);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
+	let isFlushing = false;
+	process.on("beforeExit", () => {
+		if (isFlushing) return;
+		isFlushing = true;
+		const planWaitMs = SIMULATION_PLAN_READ_TIMEOUT_MS;
+		const stopFlushing = () => {
+			isFlushing = false;
+		};
+		const deadline = setTimeout(stopFlushing, 1e4);
+		unrefTimer(deadline);
+		releaseHeldExternalSpans(planWaitMs).catch(() => {}).then(() => {
+			stopSimulationPlans();
+		}).then(() => Promise.allSettled([...Array.from(pendingTracePromises).map((p) => p.catch(() => {})), shutdownTraceTransports(EXIT_FLUSH_TIMEOUT_MS).catch(() => false)])).then(() => {
+			clearTimeout(deadline);
+			stopFlushing();
+		});
+	});
+}
+//#endregion
+//#region src/replayInterrupt.ts
+function describeReplayInterrupt(experimentId, markedInterrupted) {
+	if (markedInterrupted) return `[replay] Experiment ${experimentId} interrupted.`;
+	return `[replay] Experiment ${experimentId} stopped, but Bitfab could not mark it interrupted. It will be marked interrupted within 15 minutes. A resume in the next two minutes may be refused as still running.`;
+}
+//#endregion
+//#region src/replayInvocation.ts
+const CLI_FLAGS = Symbol("bitfab.replayCliFlags");
+const CLI_FLAG_ALIASES = {
+	"max-concurrency": "concurrency",
+	"dataset-id": "dataset-ids"
+};
+function canonicalCliFlag(name) {
+	return CLI_FLAG_ALIASES[name] ?? name;
+}
+function withCliFlags(options, flags) {
+	Object.defineProperty(options, CLI_FLAGS, {
+		value: flags,
+		enumerable: false
+	});
+	return options;
+}
+//#endregion
+//#region src/replay.ts
+const BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
+function reportReplayProgress(progress) {
+	const stderr = typeof process !== "undefined" ? process.stderr : void 0;
+	if (!stderr) return;
+	try {
+		stderr.write(`${BITFAB_PROGRESS_PREFIX}${JSON.stringify(progress, replayJsonReplacer)}\n`);
+	} catch {}
+}
+var ReplayError = class extends BitfabError {
+	constructor(message, items, experimentId, experimentUrl, cause) {
+		super(message, experimentUrl);
+		this.items = items;
+		this.experimentId = experimentId;
+		this.experimentUrl = experimentUrl;
+		this.cause = cause;
+		this.name = "ReplayError";
+		this.testRunId = experimentId;
+		this.testRunUrl = experimentUrl;
+	}
+};
+var DbBranchReplayError = class extends BitfabError {
+	constructor(code, message, originalTraceId, cause) {
+		super(message);
+		this.code = code;
+		this.originalTraceId = originalTraceId;
+		this.cause = cause;
+		this.name = "DbBranchReplayError";
+	}
+};
+function replayJsonReplacer(_key, value) {
+	if (value instanceof Error) {
+		const serialized = {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		if (value instanceof DbBranchReplayError) {
+			serialized.code = value.code;
+			serialized.originalTraceId = value.originalTraceId;
+			if (value.cause !== void 0) serialized.cause = value.cause;
+		}
+		return serialized;
+	}
+	return value;
+}
+function serializeReplayResult(result) {
+	return JSON.stringify(result, replayJsonReplacer, 2);
+}
+const JUDGE_ASSERTIONS_DEPRECATION_WARNING = "Bitfab: judgeAssertions is deprecated. Assertion judging is on by default; pass skipAssertionJudging: true (--skip-assertion-judging) to turn it off.";
+function warnJudgeAssertionsDeprecated(write = console.warn) {
+	writeOnce("judgeAssertions-deprecated", JUDGE_ASSERTIONS_DEPRECATION_WARNING, write);
+}
+//#endregion
+//#region src/autoTrace.ts
+const autoTraceGlobal = globalThis;
+autoTraceGlobal.__bitfabAutoTraceStateV4 = autoTraceGlobal.__bitfabAutoTraceStateV4 ?? {
+	storage: null,
+	browserScope: void 0,
+	capturePolicies: /* @__PURE__ */ new WeakMap(),
+	activeRoots: 0
+};
+const VERCEL_PROVIDER_HOSTS = {
+	github: "github.com",
+	gitlab: "gitlab.com",
+	bitbucket: "bitbucket.org"
+};
+function read(env, name) {
+	if (name === null) return null;
+	const value = env(name)?.trim();
+	return value ? value : null;
+}
+function remoteFrom(...names) {
+	return (env) => {
+		const parts = names.map((name) => read(env, name));
+		if (parts.some((part) => part === null)) return null;
+		return normalizeRemote(parts.join("/"));
+	};
+}
+function vercelRemote(env) {
+	const provider = read(env, "VERCEL_GIT_PROVIDER")?.toLowerCase() ?? "";
+	const host = VERCEL_PROVIDER_HOSTS[provider];
+	const owner = read(env, "VERCEL_GIT_REPO_OWNER");
+	const slug = read(env, "VERCEL_GIT_REPO_SLUG");
+	if (!host || !owner || !slug) return null;
+	return `${host}/${owner}/${slug}`;
+}
+function noRemote() {
+	return null;
+}
+[...[
+	[
+		"VERCEL_GIT_COMMIT_SHA",
+		"VERCEL_GIT_COMMIT_REF",
+		vercelRemote
+	],
+	[
+		"GITHUB_SHA",
+		"GITHUB_REF_NAME",
+		remoteFrom("GITHUB_SERVER_URL", "GITHUB_REPOSITORY")
+	],
+	[
+		"RAILWAY_GIT_COMMIT_SHA",
+		"RAILWAY_GIT_BRANCH",
+		noRemote
+	],
+	[
+		"RENDER_GIT_COMMIT",
+		"RENDER_GIT_BRANCH",
+		noRemote
+	],
+	[
+		"SOURCE_VERSION",
+		null,
+		noRemote
+	],
+	[
+		"CF_PAGES_COMMIT_SHA",
+		"CF_PAGES_BRANCH",
+		noRemote
+	],
+	[
+		"CI_COMMIT_SHA",
+		"CI_COMMIT_REF_NAME",
+		remoteFrom("CI_REPOSITORY_URL")
+	],
+	[
+		"BUILD_SOURCEVERSION",
+		"BUILD_SOURCEBRANCHNAME",
+		remoteFrom("BUILD_REPOSITORY_URI")
+	],
+	[
+		"CIRCLE_SHA1",
+		"CIRCLE_BRANCH",
+		remoteFrom("CIRCLE_REPOSITORY_URL")
+	]
+].flatMap(([sha, branch]) => branch === null ? [sha] : [sha, branch])];
+function normalizeRemote(raw) {
+	const value = raw?.trim();
+	if (!value) return null;
+	let host = "";
+	let path = value;
+	if (value.includes("://")) try {
+		const parsed = new URL(value);
+		host = parsed.hostname;
+		path = parsed.pathname;
+	} catch {
+		return null;
+	}
+	else {
+		const separator = value.indexOf(":");
+		if (separator !== -1) {
+			const head = value.slice(0, separator);
+			host = head.slice(head.lastIndexOf("@") + 1);
+			path = value.slice(separator + 1);
+		}
+	}
+	path = path.replace(/^\/+|\/+$/g, "");
+	if (path.endsWith(".git")) path = path.slice(0, -4).replace(/\/+$/, "");
+	if (!host) return path || null;
+	return path ? `${host}/${path}` : host;
+}
+Promise.resolve();
+//#endregion
+//#region src/openaiAgentsSpanContext.ts
+const spanGlobal = globalThis;
+spanGlobal.__bitfabOpenAiAgentsSpansV1 = spanGlobal.__bitfabOpenAiAgentsSpansV1 ?? {
+	bitfabTraceIds: /* @__PURE__ */ new Map(),
+	endedSpanIds: /* @__PURE__ */ new Map()
+};
+//#endregion
+//#region src/rivetContext.ts
+let storage = null;
+const STORAGE_SYMBOL = Symbol.for("bitfab.rivetContextStorage");
+function initializeStorage() {
+	if (storage) return;
+	const shared = globalThis;
+	const existing = shared[STORAGE_SYMBOL];
+	if (existing) {
+		storage = existing;
+		return;
+	}
+	const created = createAsyncLocalStorage();
+	if (created) {
+		shared[STORAGE_SYMBOL] = created;
+		storage = created;
+	}
+}
+asyncStorageReady.then(() => {
+	initializeStorage();
+});
+const SEED_CONTEXT_STORAGE_SYMBOL = Symbol.for("bitfab.seedContextStorage");
+asyncStorageReady.then(() => {
+	const shared = globalThis;
+	if (shared[SEED_CONTEXT_STORAGE_SYMBOL]) return;
+	const created = createAsyncLocalStorage();
+	if (created) shared[SEED_CONTEXT_STORAGE_SYMBOL] = created;
+});
+//#endregion
+//#region src/client.ts
+let asyncLocalStorage = null;
+const SPAN_CONTEXT_STORAGE_SYMBOL = Symbol.for("bitfab.spanContextStorage");
+const initializeAsyncContext = () => {
+	if (asyncLocalStorage) return;
+	const shared = globalThis;
+	const existing = shared[SPAN_CONTEXT_STORAGE_SYMBOL];
+	if (existing) {
+		asyncLocalStorage = existing;
+		return;
+	}
+	const created = createAsyncLocalStorage();
+	if (created) {
+		shared[SPAN_CONTEXT_STORAGE_SYMBOL] = created;
+		asyncLocalStorage = created;
+	}
+};
+asyncStorageReady.then(() => {
+	initializeAsyncContext();
+});
+function _resolvedApiKey(client) {
+	return client.findApiKey(true) ?? null;
+}
+function _serviceUrl(client) {
+	return client.serviceUrl;
+}
+//#endregion
+//#region src/replayRegistry.ts
+const REGISTRATION_FIELDS = /* @__PURE__ */ new Set([
+	"client",
+	"fn",
+	"traceFunctionKey",
+	"options",
+	"optionsFactory"
+]);
+function validateReplayRegistry(registry) {
+	for (const [pipeline, registration] of Object.entries(registry)) {
+		if (typeof registration !== "object" || registration === null) throw new BitfabError(`Replay registry entry '${pipeline}' must be an object with client and fn.`);
+		const unknownFields = Object.keys(registration).filter((field) => !REGISTRATION_FIELDS.has(field));
+		if (unknownFields.length > 0) warnOnce(`replay-registry-unknown-fields:${pipeline}:${unknownFields.join(",")}`, `Replay registry entry '${pipeline}' has unknown field(s): ${unknownFields.join(", ")}. They are ignored. An entry takes client, fn, traceFunctionKey, options, and optionsFactory. Put replay options such as adaptInputs, mock, and mockOverride inside options. A later SDK release will reject unknown fields.`);
+	}
+}
+const VALUE_FLAGS = /* @__PURE__ */ new Set([
+	"--limit",
+	"--attempts",
+	"--trace-ids",
+	"--name",
+	"--notes",
+	"--metadata",
+	"--concurrency",
+	"--max-concurrency",
+	"--code-change",
+	"--experiment-group-id",
+	"--experiment-group-name",
+	"--dataset-id",
+	"--dataset-ids",
+	"--grader-ids",
+	"--mock",
+	"--param",
+	"--params",
+	"--resume"
+]);
+const BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+	"--only-with-assertions",
+	"--skip-assertion-judging",
+	"--judge-assertions",
+	"--db-branch",
+	"--no-db-branch",
+	"--no-code-change",
+	"--dry-run",
+	"--fail-on-error",
+	"--force"
+]);
+const HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+const REPEATABLE_FLAGS = /* @__PURE__ */ new Set(["--metadata", "--param"]);
+function recordFlag(flags, flag, raw) {
+	const name = canonicalCliFlag(flag.slice(2));
+	if (raw === void 0) {
+		flags[name] = true;
+		return;
+	}
+	const value = flag === "--param" ? raw.split("=")[0] : raw;
+	if (REPEATABLE_FLAGS.has(flag)) {
+		const previous = flags[name];
+		flags[name] = [...Array.isArray(previous) ? previous : [], value];
+		return;
+	}
+	flags[name] = value;
+}
+const MAX_ATTEMPTS = 100;
+const MAX_PINNED_TRACE_IDS = 100;
+const INTERRUPT_EXIT_CODES = {
+	SIGINT: 130,
+	SIGTERM: 143
+};
+const RESUME_CONFLICTING_FLAGS = [
+	["traceIds", "--trace-ids"],
+	["datasetIds", "--dataset-ids"],
+	["limit", "--limit"],
+	["attempts", "--attempts"],
+	["graderIds", "--grader-ids"],
+	["onlyWithAssertions", "--only-with-assertions"],
+	["dryRun", "--dry-run"]
+];
+const RESUME_CLEARED_OPTIONS = {
+	traceIds: void 0,
+	limit: void 0,
+	datasetId: void 0,
+	datasetIds: void 0,
+	attempts: void 0,
+	graderIds: void 0,
+	onlyWithAssertions: void 0,
+	dryRun: void 0
+};
+function hasApprovedAssertion(assertions) {
+	return assertions.some((assertion) => assertion.approvalState === "approved");
+}
+async function boundTraceIds(client, traceIds, limit, onlyWithAssertions) {
+	if (!Number.isInteger(limit) || limit < 1) throw new BitfabError("Replay limit must be a positive integer.");
+	if (!onlyWithAssertions || limit >= traceIds.length) return traceIds.slice(0, limit);
+	const selected = [];
+	for (const traceId of traceIds) {
+		const { assertions, inheritedFrom } = await client.traces.getAssertions(traceId);
+		if (inheritedFrom === null && hasApprovedAssertion(assertions)) {
+			selected.push(traceId);
+			if (selected.length === limit) break;
+		}
+	}
+	if (selected.length === 0) throw new BitfabError("No traces with approved assertions matched this replay selection.");
+	return selected;
+}
+async function pinnedDatasetMembers(client, datasetIds, limit, onlyWithAssertions = false) {
+	const members = /* @__PURE__ */ new Set();
+	for (const datasetId of datasetIds) {
+		const { traceIds } = await client.datasets.listTraces(datasetId);
+		for (const traceId of traceIds) members.add(traceId);
+	}
+	const ordered = [...members].sort();
+	if (limit >= ordered.length) return;
+	if (limit > MAX_PINNED_TRACE_IDS) throw new BitfabError(`Bounding a dataset replay to ${limit} names one trace ID per replayed item, and a replay accepts at most ${MAX_PINNED_TRACE_IDS}. Drop the limit to replay every selected dataset in full.`);
+	return boundTraceIds(client, ordered, limit, onlyWithAssertions);
+}
+function usage(registry) {
+	return `Usage: bitfab-replay --registry <path> <${registry === void 0 ? "pipeline" : Object.keys(registry).join("|")}> [options]\n\nOptions:\n  --limit N (bounds a trace ID or dataset selection instead of replacing it)\n  --attempts N (replay each trace N times in this run, max ${MAX_ATTEMPTS})\n  --trace-ids id1,id2\n  --name NAME (what this run is testing, such as "baseline"; Bitfab already records the commit, branch, and datasets)\n  --notes TEXT (run conditions Bitfab cannot see, such as a forced feature flag)\n  --metadata key=value (repeatable; tags kept on the experiment, such as which schedule launched it, and filterable through client.experiments.list)\n  --concurrency N, --max-concurrency N\n  --code-change PATH, --no-code-change\n  --experiment-group-id UUID (join this experiment group; a new UUID creates the group)\n  --experiment-group-name NAME (name the group when this run creates it or it has no name yet; requires --experiment-group-id)\n  --dataset-ids uuid1,uuid2 (--dataset-id is the same flag)\n  --grader-ids id1,id2\n  --only-with-assertions (replay only traces carrying an approved assertion)\n  --skip-assertion-judging (don't judge approved assertions on each replay; judging is on by default and costs model calls)\n  --judge-assertions (deprecated: judging is on by default)\n  --mock none|all|marked\n  --db-branch, --no-db-branch\n  --dry-run (resolve inputs, run nothing)\n  --fail-on-error (exit 1 after printing the result when any replayed item errored; under --dry-run, items whose inputs failed to resolve count)\n  --resume EXPERIMENT_ID (finish an experiment that stopped partway, running only the items it did not finish, with the traces, attempts, and graders it started with)\n  --force (with --resume, resume even when the experiment may still be running or the code changed since it started)\n  --params PATH\n  --param name=value (repeatable)\n  -h, --help`;
+}
+var ReplayCliHelp = class extends Error {};
+async function reseedFromRegistry(registry, pipeline, traceIds) {
+	const registration = registry[pipeline];
+	if (registration === void 0) throw new BitfabError(`Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`);
+	const traceFunctionKey = resolveTraceFunctionKey(registration);
+	const reseeded = [];
+	for (const traceId of traceIds) reseeded.push(await registration.client.reseedTrace(traceFunctionKey, registration.fn, { traceId }));
+	return {
+		pipeline,
+		traceFunctionKey,
+		reseeded
+	};
+}
+function parseSeedCases(raw, path, run) {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) throw new BitfabError(`Seed file '${path}' is empty.`);
+	return (trimmed.startsWith("[") ? JSON.parse(trimmed) : trimmed.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line))).map((value, index) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new BitfabError(`Seed case ${index} in '${path}' must be an object with an "input" array.`);
+		const { input } = value;
+		if (!Array.isArray(input)) throw new BitfabError(`Seed case ${index} in '${path}' is missing an "input" array. Wrap a single argument as [arg].`);
+		if (run && "expected" in value) throw new BitfabError(`Seed case ${index} in '${path}' carries "expected", which --run does not record: the case is run once and its output is what the run produced. Remove the field, or drop --run to record the case without running it.`);
+		return value;
+	});
+}
+async function seedFromRegistry(registry, pipeline, cases, options = {}) {
+	const registration = registry[pipeline];
+	if (registration === void 0) throw new BitfabError(`Unknown pipeline '${pipeline}'. Registered: ${Object.keys(registry).join(", ")}`);
+	const traceFunctionKey = resolveTraceFunctionKey(registration);
+	if (options.run === true) {
+		const traceIds = [];
+		for (const seedCase of cases) traceIds.push(await registration.client.seedTrace(traceFunctionKey, registration.fn, {
+			args: seedCase.input,
+			metadata: seedCase.metadata,
+			sessionId: seedCase.sessionId
+		}));
+		return {
+			pipeline,
+			traceFunctionKey,
+			traceIds
+		};
+	}
+	const traceIds = cases.map((seedCase) => registration.client.seedTrace(traceFunctionKey, {
+		input: seedCase.input,
+		expected: seedCase.expected,
+		fn: registration.fn,
+		metadata: seedCase.metadata,
+		sessionId: seedCase.sessionId
+	}));
+	const { flushTraces } = await Promise.resolve().then(() => http_exports);
+	await flushTraces(3e4);
+	return {
+		pipeline,
+		traceFunctionKey,
+		traceIds
+	};
+}
+const SEED_USAGE = "Usage: bitfab-seed --registry <path> <pipeline> --from-trace <id>[,<id>...]\n       bitfab-seed --registry <path> <pipeline> --cases <cases.jsonl> [--run]\n\n--from-trace re-seeds each trace: the registered function runs once on the trace's recorded inputs and the result is recorded under the same trace id, with the previous run kept as history under a new id. Nothing is mocked and no experiment is created. Labels, assertions, and dataset membership stay on the trace.\n\n--cases seeds new cases. Each case is a JSON object with an \"input\" array, plus optional \"expected\", \"metadata\", and \"sessionId\"; a JSON array of those objects works too. Without --run, each case is written as a trace directly (\"input\" becomes the root span input and \"expected\" its output) and nothing executes. With --run, each case runs once through the registered function with capture off and the execution is recorded, so the output is what the run produced; cases carrying \"expected\" are rejected.\n\nbitfab-replay --registry <path> <pipeline> --seed <cases.jsonl> [--run] is the older spelling of --cases.";
+async function runSeedCli(registry, argv, io = {}) {
+	const stdout = io.stdout ?? console.log;
+	const stderr = io.stderr ?? console.error;
+	if (argv.some((value) => HELP_FLAGS.has(value))) throw new ReplayCliHelp(SEED_USAGE);
+	const pipeline = argv[0];
+	if (pipeline === void 0 || registry[pipeline] === void 0) throw new BitfabError(SEED_USAGE);
+	const fromTraceIndex = argv.indexOf("--from-trace");
+	if (fromTraceIndex !== -1) {
+		const raw = argv[fromTraceIndex + 1];
+		if (raw === void 0 || raw.startsWith("--")) throw new BitfabError("--from-trace requires one or more trace ids.");
+		const traceIds = commaSeparated("--from-trace", raw);
+		stderr(`[seed] Re-seeding ${traceIds.length} trace(s) through "${pipeline}"...`);
+		const result = await reseedFromRegistry(registry, pipeline, traceIds);
+		for (const entry of result.reseeded) stderr(`[seed] ${entry.traceId} now holds the fresh run; the previous run is kept as ${entry.previousRunTraceId}`);
+		stdout(JSON.stringify(result, null, 2));
+		return result;
+	}
+	const casesFlagIndex = argv.indexOf("--cases");
+	const seedIndex = casesFlagIndex === -1 ? argv.indexOf("--seed") : casesFlagIndex;
+	if (seedIndex === -1) throw new BitfabError(SEED_USAGE);
+	const casesPath = argv[seedIndex + 1];
+	if (casesPath === void 0 || casesPath.startsWith("--")) throw new BitfabError(`${argv[seedIndex]} requires a path to a cases file.`);
+	const run = argv.includes("--run");
+	const cases = parseSeedCases(await (io.readFile ?? defaultReadFile)(casesPath), casesPath, run);
+	stderr(run ? `[seed] Running ${cases.length} case(s) through "${pipeline}"...` : `[seed] Seeding ${cases.length} case(s) into "${pipeline}"...`);
+	const result = await seedFromRegistry(registry, pipeline, cases, { run });
+	stderr(`[seed] ${run ? "Recorded" : "Wrote"} ${result.traceIds.length} trace(s) for "${result.traceFunctionKey}". Replay them with --trace-ids ${result.traceIds.slice(0, 3).join(",")}${result.traceIds.length > 3 ? ",..." : ""}`);
+	stdout(JSON.stringify(result, null, 2));
+	return result;
+}
+function requirePositiveInteger(flag, raw, max) {
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value < 1) throw new BitfabError(`${flag} must be a positive integer (received '${raw}').`);
+	if (max !== void 0 && value > max) throw new BitfabError(`${flag} must be at most ${max} (received '${raw}').`);
+	return value;
+}
+function commaSeparated(flag, raw) {
+	const values = raw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+	if (values.length === 0) throw new BitfabError(`${flag} must contain at least one value.`);
+	return values;
+}
+function checkReplayCliArgs(argv) {
+	parseReplayCliArgs(void 0, argv);
+}
+function parseReplayCliArgs(registry, argv) {
+	if (argv.some((value) => HELP_FLAGS.has(value))) throw new ReplayCliHelp(usage(registry));
+	const pipeline = argv[0];
+	if (pipeline === void 0 || registry !== void 0 && registry[pipeline] === void 0) throw new BitfabError(usage(registry));
+	const parsed = {
+		pipeline,
+		params: [],
+		flags: {}
+	};
+	for (let index = 1; index < argv.length; index += 1) {
+		const flag = argv[index];
+		if (BOOLEAN_FLAGS.has(flag)) {
+			recordFlag(parsed.flags, flag);
+			switch (flag) {
+				case "--db-branch":
+					if (parsed.dbBranch === false) throw new BitfabError("--db-branch and --no-db-branch cannot be used together.");
+					parsed.dbBranch = true;
+					break;
+				case "--no-db-branch":
+					if (parsed.dbBranch === true) throw new BitfabError("--db-branch and --no-db-branch cannot be used together.");
+					parsed.dbBranch = false;
+					break;
+				case "--only-with-assertions":
+					parsed.onlyWithAssertions = true;
+					break;
+				case "--skip-assertion-judging":
+					parsed.skipAssertionJudging = true;
+					break;
+				case "--judge-assertions":
+					parsed.judgeAssertionsFlag = true;
+					break;
+				case "--no-code-change":
+					parsed.noCodeChange = true;
+					break;
+				case "--dry-run":
+					parsed.dryRun = true;
+					break;
+				case "--fail-on-error":
+					parsed.failOnError = true;
+					break;
+				case "--force": parsed.force = true;
+			}
+			continue;
+		}
+		if (!VALUE_FLAGS.has(flag)) throw new BitfabError(`Unknown replay option '${flag}'.\n${usage(registry)}`);
+		const raw = argv[index + 1];
+		if (raw === void 0 || raw.startsWith("--")) throw new BitfabError(`${flag} requires a value.`);
+		index += 1;
+		recordFlag(parsed.flags, flag, raw);
+		switch (flag) {
+			case "--limit":
+				parsed.limit = requirePositiveInteger(flag, raw);
+				break;
+			case "--attempts":
+				parsed.attempts = requirePositiveInteger(flag, raw, MAX_ATTEMPTS);
+				break;
+			case "--trace-ids":
+				parsed.traceIds = commaSeparated(flag, raw);
+				break;
+			case "--name":
+				parsed.name = raw;
+				break;
+			case "--notes":
+				parsed.notes = raw;
+				break;
+			case "--metadata": {
+				const [key, value] = parseMetadataTag(raw);
+				parsed.metadata = {
+					...parsed.metadata,
+					[key]: value
+				};
+				break;
+			}
+			case "--concurrency":
+			case "--max-concurrency":
+				parsed.maxConcurrency = requirePositiveInteger(flag, raw);
+				break;
+			case "--code-change":
+				parsed.codeChangePath = raw;
+				break;
+			case "--experiment-group-id":
+				parsed.experimentGroupId = raw;
+				break;
+			case "--experiment-group-name":
+				parsed.experimentGroupName = raw;
+				break;
+			case "--dataset-id":
+			case "--dataset-ids":
+				parsed.datasetIds = commaSeparated(flag, raw);
+				break;
+			case "--grader-ids":
+				parsed.graderIds = commaSeparated(flag, raw);
+				break;
+			case "--mock":
+				if (raw !== "none" && raw !== "all" && raw !== "marked") throw new BitfabError(`--mock must be one of: none, all, marked (received '${raw}').`);
+				parsed.mock = raw;
+				break;
+			case "--params":
+				parsed.paramsPath = raw;
+				break;
+			case "--param":
+				parsed.params.push(raw);
+				break;
+			case "--resume": parsed.resume = raw;
+		}
+	}
+	if (parsed.force === true && parsed.resume === void 0) throw new BitfabError("--force only applies with --resume <experimentId>.");
+	if (parsed.resume !== void 0) {
+		const conflicting = RESUME_CONFLICTING_FLAGS.filter(([key]) => parsed[key] !== void 0).map(([, flag]) => flag);
+		if (conflicting.length > 0) throw new BitfabError(`--resume reuses the traces, attempts, and graders experiment ${parsed.resume} started with, so it cannot be combined with ${conflicting.join(", ")}.`);
+	}
+	if (parsed.traceIds !== void 0 && parsed.datasetIds !== void 0) throw new BitfabError("--trace-ids and --dataset-ids select different replay sources and cannot be used together.");
+	if (parsed.codeChangePath !== void 0 && parsed.noCodeChange === true) throw new BitfabError("--code-change and --no-code-change cannot be used together.");
+	return parsed;
+}
+function resolveRegistrationDatasetIds(options) {
+	if (options.datasetId !== void 0 && options.datasetIds !== void 0) throw new BitfabError("Replay registry options datasetId and datasetIds are the same selector: set one of them.");
+	if (options.datasetId !== void 0) return [options.datasetId];
+	return options.datasetIds;
+}
+function describeSelection(options) {
+	if (options.traceIds !== void 0) return `${options.traceIds.length} traces`;
+	if (options.limit !== void 0) return `${options.limit} traces`;
+	const datasetCount = options.datasetIds?.length ?? 1;
+	return datasetCount > 1 ? `${datasetCount} datasets' traces` : "dataset traces";
+}
+function resolveTraceFunctionKey(registration) {
+	const wrappedKey = registration.fn._bitfabTraceFunctionKey;
+	const key = registration.traceFunctionKey ?? wrappedKey;
+	if (key === void 0) throw new BitfabError("Replay registry entry uses a plain function. Set traceFunctionKey to the key its production handler records.");
+	return key;
+}
+async function defaultReadFile(path) {
+	const fs = await import("fs/promises").catch(() => null);
+	if (fs === null) throw new BitfabError("--code-change requires a runtime that can read local files.");
+	return fs.readFile(path, "utf8");
+}
+async function loadCodeChange(path, readFile) {
+	if (path === void 0) return;
+	const value = JSON.parse(await readFile(path));
+	if (typeof value.description !== "string" || !Array.isArray(value.files)) throw new BitfabError(`Invalid --code-change file '${path}': expected { description, files }.`);
+	return {
+		description: value.description,
+		files: value.files
+	};
+}
+function parseMetadataTag(raw) {
+	const separator = raw.indexOf("=");
+	const key = raw.slice(0, separator).trim();
+	if (separator < 1 || key.length === 0) throw new BitfabError(`Invalid --metadata '${raw}': expected a non-empty key=value pair.`);
+	return [key, raw.slice(separator + 1)];
+}
+function parseParameter(raw) {
+	const separator = raw.indexOf("=");
+	const key = raw.slice(0, separator).trim();
+	if (separator < 1 || key.length === 0) throw new BitfabError(`Invalid --param '${raw}': expected a non-empty name=value pair.`);
+	const value = raw.slice(separator + 1);
+	try {
+		return [key, JSON.parse(value)];
+	} catch {
+		return [key, value];
+	}
+}
+async function loadParameters(path, rawParameters, readFile) {
+	let params = {};
+	if (path !== void 0) {
+		const value = JSON.parse(await readFile(path));
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new BitfabError(`Invalid --params file '${path}': expected a JSON object.`);
+		params = { ...value };
+	}
+	for (const raw of rawParameters) {
+		const [key, value] = parseParameter(raw);
+		params[key] = value;
+	}
+	return params;
+}
+function valuesEqual(left, right) {
+	try {
+		return JSON.stringify(left) === JSON.stringify(right);
+	} catch {
+		return Object.is(left, right);
+	}
+}
+function renderSummary(pipeline, result, stderr) {
+	let same = 0;
+	let changed = 0;
+	let matched = 0;
+	let missed = 0;
+	let errors = 0;
+	let carriedOver = 0;
+	for (const item of result.items) {
+		if (item.carriedOver === true) {
+			carriedOver += 1;
+			continue;
+		}
+		if (item.error !== null) {
+			errors += 1;
+			continue;
+		}
+		const equal = valuesEqual(item.result, item.originalOutput);
+		if (item.ingestionType === "seeded") {
+			if (equal) matched += 1;
+			else missed += 1;
+		} else if (equal) same += 1;
+		else changed += 1;
+	}
+	stderr("\n─── Summary ───");
+	stderr(`  Pipeline: ${pipeline}`);
+	stderr(`  Replayed: ${result.items.length - carriedOver}`);
+	if (carriedOver > 0) stderr(`  Carried over from the earlier run: ${carriedOver}`);
+	if (result.attempts > 1) stderr(`  Attempts: ${result.attempts}`);
+	if (same > 0 || changed > 0 || matched + missed === 0) {
+		stderr(`  Same:     ${same}`);
+		stderr(`  Changed:  ${changed}`);
+	}
+	if (matched > 0 || missed > 0) {
+		stderr(`  Matched expected: ${matched}`);
+		stderr(`  Missed expected:  ${missed}`);
+	}
+	if (errors > 0) stderr(`  Errors:   ${errors}`);
+	stderr(`\n  ${result.experimentUrl}`);
+}
+function countErroredItems(result) {
+	const replayed = result.items.filter((item) => item.carriedOver !== true);
+	return {
+		errored: replayed.filter((item) => item.error !== null).length,
+		replayed: replayed.length
+	};
+}
+function renderDryRun(pipeline, result, stderr) {
+	stderr("\n─── Dry run ───");
+	stderr(`  Pipeline: ${pipeline}`);
+	stderr(`  Resolved: ${result.items.length} (nothing was executed)`);
+	for (const item of result.items) {
+		stderr(`\n  ${item.originalTraceId}`);
+		stderr(`    args: ${safeJson(item.input)}`);
+	}
+	if (result.experimentUrl !== null) stderr(`\n  ${result.experimentUrl}`);
+}
+function safeJson(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+function shellQuote(value) {
+	return /^[\w@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function resumeCommand(registryPath, args, experimentId) {
+	const carried = [
+		...args.mock === void 0 ? [] : ["--mock", args.mock],
+		...args.paramsPath === void 0 ? [] : ["--params", args.paramsPath],
+		...args.params.flatMap((param) => ["--param", param])
+	];
+	return [
+		"Resume with: bitfab-replay --registry",
+		registryPath === void 0 ? "<path>" : shellQuote(registryPath),
+		...[
+			args.pipeline,
+			...carried,
+			"--resume",
+			experimentId
+		].map(shellQuote)
+	].join(" ");
+}
+function reportReplayError(error, stderr) {
+	for (const item of error.items) stderr(`${item.originalTraceId}: ${String(item.traceError ?? item.replayError ?? item.error)}`);
+}
+const API_KEY_LINE_PREFIX = "@@bitfab:api-key ";
+const PRINT_API_KEY_FLAG = "--print-api-key";
+async function runReplayCli(registry, argv = typeof process === "undefined" ? [] : process.argv.slice(2), io = {}, registryPath) {
+	const stdout = io.stdout ?? console.log;
+	const stderr = io.stderr ?? console.error;
+	const printApiKey = argv.includes(PRINT_API_KEY_FLAG);
+	const args = parseReplayCliArgs(registry, argv.filter((arg) => arg !== PRINT_API_KEY_FLAG));
+	if (printApiKey) {
+		const client = registry[args.pipeline].client;
+		const apiKey = _resolvedApiKey(client);
+		const serviceUrl = _serviceUrl(client);
+		stdout(`${API_KEY_LINE_PREFIX}${JSON.stringify({
+			apiKey,
+			serviceUrl
+		})}`);
+		return null;
+	}
+	if (args.judgeAssertionsFlag) warnJudgeAssertionsDeprecated(stderr);
+	const registration = registry[args.pipeline];
+	const traceFunctionKey = resolveTraceFunctionKey(registration);
+	const readFile = io.readFile ?? defaultReadFile;
+	const params = await loadParameters(args.paramsPath, args.params, readFile);
+	const dynamicOptions = await registration.optionsFactory?.({ params });
+	const registrationOptions = {
+		...registration.options,
+		...dynamicOptions
+	};
+	const registrationDatasetIds = resolveRegistrationDatasetIds(registrationOptions);
+	if (registrationOptions.traceIds !== void 0 && registrationDatasetIds !== void 0) throw new BitfabError("Replay registry options traceIds and datasetIds select different sources and cannot be used together.");
+	const selectedDatasetIds = args.datasetIds ?? registrationDatasetIds;
+	const codeChange = await loadCodeChange(args.codeChangePath, readFile);
+	let startedExperimentId;
+	const options = {
+		...registrationOptions,
+		...args.name === void 0 ? {} : { name: args.name },
+		...args.notes === void 0 ? {} : { notes: args.notes },
+		...args.metadata === void 0 ? {} : { metadata: args.metadata },
+		...args.attempts === void 0 ? {} : { attempts: args.attempts },
+		...args.maxConcurrency === void 0 ? {} : { maxConcurrency: args.maxConcurrency },
+		...args.experimentGroupId === void 0 ? {} : { experimentGroupId: args.experimentGroupId },
+		...args.experimentGroupName === void 0 ? {} : { experimentGroupName: args.experimentGroupName },
+		datasetId: void 0,
+		datasetIds: selectedDatasetIds,
+		...args.graderIds === void 0 ? {} : { graderIds: args.graderIds },
+		...args.onlyWithAssertions === void 0 ? {} : { onlyWithAssertions: args.onlyWithAssertions },
+		...args.skipAssertionJudging === void 0 ? {} : { skipAssertionJudging: args.skipAssertionJudging },
+		...args.mock === void 0 ? {} : { mock: args.mock },
+		...args.dbBranch === void 0 ? {} : { dbBranch: args.dbBranch && registrationOptions.dbBranch !== void 0 && registrationOptions.dbBranch !== false ? registrationOptions.dbBranch : args.dbBranch },
+		...args.noCodeChange === true ? {
+			codeChangeDescription: null,
+			codeChangeFiles: null
+		} : {},
+		...args.dryRun === true ? { dryRun: true } : {},
+		...codeChange === void 0 ? {} : {
+			codeChangeDescription: codeChange.description,
+			codeChangeFiles: codeChange.files
+		},
+		onItemStart: reportReplayProgress,
+		onItemFinish: reportReplayProgress,
+		onExperimentStart: ({ experimentId, experimentUrl }) => {
+			startedExperimentId = experimentId;
+			stderr(`[replay] Experiment ${experimentId}: ${experimentUrl}`);
+		},
+		onInterrupt: ({ experimentId, signal, markedInterrupted }) => {
+			stderr(`${describeReplayInterrupt(experimentId, markedInterrupted)} ${resumeCommand(registryPath, args, experimentId)}`);
+			process.exit(INTERRUPT_EXIT_CODES[signal]);
+		}
+	};
+	withCliFlags(options, args.flags);
+	if (args.resume !== void 0) {
+		Object.assign(options, RESUME_CLEARED_OPTIONS, {
+			resume: args.resume,
+			...args.force === true ? { force: true } : {}
+		});
+		stderr(`[replay] Resuming experiment ${args.resume} of "${traceFunctionKey}"...`);
+	} else {
+		if (args.traceIds !== void 0) {
+			options.traceIds = args.traceIds;
+			options.datasetIds = void 0;
+		} else if (args.datasetIds !== void 0) options.traceIds = void 0;
+		const bound = args.limit ?? registrationOptions.limit;
+		options.limit = void 0;
+		if (options.traceIds !== void 0) {
+			if (bound !== void 0) options.traceIds = await boundTraceIds(registration.client, options.traceIds, bound, options.onlyWithAssertions === true);
+		} else if (options.datasetIds !== void 0) {
+			if (bound !== void 0) {
+				const pinned = await pinnedDatasetMembers(registration.client, options.datasetIds, bound, options.onlyWithAssertions === true);
+				if (pinned !== void 0) options.traceIds = pinned;
+			}
+		} else options.limit = bound ?? 10;
+		const attemptsSuffix = options.attempts !== void 0 && options.attempts > 1 ? ` (${options.attempts} attempts each)` : "";
+		stderr(`[replay] ${args.dryRun === true ? "Resolving inputs for" : "Replaying"} ${describeSelection(options)} from "${traceFunctionKey}"${attemptsSuffix}...`);
+	}
+	let result;
+	try {
+		result = await registration.client.replay(traceFunctionKey, registration.fn, options);
+	} catch (error) {
+		if (error instanceof ReplayError) reportReplayError(error, stderr);
+		const experimentId = error instanceof ReplayError ? error.experimentId : startedExperimentId;
+		if (experimentId !== void 0) stderr(resumeCommand(registryPath, args, experimentId));
+		throw error;
+	}
+	if (args.dryRun === true) renderDryRun(args.pipeline, result, stderr);
+	else renderSummary(args.pipeline, result, stderr);
+	stdout(serializeReplayResult(result));
+	if (result.items.length === 0) throw new BitfabError(`No traces matched "${traceFunctionKey}", so nothing was replayed. Seed cases with --seed, or capture a trace first.`);
+	if (args.failOnError === true) {
+		const { errored, replayed } = countErroredItems(result);
+		if (errored > 0) throw new BitfabError(`[replay] ${errored} of ${replayed} ${args.dryRun === true ? "resolved" : "replayed"} items errored; exiting 1 because of --fail-on-error`);
+	}
+	return result;
+}
+//#endregion
+//#region src/registryCommand.ts
+let isTypeScriptLoaderRegistered = false;
+async function parseRegistryCommandArgs(argv, usage) {
+	if (argv.some((value) => value === "--help" || value === "-h") && !argv.includes("--registry")) throw new ReplayCliHelp(usage);
+	const registryFlagIndex = argv.indexOf("--registry");
+	const registryPath = argv[registryFlagIndex + 1];
+	if (registryFlagIndex === -1 || registryPath === void 0 || registryPath.startsWith("--")) throw new BitfabError(usage);
+	const commandArgs = argv.filter((_value, index) => index !== registryFlagIndex && index !== registryFlagIndex + 1);
+	if (commandArgs.length === 0) throw new BitfabError(usage);
+	const { resolve } = await import("path");
+	return {
+		registryPath: resolve(registryPath),
+		commandArgs
+	};
+}
+async function importRegistry(path) {
+	const { pathToFileURL } = await import("url");
+	if (!isTypeScriptLoaderRegistered) {
+		register();
+		isTypeScriptLoaderRegistered = true;
+	}
+	try {
+		return await import(pathToFileURL(path).href);
+	} catch (error) {
+		if (isModuleNotFoundError(error)) throw new BitfabError(`${error.message}\n\n${registryImportHint(path)}`);
+		throw error;
+	}
+}
+function isModuleNotFoundError(error) {
+	const code = error?.code;
+	return error instanceof Error && (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND");
+}
+function registryImportHint(path) {
+	return [
+		`The replay registry '${path}' could not load one of its imports.`,
+		"A registry belongs in the package that builds the traced function's call and already depends on everything it imports (its tools, clients, and config), and bitfab-replay runs from that package's directory.",
+		"When the traced function lives in a lower-level library that an app package calls, put the registry in the app package and add @bitfab/sdk to it. Copying the app's dependencies into the library is the wrong fix.",
+		`See "When the traced function needs the app's dependencies" at https://docs.bitfab.ai/typescript-sdk.`
+	].join("\n");
+}
+function resolveRegistry(moduleValue, path) {
+	if (typeof moduleValue !== "object" || moduleValue === null) throw new BitfabError(`Replay registry '${path}' must export a default registry.`);
+	const registry = moduleValue.default;
+	if (typeof registry !== "object" || registry === null) throw new BitfabError(`Replay registry '${path}' must export a default registry.`);
+	validateReplayRegistry(registry);
+	return registry;
+}
+async function runRegistryMain(run, io = {}) {
+	const stdout = io.stdout ?? console.log;
+	const stderr = io.stderr ?? console.error;
+	try {
+		await run();
+		return 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (error instanceof ReplayCliHelp) {
+			stdout(message);
+			return 0;
+		}
+		if (error instanceof ReplayError) stderr(`Experiment ${error.experimentId}: ${error.experimentUrl}`);
+		stderr(message);
+		return 1;
+	}
+}
+async function isEntrypoint(moduleUrl) {
+	const executablePath = process.argv[1];
+	if (executablePath === void 0) return false;
+	const [{ realpath }, { fileURLToPath }] = await Promise.all([import("fs/promises"), import("url")]);
+	return await realpath(executablePath) === await realpath(fileURLToPath(moduleUrl));
+}
+function runIfEntrypoint(moduleUrl, main) {
+	isEntrypoint(moduleUrl).then((entrypoint) => {
+		if (entrypoint) main().then((exitCode) => {
+			process.exitCode = exitCode;
+		});
+	});
+}
+//#endregion
+export { runRegistryMain as a, runSeedCli as c, runIfEntrypoint as i, parseRegistryCommandArgs as n, checkReplayCliArgs as o, resolveRegistry as r, runReplayCli as s, importRegistry as t };
+
+//# sourceMappingURL=registryCommand-Di8x0YoJ.js.map