@shapeshift-labs/frontier-lang-compiler 0.2.189 → 0.2.190

package/README.md

@@ -557,7 +557,7 @@ Current JS/TS semantic-merge status matrix:
 | CSS dependency graph evidence | bounded-evidence | CSS dependency graph proof uses `cssDependencySurfaceFiles`, `cssDependencyGraphEvidenceFiles`, missing-proof/blocker counters, and the `css-dependency-graph` proof status for custom property, `var()` fallback, animation, font, asset, `@property`, and `@page` dependency surfaces. It is absent when no dependency surface is present and does not claim cascade/browser equivalence. |
 | CSS runtime descriptor evidence | bounded-evidence | CSS runtime descriptor proof uses `cssRuntimeDescriptorFiles`, `cssRuntimeDescriptorEvidenceFiles`, property/page descriptor counters, and the `css-runtime-descriptor-evidence` proof status for parser-backed `@property` syntax/inherits/initial-value evidence plus `@page` descriptor and margin-box records. It is source/shape-key evidence only; browser cascade, render, and runtime equivalence remain in the separate browser proof row. |
 | HTML/CSS browser runtime proof | bounded-evidence | HTML/CSS browser proof is an explicit separate row tracked by `htmlCssBrowserRuntimeProofs`, the `html-css-browser-runtime-proof` surface, and the `browser-runtime-proof` proof status. Structural source merges keep browser/render/cascade equivalence claims false unless a bounded browser proof bundle is attached; HTML runtime-boundary proofs and CSS cascade runtime proofs must include source hashes, a runtime command, probe id, evidence hash, and the required runtime signal. Missing proof routes to `prove-html-css-browser-runtime`. |
-| Parser/source-span/trivia evidence | Partial | Source preservation, source hashes, runtime directive-prologue entries, directives, comments/trivia summaries, project `sourceFileRecords` / `sourceSpanRecords`, protected-span hashes, shebang file-entrypoint directive ownership anchors, `sourceMappingURL` and `sourceURL` generated-boundary source-map spans, deterministic source-map generated-boundary ownership keys from supplied exact source/generated spans and hashes, generated-boundary position conflict evidence, deterministic ownership anchors, source-span/trivia ownership blockers, exact parser-trivia ownership records for directive prologues plus leading/trailing comments and JSDoc/block-comment spans when parser evidence matches the source hash, TypeScript `SourceFile` compiler-scanner exact token/trivia source-preservation evidence for JS/TS/JSX/TSX imports, ESTree/Babel parser token/comment range evidence when the supplied AST covers every non-whitespace byte of the current source, fail-closed scanner/ledger spoof blockers, source-span delta conflicts, parser roundtrip proof records, failed source-span roundtrip proof admission blockers, project-merge stage parser-trivia evidence from supplied parser-backed imports for base/worker/head/output, metadata-only exactness blockers for scanner fallbacks, and fixture corpus checks. Parser-backed exactness also requires contiguous current-source token/comment/trivia coverage with no gaps, overlaps, truncation, or text mismatches; truncated coverage blocks exact token/comment ownership. Adapters without token/comment ranges remain approximate/caller evidence, not exact parser trivia. |
+| Parser/source-span/trivia evidence | Partial | Source preservation, source hashes, runtime directive-prologue entries, directives, comments/trivia summaries, project `sourceFileRecords` / `sourceSpanRecords`, protected-span hashes, shebang file-entrypoint directive ownership anchors, `sourceMappingURL` and `sourceURL` generated-boundary source-map spans, deterministic source-map generated-boundary ownership keys from supplied exact source/generated spans and hashes, generated-boundary position conflict evidence, deterministic ownership anchors, source-span/trivia ownership blockers, exact parser-trivia ownership records for directive prologues plus leading/trailing comments and JSDoc/block-comment spans when parser evidence matches the source hash, TypeScript `SourceFile` compiler-scanner exact token/trivia source-preservation evidence for JS/TS/JSX/TSX imports, ESTree/Babel parser token/comment range evidence plus first-class `parserSpanCoverageProof` records when the supplied AST covers every non-whitespace byte of the current source, project source file/span parser-span coverage status/evidence fields, fail-closed scanner/ledger spoof blockers, source-span delta conflicts, parser roundtrip proof records, failed source-span roundtrip proof admission blockers, project-merge stage parser-trivia evidence from supplied parser-backed imports for base/worker/head/output, metadata-only exactness blockers for scanner fallbacks, and fixture corpus checks. Parser-backed exactness also requires contiguous current-source token/comment/trivia coverage with no gaps, overlaps, truncation, or text mismatches; truncated coverage blocks exact token/comment ownership. Adapters without token/comment ranges remain approximate/caller evidence, not exact parser trivia. |
 | Scope/use-def graph | Partial | Lightweight lexical scope/use-def scans, destructuring alias binding records, object/array/nested/rest/default-initializer parameter binding evidence for function and arrow parameters, default import alias reads through re-export chains when a stable default-export local binding is observed, source-bound anonymous default export fallback evidence for resolved default re-export chains with source hash/span and source symbol hashes, fail-closed `lexical-scope-import-alias-target-unresolved` records when an alias target cannot be tied to either lexical binding or source-bound anonymous default evidence, namespace import dot and literal/static-template computed member-read evidence, blocked evidence for ambiguous computed namespace reads and namespace member writes, `this`/`super` receiver member read/write evidence including computed string and static-template members, optional chaining markers, and TypeScript checker-backed receiver-member reference proof for full `this`/`super` access spans including private identifiers, template-literal interpolation live-reference records with expression hashes plus tagged-template site/tag root/member metadata, caller-supplied ESTree/scope-manager structural evidence normalization, closure-capture depth/owner/reference hashes, binding-level closure capture hashes, project `scopeBindingRecords` / `scopeReferenceRecords`, public owner use hashes, public scope-use and reference-site delta conflicts with alias target route/use-hash evidence, TypeScript compiler reference relations when a checker is supplied, exact compiler reference-site proof hashes on scope reference records, fail-closed `typescript-compiler-reference-site-ambiguous`, `typescript-compiler-reference-lexical-binding-mismatch`, and `typescript-compiler-reference-import-alias-target-mismatch` records when compiler alias evidence cannot be reconciled with the lexical route or re-export/import target, and dependency-sensitive fixture coverage. Full whole-program binding/control-flow resolution is still caller/compiler-evidence bounded. |
 | Module/export/import graph | Partial | Project graph stages, module resolution, runtime-neutral package manifest conversion from in-memory `package.json` objects/text, duplicate workspace-root package-name ambiguity diagnostics and fail-closed `package-workspace-root-ambiguous-missing` edges with `packageWorkspaceRoots` evidence, package exports/imports including wildcard package export key/target evidence, fail-closed package `imports` condition misses, runtime-ambiguous `import`/`require` condition blockers, caller-supplied package type runtime-condition evidence for `.js`/`.ts` package exports/imports, caller-supplied package environment-condition evidence such as `browser`, fail-closed `package-export-environment-ambiguous-missing` / `package-import-environment-ambiguous-missing` blockers with condition candidates when environment targets such as `browser` and `node` diverge without explicit evidence, and fail-closed host-runtime ambiguity blockers for non-resolver host package specifiers with divergent `import`/`require` targets, re-export identities including static TypeScript-style CommonJS bare and `tslib_1.__...` member-form `__exportStar(require("./dep"), exports)` fanout and `__createBinding(exports, require("./dep"), "name", "alias")` named re-export fanout, same-document CommonJS require-alias getter re-export identities for descriptor `get: function () { return dep.name; }`, named descriptor `get: function getName() { return dep.name; }`, shorthand `get() { return dep.name; }`, and block-bodied arrow `get: () => { return dep.name; }`, TypeScript-style CommonJS bare and `tslib_1.__...` member-form `__importDefault(require("./dep"))` and `__importStar(require("./dep"))` helper import edges, CommonJS `module.exports` default-import interop when no direct `default` export exists, literal computed CommonJS export properties such as `exports["default"]`, static `module.exports = { named }`, `Object.assign(exports, { named })`, `Object.defineProperty(exports, "named", { value/get })`, and `Object.defineProperties(exports, { named: { value/get } })` export maps in lightweight and AST-backed imports, ESTree/Babel no-expression `TemplateLiteral` normalization for CommonJS `require`, computed export keys, descriptor export specifiers, dynamic `import()`, CommonJS helper re-export specifiers, and host dependency specifiers while expression-bearing templates stay unresolved, TypeScript compiler no-substitution dynamic import and host dependency template evidence, `exports.__esModule` marker filtering, import-target deltas for head-introduced CommonJS export assignments, namespace/ambient module/global augmentation/export-assignment static shape records with proof hashes and no runtime-equivalence claim, fail-closed namespace/export-assignment shape delta conflicts, non-literal dynamic `import()` pseudo-specifiers with expression kind/text/hash evidence and fail-closed resolution evidence, static `new URL(specifier, import.meta.url)`, `Worker`, `SharedWorker`, `serviceWorker.register`, worklet `addModule`, `importScripts`, `import.meta.resolve`, and `require.resolve` host dependency edges with expression hashes and no runtime-resolution claim, dynamic host dependency targets emitted as `<host-dependency>` with expression hashes, `hostDependencyStaticSpecifierEvidence: false`, and proof-required unresolved evidence, import-attribute/import-assertion normalized key/value/count/hash evidence on static imports, dynamic imports, and re-exports, import-attribute delta conflicts, output graph unresolved-module conflicts that preserve edge-level fail-closed package, host, dynamic import, and import-attribute value evidence, and output graph resolved-module missing-export conflicts that preserve edge-level package and import-attribute evidence. Host filesystem/package graph crawling, namespace runtime evaluation, ambient/global compatibility, and CommonJS runtime interop equivalence remain out of the root API. |
 | Type/public API graph | Partial | Public-contract regions, signature/contract hashes, TypeScript compiler symbol/type records, source-bound checker proof source path/hash requirements, compiler-backed type-reference target proof that binds public API type references to resolved target symbols, declaration spans, and declaration source text hashes, inferred exported factory call-signature evidence, compiler-backed public call/construct signature shape evidence and proof hashes, exported overload declaration/signature counts, compiler-backed overload signature-set proof, compiler-backed generic type-parameter/default proof, compiler-backed public member property/method property-set proof, compiler-backed public index-signature key/value/readonly evidence and proof hashes, stable public-surface hashes that ignore transient TypeScript symbol flags, compiler-backed class heritage and constructor-signature evidence/proof hashes, compiler-backed private class member and accessor-field static shape records/proof hashes plus source- and required-signal-bound private/accessor runtime proof binding with command/trace/evidence hashes, private brand, private method, private accessor, static private, subclass brand-boundary, and accessor descriptor trace slots, and false claim flags, compiler-backed class/member/parameter decorator target and expression static metadata records/proof hashes plus source-bound decorator runtime execution proof binding with trace hashes and false claim flags, compiler-backed enum runtime-shape/member-value evidence and proof hashes, TypeScript compiler importer support for source-bound computed enum evaluated-value traces with emitted-shape hashes, trace/evidence hashes, and false claim flags, compiler-backed conditional, indexed-access, mapped, `keyof`, template-literal, `infer`, union, intersection, tuple, and mixed known advanced/composite type-shape proof hashes, static compiler-backed inference syntax evidence/proof hashes for `satisfies`, `as const`, and const type parameters, bounded TypeChecker `isTypeAssignableTo` oracle proof for simple public type aliases with source path/hash binding and fail-closed `typescript-public-api-type-equivalence-proof-missing` for missing or ambiguous oracle evidence, class private/accessor/decorator/class/enum/advanced-shape/composite-shape/inference-syntax/index-signature/callable-signature/type-reference-target hashes in public compiler-type delta fingerprints, fail-closed missing-proof blockers for missing public API source hashes, type-reference target proof hashes, call/construct signature return/parameter evidence, constructor/class-heritage/private-class-member/accessor-field/index-signature value-type/enum runtime-shape/conditional-branch/indexed-access object-index-result/mapped constraint-value/`keyof` target/template-literal span/`infer` type-parameter/union member/intersection member/tuple element evidence, fail-closed computed enum runtime-value blockers when source-bound evaluated-value proof is missing, stale, trace-incomplete, value-incomplete, or claim-bearing, fail-closed private/accessor and decorator runtime execution blockers when source-bound trace proof is missing, stale, trace-incomplete, schema/kind-mismatched, required-signal-incomplete, commandless, or claim-bearing, fail-closed unknown advanced type-shape evidence, unsupported type-equivalence reason codes, public compiler-type delta conflicts, declaration-output gate, TypeScript declaration emit parity proof for worker/head/output public boundaries, and project graph delta conflicts. Full type-equivalence, broad decorator execution equivalence beyond source-bound trace proofs, broad enum runtime evaluation beyond source-bound computed-value traces, broad runtime equivalence for private/accessor execution beyond source-bound trace proofs, or broad inference-semantics proof beyond these focused compiler-backed cases is not claimed. |
@@ -598,6 +598,7 @@ Recent residual closures represented in the matrix shards:
 - Project admission now exposes `admission.routes` / `routeSummary` records for structural apply/review/reject/rerun/rebase decisions across cross-file symbol rename, symbol move, split/merge, replay-proof, and missing-evidence paths, while keeping `autoMergeClaim: false` and `semanticEquivalenceClaim: false`.
 - Semantic equivalence proof now accepts source/output/gate-bound external proof records for exact JS/TS project bindings, removes the external-proof missing route only when the proof validates, and keeps stale, malformed, or overclaiming proofs fail-closed with `semantic-equivalence-unknown`.
 - Parser/source-span/trivia now requires contiguous parser-backed current-source token/comment/trivia coverage with no gaps, overlaps, truncation, or text mismatches before claiming exact token/comment ownership, including distinct JSDoc and block-comment ownership relations.
+- Parser/source-span/trivia now emits first-class ESTree/Babel `parserSpanCoverageProof` evidence from token/comment ranges, threads it into parser-trivia exactness, source file/span records, ownership anchors, and source-span roundtrip summaries, and keeps truncated syntax-AST coverage fail-closed.
 - Scope/use-def graph now blocks compiler/lexical import-alias re-export target disagreement with `typescript-compiler-reference-import-alias-target-mismatch`.
 - Scope/use-def graph now treats no-expression template literals in namespace-import and `this`/`super` computed member reads as static member evidence while expression templates remain blocked.
 - Module/export/import graph now treats duplicate package names across different workspace roots as `ambiguous-package-workspace-root` and emits fail-closed `package-workspace-root-ambiguous-missing` edges.

package/dist/internal/index-impl/projectSymbolGraphSourceRecords.js

@@ -70,6 +70,10 @@ function sourceFileRecord(context) {
     exactParserTrivia: parserTriviaExactness.exactParserTrivia,
     parserTriviaEvidenceId: parserTriviaExactness.evidenceId,
     parserTriviaAdapterId: parserTriviaExactness.adapterId,
+    parserSpanCoverageStatus: parserTriviaExactness.parserSpanCoverageStatus,
+    parserSpanCoverageEvidenceId: parserTriviaExactness.parserSpanCoverageEvidenceId,
+    parserSpanCoverageReasonCodes: parserTriviaExactness.parserSpanCoverageReasonCodes,
+    parserSpanCoverageBlockReasonCodes: parserTriviaExactness.parserSpanCoverageBlockReasonCodes,
     parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
     parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes,
     sourceLedgerAvailable: ownership.sourceLedgerAvailable,
@@ -159,6 +163,10 @@ function sourceSpanRecord(span, index, context, identity) {
     exactParserTrivia: parserTriviaExactness.exactParserTrivia,
     parserTriviaEvidenceId: parserTriviaExactness.evidenceId,
     parserTriviaAdapterId: parserTriviaExactness.adapterId,
+    parserSpanCoverageStatus: parserTriviaExactness.parserSpanCoverageStatus,
+    parserSpanCoverageEvidenceId: parserTriviaExactness.parserSpanCoverageEvidenceId,
+    parserSpanCoverageReasonCodes: parserTriviaExactness.parserSpanCoverageReasonCodes,
+    parserSpanCoverageBlockReasonCodes: parserTriviaExactness.parserSpanCoverageBlockReasonCodes,
     parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
     parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes,
     parserTriviaOwnershipStatus,
@@ -218,6 +226,7 @@ function parserTriviaExactnessForPreservation(preservation) {
       sourceHash: preservation?.sourceHash,
       parserEvidence: tokenTriviaParserEvidence,
       parserTokenTriviaEvidence: tokenTriviaParserEvidence,
+      parserSpanCoverageProof: preservation?.metadata?.parserSpanCoverageProof,
       truncated: preservation?.summary?.truncated === true
     });
   }

package/dist/internal/index-impl/projectSymbolGraphSourceRecordsOwnership.js

@@ -67,6 +67,10 @@ function sourceSpanOwnershipAnchor(span, role, context, spans, index) {
     exactParserTrivia: parserTriviaExactness.exactParserTrivia,
     parserTriviaEvidenceId: parserTriviaExactness.evidenceId,
     parserTriviaAdapterId: parserTriviaExactness.adapterId,
+    parserSpanCoverageStatus: parserTriviaExactness.parserSpanCoverageStatus,
+    parserSpanCoverageEvidenceId: parserTriviaExactness.parserSpanCoverageEvidenceId,
+    parserSpanCoverageReasonCodes: parserTriviaExactness.parserSpanCoverageReasonCodes,
+    parserSpanCoverageBlockReasonCodes: parserTriviaExactness.parserSpanCoverageBlockReasonCodes,
     parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
     parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes,
     ...parserTriviaOwnership
@@ -94,6 +98,7 @@ function parserTriviaExactnessForContext(context) {
       sourceHash: context.sourceHash,
       parserEvidence,
       parserTokenTriviaEvidence: parserEvidence,
+      parserSpanCoverageProof: context.preservation.metadata?.parserSpanCoverageProof,
       truncated: context.preservation.summary?.truncated === true
     });
   }
@@ -102,6 +107,7 @@ function parserTriviaExactnessForContext(context) {
     sourceHash: context.sourceHash,
     parserEvidence,
     parserTokenTriviaEvidence: parserEvidence,
+    parserSpanCoverageProof: context.preservation.metadata?.parserSpanCoverageProof,
     truncated: context.preservation.summary?.truncated === true
   });
 }

package/dist/internal/index-impl/syntaxAstParserSpanCoverage.js

@@ -0,0 +1,54 @@
+import { idFragment } from '../../native-import-utils.js';
+import { createParserSpanCoverageProof } from '../../native-source-preservation-ownership.js';
+
+export function createSyntaxAstParserSpanCoverageEvidence(input) {
+  const parserSpanCoverageProof = createParserSpanCoverageProof({
+    sourceText: input.sourceText,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    segments: input.segments,
+    tokenCount: input.tokenCount,
+    triviaCount: input.triviaCount,
+    commentCount: input.commentCount,
+    parserEvidence: input.parserEvidence,
+    adapterId: input.adapterId,
+    evidenceId: `${input.adapterId}:parser-span-coverage:${idFragment(input.sourcePath ?? input.sourceHash)}`,
+    languageMode: sourceLanguageMode(input),
+    boundedLanguages: ['javascript', 'typescript', 'jsx', 'tsx'],
+    truncated: input.truncated
+  });
+  return {
+    parserSpanCoverageProof,
+    parserTriviaEvidence: parserTriviaEvidenceForSpanCoverage(parserSpanCoverageProof, input)
+  };
+}
+
+function parserTriviaEvidenceForSpanCoverage(parserSpanCoverageProof, input) {
+  const exact = parserSpanCoverageProof?.status === 'exact';
+  const blockReasonCodes = exact ? [] : [
+    'exact-parser-trivia-span-coverage-blocked',
+    ...(parserSpanCoverageProof?.blockReasonCodes ?? []),
+    input.truncated ? 'source-preservation-truncated' : undefined
+  ].filter(Boolean);
+  return {
+    status: exact ? 'exact' : 'blocked',
+    exactParserTrivia: exact,
+    losslessCst: exact,
+    sourceHash: input.sourceHash,
+    adapterId: input.adapterId,
+    evidenceId: `${input.adapterId}:parser-token-comment:${idFragment(input.sourcePath ?? input.sourceHash)}`,
+    parserEvidence: input.parserEvidence,
+    parserSpanCoverageProof,
+    ...(exact ? {} : { blockReasonCodes })
+  };
+}
+
+function sourceLanguageMode(input) {
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  if (sourcePath.endsWith('.tsx')) return 'tsx';
+  if (sourcePath.endsWith('.jsx')) return 'jsx';
+  if (sourcePath.endsWith('.ts') || sourcePath.endsWith('.mts') || sourcePath.endsWith('.cts')) return 'typescript';
+  if (sourcePath.endsWith('.js') || sourcePath.endsWith('.mjs') || sourcePath.endsWith('.cjs')) return 'javascript';
+  const language = String(input.language ?? '').toLowerCase();
+  return language === 'typescript' ? 'typescript' : 'javascript';
+}

package/dist/internal/index-impl/syntaxAstSourcePreservation.js

@@ -6,20 +6,22 @@ import {
   preservedSourceSegmentRole
 } from '../../native-source-preservation-ownership.js';
 import { createNativeSourcePreservation } from './createNativeSourcePreservation.js';
+import { createSyntaxAstParserSpanCoverageEvidence } from './syntaxAstParserSpanCoverage.js';
 
 export function createSyntaxAstSourcePreservation(ast, input, options = {}) {
   if (!ast || typeof input.sourceText !== 'string') return undefined;
   const sourceText = input.sourceText;
   const sourceHash = hashSemanticValue(sourceText);
   const parserEvidence = `${options.parser ?? input.parser ?? 'syntax-ast'}-parser-token-comment-ranges`;
+  const adapterId = input.adapterId ?? options.adapterId ?? `${options.parser ?? input.parser ?? 'syntax'}-native-importer`;
   const tokensAndTrivia = syntaxAstTokensAndTrivia(ast, input, {
     ...options,
+    adapterId,
     parserEvidence,
     sourceHash,
     sourceText
   });
   if (!tokensAndTrivia?.exact) return undefined;
-  const adapterId = input.adapterId ?? options.adapterId ?? `${options.parser ?? input.parser ?? 'syntax'}-native-importer`;
   return createNativeSourcePreservation({
     language: input.language ?? options.language ?? 'javascript',
     sourcePath: input.sourcePath,
@@ -28,15 +30,8 @@ export function createSyntaxAstSourcePreservation(ast, input, options = {}) {
     tokensAndTrivia,
     includeTokens: options.includeTokens !== false,
     includeTrivia: options.includeTrivia !== false,
-    parserTriviaEvidence: {
-      status: 'exact',
-      exactParserTrivia: true,
-      losslessCst: true,
-      sourceHash,
-      adapterId,
-      evidenceId: `${adapterId}:parser-token-comment:${idFragment(input.sourcePath ?? sourceHash)}`,
-      parserEvidence
-    },
+    parserSpanCoverageProof: tokensAndTrivia.parserSpanCoverageProof,
+    parserTriviaEvidence: tokensAndTrivia.parserTriviaEvidence,
     metadata: {
       parserTokenTriviaEvidence: parserEvidence,
       parserTokenTriviaSource: options.astFormat ?? options.parser ?? 'syntax-ast'
@@ -56,14 +51,30 @@ function syntaxAstTokensAndTrivia(ast, input, options) {
   const whitespaceSegments = whitespaceTriviaSegments(parserSegments, input, options);
   const allTrivia = [...parserSegments.filter((segment) => segment.role === 'trivia'), ...whitespaceSegments]
     .sort((left, right) => left.span.start - right.span.start || left.span.end - right.span.end);
-  const tokens = limitRecords(parserSegments.filter((segment) => segment.role !== 'trivia'), options.maxTokens);
-  const trivia = limitRecords(allTrivia, options.maxTrivia);
+  const tokenLimit = limitRecords(parserSegments.filter((segment) => segment.role !== 'trivia'), options.maxTokens);
+  const triviaLimit = limitRecords(allTrivia, options.maxTrivia);
+  const truncated = tokenLimit.truncated || triviaLimit.truncated;
+  const coverage = createSyntaxAstParserSpanCoverageEvidence({
+    sourceText,
+    sourcePath: input.sourcePath,
+    language: input.language ?? options.language,
+    sourceHash: options.sourceHash,
+    segments: [...tokenLimit.records, ...triviaLimit.records],
+    tokenCount: tokenLimit.records.length,
+    triviaCount: triviaLimit.records.length,
+    commentCount: triviaLimit.records.filter((entry) => isCommentKind(entry.kind)).length,
+    parserEvidence: options.parserEvidence,
+    adapterId: options.adapterId,
+    truncated
+  });
   return {
     exact: true,
-    tokens: tokens.records,
-    trivia: trivia.records,
-    truncated: tokens.truncated || trivia.truncated,
-    parserEvidence: options.parserEvidence
+    tokens: tokenLimit.records.map((entry) => withParserTriviaEvidence(entry, coverage.parserTriviaEvidence)),
+    trivia: triviaLimit.records.map((entry) => withParserTriviaEvidence(entry, coverage.parserTriviaEvidence)),
+    truncated,
+    parserEvidence: options.parserEvidence,
+    parserSpanCoverageProof: coverage.parserSpanCoverageProof,
+    parserTriviaEvidence: coverage.parserTriviaEvidence
   };
 }
 
@@ -172,6 +183,29 @@ function preservedParserSegment(input) {
   };
 }
 
+function withParserTriviaEvidence(record, parserTriviaEvidence) {
+  const role = preservedSourceSegmentRole(record.kind);
+  return {
+    ...record,
+    ownershipAnchor: createPreservedSourceOwnershipAnchor({
+      kind: record.kind,
+      role,
+      text: record.text,
+      textHash: record.textHash,
+      sourcePath: record.span.path,
+      sourceHash: record.span.sourceId,
+      span: record.span,
+      anchorKind: preservedOwnershipAnchorKind(record.kind, role),
+      parserEvidence: parserTriviaEvidence.parserEvidence,
+      parserTriviaEvidence
+    }),
+    metadata: {
+      ...record.metadata,
+      parserSpanCoverageStatus: parserTriviaEvidence.parserSpanCoverageProof?.status
+    }
+  };
+}
+
 function parserSegmentsCoverSource(segments, sourceText) {
   let cursor = 0;
   for (const segment of segments) {
@@ -243,6 +277,10 @@ function preservedCommentKind(text) {
   return 'comment';
 }
 
+function isCommentKind(kind) {
+  return kind === 'comment' || kind === 'jsdoc-comment' || kind === 'block-comment' || kind === 'source-map-comment';
+}
+
 function limitRecords(records, maxValue) {
   const max = Number.isFinite(maxValue) ? Math.max(0, maxValue) : 20000;
   return { records: records.slice(0, max), truncated: records.length > max };

package/dist/js-ts-safe-project-merge-source-span-roundtrip-proof.js

@@ -96,7 +96,11 @@ function parserTriviaExactnessForFile(file, artifacts) {
     {
       sourcePath: file.sourcePath,
       sourceHash: file.outputHash,
-      parserEvidence: artifacts?.metadata?.parserEvidence
+      parserEvidence: artifacts?.metadata?.parserEvidence,
+      parserSpanCoverageProof: file.parserSpanCoverageProof
+        ?? file.metadata?.parserSpanCoverageProof
+        ?? file.result?.metadata?.parserSpanCoverageProof
+        ?? artifacts?.metadata?.parserSpanCoverageProof
     }
   );
 }

package/dist/native-source-preservation-ownership.js

@@ -207,6 +207,10 @@ function createPreservedSourceOwnershipAnchor(input = {}) {
     exactParserTrivia: parserTriviaExactness.exactParserTrivia,
     parserTriviaEvidenceId: parserTriviaExactness.evidenceId,
     parserTriviaAdapterId: parserTriviaExactness.adapterId,
+    parserSpanCoverageStatus: parserTriviaExactness.parserSpanCoverageStatus,
+    parserSpanCoverageEvidenceId: parserTriviaExactness.parserSpanCoverageEvidenceId,
+    parserSpanCoverageReasonCodes: parserTriviaExactness.parserSpanCoverageReasonCodes,
+    parserSpanCoverageBlockReasonCodes: parserTriviaExactness.parserSpanCoverageBlockReasonCodes,
     parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
     parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.189",
+  "version": "0.2.190",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",