@bitfab/sdk 0.65.3 → 0.65.5

package/dist/chunk-BRMGNMDO.js

@@ -1,1176 +0,0 @@
-import {
-  ReplayError,
-  canonicalCliFlag,
-  describeReplayInterrupt,
-  reportReplayProgress,
-  serializeReplayResult,
-  warnJudgeAssertionsDeprecated,
-  withCliFlags
-} from "./chunk-Z26K57WZ.js";
-import {
-  BitfabError,
-  asyncStorageReady,
-  createAsyncLocalStorage,
-  warnOnce
-} from "./chunk-CLP2L5PU.js";
-
-// src/autoTrace.ts
-var autoTraceGlobal = globalThis;
-var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV4 ?? {
-  storage: null,
-  browserScope: void 0,
-  capturePolicies: /* @__PURE__ */ new WeakMap(),
-  activeRoots: 0
-};
-autoTraceGlobal.__bitfabAutoTraceStateV4 = autoTraceState;
-
-// src/commitRef.ts
-var EXPLICIT_SHA_ENV = "BITFAB_COMMIT_SHA";
-var DISABLE_ENV = "BITFAB_DISABLE_COMMIT_REF";
-var GIT_MAX_BUFFER = 1024 * 1024;
-var 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;
-}
-var PLATFORM_ENVS = [
-  ["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")]
-];
-var COMMIT_REF_ENV_NAMES = [
-  EXPLICIT_SHA_ENV,
-  DISABLE_ENV,
-  ...PLATFORM_ENVS.flatMap(
-    ([sha, branch]) => branch === null ? [sha] : [sha, branch]
-  ),
-  "GITHUB_SERVER_URL",
-  "GITHUB_REPOSITORY",
-  "CI_REPOSITORY_URL",
-  "BUILD_REPOSITORY_URI",
-  "CIRCLE_REPOSITORY_URL",
-  "VERCEL_GIT_PROVIDER",
-  "VERCEL_GIT_REPO_OWNER",
-  "VERCEL_GIT_REPO_SLUG"
-];
-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, -".git".length).replace(/\/+$/, "");
-  }
-  if (!host) {
-    return path || null;
-  }
-  return path ? `${host}/${path}` : host;
-}
-var settled = Promise.resolve();
-
-// src/openaiAgentsSpanContext.ts
-var spanGlobal = globalThis;
-var state = spanGlobal.__bitfabOpenAiAgentsSpansV1 ?? {
-  bitfabTraceIds: /* @__PURE__ */ new Map(),
-  endedSpanIds: /* @__PURE__ */ new Map()
-};
-spanGlobal.__bitfabOpenAiAgentsSpansV1 = state;
-
-// src/rivetContext.ts
-var storage = null;
-var STORAGE_SYMBOL = /* @__PURE__ */ 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;
-  }
-}
-var rivetContextReady = asyncStorageReady.then(() => {
-  initializeStorage();
-});
-
-// src/seedContext.ts
-var seedContextStorage = null;
-var SEED_CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("bitfab.seedContextStorage");
-var seedContextReady = asyncStorageReady.then(() => {
-  const shared = globalThis;
-  const existing = shared[SEED_CONTEXT_STORAGE_SYMBOL];
-  if (existing) {
-    seedContextStorage = existing;
-    return;
-  }
-  const created = createAsyncLocalStorage();
-  if (created) {
-    shared[SEED_CONTEXT_STORAGE_SYMBOL] = created;
-    seedContextStorage = created;
-  }
-});
-
-// src/client.ts
-var asyncLocalStorage = null;
-var SPAN_CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("bitfab.spanContextStorage");
-var 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;
-  }
-};
-var asyncLocalStorageReady = asyncStorageReady.then(() => {
-  initializeAsyncContext();
-});
-function _resolvedApiKey(client) {
-  const keyed = client;
-  return keyed.findApiKey(true) ?? null;
-}
-function _serviceUrl(client) {
-  return client.serviceUrl;
-}
-
-// src/replayRegistry.ts
-var 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.`
-      );
-    }
-  }
-}
-var 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"
-]);
-var 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"
-]);
-var HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
-var 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;
-}
-var MAX_ATTEMPTS = 100;
-var MAX_PINNED_TRACE_IDS = 100;
-var INTERRUPT_EXIT_CODES = {
-  SIGINT: 130,
-  SIGTERM: 143
-};
-var RESUME_CONFLICTING_FLAGS = [
-  ["traceIds", "--trace-ids"],
-  ["datasetIds", "--dataset-ids"],
-  ["limit", "--limit"],
-  ["attempts", "--attempts"],
-  ["graderIds", "--grader-ids"],
-  ["onlyWithAssertions", "--only-with-assertions"],
-  ["dryRun", "--dry-run"]
-];
-var 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 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 boundTraceIds(client, ordered, limit, onlyWithAssertions);
-}
-function usage(registry) {
-  const pipelines = registry === void 0 ? "pipeline" : Object.keys(registry).join("|");
-  return `Usage: bitfab-replay --registry <path> <${pipelines}> [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 (what this run is testing, such as "baseline"; Bitfab already records the commit, branch, and datasets)
-  --notes TEXT (run conditions Bitfab cannot see, such as a forced feature flag)
-  --metadata key=value (repeatable; tags kept on the experiment, such as which schedule launched it, and filterable through client.experiments.list)
-  --concurrency N, --max-concurrency N
-  --code-change PATH, --no-code-change
-  --experiment-group-id UUID (join this experiment group; a new UUID creates the group)
-  --experiment-group-name NAME (name the group when this run creates it or it has no name yet; requires --experiment-group-id)
-  --dataset-ids uuid1,uuid2 (--dataset-id is the same flag)
-  --grader-ids id1,id2
-  --only-with-assertions (replay only traces carrying an approved assertion)
-  --skip-assertion-judging (don't judge approved assertions on each replay; judging is on by default and costs model calls)
-  --judge-assertions (deprecated: judging is on by default)
-  --mock none|all|marked
-  --db-branch, --no-db-branch
-  --dry-run (resolve inputs, run nothing)
-  --fail-on-error (exit 1 after printing the result when any replayed item errored; under --dry-run, items whose inputs failed to resolve count)
-  --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)
-  --force (with --resume, resume even when the experiment may still be running or the code changed since it started)
-  --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 } = await import("./http-WP4YPPKC.js");
-  await flushTraces(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 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;
-          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;
-    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;
-        break;
-    }
-  }
-  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 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 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\u2500\u2500\u2500 Summary \u2500\u2500\u2500");
-  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(`
-  ${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\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)}`);
-  }
-  if (result.experimentUrl !== null) {
-    stderr(`
-  ${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)}`
-    );
-  }
-}
-var API_KEY_LINE_PREFIX = "@@bitfab:api-key ";
-var 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;
-}
-
-// src/registryCommand.ts
-import { register } from "tsx/esm/api";
-var isTypeScriptLoaderRegistered = false;
-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");
-  if (!isTypeScriptLoaderRegistered) {
-    register();
-    isTypeScriptLoaderRegistered = true;
-  }
-  try {
-    return await import(pathToFileURL(path).href);
-  } catch (error) {
-    if (isModuleNotFoundError(error)) {
-      throw new BitfabError(`${error.message}
-
-${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) {
-  void isEntrypoint(moduleUrl).then((entrypoint) => {
-    if (entrypoint) {
-      void main().then((exitCode) => {
-        process.exitCode = exitCode;
-      });
-    }
-  });
-}
-
-export {
-  runSeedCli,
-  checkReplayCliArgs,
-  runReplayCli,
-  parseRegistryCommandArgs,
-  importRegistry,
-  resolveRegistry,
-  runRegistryMain,
-  runIfEntrypoint
-};
-//# sourceMappingURL=chunk-BRMGNMDO.js.map