bitfab 0.32.0 → 0.33.0

package/dist/index.cjs

@@ -14,6 +14,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -38,6 +41,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
 // src/errors.ts
 var BitfabError;
@@ -533,11 +540,11 @@ __export(replay_exports, {
   replay: () => replay,
   reportReplayProgress: () => reportReplayProgress
 });
-function resolveDbBranchSettings(environment) {
-  if (!environment) {
+function resolveDbBranchSettings(dbBranch) {
+  if (!dbBranch) {
     return void 0;
   }
-  const { minCu, maxCu, warmupSql } = environment.dbBranch;
+  const { minCu, maxCu, warmupSql } = dbBranch;
   const settings = {
     ...minCu === void 0 ? {} : { minCu },
     ...maxCu === void 0 ? {} : { maxCu },
@@ -605,9 +612,9 @@ function buildMockTree(rootNode) {
   }
   return { spans };
 }
-async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy, resolvedOverrides, replayedTraceId, environment, adaptInputs) {
-  const lease = environment ? serverItem.dbBranchLease : void 0;
-  const leaseError = environment ? serverItem.dbBranchLeaseError : void 0;
+async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy, resolvedOverrides, replayedTraceId, includeDbBranchLease, adaptInputs) {
+  const lease = includeDbBranchLease ? serverItem.dbBranchLease : void 0;
+  const leaseError = includeDbBranchLease ? serverItem.dbBranchLeaseError : void 0;
   let inputs = [];
   let originalOutput;
   let result;
@@ -790,12 +797,12 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     options?.name,
     codeChangeDescription,
     codeChangeFiles,
-    options?.environment !== void 0,
+    options?.dbBranch !== void 0,
     // includeDbBranchLease
     options?.experimentGroupId,
     options?.datasetId,
     options?.graderIds,
-    resolveDbBranchSettings(options?.environment)
+    resolveDbBranchSettings(options?.dbBranch)
   );
   const mockStrategy = options?.mock ?? "marked";
   const maxConcurrency = options?.maxConcurrency ?? 10;
@@ -813,7 +820,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       mockStrategy,
       resolvedOverrides,
       replayedTraceIds[index],
-      options?.environment,
+      options?.dbBranch !== void 0,
       options?.adaptInputs
     )
   );
@@ -970,11 +977,11 @@ __export(index_exports, {
   BitfabOpenAITracingProcessor: () => BitfabOpenAITracingProcessor,
   BitfabVercelAiHandler: () => BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL: () => DEFAULT_SERVICE_URL,
-  ReplayEnvironment: () => ReplayEnvironment,
   SUPPORTED_PROVIDERS: () => SUPPORTED_PROVIDERS,
   __version__: () => __version__,
   finalizers: () => finalizers,
   flushTraces: () => flushTraces,
+  getCurrentReplayBranch: () => getCurrentReplayBranch,
   getCurrentSpan: () => getCurrentSpan,
   getCurrentTrace: () => getCurrentTrace,
   reportReplayProgress: () => reportReplayProgress
@@ -982,7 +989,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.generated.ts
-var __version__ = "0.32.0";
+var __version__ = "0.33.0";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -1785,7 +1792,7 @@ var BitfabClaudeAgentHandler = class {
     }
   }
   // ── hook callbacks ───────────────────────────────────────────
-  async preToolUseHook(inputData, toolUseId, _context) {
+  async preToolUseHook(inputData, toolUseId, _context2) {
     try {
       const sid = inputData.tool_use_id ?? toolUseId ?? randomUuid();
       const toolName = inputData.tool_name ?? "tool";
@@ -1797,7 +1804,7 @@ var BitfabClaudeAgentHandler = class {
     }
     return {};
   }
-  async postToolUseHook(inputData, toolUseId, _context) {
+  async postToolUseHook(inputData, toolUseId, _context2) {
     try {
       const sid = inputData.tool_use_id ?? toolUseId ?? "";
       const toolResponse = inputData.tool_response;
@@ -1806,7 +1813,7 @@ var BitfabClaudeAgentHandler = class {
     }
     return {};
   }
-  async postToolUseFailureHook(inputData, toolUseId, _context) {
+  async postToolUseFailureHook(inputData, toolUseId, _context2) {
     try {
       const sid = inputData.tool_use_id ?? toolUseId ?? "";
       const error = String(inputData.error ?? "Unknown error");
@@ -1815,7 +1822,7 @@ var BitfabClaudeAgentHandler = class {
     }
     return {};
   }
-  async subagentStartHook(inputData, _toolUseId, _context) {
+  async subagentStartHook(inputData, _toolUseId, _context2) {
     try {
       const agentId = inputData.agent_id ?? randomUuid();
       const agentType = inputData.agent_type ?? "subagent";
@@ -1833,7 +1840,7 @@ var BitfabClaudeAgentHandler = class {
     }
     return {};
   }
-  async subagentStopHook(inputData, _toolUseId, _context) {
+  async subagentStopHook(inputData, _toolUseId, _context2) {
     try {
       const agentId = inputData.agent_id ?? "";
       const spanId = this.activeSubagentSpans.get(agentId);
@@ -3073,106 +3080,46 @@ var BitfabOpenAIAgentHandler = class {
 
 // src/client.ts
 init_randomUuid();
-init_replayContext();
 
-// src/replayEnvironment.ts
-init_replayContext();
-var ReplayEnvironment = class {
-  constructor(options = {}) {
-    this.dbBranch = { ...options };
+// src/replayBranch.ts
+var _url, _context;
+var ReplayBranch = class {
+  /** @internal Built by `getCurrentReplayBranch()`; never constructed by callers. */
+  constructor(lease, traceId, context) {
+    // Genuine JS private fields, not TypeScript `private`: these must be
+    // non-enumerable so neither the connection string nor the whole replay
+    // context can ride along into a log line or a serialized payload.
+    __privateAdd(this, _url);
+    __privateAdd(this, _context);
+    this.expiresAt = lease.expiresAt;
+    this.providerConsoleUrl = lease.providerConsoleUrl;
+    this.readOnly = lease.readOnly;
+    this.region = lease.region;
+    this.traceId = traceId;
+    __privateSet(this, _url, lease.databaseUrl);
+    __privateSet(this, _context, context);
   }
   /**
-   * The per-trace branch URL for the item currently being replayed.
-   * Throws if read outside a replay item.
+   * Connection string for this item's branch. Point your database client at it
+   * instead of the live database for the duration of the replayed call.
+   *
+   * Reading it records on the trace that the replayed code obtained the branch
+   * URL, which is what separates "a branch was provisioned" from "the branch
+   * was actually used". The other fields inspect the lease without exposing the
+   * connection string, so they deliberately do not record anything. That is
+   * also why this is a getter and not a plain field: the URL is absent from
+   * `JSON.stringify(branch)` and from logging the object.
    */
   get databaseUrl() {
-    const snapshot = this.require();
-    this.markAccessed();
-    return snapshot.databaseUrl;
-  }
-  /** When the per-trace branch URL stops being valid. ISO-8601. */
-  get expiresAt() {
-    return this.require().expiresAt;
-  }
-  /** Deep link to the branch in the provider console, if available. */
-  get providerConsoleUrl() {
-    return this.require().providerConsoleUrl;
-  }
-  /**
-   * True if the branch is read-only. Customer code can use this to skip
-   * write operations during replay when the provider returned a read-only
-   * lease.
-   */
-  get readOnly() {
-    return this.require().readOnly;
-  }
-  /**
-   * The branch's region, e.g. `aws-us-east-1`. A compute runs in its project's
-   * region, so a replay runner elsewhere pays that round trip on every query.
-   */
-  get region() {
-    return this.require().region;
-  }
-  /** The historical trace ID that produced the input for this replay item. */
-  get traceId() {
-    return this.require().traceId;
-  }
-  /** True when read inside a replay item that has a resolved branch. */
-  get active() {
-    return this.read() !== null;
-  }
-  /** Non-throwing variant for callers that handle the inactive case. */
-  snapshot() {
-    const snapshot = this.read();
-    if (snapshot) {
-      this.markAccessed();
-    }
-    return snapshot;
-  }
-  /**
-   * Record on the replay context that customer code obtained the branch
-   * URL. Only `databaseUrl` and `snapshot()` count - `active`, `readOnly`
-   * and friends inspect the lease without exposing the connection string,
-   * so they don't prove the replayed code could have connected to the
-   * branch.
-   */
-  markAccessed() {
-    const ctx = getReplayContext();
-    if (ctx?.dbBranchLease) {
-      ctx.dbSnapshotAccessed = true;
-    }
-  }
-  read() {
-    const ctx = getReplayContext();
-    if (!ctx?.dbBranchLease) {
-      return null;
-    }
-    const traceId = ctx.sourceBitfabTraceId ?? ctx.inputSourceTraceId;
-    if (!traceId) {
-      return null;
-    }
-    const lease = ctx.dbBranchLease;
-    return {
-      databaseUrl: lease.databaseUrl,
-      expiresAt: lease.expiresAt,
-      providerConsoleUrl: lease.providerConsoleUrl,
-      readOnly: lease.readOnly,
-      region: lease.region,
-      traceId
-    };
-  }
-  require() {
-    const snapshot = this.read();
-    if (!snapshot) {
-      throw new Error(
-        "ReplayEnvironment accessed outside of a replay item. Pass it to bitfab.replay({ environment }) and only read it inside the replayed function."
-      );
-    }
-    return snapshot;
+    __privateGet(this, _context).dbSnapshotAccessed = true;
+    return __privateGet(this, _url);
   }
 };
+_url = new WeakMap();
+_context = new WeakMap();
 
 // src/client.ts
+init_replayContext();
 init_serialize();
 
 // src/tracing.ts
@@ -3769,6 +3716,17 @@ function getCurrentSpan() {
     }
   };
 }
+function getCurrentReplayBranch() {
+  const ctx = getReplayContext();
+  if (!ctx?.dbBranchLease) {
+    return null;
+  }
+  const traceId = ctx.sourceBitfabTraceId ?? ctx.inputSourceTraceId;
+  if (!traceId) {
+    return null;
+  }
+  return new ReplayBranch(ctx.dbBranchLease, traceId, ctx);
+}
 function getCurrentTrace() {
   const stack = getSpanStack();
   const current = stack[stack.length - 1];
@@ -4843,12 +4801,6 @@ var Bitfab = class {
     );
   }
 };
-/**
- * Per-trace environment for `replay({ environment })`. Construct one,
- * pass it to replay, and read `env.databaseUrl` inside the replayed
- * function to pick up the per-trace branch URL.
- */
-Bitfab.ReplayEnvironment = ReplayEnvironment;
 var BitfabFunction = class {
   constructor(client, traceFunctionKey) {
     this.client = client;
@@ -5056,11 +5008,11 @@ init_replay();
   BitfabOpenAITracingProcessor,
   BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
-  ReplayEnvironment,
   SUPPORTED_PROVIDERS,
   __version__,
   finalizers,
   flushTraces,
+  getCurrentReplayBranch,
   getCurrentSpan,
   getCurrentTrace,
   reportReplayProgress