@lumy-pack/line-lore 0.0.7 → 0.0.9

package/dist/core/ancestry/ancestry.d.ts

@@ -5,6 +5,11 @@ export interface AncestryResult {
     subject: string;
 }
 export declare const DEFAULT_ANCESTRY_TIMEOUT = 30000;
+/**
+ * @deprecated Use {@link findMergeCommits} (plural) instead.
+ * Returns only the first verified merge commit. The plural version returns
+ * multiple candidates from both first-parent and full ancestry paths.
+ */
 export declare function findMergeCommit(commitSha: string, options?: GitExecOptions & {
     ref?: string;
 }): Promise<AncestryResult | null>;
@@ -19,6 +24,19 @@ export declare function findMergeCommit(commitSha: string, options?: GitExecOpti
  * Returns false on git command failure (fail-skip policy).
  */
 export declare function verifyMergeIntroducesCommit(targetSha: string, mergeResult: AncestryResult, options?: GitExecOptions): Promise<boolean>;
+/**
+ * Multi-candidate merge commit search.
+ * Returns up to MAX_CANDIDATES verified merge commits from both first-parent
+ * and full ancestry paths, deduplicated by mergeCommitSha and ordered with
+ * first-parent results first.
+ *
+ * Unlike `findMergeCommit` (singular) which returns only the first verified candidate,
+ * this function enables callers to iterate through multiple candidates when the
+ * first one doesn't yield a PR (e.g., bulk merge with non-standard message).
+ */
+export declare function findMergeCommits(commitSha: string, options?: GitExecOptions & {
+    ref?: string;
+}): Promise<AncestryResult[]>;
 /** Retrieve the subject line of a single commit. Returns null on git failure. */
 export declare function getCommitSubject(sha: string, options?: GitExecOptions): Promise<string | null>;
 export declare function extractPRFromMergeMessage(subject: string, platform?: string): number | null;

package/dist/core/ancestry/index.d.ts

@@ -1,2 +1,2 @@
-export { extractPRFromMergeMessage, findMergeCommit, getCommitSubject, verifyMergeIntroducesCommit, } from './ancestry.js';
+export { extractPRFromMergeMessage, findMergeCommit, findMergeCommits, getCommitSubject, verifyMergeIntroducesCommit, } from './ancestry.js';
 export type { AncestryResult } from './ancestry.js';

package/dist/core/blame/blame.d.ts

@@ -1,3 +1,11 @@
-import type { BlameResult, BlameStageResult, GitExecOptions, LineRange } from '../../types/index.js';
-export declare function executeBlame(file: string, lineRange: LineRange, options?: GitExecOptions): Promise<BlameResult[]>;
-export declare function analyzeBlameResults(results: BlameResult[], filePath: string, options?: GitExecOptions): Promise<BlameStageResult[]>;
+import type { BlameExecOptions, BlameResult, BlameStageResult, DualBlameResult, GitExecOptions, LineRange } from '../../types/index.js';
+export declare function executeBlame(file: string, lineRange: LineRange, options?: BlameExecOptions): Promise<BlameResult[]>;
+/**
+ * Run dual blame for origin mode: origin blame (-C -C -M) and change blame (-w)
+ * in parallel. For change mode, only runs the single blame.
+ *
+ * Assumes both blames on the same -L range produce results in the same
+ * finalLine order (guaranteed by git blame line-ordered output).
+ */
+export declare function executeDualBlame(file: string, lineRange: LineRange, options?: BlameExecOptions): Promise<DualBlameResult>;
+export declare function analyzeBlameResults(results: BlameResult[], filePath: string, options?: GitExecOptions, changeResults?: BlameResult[]): Promise<BlameStageResult[]>;

package/dist/core/blame/index.d.ts

@@ -1,4 +1,4 @@
-export { analyzeBlameResults, executeBlame } from './blame.js';
+export { analyzeBlameResults, executeBlame, executeDualBlame } from './blame.js';
 export { getCosmeticDiff, isCosmeticDiff } from './detection/index.js';
 export type { CosmeticCheckResult } from './detection/index.js';
 export { parsePorcelainOutput } from './parsing/index.js';

package/dist/core/index.d.ts

@@ -1,6 +1,6 @@
 export { analyzeBlameResults, executeBlame, isCosmeticDiff, parsePorcelainOutput, } from './blame/index.js';
 export { compareSymbolMaps, computeContentHash, computeExactHash, computeStructuralHash, extractSymbols, findContainingSymbol, findMatchAcrossFiles, traceByAst, } from './ast-diff/index.js';
-export { extractPRFromMergeMessage, findMergeCommit, } from './ancestry/index.js';
+export { extractPRFromMergeMessage, findMergeCommit, findMergeCommits, } from './ancestry/index.js';
 export type { AncestryResult } from './ancestry/index.js';
 export { computePatchId, findPatchIdMatch, resetPatchIdCache, } from './patch-id/index.js';
 export type { PatchIdResult } from './patch-id/index.js';

package/dist/index.cjs

@@ -381,25 +381,6 @@ var init_executor = __esm({
 });
 
 // src/core/ancestry/ancestry.ts
-async function findMergeCommit(commitSha, options) {
-  const ref = options?.ref ?? "HEAD";
-  const budget = options?.timeout ?? DEFAULT_ANCESTRY_TIMEOUT;
-  const startTime = Date.now();
-  const firstParentResult = await findMergeCommitWithArgs(
-    commitSha,
-    ref,
-    ["--first-parent"],
-    { ...options, timeout: budget }
-  );
-  if (firstParentResult) return firstParentResult;
-  const elapsed = Date.now() - startTime;
-  const remaining = budget - elapsed;
-  if (remaining <= 0) return null;
-  return findMergeCommitWithArgs(commitSha, ref, [], {
-    ...options,
-    timeout: remaining
-  });
-}
 async function verifyMergeIntroducesCommit(targetSha, mergeResult, options) {
   if (mergeResult.parentShas.length < 2) return true;
   const firstParent = mergeResult.parentShas[0];
@@ -429,7 +410,7 @@ async function isAncestor(commitA, commitB, options) {
     return null;
   }
 }
-async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
+async function findMergeCommitsWithArgs(commitSha, ref, extraArgs, options) {
   try {
     const result = await gitExec(
       [
@@ -445,28 +426,29 @@ async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
       { cwd: options?.cwd, timeout: options?.timeout }
     );
     const lines = (0, import_common_utils9.filter)(result.stdout.trim().split("\n"), import_common_utils9.isTruthy);
-    if (lines.length === 0) return null;
+    if (lines.length === 0) return [];
+    const verifiedCandidates = [];
     const candidateCount = Math.min(lines.length, MAX_CANDIDATES);
-    let verifiedCount = 0;
+    let attemptedCount = 0;
     for (let i = 0; i < candidateCount; i++) {
       const candidate = parseMergeLogLine(lines[i]);
       if (!candidate) continue;
-      verifiedCount++;
+      attemptedCount++;
       const verified = await verifyMergeIntroducesCommit(
         commitSha,
         candidate,
         options
       );
-      if (verified) return candidate;
+      if (verified) verifiedCandidates.push(candidate);
     }
-    if (verifiedCount > 0 && options?.warnings) {
+    if (attemptedCount > 0 && verifiedCandidates.length === 0 && options?.warnings) {
       options.warnings.push(
-        `ancestry: all ${verifiedCount} merge candidate(s) failed verification for ${commitSha.slice(0, 8)}`
+        `ancestry: all ${attemptedCount} merge candidate(s) failed verification for ${commitSha.slice(0, 8)}`
       );
     }
-    return null;
+    return verifiedCandidates;
   } catch {
-    return null;
+    return [];
   }
 }
 function parseMergeLogLine(line) {
@@ -486,6 +468,38 @@ function parseMergeLogLine(line) {
   const subject = parts.slice(subjectStart).join(" ");
   return { mergeCommitSha, parentShas, subject };
 }
+async function findMergeCommits(commitSha, options) {
+  const ref = options?.ref ?? "HEAD";
+  const budget = options?.timeout ?? DEFAULT_ANCESTRY_TIMEOUT;
+  const startTime = Date.now();
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushUnique = (candidates) => {
+    for (const candidate of candidates) {
+      if (seen.has(candidate.mergeCommitSha)) continue;
+      seen.add(candidate.mergeCommitSha);
+      results.push(candidate);
+      if (results.length >= MAX_CANDIDATES) break;
+    }
+  };
+  const firstParent = await findMergeCommitsWithArgs(
+    commitSha,
+    ref,
+    ["--first-parent"],
+    { ...options, timeout: budget }
+  );
+  pushUnique(firstParent);
+  const elapsed = Date.now() - startTime;
+  const remaining = budget - elapsed;
+  if (remaining > 0 && results.length < MAX_CANDIDATES) {
+    const full = await findMergeCommitsWithArgs(commitSha, ref, [], {
+      ...options,
+      timeout: remaining
+    });
+    pushUnique(full);
+  }
+  return results;
+}
 async function getCommitSubject(sha, options) {
   try {
     const result = await gitExec(["log", "-1", "--format=%s", sha], {
@@ -689,16 +703,17 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
     }
   }
   let mergeBasedPR = null;
-  const mergeResult = await findMergeCommit(commitSha, options);
-  if (mergeResult) {
+  const mergeCandidates = await findMergeCommits(commitSha, options);
+  const hasAncestryMerges = mergeCandidates.length > 0;
+  for (const candidate of mergeCandidates) {
     const prNumber = extractPRFromMergeMessage(
-      mergeResult.subject,
+      candidate.subject,
       options?.platform
     );
     if (prNumber) {
       if (adapter) {
         const prInfo = await adapter.getPRForCommit(
-          mergeResult.mergeCommitSha,
+          candidate.mergeCommitSha,
           prSelectOptions
         );
         if (prInfo?.mergedAt) {
@@ -708,23 +723,32 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       if (!mergeBasedPR) {
         mergeBasedPR = {
           number: prNumber,
-          title: mergeResult.subject,
+          title: candidate.subject,
           author: "",
           url: "",
-          mergeCommit: mergeResult.mergeCommitSha,
+          mergeCommit: candidate.mergeCommitSha,
           baseBranch: "",
           resolvedVia: "ancestry"
         };
       }
-      if (!options?.deep || mergeBasedPR.mergedAt) {
-        await cache.set(commitSha, toCachedPR(mergeBasedPR));
-        return mergeBasedPR;
+      break;
+    }
+    if (adapter) {
+      const mergeCommitPR = await adapter.getPRForCommit(
+        candidate.mergeCommitSha,
+        prSelectOptions
+      );
+      if (mergeCommitPR?.mergedAt) {
+        mergeBasedPR = { ...mergeCommitPR, resolvedVia: "ancestry" };
+        break;
       }
     }
   }
   if (mergeBasedPR) {
-    await cache.set(commitSha, toCachedPR(mergeBasedPR));
-    return mergeBasedPR;
+    if (!options?.deep || mergeBasedPR.mergedAt) {
+      await cache.set(commitSha, toCachedPR(mergeBasedPR));
+      return mergeBasedPR;
+    }
   }
   const commitSubject = await getCommitSubject(commitSha, options);
   if (commitSubject) {
@@ -746,7 +770,7 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       return subjectPR;
     }
   }
-  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH) {
+  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH && (!hasAncestryMerges || options?.deep)) {
     const patchIdMatch = await findPatchIdMatch(commitSha, {
       ...options,
       scanDepth: options?.deep ? DEEP_SCAN_DEPTH : void 0
@@ -764,6 +788,10 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       }
     }
   }
+  if (mergeBasedPR) {
+    await cache.set(commitSha, toCachedPR(mergeBasedPR));
+    return mergeBasedPR;
+  }
   return null;
 }
 function resetPRCache() {
@@ -2083,6 +2111,7 @@ function parsePorcelainOutput(output) {
     }
     let commitHash = headerMatch[1];
     const originalLine = parseInt(headerMatch[2], 10);
+    const finalLine = parseInt(headerMatch[3], 10) || 0;
     const isBoundary = commitHash.startsWith("^");
     if (isBoundary) {
       commitHash = commitHash.slice(1).padStart(40, "0");
@@ -2126,6 +2155,7 @@ function parsePorcelainOutput(output) {
       authorEmail: cleanEmail,
       date,
       lineContent,
+      finalLine,
       originalFile,
       originalLine: originalFile ? originalLine : void 0
     });
@@ -2136,14 +2166,112 @@ function parsePorcelainOutput(output) {
 // src/core/blame/blame.ts
 async function executeBlame(file, lineRange, options) {
   const lineSpec = `${lineRange.start},${lineRange.end}`;
-  const result = await gitExec(
-    ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file],
-    options
-  );
+  const args = options?.mode === "change" ? ["blame", "-w", "--porcelain", "-L", lineSpec, file] : ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file];
+  const result = await gitExec(args, options);
   return parsePorcelainOutput(result.stdout);
 }
-async function analyzeBlameResults(results, filePath, options) {
-  const uniqueShas = [...new Set((0, import_common_utils7.map)(results, (r) => r.commitHash))];
+async function executeDualBlame(file, lineRange, options) {
+  if (options?.mode === "change") {
+    const results = await executeBlame(file, lineRange, options);
+    return { blame: results, changeBlame: [] };
+  }
+  const [originResult, changeResult] = await Promise.allSettled([
+    executeBlame(file, lineRange, options),
+    executeBlame(file, lineRange, { ...options, mode: "change" })
+  ]);
+  const blame = originResult.status === "fulfilled" ? originResult.value : [];
+  const changeBlame = changeResult.status === "fulfilled" ? changeResult.value : [];
+  if (originResult.status === "rejected") {
+    throw originResult.reason;
+  }
+  return { blame, changeBlame };
+}
+async function verifyRename(originalFile, currentFile, options) {
+  try {
+    const result = await gitExec(
+      [
+        "log",
+        "--diff-filter=R",
+        "--find-renames",
+        "--format=%H",
+        "--",
+        originalFile,
+        currentFile
+      ],
+      options
+    );
+    return result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function crossValidateBlame(originResults, changeResults) {
+  const changeMap = /* @__PURE__ */ new Map();
+  for (const r of changeResults) {
+    changeMap.set(r.finalLine, r);
+  }
+  const validated = [];
+  const crossValidatedFlags = [];
+  const changeFallbackFlags = [];
+  const renameChecks = [];
+  for (let i = 0; i < originResults.length; i++) {
+    const origin = originResults[i];
+    const change = changeMap.get(origin.finalLine);
+    if (!change) {
+      validated.push(origin);
+      crossValidatedFlags.push(false);
+      changeFallbackFlags.push(false);
+      continue;
+    }
+    if (origin.commitHash === change.commitHash) {
+      validated.push(origin);
+      crossValidatedFlags.push(true);
+      changeFallbackFlags.push(false);
+      continue;
+    }
+    if (origin.originalFile) {
+      renameChecks.push({
+        originalFile: origin.originalFile,
+        lineIndex: i
+      });
+    }
+    validated.push(change);
+    crossValidatedFlags.push(true);
+    changeFallbackFlags.push(true);
+  }
+  return { validated, renameChecks, crossValidatedFlags, changeFallbackFlags };
+}
+async function analyzeBlameResults(results, filePath, options, changeResults) {
+  let effectiveResults = results;
+  let crossValidatedFlags;
+  let changeFallbackFlagsResult;
+  if (changeResults && changeResults.length > 0) {
+    const { validated, renameChecks, crossValidatedFlags: cvFlags, changeFallbackFlags } = crossValidateBlame(results, changeResults);
+    if (renameChecks.length > 0) {
+      const pendingChecks = /* @__PURE__ */ new Map();
+      for (const check of renameChecks) {
+        const cacheKey = `${check.originalFile}:${filePath}`;
+        if (!pendingChecks.has(cacheKey)) {
+          pendingChecks.set(cacheKey, verifyRename(check.originalFile, filePath, options));
+        }
+      }
+      const renameResults = /* @__PURE__ */ new Map();
+      for (const [key, promise] of pendingChecks) {
+        renameResults.set(key, await promise);
+      }
+      for (const check of renameChecks) {
+        const cacheKey = `${check.originalFile}:${filePath}`;
+        if (renameResults.get(cacheKey)) {
+          validated[check.lineIndex] = results[check.lineIndex];
+          changeFallbackFlags[check.lineIndex] = false;
+        }
+      }
+    }
+    effectiveResults = validated;
+    crossValidatedFlags = cvFlags;
+    changeFallbackFlagsResult = changeFallbackFlags;
+  }
+  const uniqueShas = [...new Set((0, import_common_utils7.map)(effectiveResults, (r) => r.commitHash))];
   const cosmeticMap = /* @__PURE__ */ new Map();
   const zeroSha = "0".repeat(40);
   const tasks = [];
@@ -2152,7 +2280,7 @@ async function analyzeBlameResults(results, filePath, options) {
     tasks.push(
       (async () => {
         try {
-          const blameResult = results.find((r) => r.commitHash === sha);
+          const blameResult = effectiveResults.find((r) => r.commitHash === sha);
           if (!blameResult) return;
           const file = blameResult.originalFile ?? filePath;
           const diff = await getCosmeticDiff(sha, file, options);
@@ -2164,12 +2292,14 @@ async function analyzeBlameResults(results, filePath, options) {
     );
   });
   await Promise.all(tasks);
-  return (0, import_common_utils7.map)(results, (blame) => {
+  return (0, import_common_utils7.map)(effectiveResults, (blame, i) => {
     const cosmetic = cosmeticMap.get(blame.commitHash);
     return {
       blame,
       isCosmetic: cosmetic?.isCosmetic ?? false,
-      cosmeticReason: cosmetic?.reason
+      cosmeticReason: cosmetic?.reason,
+      crossValidated: crossValidatedFlags?.[i],
+      usedChangeFallback: changeFallbackFlagsResult?.[i]
     };
   });
 }
@@ -2350,8 +2480,11 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   const lineRange = parseLineRange(
     options.endLine ? `${options.line},${options.endLine}` : `${options.line}`
   );
-  const blameChain = executeBlame(options.file, lineRange, execOptions).then(
-    (results) => analyzeBlameResults(results, options.file, execOptions)
+  const blameChain = executeDualBlame(options.file, lineRange, {
+    ...execOptions,
+    mode: options.mode
+  }).then(
+    ({ blame, changeBlame }) => analyzeBlameResults(blame, options.file, execOptions, changeBlame.length > 0 ? changeBlame : void 0)
   );
   const [authResult, blameResult] = await Promise.allSettled([
     adapter ? adapter.checkAuth() : Promise.resolve({ authenticated: false }),
@@ -2373,12 +2506,24 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   }
   return { analyzed: blameResult.value, operatingLevel, warnings };
 }
-async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan, preferredBase) {
+function resolveTraceMode(mode) {
+  return mode ?? "origin";
+}
+function deduplicatedLookupPR(sha, adapter, options, inflight) {
+  const existing = inflight.get(sha);
+  if (existing) return existing;
+  const promise = lookupPR(sha, adapter, options);
+  inflight.set(sha, promise);
+  promise.finally(() => inflight.delete(sha));
+  return promise;
+}
+async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, inflightPR, skipPatchIdScan, preferredBase) {
   const nodes = [];
+  const traceMode = resolveTraceMode(options.mode);
   const commitNode = {
     type: entry.isCosmetic ? "cosmetic_commit" : "original_commit",
     sha: entry.blame.commitHash,
-    trackingMethod: "blame-CMw",
+    trackingMethod: traceMode === "change" || entry.usedChangeFallback ? "blame" : "blame-CMw",
     confidence: "exact",
     note: entry.cosmeticReason ? `Cosmetic change: ${entry.cosmeticReason}` : void 0
   };
@@ -2400,17 +2545,18 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
     }
   }
   const targetSha = nodes[nodes.length - 1].sha;
+  const prLookupOptions = {
+    ...execOptions,
+    noCache: options.noCache,
+    cacheOnly: options.cacheOnly,
+    deep: featureFlags.deepTrace,
+    repoId,
+    skipPatchIdScan,
+    preferredBase,
+    platform: adapter?.platform
+  };
   if (targetSha) {
-    const prInfo = await lookupPR(targetSha, adapter, {
-      ...execOptions,
-      noCache: options.noCache,
-      cacheOnly: options.cacheOnly,
-      deep: featureFlags.deepTrace,
-      repoId,
-      skipPatchIdScan,
-      preferredBase,
-      platform: adapter?.platform
-    });
+    const prInfo = await deduplicatedLookupPR(targetSha, adapter, prLookupOptions, inflightPR);
     if (prInfo) {
       nodes.push({
         type: "pull_request",
@@ -2427,6 +2573,7 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
   return nodes;
 }
 async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan, preferredBase) {
+  const inflightPR = /* @__PURE__ */ new Map();
   const results = await Promise.allSettled(
     (0, import_common_utils11.map)(
       analyzed,
@@ -2437,6 +2584,7 @@ async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOpt
         options,
         execOptions,
         repoId,
+        inflightPR,
         skipPatchIdScan,
         preferredBase
       )
@@ -2446,6 +2594,7 @@ async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOpt
 }
 var legacyCacheCleaned = false;
 async function trace(options) {
+  const mode = resolveTraceMode(options.mode);
   const { file, cwd } = await resolveFileContext(options.file, options.cwd);
   const warnings = [];
   const execOptions = { cwd, warnings };
@@ -2467,7 +2616,7 @@ async function trace(options) {
   }
   const blameAuth = await runBlameAndAuth(
     platform.adapter,
-    { ...options, file, cwd },
+    { ...options, mode, file, cwd },
     execOptions
   );
   const operatingLevel = blameAuth.operatingLevel || platform.operatingLevel;
@@ -2510,7 +2659,7 @@ async function trace(options) {
     blameAuth.analyzed,
     featureFlags,
     platform.adapter,
-    { ...options, file, cwd },
+    { ...options, mode, file, cwd },
     execOptions,
     repoId,
     cloneStatus.partialClone || void 0,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { AstDiffStageResult, AstTraceResult, AuthStatus, BlameResult, BlameStageResult, CacheEntry, ChangeType, CommitInfo, ComparisonResult, Confidence, ContentHash, CosmeticReason, FeatureFlags, GraphOptions, GraphResult, HealthReport, IssueInfo, LineRange, NormalizedResponse, OperatingLevel, PlatformAdapter, PlatformType, PRInfo, RateLimitInfo, RemoteInfo, SymbolInfo, SymbolKind, TraceNode, TraceNodeType, TraceOptions, TraceResult, TrackingMethod, } from './types/index.js';
+export type { AstDiffStageResult, AstTraceResult, AuthStatus, BlameResult, BlameStageResult, CacheEntry, ChangeType, CommitInfo, ComparisonResult, Confidence, ContentHash, CosmeticReason, FeatureFlags, GraphOptions, GraphResult, HealthReport, IssueInfo, LineRange, NormalizedResponse, OperatingLevel, PlatformAdapter, PlatformType, PRInfo, RateLimitInfo, RemoteInfo, SymbolInfo, SymbolKind, TraceNode, TraceNodeType, TraceMode, TraceOptions, TraceResult, TrackingMethod, } from './types/index.js';
 export { LineLoreError, LineLoreErrorCode } from './errors.js';
 export { clearCache, graph, health, trace } from './core/core.js';
 export type { TraceFullResult } from './core/core.js';