bitfab 0.52.2 → 0.52.4

package/dist/chunk-HKTODDFP.js

@@ -0,0 +1,747 @@
+import {
+  BitfabError
+} from "./chunk-IG3CPSRQ.js";
+
+// src/codeChange.ts
+var NUL = String.fromCharCode(0);
+
+// src/serialize.ts
+import superjson from "superjson";
+
+// src/replay.ts
+var 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)}
+`
+    );
+  } catch {
+  }
+}
+var ReplayError = class extends BitfabError {
+  constructor(message, items, testRunId, testRunUrl, cause) {
+    super(message, testRunUrl);
+    this.items = items;
+    this.testRunId = testRunId;
+    this.testRunUrl = testRunUrl;
+    this.cause = cause;
+    this.name = "ReplayError";
+  }
+};
+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);
+}
+
+// src/replayRegistry.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--limit",
+  "--attempts",
+  "--trace-ids",
+  "--name",
+  "--concurrency",
+  "--max-concurrency",
+  "--code-change",
+  "--experiment-group-id",
+  "--dataset-id",
+  "--dataset-ids",
+  "--grader-ids",
+  "--mock",
+  "--param",
+  "--params"
+]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "--only-with-assertions",
+  "--db-branch",
+  "--no-db-branch",
+  "--no-code-change",
+  "--dry-run"
+]);
+var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+var MAX_ATTEMPTS = 100;
+var MAX_PINNED_TRACE_IDS = 100;
+async function pinnedDatasetMembers(client, datasetIds, limit) {
+  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 void 0;
+  }
+  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 ordered.slice(0, limit);
+}
+function usage(registry) {
+  return `Usage: bitfab-replay --registry <path> <${Object.keys(registry).join("|")}> [options]
+
+Options:
+  --limit N (bounds a trace ID or dataset selection instead of replacing it)
+  --attempts N (replay each trace N times in this run, max ${MAX_ATTEMPTS})
+  --trace-ids id1,id2
+  --name NAME
+  --concurrency N, --max-concurrency N
+  --code-change PATH, --no-code-change
+  --experiment-group-id UUID
+  --dataset-ids uuid1,uuid2 (--dataset-id is the same flag)
+  --grader-ids id1,id2
+  --only-with-assertions (replay only traces carrying an assertion)
+  --mock none|all|marked
+  --db-branch, --no-db-branch
+  --dry-run (resolve inputs, run nothing)
+  --params PATH
+  --param name=value (repeatable)
+  -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.`);
+  }
+  const values = trimmed.startsWith("[") ? JSON.parse(trimmed) : trimmed.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line));
+  return values.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 traceIds2 = [];
+    for (const seedCase of cases) {
+      traceIds2.push(
+        await registration.client.seedTrace(traceFunctionKey, registration.fn, {
+          args: seedCase.input,
+          metadata: seedCase.metadata,
+          sessionId: seedCase.sessionId
+        })
+      );
+    }
+    return { pipeline, traceFunctionKey, traceIds: traceIds2 };
+  }
+  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: flushTraces2 } = await import("./http-F3AXLOJT.js");
+  await flushTraces2(3e4);
+  return { pipeline, traceFunctionKey, traceIds };
+}
+var SEED_USAGE = `Usage: bitfab-seed --registry <path> <pipeline> --from-trace <id>[,<id>...]
+       bitfab-seed --registry <path> <pipeline> --cases <cases.jsonl> [--run]
+
+--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.
+
+--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.
+
+bitfab-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 result2 = await reseedFromRegistry(registry, pipeline, traceIds);
+    for (const entry of result2.reseeded) {
+      stderr(
+        `[seed] ${entry.traceId} now holds the fresh run; the previous run is kept as ${entry.previousRunTraceId}`
+      );
+    }
+    stdout(JSON.stringify(result2, null, 2));
+    return result2;
+  }
+  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 readFile = io.readFile ?? defaultReadFile;
+  const cases = parseSeedCases(await readFile(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 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[pipeline] === void 0) {
+    throw new BitfabError(usage(registry));
+  }
+  const parsed = { pipeline, params: [] };
+  for (let index = 1; index < argv.length; index += 1) {
+    const flag = argv[index];
+    if (BOOLEAN_FLAGS.has(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 "--no-code-change":
+          parsed.noCodeChange = true;
+          break;
+        case "--dry-run":
+          parsed.dryRun = true;
+          break;
+      }
+      continue;
+    }
+    if (!VALUE_FLAGS.has(flag)) {
+      throw new BitfabError(
+        `Unknown replay option '${flag}'.
+${usage(registry)}`
+      );
+    }
+    const raw = argv[index + 1];
+    if (raw === void 0 || raw.startsWith("--")) {
+      throw new BitfabError(`${flag} requires a value.`);
+    }
+    index += 1;
+    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 "--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 "--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;
+    }
+  }
+  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 void 0;
+  }
+  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 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;
+  for (const item of result.items) {
+    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\u2500\u2500\u2500 Summary \u2500\u2500\u2500");
+  stderr(`  Pipeline: ${pipeline}`);
+  stderr(`  Replayed: ${result.items.length}`);
+  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(`
+  ${result.testRunUrl}`);
+}
+function renderDryRun(pipeline, result, stderr) {
+  stderr("\n\u2500\u2500\u2500 Dry run \u2500\u2500\u2500");
+  stderr(`  Pipeline: ${pipeline}`);
+  stderr(`  Resolved: ${result.items.length} (nothing was executed)`);
+  for (const item of result.items) {
+    stderr(`
+  ${item.originalTraceId}`);
+    stderr(`    args: ${safeJson(item.input)}`);
+  }
+  stderr(`
+  ${result.testRunUrl}`);
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function reportReplayError(error, stderr) {
+  for (const item of error.items) {
+    stderr(
+      `${item.originalTraceId}: ${String(item.traceError ?? item.replayError ?? item.error)}`
+    );
+  }
+}
+async function runReplayCli(registry, argv = typeof process === "undefined" ? [] : process.argv.slice(2), io = {}) {
+  const stdout = io.stdout ?? console.log;
+  const stderr = io.stderr ?? console.error;
+  const args = parseReplayCliArgs(registry, argv);
+  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);
+  const options = {
+    ...registrationOptions,
+    ...args.name === void 0 ? {} : { name: args.name },
+    ...args.attempts === void 0 ? {} : { attempts: args.attempts },
+    ...args.maxConcurrency === void 0 ? {} : { maxConcurrency: args.maxConcurrency },
+    ...args.experimentGroupId === void 0 ? {} : { experimentGroupId: args.experimentGroupId },
+    datasetId: void 0,
+    datasetIds: selectedDatasetIds,
+    ...args.graderIds === void 0 ? {} : { graderIds: args.graderIds },
+    ...args.onlyWithAssertions === void 0 ? {} : { onlyWithAssertions: args.onlyWithAssertions },
+    ...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
+  };
+  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 = options.traceIds.slice(0, bound);
+    }
+  } else if (options.datasetIds !== void 0) {
+    if (bound !== void 0) {
+      const pinned = await pinnedDatasetMembers(
+        registration.client,
+        options.datasetIds,
+        bound
+      );
+      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}...`
+  );
+  try {
+    const result = await registration.client.replay(
+      traceFunctionKey,
+      registration.fn,
+      options
+    );
+    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.`
+      );
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof ReplayError) {
+      reportReplayError(error, stderr);
+    }
+    throw error;
+  }
+}
+
+// src/registryCommand.ts
+import { tsImport } from "tsx/esm/api";
+async function parseRegistryCommandArgs(argv, usage2) {
+  if (argv.some((value) => value === "--help" || value === "-h") && !argv.includes("--registry")) {
+    throw new ReplayCliHelp(usage2);
+  }
+  const registryFlagIndex = argv.indexOf("--registry");
+  const registryPath = argv[registryFlagIndex + 1];
+  if (registryFlagIndex === -1 || registryPath === void 0 || registryPath.startsWith("--")) {
+    throw new BitfabError(usage2);
+  }
+  const commandArgs = argv.filter(
+    (_value, index) => index !== registryFlagIndex && index !== registryFlagIndex + 1
+  );
+  if (commandArgs.length === 0) {
+    throw new BitfabError(usage2);
+  }
+  const { resolve } = await import("path");
+  return { registryPath: resolve(registryPath), commandArgs };
+}
+async function importRegistry(path) {
+  const { pathToFileURL } = await import("url");
+  return tsImport(pathToFileURL(path).href, import.meta.url);
+}
+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.`
+    );
+  }
+  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;
+    }
+    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) {
+  void isEntrypoint(moduleUrl).then((entrypoint) => {
+    if (entrypoint) {
+      void main().then((exitCode) => {
+        process.exitCode = exitCode;
+      });
+    }
+  });
+}
+
+export {
+  runSeedCli,
+  runReplayCli,
+  parseRegistryCommandArgs,
+  importRegistry,
+  resolveRegistry,
+  runRegistryMain,
+  runIfEntrypoint
+};
+//# sourceMappingURL=chunk-HKTODDFP.js.map