@bitfab/sdk 0.36.10 → 0.36.12

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.10";
+    __version__ = "0.36.12";
   }
 });
 
@@ -2260,7 +2260,7 @@ async function captureCodeChangeFromGit(cwd, label) {
     const tracked = await git(root, [
       "diff",
       "--name-status",
-      "--no-renames",
+      "--find-renames",
       "-z",
       base,
       "--",
@@ -2276,23 +2276,23 @@ async function captureCodeChangeFromGit(cwd, label) {
     ]);
     const entries = [
       ...parseNameStatusZ(tracked ?? ""),
-      ...(untracked ?? "").split(NUL).filter((p) => p.length > 0).map((path) => ({ status: "A", path }))
+      ...(untracked ?? "").split(NUL).filter((p) => p.length > 0).map((path) => ({ status: "A", beforePath: path, path }))
     ];
     if (entries.length === 0) {
       return null;
     }
     const files = [];
     let totalBytes = 0;
-    for (const { status, path } of entries) {
+    for (const { status, beforePath, path } of entries) {
       if (files.length >= MAX_FILES) {
         break;
       }
-      const beforeBytes = status === "A" ? 0 : await blobBytes(base, path);
+      const beforeBytes = status === "A" ? 0 : await blobBytes(base, beforePath);
       const afterBytes = status === "D" ? 0 : await workingBytes(path);
       if (beforeBytes > MAX_FILE_BYTES || afterBytes > MAX_FILE_BYTES) {
         continue;
       }
-      const before = (status === "A" ? "" : await git(root, ["show", `${base}:${path}`]) ?? "").replace(/\r\n/g, "\n");
+      const before = (status === "A" ? "" : await git(root, ["show", `${base}:${beforePath}`]) ?? "").replace(/\r\n/g, "\n");
       const after = (status === "D" ? "" : await readWorkingFile(readFile, root, path)).replace(/\r\n/g, "\n");
       if (before === after) {
         continue;
@@ -2350,8 +2350,18 @@ async function readWorkingFile(readFile, root, path) {
 function parseNameStatusZ(raw) {
   const parts = raw.split(NUL).filter((p) => p.length > 0);
   const out = [];
-  for (let i = 0; i + 1 < parts.length; i += 2) {
-    out.push({ status: parts[i].charAt(0), path: parts[i + 1] });
+  let i = 0;
+  while (i + 1 < parts.length) {
+    const status = parts[i].charAt(0);
+    i += 1;
+    const beforePath = parts[i];
+    i += 1;
+    if ((status === "R" || status === "C") && i < parts.length) {
+      out.push({ status, beforePath, path: parts[i] });
+      i += 1;
+    } else {
+      out.push({ status, beforePath, path: beforePath });
+    }
   }
   return out;
 }
@@ -6091,14 +6101,19 @@ var Bitfab = class {
           counters.set(counterKey, callIndex + 1);
           const mockKey = `${counterKey}:${callIndex}`;
           const mockSpan = replayCtxForMock.mockTree.spans.get(mockKey);
-          const emitMock = (output) => {
-            void sendSpan({ result: output, mocked: true });
+          const emitMock = (output, mockSource) => {
+            void sendSpan({
+              result: output,
+              mocked: true,
+              mockTarget: "output",
+              mockSource
+            });
             if (fnReturnsPromise) {
               return Promise.resolve(output);
             }
             return output;
           };
-          const emitMockAsync = (pending) => {
+          const emitMockAsync = (pending, mockSource) => {
             if (!fnReturnsPromise) {
               throw new BitfabError(
                 `Cannot mock synchronous span "${traceFunctionKey}" with an asynchronously-resolved value (lazy recorded-output fetch or an async value function). Make the wrapped function async, or use mock: "all" so recorded outputs are fetched eagerly.`
@@ -6106,7 +6121,12 @@ var Bitfab = class {
             }
             return (async () => {
               const output = await pending;
-              void sendSpan({ result: output, mocked: true });
+              void sendSpan({
+                result: output,
+                mocked: true,
+                mockTarget: "output",
+                mockSource
+              });
               return output;
             })();
           };
@@ -6148,18 +6168,18 @@ var Bitfab = class {
                 getOriginalOutput: () => Promise.resolve(resolveRecordedOutput())
               });
               if (injected instanceof Promise) {
-                return emitMockAsync(injected);
+                return emitMockAsync(injected, "override");
               }
-              return emitMock(injected);
+              return emitMock(injected, "override");
             }
           }
           const shouldMock = replayCtxForMock.mockStrategy === "all" || replayCtxForMock.mockStrategy === "marked" && options.mockOnReplay === true;
           if (shouldMock && mockSpan) {
             const recorded = resolveRecordedOutput();
             if (recorded instanceof Promise) {
-              return emitMockAsync(recorded);
+              return emitMockAsync(recorded, "recorded");
             }
-            return emitMock(recorded);
+            return emitMock(recorded, "recorded");
           }
         }
         const recordSpan = (result) => {
@@ -6459,7 +6479,9 @@ var Bitfab = class {
       traceFunctionKey: params.traceFunctionKey,
       rawSpan: externalSpan,
       ...params.testRunId && { testRunId: params.testRunId },
-      ...params.mocked && { mocked: true }
+      ...params.mocked && { mocked: true },
+      ...params.mockTarget && { mockTarget: params.mockTarget },
+      ...params.mockSource && { mockSource: params.mockSource }
     });
   }
   registerMockOverride(overrideOrMatch, value) {