bitfab 0.52.4 → 0.52.6

package/dist/node.cjs

@@ -97,7 +97,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.52.4";
+    __version__ = "0.52.6";
     __packageName__ = "bitfab";
   }
 });
@@ -1137,7 +1137,7 @@ var init_otel = __esm({
         if (this.onDelivered === void 0) {
           return;
         }
-        const refs = spans.map((span) => span.ref).filter((ref) => ref !== void 0);
+        const refs = spans.map((span) => span.ref).filter((ref2) => ref2 !== void 0);
         if (refs.length === 0) {
           return;
         }
@@ -1394,9 +1394,9 @@ function parseRetryAfterMs(header) {
   }
   return Math.max(0, at - Date.now());
 }
-function carrierMeta(operation, payload, ref) {
+function carrierMeta(operation, payload, ref2) {
   return {
-    ref,
+    ref: ref2,
     name: carrierName(operation, payload),
     startTime: payloadTimestamp(payload, "started_at"),
     endTime: payloadTimestamp(payload, "ended_at"),
@@ -1641,22 +1641,22 @@ var init_http = __esm({
         return reports;
       }
       /** Build a carrier's meta and record what it adds to its trace's expected set. */
-      recordedMeta(operation, payload, ref) {
-        this.recordSubmittedCarrier(ref);
-        return carrierMeta(operation, payload, ref);
+      recordedMeta(operation, payload, ref2) {
+        this.recordSubmittedCarrier(ref2);
+        return carrierMeta(operation, payload, ref2);
       }
-      recordSubmittedCarrier(ref) {
-        if (ref === void 0) {
+      recordSubmittedCarrier(ref2) {
+        if (ref2 === void 0) {
           return;
         }
-        const delivery = this.traceDeliveries.get(ref.traceId);
+        const delivery = this.traceDeliveries.get(ref2.traceId);
         if (delivery === void 0) {
           return;
         }
-        if (ref.spanId === void 0) {
+        if (ref2.spanId === void 0) {
           delivery.closed = true;
         } else {
-          delivery.submittedSpanIds.add(ref.spanId);
+          delivery.submittedSpanIds.add(ref2.spanId);
         }
       }
       /**
@@ -1682,15 +1682,15 @@ var init_http = __esm({
         }
       }
       recordDeliveredCarriers(refs) {
-        for (const ref of refs) {
-          const delivery = this.traceDeliveries.get(ref.traceId);
+        for (const ref2 of refs) {
+          const delivery = this.traceDeliveries.get(ref2.traceId);
           if (delivery === void 0) {
             continue;
           }
-          if (ref.spanId === void 0) {
+          if (ref2.spanId === void 0) {
             delivery.closingAcked = true;
           } else {
-            delivery.ackedSpanIds.add(ref.spanId);
+            delivery.ackedSpanIds.add(ref2.spanId);
           }
         }
       }
@@ -1720,9 +1720,9 @@ var init_http = __esm({
        */
       async waitForPendingRequests(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS2) {
         const deadline = Date.now() + Math.max(timeoutMs, 0);
-        const settled = await this.settleDeferredWork(timeoutMs);
+        const settled2 = await this.settleDeferredWork(timeoutMs);
         const flushed = await this.traceTransport?.flush(Math.max(0, deadline - Date.now())) ?? true;
-        return settled && flushed;
+        return settled2 && flushed;
       }
       /**
        * Flush and permanently close this client's tracing transport. Idempotent:
@@ -1735,14 +1735,14 @@ var init_http = __esm({
         }
         const deadline = Date.now() + Math.max(timeoutMs, 0);
         this.closing = (async () => {
-          const settled = await this.settleDeferredWork(
+          const settled2 = await this.settleDeferredWork(
             Math.max(0, deadline - Date.now())
           );
           this.closed = true;
           const transport = this.traceTransport;
           this.traceTransport = void 0;
           const shutdownOk = await transport?.shutdown(Math.max(0, deadline - Date.now())) ?? true;
-          return settled && shutdownOk;
+          return settled2 && shutdownOk;
         })();
         return this.closing;
       }
@@ -2353,6 +2353,112 @@ var init_randomUuid = __esm({
   }
 });
 
+// src/gitCommand.ts
+function isUnrefable(value) {
+  return typeof value === "object" && value !== null && "unref" in value && typeof value.unref === "function";
+}
+function unrefStream(stream) {
+  if (isUnrefable(stream)) {
+    stream.unref();
+  }
+}
+function terminate(child) {
+  if (child.pid && process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+      return;
+    } catch {
+      child.kill("SIGTERM");
+      return;
+    }
+  }
+  child.kill("SIGTERM");
+}
+async function gitRunner(options) {
+  let spawn;
+  try {
+    ;
+    ({ spawn } = await import("child_process"));
+  } catch {
+    return null;
+  }
+  return (dir, args) => new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn("git", args, {
+        cwd: dir,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const chunks = [];
+    let size = 0;
+    let overflow = false;
+    let exitCode = null;
+    let done = false;
+    const timers = [];
+    const schedule = (callback, ms) => {
+      const timer = setTimeout(callback, ms);
+      if (!options.keepProcessAlive) {
+        timer.unref();
+      }
+      timers.push(timer);
+    };
+    const finish = () => {
+      if (done) {
+        return;
+      }
+      done = true;
+      for (const timer of timers) {
+        clearTimeout(timer);
+      }
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve(
+        exitCode === 0 && !overflow ? Buffer.concat(chunks).toString("utf8") : null
+      );
+    };
+    child.stdout?.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > options.maxBuffer) {
+        overflow = true;
+        terminate(child);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.stderr?.resume();
+    child.on("error", () => {
+      exitCode = null;
+      finish();
+    });
+    child.on("exit", (code) => {
+      exitCode = code;
+      schedule(finish, EXIT_GRACE_MS);
+    });
+    child.on("close", (code) => {
+      exitCode = code ?? exitCode;
+      finish();
+    });
+    schedule(() => terminate(child), options.timeoutMs);
+    if (!options.keepProcessAlive) {
+      child.unref();
+      unrefStream(child.stdout);
+      unrefStream(child.stderr);
+    }
+  });
+}
+var EXIT_GRACE_MS;
+var init_gitCommand = __esm({
+  "src/gitCommand.ts"() {
+    "use strict";
+    EXIT_GRACE_MS = 500;
+  }
+});
+
 // src/mockOverride.ts
 function resolveMockValue(value, ctx) {
   return typeof value === "function" ? value(ctx) : value;
@@ -2409,37 +2515,33 @@ async function readCodeChangeFile() {
   }
 }
 async function captureCodeChangeFromGit(cwd, label) {
-  let execFile;
   let readFile;
   try {
     ;
-    ({ execFile } = await import("child_process"));
     ({ readFile } = await import("fs/promises"));
   } catch {
     return null;
   }
-  const git = (dir, args) => new Promise((resolve) => {
-    execFile(
-      "git",
-      args,
-      // 30s timeout so a hung git (e.g. a network-touching ref op) can't
-      // block the whole replay indefinitely.
-      { cwd: dir, maxBuffer: 64 * 1024 * 1024, timeout: 3e4 },
-      (err, stdout) => resolve(err ? null : stdout)
-    );
+  const git = await gitRunner({
+    timeoutMs: 3e4,
+    maxBuffer: 64 * 1024 * 1024,
+    keepProcessAlive: true
   });
+  if (!git) {
+    return null;
+  }
   try {
     const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
     if (!root) {
       return null;
     }
-    const resolved = await resolveBase(git, root);
-    if (!resolved) {
+    const resolved2 = await resolveBase(git, root);
+    if (!resolved2) {
       return null;
     }
-    const { base, fromTrunk } = resolved;
-    const blobBytes = async (ref, path) => {
-      const out = await git(root, ["cat-file", "-s", `${ref}:${path}`]);
+    const { base, fromTrunk } = resolved2;
+    const blobBytes = async (ref2, path) => {
+      const out = await git(root, ["cat-file", "-s", `${ref2}:${path}`]);
       const n = out ? Number.parseInt(out.trim(), 10) : Number.NaN;
       return Number.isFinite(n) ? n : 0;
     };
@@ -2531,8 +2633,8 @@ async function resolveBase(git, root) {
   }
   return await refExists(git, root, "HEAD") ? { base: "HEAD", fromTrunk: false } : null;
 }
-async function refExists(git, root, ref) {
-  return await git(root, ["rev-parse", "--verify", `${ref}^{object}`]) !== null;
+async function refExists(git, root, ref2) {
+  return await git(root, ["rev-parse", "--verify", `${ref2}^{object}`]) !== null;
 }
 async function readWorkingFile(readFile, root, path) {
   try {
@@ -2567,6 +2669,7 @@ var MAX_FILES, MAX_FILE_BYTES, MAX_TOTAL_BYTES, TRUNK_CANDIDATES, NUL;
 var init_codeChange = __esm({
   "src/codeChange.ts"() {
     "use strict";
+    init_gitCommand();
     MAX_FILES = 60;
     MAX_FILE_BYTES = 5e5;
     MAX_TOTAL_BYTES = 2e6;
@@ -2771,9 +2874,9 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
   const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
   try {
     if (includeDbBranchLease && !lease && !leaseError) {
-      let resolved;
+      let resolved2;
       try {
-        resolved = await httpClient.resolveDbBranchLease(
+        resolved2 = await httpClient.resolveDbBranchLease(
           testRunId,
           originalTraceId,
           dbBranchSettings,
@@ -2787,10 +2890,10 @@ async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy,
           cause
         );
       }
-      lease = resolved.lease ?? void 0;
-      leaseError = resolved.leaseError ?? void 0;
-      dbSnapshotRef = resolved.dbSnapshotRef ?? dbSnapshotRef;
-      dbBranchTimings = resolved.timings ?? dbBranchTimings;
+      lease = resolved2.lease ?? void 0;
+      leaseError = resolved2.leaseError ?? void 0;
+      dbSnapshotRef = resolved2.dbSnapshotRef ?? dbSnapshotRef;
+      dbBranchTimings = resolved2.timings ?? dbBranchTimings;
     }
     if (leaseError) {
       throw new DbBranchReplayError(
@@ -4118,19 +4221,18 @@ init_asyncStorage();
 // src/autoTrace.ts
 init_asyncStorage();
 var autoTraceGlobal = globalThis;
-var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV3 ?? {
+var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV4 ?? {
   storage: null,
   browserScope: void 0,
   capturePolicies: /* @__PURE__ */ new WeakMap(),
   activeRoots: 0
 };
-autoTraceGlobal.__bitfabAutoTraceStateV3 = autoTraceState;
+autoTraceGlobal.__bitfabAutoTraceStateV4 = autoTraceState;
 function initializeAutoTraceStorage() {
   autoTraceState.storage ?? (autoTraceState.storage = createAsyncLocalStorage());
 }
-function runWithAutoTraceContext(context, fn, depth = 0) {
+function runWithAutoTraceScope(scope, fn) {
   initializeAutoTraceStorage();
-  const scope = { context, depth };
   if (autoTraceState.storage) {
     return autoTraceState.storage.run(scope, fn);
   }
@@ -4142,41 +4244,65 @@ function runWithAutoTraceContext(context, fn, depth = 0) {
     autoTraceState.browserScope = previous;
   }
 }
+function currentAutoTraceEntries() {
+  return currentAutoTraceScope()?.entries ?? [];
+}
+function replaceEntry(entries, previous, updated) {
+  return entries.map((entry) => entry === previous ? updated : entry);
+}
+function runWithAutoTraceEntry(previous, updated, fn) {
+  const result = runWithAutoTraceScope(
+    { entries: replaceEntry(currentAutoTraceEntries(), previous, updated) },
+    fn
+  );
+  if (isAutoTraceAsyncGenerator(result)) {
+    return wrapAutoTraceEntryAsyncGenerator(previous, updated, result);
+  }
+  return result;
+}
+function wrapAutoTraceEntryAsyncGenerator(previous, updated, source) {
+  const step = (method, value) => runWithAutoTraceScope(
+    { entries: replaceEntry(currentAutoTraceEntries(), previous, updated) },
+    () => source[method](value)
+  );
+  const wrapped = {
+    next: (value) => step("next", value),
+    return: (value) => step("return", value),
+    throw: (error) => step("throw", error),
+    [Symbol.asyncIterator]: () => wrapped
+  };
+  return wrapped;
+}
+function clearAutoTraceNodeConfiguration(fn) {
+  return runWithAutoTraceScope({ entries: currentAutoTraceEntries() }, fn);
+}
 function runWithAutoTraceNodeConfiguration(nodeConfiguration, fn) {
   const scope = currentAutoTraceScope();
-  if (!scope) {
+  if (!scope || scope.entries.length === 0) {
     return fn();
   }
-  const configuredScope = { ...scope, nodeConfiguration };
-  let result;
-  if (autoTraceState.storage) {
-    result = autoTraceState.storage.run(configuredScope, fn);
-  } else {
-    const previous = autoTraceState.browserScope;
-    autoTraceState.browserScope = configuredScope;
-    try {
-      result = fn();
-    } finally {
-      autoTraceState.browserScope = previous;
-    }
-  }
+  const result = runWithAutoTraceScope({ ...scope, nodeConfiguration }, fn);
   if (isAutoTraceAsyncGenerator(result)) {
     return wrapAutoTraceNodeAsyncGenerator(nodeConfiguration, result);
   }
   return result;
 }
-function runWithAutoTraceRootContext(context, fn) {
+function runWithAutoTraceRootContext(context, spanStack, fn) {
   autoTraceState.activeRoots += 1;
+  const entries = [
+    ...currentAutoTraceEntries(),
+    { context, depth: 0, spanStack }
+  ];
   let result;
   try {
-    result = runWithAutoTraceContext(context, fn);
+    result = runWithAutoTraceScope({ entries }, fn);
   } catch (error) {
     autoTraceState.activeRoots -= 1;
     throw error;
   }
   if (isAutoTraceAsyncGenerator(result)) {
     autoTraceState.activeRoots -= 1;
-    return wrapAutoTraceAsyncGenerator(context, result);
+    return wrapAutoTraceAsyncGenerator(context, spanStack, result);
   }
   if (result instanceof Promise) {
     return result.finally(() => {
@@ -4186,6 +4312,15 @@ function runWithAutoTraceRootContext(context, fn) {
   autoTraceState.activeRoots -= 1;
   return result;
 }
+function invokeThroughAutoTraceEntries(entries, step, fn) {
+  let run = fn;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    const next = run;
+    run = () => step(entry, next);
+  }
+  return run();
+}
 function isAutoTraceAsyncGenerator(value) {
   if (value === null || typeof value !== "object") {
     return false;
@@ -4193,8 +4328,8 @@ function isAutoTraceAsyncGenerator(value) {
   const candidate = value;
   return typeof candidate.next === "function" && typeof candidate.return === "function" && typeof candidate.throw === "function" && typeof candidate[Symbol.asyncIterator] === "function";
 }
-function wrapAutoTraceAsyncGenerator(context, source) {
-  const step = (method, value) => runWithAutoTraceRootContext(context, () => source[method](value));
+function wrapAutoTraceAsyncGenerator(context, spanStack, source) {
+  const step = (method, value) => runWithAutoTraceRootContext(context, spanStack, () => source[method](value));
   const wrapped = {
     next: (value) => step("next", value),
     return: (value) => step("return", value),
@@ -4220,7 +4355,7 @@ function __bitfabAutoTraceActive() {
   if (autoTraceState.activeRoots === 0) {
     return false;
   }
-  return currentAutoTraceScope() !== void 0;
+  return currentAutoTraceEntries().length > 0;
 }
 function currentAutoTraceScope() {
   initializeAutoTraceStorage();
@@ -4573,24 +4708,239 @@ function mixedTracingError(enteredApi, entered, enclosing, traceFunctionKey) {
     `opt-in and opt-out tracing can't be mixed in one call stack: ${enteredApi} (${entered})${subject} was entered inside a ${SURFACE_API[enclosing]} call (${enclosing}). ${MIXED_SURFACE_REMEDY[entered]}`
   );
 }
-function assertSurfacesCompatible(requested, resolved, parentSurface, traceFunctionKey) {
+function assertSurfacesCompatible(requested, resolved2, parentSurface, traceFunctionKey) {
   if (requested === "inherit" || requested === "neutral") {
     return;
   }
-  if (resolved === void 0 || parentSurface === void 0) {
+  if (resolved2 === void 0 || parentSurface === void 0) {
     return;
   }
-  if (parentSurface === resolved) {
+  if (parentSurface === resolved2) {
     return;
   }
   throw mixedTracingError(
-    SURFACE_API[resolved],
-    resolved,
+    SURFACE_API[resolved2],
+    resolved2,
     parentSurface,
     traceFunctionKey
   );
 }
 
+// src/commitRef.ts
+init_gitCommand();
+init_readEnv();
+var EXPLICIT_SHA_ENV = "BITFAB_COMMIT_SHA";
+var DISABLE_ENV = "BITFAB_DISABLE_COMMIT_REF";
+var GIT_TIMEOUT_MS = 2e3;
+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;
+}
+function resolveCommitRefFromEnv(env) {
+  const explicit = read(env, EXPLICIT_SHA_ENV);
+  const platform = PLATFORM_ENVS.find(([sha]) => read(env, sha) !== null);
+  if (!platform) {
+    if (explicit === null) {
+      return null;
+    }
+    return {
+      sha: explicit,
+      branch: null,
+      dirty: null,
+      remote: null,
+      rootSha: null
+    };
+  }
+  const [shaEnv, branchEnv, readRemote] = platform;
+  return {
+    sha: explicit ?? read(env, shaEnv),
+    branch: read(env, branchEnv),
+    dirty: null,
+    remote: readRemote(env),
+    rootSha: null
+  };
+}
+async function resolveCommitRefFromGit(cwd) {
+  const git = await gitRunner({
+    timeoutMs: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_MAX_BUFFER,
+    keepProcessAlive: false
+  });
+  if (!git) {
+    return null;
+  }
+  const run = async (args) => (await git(cwd, args))?.trim() ?? null;
+  const sha = await run(["rev-parse", "HEAD"]);
+  if (!sha) {
+    return null;
+  }
+  const [branch, status, remote, roots] = await Promise.all([
+    run(["symbolic-ref", "--short", "-q", "HEAD"]),
+    run(["status", "--porcelain"]),
+    run(["remote", "get-url", "origin"]),
+    run(["rev-list", "--max-parents=0", "HEAD"])
+  ]);
+  return {
+    sha,
+    branch: branch || null,
+    dirty: status === null ? null : status.length > 0,
+    remote: normalizeRemote(remote),
+    rootSha: roots ? roots.split(/\s+/).sort()[0] ?? null : null
+  };
+}
+function commitRefWire(ref2) {
+  return {
+    sha: ref2.sha,
+    branch: ref2.branch,
+    dirty: ref2.dirty,
+    remote: ref2.remote,
+    root_sha: ref2.rootSha
+  };
+}
+var resolved = false;
+var ref = null;
+var gitStarted = false;
+var settled = Promise.resolve();
+function startCommitRefResolution() {
+  if (resolved || gitStarted) {
+    return;
+  }
+  if (read(readEnv, DISABLE_ENV) !== null) {
+    resolved = true;
+    return;
+  }
+  const fromEnv = resolveCommitRefFromEnv(readEnv);
+  if (fromEnv) {
+    ref = fromEnv;
+    resolved = true;
+    return;
+  }
+  gitStarted = true;
+  if (typeof process === "undefined") {
+    resolved = true;
+    return;
+  }
+  let cwd;
+  try {
+    cwd = process.cwd?.() ?? ".";
+  } catch {
+    resolved = true;
+    return;
+  }
+  settled = resolveCommitRefFromGit(cwd).then(
+    (fromGit) => {
+      if (!resolved) {
+        ref = fromGit;
+        resolved = true;
+      }
+    },
+    () => {
+      resolved = true;
+    }
+  );
+}
+function currentCommitRef() {
+  startCommitRefResolution();
+  return ref;
+}
+
 // src/client.ts
 init_constants();
 
@@ -5083,11 +5433,11 @@ var BitfabLangGraphCallbackHandler = class {
         this.invocations.set(invocation.rootRunId, invocation);
       }
       if (!willHide) {
-        let resolved = parentSpan;
-        while (resolved?.hidden === true) {
-          resolved = resolved.parentId ? this.runToSpan.get(resolved.parentId) : void 0;
+        let resolved2 = parentSpan;
+        while (resolved2?.hidden === true) {
+          resolved2 = resolved2.parentId ? this.runToSpan.get(resolved2.parentId) : void 0;
         }
-        effectiveParentId = resolved ? resolved.spanId : invocation.activeContext?.spanId ?? null;
+        effectiveParentId = resolved2 ? resolved2.spanId : invocation.activeContext?.spanId ?? null;
       } else {
         effectiveParentId = parentRunId ?? null;
       }
@@ -6587,6 +6937,7 @@ var Bitfab = class {
       validateDbSnapshotConfig(config.dbSnapshot);
     }
     this.dbSnapshot = config.dbSnapshot;
+    startCommitRefResolution();
     this.httpClient = new HttpClient({
       apiKey: () => this.resolveApiKey(),
       serviceUrl: this.serviceUrl,
@@ -6757,11 +7108,15 @@ var Bitfab = class {
       type: options.type ?? "custom",
       surface: "opt-out"
     };
-    const tracedRoot = this.withSpan(
+    const rootName = options.name ?? name;
+    const buildTracedRoot = (spanOptions) => this.withSpan(
       traceFunctionKey,
-      rootOptions,
+      spanOptions,
       function(...args) {
-        const capturePolicy = getAutoTraceCapturePolicy(self, traceFunctionKey);
+        const capturePolicy = getAutoTraceCapturePolicy(
+          self,
+          traceFunctionKey
+        );
         self.refreshAutoTraceCapturePolicy(traceFunctionKey);
         let spansUsed = 0;
         let truncated = false;
@@ -6782,19 +7137,54 @@ var Bitfab = class {
             `"${traceFunctionKey}" hit an automatic subtree capture limit (maxDepth=${maxDepth}, maxSpans=${maxSpans}); its trace is incomplete. Raise the limits or narrow the subtree with exclude.`
           );
         };
+        const spanStackOf = (entry) => entry.spanStack;
+        const openChild = (entry, childOptions, inputs, isAsync, invokeFn) => {
+          const runInside = () => runWithAutoTraceEntry(
+            entry,
+            {
+              context: autoTraceContext,
+              depth: entry.depth + 1,
+              spanStack: getSpanStack()
+            },
+            invokeFn
+          );
+          return runWithSpanStack(spanStackOf(entry), () => {
+            if (isAsync) {
+              const tracedAsyncChild = self.withSpan(
+                traceFunctionKey,
+                childOptions,
+                async (..._inputs) => await runInside()
+              );
+              return tracedAsyncChild(...inputs);
+            }
+            const tracedChild = self.withSpan(
+              traceFunctionKey,
+              childOptions,
+              (..._inputs) => runInside()
+            );
+            return tracedChild(...inputs);
+          });
+        };
+        const overBudget = (entry) => {
+          if (entry.depth < maxDepth && spansUsed < maxSpans) {
+            return false;
+          }
+          runWithSpanStack(spanStackOf(entry), warnTruncated);
+          return true;
+        };
         const autoTraceContext = {
-          invoke(definition, inputs, invokeFn, depth, nodeConfiguration) {
+          traceFunctionKey,
+          invoke(definition, inputs, invokeFn, entry, nodeConfiguration) {
             const nameParts = definition.name.split(".");
             const simpleName = nameParts[nameParts.length - 1];
-            const invokeWithoutNode = () => nodeConfiguration === void 0 ? invokeFn() : runWithAutoTraceContext(autoTraceContext, invokeFn, depth);
+            const invokeWithoutNode = () => nodeConfiguration === void 0 ? invokeFn() : clearAutoTraceNodeConfiguration(invokeFn);
             if (excluded.has(definition.name) || simpleName !== void 0 && excluded.has(simpleName) || nodeConfiguration === void 0 && definition.wrapper === true && !includeWrappers) {
               return invokeWithoutNode();
             }
             if (nodeConfiguration?.capture === false) {
-              return runWithAutoTraceContext(autoTraceContext, invokeFn, depth);
+              return clearAutoTraceNodeConfiguration(invokeFn);
             }
-            if (depth >= maxDepth || spansUsed >= maxSpans) {
-              warnTruncated();
+            if (overBudget(entry)) {
               return invokeWithoutNode();
             }
             spansUsed += 1;
@@ -6817,34 +7207,81 @@ var Bitfab = class {
                 finalize: nodeConfiguration.finalize
               }
             };
-            const invokeWithAutoTraceContext = () => runWithAutoTraceContext(autoTraceContext, invokeFn, depth + 1);
-            if (definition.async === true) {
-              const tracedAsyncChild = self.withSpan(
-                traceFunctionKey,
-                childOptions,
-                async (..._inputs) => await invokeWithAutoTraceContext()
-              );
-              return tracedAsyncChild(...inputs);
-            }
-            const tracedChild = self.withSpan(
-              traceFunctionKey,
+            return openChild(
+              entry,
               childOptions,
-              (..._inputs) => invokeWithAutoTraceContext()
+              inputs,
+              definition.async === true,
+              invokeFn
             );
-            return tracedChild(...inputs);
+          },
+          invokeNestedRoot(nestedName, nestedFunctionName, inputs, invokeFn, entry, link) {
+            if (excluded.has(nestedName) || excluded.has(nestedFunctionName) || overBudget(entry)) {
+              return invokeFn();
+            }
+            spansUsed += 1;
+            const childOptions = {
+              name: nestedName,
+              type: "function",
+              captureWhen: "nested",
+              surface: "opt-out",
+              captureContent: true,
+              ...link !== void 0 && { nestedTrace: link }
+            };
+            return openChild(entry, childOptions, inputs, false, invokeFn);
           }
         };
         return runWithAutoTraceRootContext(
           autoTraceContext,
+          getSpanStack(),
           () => fn.apply(this, args)
         );
       }
     );
+    const tracedRoot = buildTracedRoot(rootOptions);
     const autoTraceRoot = function(...args) {
       if (!self.shouldRecord()) {
         return fn.apply(this, args);
       }
-      return tracedRoot.apply(this, args);
+      const enclosing = currentAutoTraceEntries();
+      if (enclosing.length === 0) {
+        return tracedRoot.apply(this, args);
+      }
+      const link = getReplayContext() || inSeedScope() ? void 0 : { traceFunctionKey };
+      return invokeThroughAutoTraceEntries(
+        enclosing,
+        (entry, next) => entry.context.invokeNestedRoot(
+          rootName,
+          name,
+          args,
+          next,
+          entry,
+          link
+        ),
+        () => {
+          if (link === void 0) {
+            return fn.apply(this, args);
+          }
+          const innermost = enclosing[enclosing.length - 1];
+          const innermostNow = currentAutoTraceEntries().find(
+            (entry) => entry.context === innermost.context
+          ) ?? innermost;
+          const innermostStack = innermostNow.spanStack;
+          const copy = innermostStack[innermostStack.length - 1];
+          const detachedRoot = buildTracedRoot({
+            ...rootOptions,
+            ...copy !== void 0 && {
+              enclosingTrace: {
+                traceId: copy.traceId,
+                spanId: copy.spanId,
+                traceFunctionKey: innermost.context.traceFunctionKey,
+                link
+              }
+            }
+          });
+          return runWithSpanStack([], () => detachedRoot.apply(this, args));
+        }
+      );
     };
     Object.defineProperty(autoTraceRoot, "_bitfabTraceFunctionKey", {
       value: traceFunctionKey
@@ -7433,6 +7870,10 @@ var Bitfab = class {
         const spanId = randomUuid();
         const parentSpanId = parentContext?.spanId ?? null;
         const isRootSpan = parentSpanId === null;
+        if (options.enclosingTrace !== void 0) {
+          options.enclosingTrace.link.traceId = traceId;
+          options.enclosingTrace.link.rootSpanId = spanId;
+        }
         const requestedSurface = options.surface ?? DEFAULT_SURFACE;
         const surface = resolveSurface(requestedSurface, parentContext?.surface);
         assertSurfacesCompatible(
@@ -7482,7 +7923,9 @@ var Bitfab = class {
           spanType: options.type ?? "custom",
           functionId: options.functionId,
           captureContent: options.captureContent ?? true,
-          autoTraceDefinition: options.autoTraceDefinition
+          autoTraceDefinition: options.autoTraceDefinition,
+          nestedTrace: options.nestedTrace,
+          enclosingTrace: options.enclosingTrace
         };
         const sendSpan = async (params) => {
           const replayCtx = getReplayContext();
@@ -7680,15 +8123,15 @@ var Bitfab = class {
                 );
               }
               return runWithSpanStack(newStack, async () => {
-                const resolved = await resolution;
-                if (resolved.matched) {
+                const resolved2 = await resolution;
+                if (resolved2.matched) {
                   void sendSpan({
-                    result: resolved.output,
+                    result: resolved2.output,
                     mocked: true,
                     mockTarget: "output",
                     mockSource: "override"
                   });
-                  return resolved.output;
+                  return resolved2.output;
                 }
                 if (shouldMockWithBaseStrategy && !mockSpan) {
                   throw new BitfabError(
@@ -7924,6 +8367,10 @@ var Bitfab = class {
     if (params.dbSnapshotRef) {
       rawTrace.db_snapshot_ref = params.dbSnapshotRef;
     }
+    const commitRef = currentCommitRef();
+    if (commitRef) {
+      rawTrace.commit_ref = commitRefWire(commitRef);
+    }
     if (params.ingestionType) {
       rawTrace.ingestion_type = params.ingestionType;
     }
@@ -7988,6 +8435,16 @@ var Bitfab = class {
           function_line: params.autoTraceDefinition.line,
           function_column: params.autoTraceDefinition.column
         },
+        ...params.nestedTrace?.traceId !== void 0 && {
+          nested_trace_id: params.nestedTrace.traceId,
+          nested_trace_function_key: params.nestedTrace.traceFunctionKey,
+          nested_root_span_id: params.nestedTrace.rootSpanId
+        },
+        ...params.enclosingTrace !== void 0 && {
+          enclosing_trace_id: params.enclosingTrace.traceId,
+          enclosing_trace_function_key: params.enclosingTrace.traceFunctionKey,
+          enclosing_span_id: params.enclosingTrace.spanId
+        },
         ...serializedInputs !== void 0 && {
           input: serializedInputs.json,
           ...serializedInputs.meta !== void 0 && {