@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

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

@@ -0,0 +1,142 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { spanFromTypeScriptNode } from './spanFromTypeScriptNode.js';
+
+function compilerTypeReferenceTargets(checker, identitySymbol, location, ts) {
+  const declarations = Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations : [];
+  const records = [];
+  for (const declaration of declarations) {
+    visitTypeNodes(ts, declaration, (node) => {
+      if (!isSyntaxKind(ts, node, 'TypeReference')) return;
+      const record = typeReferenceTargetRecord(checker, node, location, ts);
+      if (record) records.push(record);
+    });
+  }
+  return uniqueRecords(records, (record) => [
+    record.typeReferenceName,
+    record.nodeText,
+    record.targetFullyQualifiedName,
+    record.targetDeclarationTextHash
+  ].join('\0'));
+}
+
+function typeReferenceTargetRecord(checker, node, location, ts) {
+  const symbol = safeCall(checker?.getSymbolAtLocation, checker, node.typeName);
+  const aliasedSymbol = safeCall(checker?.getAliasedSymbol, checker, symbol);
+  const targetSymbol = aliasedSymbol && aliasedSymbol !== symbol ? aliasedSymbol : symbol;
+  const declaration = targetDeclaration(targetSymbol);
+  if (!targetSymbol || !declaration) return undefined;
+  const referenceSpan = spanForNode(node, location);
+  const declarationSpan = spanForNode(declaration, location);
+  const declarationTextHash = declarationSourceHash(declaration, declarationSpan);
+  const targetSymbolIdentityHash = targetSymbol ? hashSemanticValue({
+    kind: 'frontier.lang.typescript.compilerTypeReferenceTargetSymbol.v1',
+    name: stringValue(targetSymbol.escapedName ?? targetSymbol.name),
+    fullyQualifiedName: stringValue(safeCall(checker?.getFullyQualifiedName, checker, targetSymbol)),
+    flags: numberValue(targetSymbol.flags),
+    declarationKind: syntaxKindName(ts, declaration?.kind),
+    declarationSpan,
+    declarationTextHash
+  }) : undefined;
+  const targetProof = compactRecord({
+    kind: 'frontier.lang.typescript.compilerPublicApiTypeReferenceTargetProof.v1',
+    typeReferenceName: nodeText(node.typeName),
+    targetSymbolName: stringValue(targetSymbol?.escapedName ?? targetSymbol?.name),
+    targetFullyQualifiedName: stringValue(targetSymbol ? safeCall(checker?.getFullyQualifiedName, checker, targetSymbol) : undefined),
+    targetSymbolFlags: numberValue(targetSymbol?.flags),
+    targetDeclarationKind: syntaxKindName(ts, declaration?.kind),
+    targetDeclarationSourcePath: declarationSpan?.path ?? sourcePathForNode(declaration),
+    targetDeclarationSpan: declarationSpan,
+    targetDeclarationTextHash: declarationTextHash,
+    targetSymbolIdentityHash
+  });
+  return compactRecord({
+    kind: 'type-reference-target',
+    syntaxKind: syntaxKindName(ts, node.kind),
+    nodeText: nodeText(node),
+    typeText: typeTextFromTypeNode(checker, node, location),
+    typeReferenceName: nodeText(node.typeName),
+    sourceSpan: referenceSpan,
+    typeArgumentCount: arrayValue(node.typeArguments).length || undefined,
+    targetStatus: 'resolved',
+    targetAliased: aliasedSymbol && aliasedSymbol !== symbol ? true : undefined,
+    targetSymbolName: targetProof.targetSymbolName,
+    targetFullyQualifiedName: targetProof.targetFullyQualifiedName,
+    targetSymbolFlags: targetProof.targetSymbolFlags,
+    targetSymbolIdentityHash,
+    targetDeclarationKind: targetProof.targetDeclarationKind,
+    targetDeclarationSourcePath: targetProof.targetDeclarationSourcePath,
+    targetDeclarationSpan: declarationSpan,
+    targetDeclarationTextHash: declarationTextHash,
+    typeReferenceTargetProofHash: hashSemanticValue(targetProof),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  });
+}
+
+function targetDeclaration(symbol) {
+  return symbol?.valueDeclaration ?? arrayValue(symbol?.declarations)[0];
+}
+
+function declarationSourceHash(node, span) {
+  const text = nodeText(node);
+  if (!text) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.compilerTypeReferenceTargetDeclarationSource.v1',
+    sourcePath: span?.path ?? sourcePathForNode(node),
+    span,
+    text
+  });
+}
+
+function spanForNode(node, fallback) {
+  if (!node || typeof node !== 'object') return undefined;
+  const sourceFile = safeCall(node.getSourceFile, node) ?? safeCall(fallback?.getSourceFile, fallback);
+  return sourceFile ? spanFromTypeScriptNode(node, sourceFile) : undefined;
+}
+
+function sourcePathForNode(node) {
+  return stringValue(safeCall(node?.getSourceFile, node)?.fileName);
+}
+
+function visitTypeNodes(ts, node, visit) {
+  if (!node || typeof node !== 'object') return;
+  visit(node);
+  if (typeof ts?.forEachChild === 'function') {
+    ts.forEachChild(node, (child) => visitTypeNodes(ts, child, visit));
+    return;
+  }
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) value.forEach((child) => visitTypeNodes(ts, child, visit));
+    else if (value && typeof value === 'object' && Number.isFinite(value.kind)) visitTypeNodes(ts, value, visit);
+  }
+}
+
+function typeTextFromTypeNode(checker, node, location) {
+  const type = safeCall(checker?.getTypeFromTypeNode, checker, node) ?? safeCall(checker?.getTypeAtLocation, checker, node ?? location);
+  return type ? stringValue(safeCall(checker?.typeToString, checker, type)) : nodeText(node);
+}
+
+function syntaxKind(ts, name) { return numberValue(ts?.SyntaxKind?.[name]); }
+function isSyntaxKind(ts, node, name) { return node?.kind === syntaxKind(ts, name); }
+function syntaxKindName(ts, kind) { return stringValue(ts?.SyntaxKind?.[kind]) ?? (Number.isFinite(kind) ? String(kind) : undefined); }
+function nodeText(node) { return stringValue(safeCall(node?.getText, node)); }
+function safeCall(fn, receiver, ...args) {
+  if (typeof fn !== 'function') return undefined;
+  try { return fn.apply(receiver, args); } catch { return undefined; }
+}
+function stringValue(value) { return value === undefined || value === null || value === '' ? undefined : String(value); }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueRecords(records, keyFn) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = keyFn(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export { compilerTypeReferenceTargets };

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

@@ -1,5 +1,6 @@
-import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';import{idFragment}from'../../native-import-utils.js';
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 import{declarationRecord}from'./declarationRecord.js';import{namedDeclaration}from'./namedDeclaration.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';import{typeScriptExportedDeclarationEntries}from'./typeScriptExportedDeclarationEntries.js';import{typeScriptModuleDeclarationEntries}from'./typeScriptModuleDeclarationEntries.js';
+import{typeScriptCompilerSymbolRecordForNode}from'./typeScriptCompilerSymbolIdentity.js';
 export function typeScriptDeclaration(node, kind, nativeNodeId, input, options = {}) {
   const enrich = (declaration, symbolNode = node.name ?? node) => enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options);
   const moduleEntries = typeScriptModuleDeclarationEntries(node, kind, nativeNodeId, input);
@@ -41,51 +42,22 @@ function moduleDeclaration(input, nativeNodeId, node) {
 
 function enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options) {
   if (!declaration) return declaration;
-  const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();
-  const symbol = safeCall(checker?.getSymbolAtLocation, checker, symbolNode) ?? safeCall(checker?.getSymbolAtLocation, checker, node.name);
-  if (!symbol) return declaration;
-  const aliasedSymbol = safeCall(checker?.getAliasedSymbol, checker, symbol);
-  const targetSymbol = aliasedSymbol && aliasedSymbol !== symbol ? aliasedSymbol : undefined;
-  const identitySymbol = targetSymbol ?? symbol;
-  const fullyQualifiedName = stringValue(safeCall(checker?.getFullyQualifiedName, checker, identitySymbol));
-  const localName = stringValue(symbol.escapedName ?? symbol.name) ?? declaration.name;
-  const targetName = targetSymbol ? stringValue(targetSymbol.escapedName ?? targetSymbol.name) : undefined;
-  const identity = fullyQualifiedName ?? targetName ?? localName;
-  const compilerSymbol = compactRecord({
-    parser: options.parser,
-    localName,
-    targetName,
-    fullyQualifiedName,
-    flags: numberValue(symbol.flags),
-    targetFlags: numberValue(targetSymbol?.flags),
-    declarations: Array.isArray(identitySymbol.declarations) ? identitySymbol.declarations.length : undefined,
-    aliased: Boolean(targetSymbol)
-  });
+  const compiler = typeScriptCompilerSymbolRecordForNode(symbolNode, input, options, node.name, { importRole: declaration.role === 'import' });
+  if (!compiler) return declaration;
   return {
     ...declaration,
-    symbolId: `symbol:${input.language}:compiler:${declaration.role === 'import' ? 'import:' : ''}${idFragment(identity)}`,
-    signatureHash: hashSemanticValue([input.language, declaration.symbolKind, identity, compilerSymbol]),
+    symbolId: compiler.symbolId,
+    signatureHash: hashSemanticValue([input.language, declaration.symbolKind, compiler.identity, compiler.compilerSymbol, compiler.compilerType]),
     metadata: {
       ...declaration.metadata,
-      compilerSymbol,
-      compilerSymbolIdentityHash: hashSemanticValue(compilerSymbol)
+      compilerSymbol: compiler.compilerSymbol,
+      compilerSymbolIdentityHash: compiler.compilerSymbolIdentityHash,
+      compilerType: compiler.compilerType,
+      compilerTypeIdentityHash: compiler.compilerTypeIdentityHash
     }
   };
 }
 
-function safeCall(fn, receiver, ...args) {
-  if (typeof fn !== 'function') return undefined;
-  try { return fn.apply(receiver, args); } catch { return undefined; }
-}
-
-function stringValue(value) {
-  return value === undefined || value === null || value === '' ? undefined : String(value);
-}
-
-function numberValue(value) {
-  return Number.isFinite(value) ? value : undefined;
-}
-
 function compactRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }

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

@@ -1,10 +1,11 @@
 import{idFragment}from'../../native-import-utils.js';
-import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+import{declarationRecord}from'./declarationRecord.js';import{dynamicImportExpressionMetadata}from'./dynamicImportExpressionMetadata.js';import{identifierName}from'./identifierName.js';import{hostModuleDependencyMetadata}from'./importMetaUrlDependencyMetadata.js';import{moduleImportAttributeMetadata}from'./moduleImportAttributeMetadata.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
 export function typeScriptModuleDeclarationEntries(node, kind, nativeNodeId, input) {
   if (kind === 'ImportDeclaration') return importDeclarationEntries(node, nativeNodeId, input);
   if (kind === 'ImportEqualsDeclaration') return importEqualsDeclarationEntries(node, nativeNodeId, input);
-  if (kind === 'ExportDeclaration') return exportDeclarationEntries(node, nativeNodeId, input);
-  if (kind === 'ExportAssignment') return exportAssignmentEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' && isDynamicImportCall(node)) return dynamicImportExpressionEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' || kind === 'NewExpression') { const dependencies = hostModuleDependencyMetadata(node, { kind }); if (dependencies.length) return dependencies.flatMap((dependency) => importModuleEntries(input, nativeNodeId, dependency.moduleSpecifier, 'HostModuleDependency', [], dependency.metadata)); }
+  if (kind === 'ExportDeclaration') return exportDeclarationEntries(node, nativeNodeId, input); if (kind === 'ExportAssignment') return exportAssignmentEntries(node, nativeNodeId, input);
   return undefined;
 }
 
@@ -16,7 +17,8 @@ function importDeclarationEntries(node, nativeNodeId, input) {
   return importModuleEntries(input, nativeNodeId, moduleSpecifier, 'ImportDeclaration', bindings, {
     typeOnly,
     sideEffectOnly: bindings.length === 0,
-    importKind: bindings.length === 0 ? 'side-effect' : 'module'
+    importKind: bindings.length === 0 ? 'side-effect' : 'module',
+    ...moduleImportAttributeMetadata(node)
   });
 }
 
@@ -34,6 +36,16 @@ function importEqualsDeclarationEntries(node, nativeNodeId, input) {
   }], { typeOnly, importKind: 'commonjs-require' });
 }
 
+function dynamicImportExpressionEntries(node, nativeNodeId, input) {
+  const firstArgument = node.arguments?.[0], moduleSpecifier = firstArgument ? stringLiteralFromTsExpression(firstArgument) ?? '<dynamic-import>' : undefined;
+  if (!moduleSpecifier) return [];
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, 'DynamicImportExpression', [], {
+    importKind: 'dynamic-import',
+    dynamicImport: true, ...dynamicImportExpressionMetadata(firstArgument, moduleSpecifier),
+    ...moduleImportAttributeMetadata(node)
+  });
+}
+
 function exportDeclarationEntries(node, nativeNodeId, input) {
   const moduleSpecifier = stringFromTsExpression(node.moduleSpecifier);
   const typeOnly = Boolean(node.isTypeOnly);
@@ -46,14 +58,16 @@ function exportDeclarationEntries(node, nativeNodeId, input) {
       reexport: true,
       exportStar,
       namespaceReExport,
-      importKind: exportStar ? 'reexport' : 'reexport'
+      importKind: exportStar ? 'reexport' : 'reexport',
+      ...moduleImportAttributeMetadata(node)
     }) : []),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       exportStar,
       reExport: Boolean(moduleSpecifier),
       namespaceReExport,
-      exportKind: exportStar ? 'export-star' : 'named'
+      exportKind: exportStar ? 'export-star' : 'named',
+      ...moduleImportAttributeMetadata(node)
     })
   ];
 }
@@ -177,10 +191,10 @@ function importModuleEntries(input, nativeNodeId, moduleSpecifier, _languageKind
       metadata: moduleMetadata('typescript-import', bindings, metadata)
     })
   };
-  return [moduleEntry, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
+  return [moduleEntry, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
 }
 
-function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
+function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
   const declaration = compactRecord({
     ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
     symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
@@ -202,7 +216,7 @@ function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
       namespace: binding.namespace,
       importKind: binding.importKind,
       isTypeOnly: binding.isTypeOnly,
-      typeOnly: binding.isTypeOnly
+      typeOnly: binding.isTypeOnly, hasImportAttributes: metadata.hasImportAttributes, importAttributeCount: metadata.importAttributeCount, importAttributeKeys: metadata.importAttributeKeys, importAttributeHash: metadata.importAttributeHash, importAttributes: metadata.importAttributes
     })
   });
   return { declaration, symbolNode: binding.symbolNode };
@@ -225,10 +239,10 @@ function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, met
       metadata: moduleMetadata('typescript-export', bindings, metadata)
     })
   };
-  return [statement, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
+  return [statement, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
 }
 
-function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
+function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
   const declaration = compactRecord({
     ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
     symbolId: `symbol:${input.language}:export:${idFragment(`${moduleSpecifier ?? 'local'}:${binding.exportedName}:${binding.localName}`)}`,
@@ -254,7 +268,7 @@ function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
       isTypeOnly: binding.isTypeOnly,
       typeOnly: binding.isTypeOnly,
       reExport: binding.reExport,
-      publicContract: true
+      publicContract: true, hasImportAttributes: metadata.hasImportAttributes, importAttributeCount: metadata.importAttributeCount, importAttributeKeys: metadata.importAttributeKeys, importAttributeHash: metadata.importAttributeHash, importAttributes: metadata.importAttributes
     })
   });
   return { declaration, symbolNode: binding.symbolNode };
@@ -269,7 +283,13 @@ function moduleMetadata(scan, bindings, metadata) {
     exportKind: metadata.exportKind,
     isTypeOnly: metadata.typeOnly,
     typeOnly: metadata.typeOnly,
-    sideEffectOnly: metadata.sideEffectOnly,
+    sideEffectOnly: metadata.sideEffectOnly, dynamicImport: metadata.dynamicImport,
+    dynamicImportSpecifierKind: metadata.dynamicImportSpecifierKind, dynamicImportExpressionText: metadata.dynamicImportExpressionText, dynamicImportExpressionHash: metadata.dynamicImportExpressionHash, dynamicImportStaticSpecifierEvidence: metadata.dynamicImportStaticSpecifierEvidence, dynamicImportRuntimeResolutionClaim: metadata.dynamicImportRuntimeResolutionClaim, dynamicImportResolutionProofRequired: metadata.dynamicImportResolutionProofRequired, hostDependency: metadata.hostDependency, hostDependencyKind: metadata.hostDependencyKind, hostDependencyBase: metadata.hostDependencyBase, hostDependencyExpressionText: metadata.hostDependencyExpressionText, hostDependencyExpressionHash: metadata.hostDependencyExpressionHash, hostDependencyStaticSpecifierEvidence: metadata.hostDependencyStaticSpecifierEvidence, hostDependencyRuntimeResolutionClaim: metadata.hostDependencyRuntimeResolutionClaim, hostDependencyResolutionProofRequired: metadata.hostDependencyResolutionProofRequired,
+    hasImportAttributes: metadata.hasImportAttributes,
+    importAttributeCount: metadata.importAttributeCount,
+    importAttributeKeys: metadata.importAttributeKeys,
+    importAttributeHash: metadata.importAttributeHash,
+    importAttributes: metadata.importAttributes,
     reexport: metadata.reexport,
     reExport: metadata.reExport,
     namespaceReExport: metadata.namespaceReExport,
@@ -278,6 +298,23 @@ function moduleMetadata(scan, bindings, metadata) {
   });
 }
 
-function compactRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+function isDynamicImportCall(node) {
+  return Array.isArray(node?.arguments) && node.arguments.length > 0 && typeScriptExpressionText(node.expression) === 'import';
+}
+
+function typeScriptExpressionText(node) {
+  if (!node) return undefined;
+  if (typeof node.getText === 'function') {
+    try { return node.getText(); } catch {}
+  }
+  if (typeof node.kindName === 'string') return node.kindName === 'ImportKeyword' ? 'import' : node.kindName;
+  if (node.kind === 'ImportKeyword') return 'import';
+  return undefined;
+}
+
+function stringLiteralFromTsExpression(node) {
+  if (!node) return undefined; if (typeof node.value === 'string') return node.value;
+  const rawText = typeof node.text === 'string' && typeof node.escapedText !== 'string' ? typeScriptExpressionText(node) : undefined; return rawText && /^['"`]/.test(rawText) ? node.text : undefined;
 }

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

@@ -0,0 +1,296 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import {
+  createParserSpanCoverageProof,
+  createPreservedSourceOwnershipAnchor,
+  preservedOwnershipAnchorKind,
+  preservedSourceSegmentRole
+} from '../../native-source-preservation-ownership.js';
+import { createNativeSourcePreservation } from './createNativeSourcePreservation.js';
+
+const PARSER_EVIDENCE = 'typescript-compiler-api-source-file-scanner';
+
+export function createTypeScriptSourceFilePreservation(sourceFile, input, options = {}) {
+  const ts = options.ts;
+  const sourceText = sourceFileText(sourceFile, input);
+  if (!sourceText || !ts || typeof ts.createScanner !== 'function') return undefined;
+  const sourceHash = hashSemanticValue(sourceText);
+  const tokensAndTrivia = scanTypeScriptSourceFileTokens(sourceFile, input, { ...options, sourceHash, sourceText });
+  if (!tokensAndTrivia) return undefined;
+  return createNativeSourcePreservation({
+    language: input.language ?? options.language ?? 'typescript',
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    sourceText,
+    tokensAndTrivia,
+    includeTokens: options.includeTokens !== false,
+    includeTrivia: options.includeTrivia !== false,
+    parserSpanCoverageProof: tokensAndTrivia.parserSpanCoverageProof,
+    parserTriviaEvidence: tokensAndTrivia.parserTriviaEvidence,
+    metadata: {
+      parserTokenTriviaEvidence: PARSER_EVIDENCE,
+      parserTokenTriviaSource: 'typescript-source-file',
+      parserSpanCoverageProof: tokensAndTrivia.parserSpanCoverageProof,
+      ...(options.sourcePreservationMetadata ?? {})
+    }
+  });
+}
+
+function scanTypeScriptSourceFileTokens(sourceFile, input, options) {
+  const ts = options.ts;
+  const sourceText = options.sourceText;
+  const scanner = ts.createScanner(
+    options.scriptTarget ?? ts.ScriptTarget?.Latest ?? ts.ScriptTarget?.ESNext ?? 99,
+    false,
+    languageVariant(ts, input, options),
+    sourceText,
+    undefined,
+    0,
+    sourceText.length
+  );
+  const lineStarts = sourceLineStarts(sourceFile, sourceText);
+  const tokens = [];
+  const trivia = [];
+  const maxTokens = Number.isFinite(options.maxTokens) ? Math.max(0, options.maxTokens) : 20000;
+  const maxTrivia = Number.isFinite(options.maxTrivia) ? Math.max(0, options.maxTrivia) : 20000;
+  let truncated = false;
+  for (let kind = scanner.scan(); !isEndOfFile(ts, kind); kind = scanner.scan()) {
+    const start = scanner.getTokenPos();
+    const end = scanner.getTextPos();
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) continue;
+    const text = sourceText.slice(start, end);
+    const mappedKind = sourceSegmentKind(ts, kind, text, input, options);
+    const target = preservedSourceSegmentRole(mappedKind) === 'trivia' ? trivia : tokens;
+    const max = target === tokens ? maxTokens : maxTrivia;
+    if (target.length >= max) {
+      truncated = true;
+      continue;
+    }
+    target.push(preservedParserSegment({
+      index: target.length,
+      kind: mappedKind,
+      text,
+      start,
+      end,
+      lineStarts,
+      sourceHash: options.sourceHash,
+      sourcePath: input.sourcePath,
+      syntaxKind: syntaxKindName(ts, kind)
+    }));
+  }
+  const parserSpanCoverageProof = createParserSpanCoverageProof({
+    sourceText,
+    sourcePath: input.sourcePath,
+    sourceHash: options.sourceHash,
+    segments: [...tokens, ...trivia],
+    tokenCount: tokens.length,
+    triviaCount: trivia.length,
+    commentCount: trivia.filter((entry) => isCommentKind(entry.kind)).length,
+    parserEvidence: PARSER_EVIDENCE,
+    adapterId: input.adapterId ?? options.adapterId ?? 'frontier.typescript-compiler-native-importer',
+    evidenceId: `${input.adapterId ?? options.adapterId ?? 'frontier.typescript-compiler-native-importer'}:parser-span-coverage:${idFragment(input.sourcePath ?? options.sourceHash)}`,
+    languageMode: sourceLanguageMode(ts, input, options),
+    boundedLanguages: ['javascript', 'typescript', 'jsx', 'tsx'],
+    truncated
+  });
+  const parserTriviaEvidence = parserTriviaEvidenceForSpanCoverage(parserSpanCoverageProof, {
+    sourceHash: options.sourceHash,
+    sourcePath: input.sourcePath,
+    adapterId: input.adapterId ?? options.adapterId ?? 'frontier.typescript-compiler-native-importer',
+    truncated
+  });
+  return {
+    tokens: tokens.map((entry) => withParserTriviaEvidence(entry, parserTriviaEvidence)),
+    trivia: trivia.map((entry) => withParserTriviaEvidence(entry, parserTriviaEvidence)),
+    truncated,
+    parserEvidence: PARSER_EVIDENCE,
+    parserSpanCoverageProof,
+    parserTriviaEvidence
+  };
+}
+
+function preservedParserSegment(input) {
+  const role = preservedSourceSegmentRole(input.kind);
+  const textHash = hashSemanticValue(input.text);
+  const span = {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    ...sourceSpanPositions(input.start, input.end, input.lineStarts)
+  };
+  return {
+    id: `${input.kind}_${input.index + 1}_${idFragment(input.start)}`,
+    kind: input.kind,
+    text: input.text,
+    textHash,
+    span,
+    ownershipAnchor: createPreservedSourceOwnershipAnchor({
+      kind: input.kind,
+      role,
+      text: input.text,
+      textHash,
+      sourcePath: input.sourcePath,
+      sourceHash: input.sourceHash,
+      span,
+      anchorKind: preservedOwnershipAnchorKind(input.kind, role),
+      parserEvidence: PARSER_EVIDENCE,
+      parserTriviaEvidence: {
+        status: 'exact',
+        exactParserTrivia: true,
+        losslessCst: true,
+        sourceHash: input.sourceHash,
+        parserEvidence: PARSER_EVIDENCE,
+        adapterId: 'typescript-compiler-api'
+      }
+    }),
+    metadata: { syntaxKind: input.syntaxKind, parserEvidence: PARSER_EVIDENCE }
+  };
+}
+
+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: PARSER_EVIDENCE,
+      parserTriviaEvidence
+    }),
+    metadata: {
+      ...record.metadata,
+      parserSpanCoverageStatus: parserTriviaEvidence.parserSpanCoverageProof?.status
+    }
+  };
+}
+
+function sourceSpanPositions(start, end, lineStarts) {
+  const startLine = lineForOffset(lineStarts, start);
+  const endLine = lineForOffset(lineStarts, end);
+  return {
+    start,
+    end,
+    startLine: startLine + 1,
+    startColumn: start - lineStarts[startLine] + 1,
+    endLine: endLine + 1,
+    endColumn: end - lineStarts[endLine] + 1
+  };
+}
+
+function sourceLineStarts(sourceFile, sourceText) {
+  const starts = typeof sourceFile.getLineStarts === 'function' ? [...sourceFile.getLineStarts()] : [0];
+  if (starts.length > 1 || sourceText.length === 0) return starts;
+  for (let index = 0; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (char === '\r' || char === '\n') {
+      if (char === '\r' && sourceText[index + 1] === '\n') index += 1;
+      starts.push(index + 1);
+    }
+  }
+  return starts;
+}
+
+function lineForOffset(lineStarts, offset) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (lineStarts[mid] <= offset && (mid === lineStarts.length - 1 || lineStarts[mid + 1] > offset)) return mid;
+    if (lineStarts[mid] > offset) high = mid - 1;
+    else low = mid + 1;
+  }
+  return 0;
+}
+
+function sourceSegmentKind(ts, kind, text, input, options) {
+  const name = syntaxKindName(ts, kind);
+  if (text === '\r' || text === '\n' || text === '\r\n') return 'newline';
+  if (/^[ \t\v\f]+$/.test(text)) return 'whitespace';
+  if (String(text).startsWith('//') || String(text).startsWith('/*')) return preservedCommentKind(text);
+  if (/^[0-9]/.test(text)) return 'number';
+  if (String(text).startsWith('`')) return 'template';
+  if (String(text).startsWith('"') || String(text).startsWith("'")) return 'string';
+  if (isJsxSource(ts, input, options) && (text === '<' || text === '</' || text === '/>')) return 'jsx';
+  if (name === 'WhitespaceTrivia') return 'whitespace';
+  if (name === 'NewLineTrivia') return 'newline';
+  if (name === 'ShebangTrivia') return 'shebang';
+  if (name === 'SingleLineCommentTrivia' || name === 'MultiLineCommentTrivia') return preservedCommentKind(text);
+  if (name === 'Identifier' || name === 'PrivateIdentifier') return 'identifier';
+  if (name.endsWith('Keyword')) return 'keyword';
+  if (name.includes('StringLiteral')) return 'string';
+  if (name.includes('Template')) return 'template';
+  if (name === 'NumericLiteral' || name === 'BigIntLiteral') return 'number';
+  if (name === 'RegularExpressionLiteral') return 'regex-like';
+  if (name.includes('Jsx')) return 'jsx';
+  if (/^[()[\]{};,]$/.test(text)) return 'punctuation';
+  if (/^[=+\-*/%&|^!<>?:.]+$/.test(text)) return 'operator';
+  return 'unknown';
+}
+
+function sourceFileText(sourceFile, input) {
+  return typeof sourceFile?.getFullText === 'function'
+    ? sourceFile.getFullText()
+    : typeof sourceFile?.text === 'string' ? sourceFile.text : input.sourceText;
+}
+
+function languageVariant(ts, input, options) {
+  return isJsxSource(ts, input, options) ? ts.LanguageVariant?.JSX ?? 1 : ts.LanguageVariant?.Standard ?? 0;
+}
+
+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-trivia:${idFragment(input.sourcePath ?? input.sourceHash)}`,
+    parserEvidence: PARSER_EVIDENCE,
+    parserSpanCoverageProof,
+    ...(exact ? {} : { blockReasonCodes })
+  };
+}
+
+function sourceLanguageMode(ts, input, options) {
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  if (sourcePath.endsWith('.tsx') || options.scriptKind === ts.ScriptKind?.TSX) return 'tsx';
+  if (sourcePath.endsWith('.jsx') || options.scriptKind === ts.ScriptKind?.JSX) return 'jsx';
+  if (sourcePath.endsWith('.js') || sourcePath.endsWith('.mjs') || sourcePath.endsWith('.cjs') || options.scriptKind === ts.ScriptKind?.JS) return 'javascript';
+  return 'typescript';
+}
+
+function isJsxSource(ts, input, options) {
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  return sourcePath.endsWith('.tsx') || sourcePath.endsWith('.jsx') || options.scriptKind === ts.ScriptKind?.TSX || options.scriptKind === ts.ScriptKind?.JSX;
+}
+
+function isEndOfFile(ts, kind) {
+  return kind === ts.SyntaxKind?.EndOfFileToken || syntaxKindName(ts, kind) === 'EndOfFileToken';
+}
+
+function syntaxKindName(ts, kind) {
+  return ts?.SyntaxKind?.[kind] ?? String(kind);
+}
+
+function preservedCommentKind(text) {
+  const value = String(text ?? '');
+  if (/[#@]\s*sourceMappingURL=|[#@]\s*sourceURL=/.test(value)) return 'source-map-comment';
+  if (value.startsWith('/**') && value[3] !== '/') return 'jsdoc-comment';
+  if (value.startsWith('/*')) return 'block-comment';
+  return 'comment';
+}
+
+function isCommentKind(kind) {
+  return kind === 'comment' || kind === 'jsdoc-comment' || kind === 'block-comment' || kind === 'source-map-comment';
+}