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

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

@@ -0,0 +1,145 @@
+function createNativeProjectModuleResolutionFromPackageManifests(input = {}) {
+  const options = Array.isArray(input) ? { manifests: input } : input;
+  const base = options.baseModuleResolution ?? options.moduleResolution ?? {};
+  const packages = { ...(base.packages ?? {}) };
+  const packageTypeByRoot = { ...(base.packageTypeByRoot ?? {}) };
+  const packageWorkspaceRootAmbiguities = { ...(base.packageWorkspaceRootAmbiguities ?? {}) };
+  const diagnostics = [];
+  const records = [];
+  for (const manifestInput of options.manifests ?? []) {
+    const parsed = packageJsonValue(manifestInput);
+    if (!parsed) {
+      diagnostics.push(diagnostic('invalid-package-json', manifestInput));
+      continue;
+    }
+    const root = normalizeProjectPath(manifestInput.root ?? rootFromPackageJsonPath(manifestInput.sourcePath ?? manifestInput.path));
+    const packageName = stringValue(manifestInput.packageName ?? parsed.name);
+    if (!packageName) {
+      diagnostics.push(diagnostic('missing-package-name', manifestInput, { root }));
+      continue;
+    }
+    const packageType = normalizePackageType(manifestInput.packageType ?? manifestInput.type ?? parsed.type);
+    const existingRoots = packageWorkspaceRoots(packages[packageName], packageWorkspaceRootAmbiguities[packageName]);
+    const workspaceRoots = uniqueStrings([...existingRoots, root]);
+    const rootAmbiguous = existingRoots.length > 1 || existingRoots.length > 0 && root && !existingRoots.includes(root);
+    if (rootAmbiguous) {
+      packageWorkspaceRootAmbiguities[packageName] = workspaceRoots;
+      diagnostics.push(diagnostic('ambiguous-package-workspace-root', manifestInput, { root, packageName, existingRoot: existingRoots[0], packageWorkspaceRoots: workspaceRoots }));
+    }
+    const packageOptions = compactRecord({
+      ...(packages[packageName] ?? {}),
+      root,
+      main: stringValue(parsed.main),
+      types: stringValue(parsed.types ?? parsed.typings),
+      type: packageType,
+      packageType,
+      exports: packageMapValue(parsed.exports),
+      imports: packageMapValue(parsed.imports),
+      packageWorkspaceRootAmbiguous: rootAmbiguous || undefined,
+      packageWorkspaceRoots: rootAmbiguous ? workspaceRoots : undefined,
+      packageResolutionReasonCode: rootAmbiguous ? 'package-workspace-root-ambiguous-missing' : undefined
+    });
+    packages[packageName] = packageOptions;
+    if (packageType) packageTypeByRoot[root] = packageType;
+    records.push(compactRecord({
+      packageName,
+      root,
+      sourcePath: manifestInput.sourcePath ?? manifestInput.path,
+      packageType,
+      hasExports: Object.prototype.hasOwnProperty.call(packageOptions, 'exports'),
+      hasImports: Object.prototype.hasOwnProperty.call(packageOptions, 'imports')
+    }));
+  }
+  return {
+    kind: 'frontier.lang.nativeProjectModuleResolutionFromPackageManifests',
+    version: 1,
+    ok: diagnostics.length === 0,
+    moduleResolution: compactRecord({
+      ...base,
+      packages,
+      packageTypeByRoot,
+      packageWorkspaceRootAmbiguities: optionalRecord(packageWorkspaceRootAmbiguities),
+      packageExportConditions: options.packageExportConditions ?? base.packageExportConditions,
+      conditions: options.conditions ?? base.conditions
+    }),
+    packages: records,
+    packageCount: records.length,
+    diagnostics
+  };
+}
+
+function packageJsonValue(input) {
+  const value = input.packageJson ?? input.json ?? input.packageJsonText ?? input.text;
+  if (isRecord(value)) return value;
+  if (typeof value !== 'string') return undefined;
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function packageMapValue(value) {
+  if (value === null) return null;
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(packageMapValue).filter((entry) => entry !== undefined);
+  if (!isRecord(value)) return undefined;
+  return Object.fromEntries(
+    Object.entries(value)
+      .map(([key, entry]) => [key, packageMapValue(entry)])
+      .filter(([, entry]) => entry !== undefined)
+  );
+}
+
+function diagnostic(reasonCode, input, metadata = {}) {
+  return compactRecord({
+    reasonCode,
+    sourcePath: input.sourcePath ?? input.path,
+    root: input.root,
+    packageName: input.packageName,
+    ...metadata
+  });
+}
+
+function stringValue(value) {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function normalizePackageType(value) {
+  return value === 'module' || value === 'commonjs' ? value : undefined;
+}
+
+function packageWorkspaceRoots(options, ambiguousRoots) {
+  return uniqueStrings([...(Array.isArray(ambiguousRoots) ? ambiguousRoots : []), ...(Array.isArray(options?.packageWorkspaceRoots) ? options.packageWorkspaceRoots : []), options?.root]);
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value))];
+}
+
+function rootFromPackageJsonPath(path) {
+  const normalized = normalizeProjectPath(path ?? '');
+  return normalized.endsWith('/package.json') ? normalized.slice(0, -'/package.json'.length) : '';
+}
+
+function normalizeProjectPath(path) {
+  const parts = [];
+  for (const part of String(path ?? '').split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') parts.pop(); else parts.push(part);
+  }
+  return parts.join('/');
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function optionalRecord(record) {
+  return Object.keys(record).length ? record : undefined;
+}
+
+function isRecord(value) { return value && typeof value === 'object' && !Array.isArray(value); }
+
+export { createNativeProjectModuleResolutionFromPackageManifests };

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

@@ -1,5 +1,6 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { countBy, idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { createParserTriviaExactnessRecord } from '../../native-source-preservation-ownership.js';
 import {
   detectNewlineStyle,
   isJavaScriptTypeScriptSource,
@@ -17,7 +18,7 @@ export function createNativeSourcePreservation(options) {
   const computedSourceHash = hashSemanticValue(sourceText);
   const declaredSourceHash = options.sourceHash;
   const sourceHash = computedSourceHash;
-  const tokensAndTrivia = scanPreservedSourceTokens(sourceText, {
+  const tokensAndTrivia = options.tokensAndTrivia ?? scanPreservedSourceTokens(sourceText, {
     language,
     sourcePath: options.sourcePath,
     sourceHash,
@@ -47,13 +48,26 @@ export function createNativeSourcePreservation(options) {
   const directivesByKind = countBy(directives.map((entry) => entry.kind ?? 'directive'));
   const directiveKinds = uniqueStrings(directives.map((entry) => entry.kind ?? 'directive'));
   const commentSpanIds = tokensAndTrivia.trivia
-    .filter((entry) => entry.kind === 'comment')
+    .filter((entry) => isCommentKind(entry.kind))
     .map((entry) => entry.id)
     .filter(Boolean);
   const directiveSpanIds = directives
     .map((entry) => entry.id)
     .filter(Boolean);
   const newline = detectNewlineStyle(sourceText);
+  const scannerEvidence = ledger ? 'frontier-lightweight-js-ts-source-ledger' : 'frontier-lightweight-lexical-scan';
+  const tokenTriviaParserEvidence = tokensAndTrivia.parserEvidence;
+  const parserEvidence = tokenTriviaParserEvidence ?? scannerEvidence;
+  const truncated = tokensAndTrivia.truncated || directiveScan.truncated || Boolean(ledger?.summary?.truncated);
+  const parserSpanCoverageProof = options.parserSpanCoverageProof ?? tokensAndTrivia.parserSpanCoverageProof;
+  const parserTriviaExactness = createParserTriviaExactnessRecord(options.parserTriviaEvidence ?? options.metadata?.parserTriviaEvidence, {
+    sourcePath: options.sourcePath,
+    sourceHash,
+    parserEvidence,
+    parserTokenTriviaEvidence: tokenTriviaParserEvidence ?? scannerEvidence,
+    parserSpanCoverageProof,
+    truncated
+  });
   return {
     kind: 'frontier.lang.nativeSourcePreservation',
     version: 1,
@@ -74,7 +88,7 @@ export function createNativeSourcePreservation(options) {
       tokens: tokensAndTrivia.tokens.length,
       trivia: tokensAndTrivia.trivia.length,
       directives: directives.length,
-      comments: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'comment').length,
+      comments: tokensAndTrivia.trivia.filter((entry) => isCommentKind(entry.kind)).length,
       whitespace: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'whitespace' || entry.kind === 'newline').length,
       ...(ledger ? {
         ledger: ledger.summary,
@@ -89,17 +103,30 @@ export function createNativeSourcePreservation(options) {
       commentSpanIds,
       directiveSpanIds,
       exactSourceAvailable: options.includeSourceText !== false,
-      truncated: tokensAndTrivia.truncated || directiveScan.truncated || Boolean(ledger?.summary?.truncated)
+      truncated,
+      parserTriviaExactnessStatus: parserTriviaExactness.status,
+      exactParserTrivia: parserTriviaExactness.exactParserTrivia,
+      parserSpanCoverageStatus: parserSpanCoverageProof?.status,
+      parserSpanCoverageReasonCodes: parserSpanCoverageProof?.reasonCodes,
+      parserSpanCoverageBlockReasonCodes: parserSpanCoverageProof?.blockReasonCodes,
+      parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
+      parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes
     },
     metadata: {
       preservation: 'source-text-token-trivia-directive-evidence',
-      tokenization: 'frontier-lightweight-lexical-scan',
+      tokenization: tokensAndTrivia.parserEvidence ?? 'frontier-lightweight-lexical-scan',
       ...(ledger ? { sourceLedger: 'frontier-lightweight-js-ts-source-ledger' } : {}),
+      ...options.metadata,
+      ...(parserSpanCoverageProof ? { parserSpanCoverageProof } : {}),
+      parserTriviaExactness,
       ...(declaredSourceHash ? {
         declaredSourceHash,
         sourceHashVerified: declaredSourceHash === computedSourceHash
-      } : {}),
-      ...options.metadata
+      } : {})
     }
   };
 }
+
+function isCommentKind(kind) {
+  return kind === 'comment' || kind === 'jsdoc-comment' || kind === 'block-comment';
+}

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

@@ -1,4 +1,4 @@
-import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportDependencies}from'../../semantic-import-dependencies.js';import{createSemanticImportImpact}from'../../semantic-import-impact.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportDependencies}from'../../semantic-import-dependencies.js';import{createSemanticGraphLayerSummary}from'../../semantic-import-graph-layers.js';import{createSemanticImportImpact}from'../../semantic-import-impact.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
 import{createSemanticImportSidecarAdmission,createSemanticImportSidecarQuality}from'./createSemanticImportSidecarAdmission.js';
 import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
 export function createSemanticImportSidecar(importResult, options = {}) {
@@ -55,6 +55,28 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     },
     readiness
   });
+  const graphLayers = createSemanticGraphLayerSummary({
+    importResult,
+    imports,
+    importEntries,
+    symbols,
+    ownershipRegions,
+    sourceMaps,
+    sourceMapMappings,
+    sourcePreservation,
+    universalAstLayers,
+    proofSpec,
+    paradigmSemantics,
+    dependencies,
+    semanticImpact,
+    patchHints,
+    quality,
+    admission,
+    mergeCandidates,
+    losses,
+    evidence,
+    readiness
+  });
   return {
     kind: 'frontier.lang.semanticImportSidecar',
     version: 1,
@@ -75,6 +97,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     proofSpec,
     paradigmSemantics,
     dependencies,
+    graphLayers,
     semanticImpact,
     patchHints,
     quality,
@@ -125,6 +148,9 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       paradigmSemanticsLoweringRecords: paradigmSemantics.loweringRecords,
       dependencyRelations: dependencies.total,
       dependencyPredicates: dependencies.predicates,
+      graphLayers: graphLayers.summary.total,
+      graphLayersUsable: graphLayers.summary.usable,
+      graphLayerStatus: graphLayers.status,
       semanticImpactRecords: semanticImpact.summary.total,
       semanticImpactHighRiskRecords: semanticImpact.summary.byRisk.high ?? 0,
       semanticImpactRequiredVerificationSteps: semanticImpact.summary.requiredVerificationSteps,

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

@@ -6,19 +6,21 @@ export function createTypeScriptCompilerNativeImporterAdapter(options = {}) {
     language: options.language ?? 'typescript',
     parser: options.parser ?? 'typescript-compiler-api',
     version: options.version,
-    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', 'tokens', 'trivia', 'parserTriviaExactness', 'compilerSymbolFacts', 'compilerTypeFacts', 'compilerReferenceGraph', ...(options.capabilities ?? [])]),
     coverage: nativeImporterAdapterCoverage({
       exactness: 'exact-parser-ast',
       exactAst: true,
-      tokens: false,
-      trivia: false,
+      tokens: true,
+      trivia: true,
       diagnostics: true,
       sourceRanges: true,
       generatedRanges: false,
       semanticCoverage: declarationSemanticCoverage(),
       notes: [
         'Normalizes a caller-owned TypeScript SourceFile into native AST nodes and declaration-level semantic index records.',
-        'Type resolution, reference resolution, control flow, generated ranges, and parser token/trivia streams require host-supplied adapter evidence.'
+        'When the compiler scanner is available, SourceFile token/trivia spans become exact source-preservation evidence.',
+        'When a TypeScript checker is supplied, declaration records carry compiler symbol/type facts and reference relations for merge evidence.',
+        'Full reference resolution, control flow, and generated ranges require additional host-supplied adapter evidence.'
       ]
     }, options.coverage),
     supportedExtensions: options.supportedExtensions ?? ['.ts', '.tsx', '.js', '.jsx'],
@@ -42,7 +44,16 @@ export function createTypeScriptCompilerNativeImporterAdapter(options = {}) {
         program,
         typeChecker,
         maxNodes: options.maxNodes,
-        includeTokens: options.includeTokens
+        includeTokens: options.includeTokens,
+        includeTrivia: options.includeTrivia,
+        maxTokens: options.maxTokens,
+        maxTrivia: options.maxTrivia,
+        computedEnumRuntimeValueProofs: input.options?.computedEnumRuntimeValueProofs ?? options.computedEnumRuntimeValueProofs,
+        computedEnumRuntimeValueProof: input.options?.computedEnumRuntimeValueProof ?? options.computedEnumRuntimeValueProof,
+        computedEnumRuntimeValueProofProvider: input.options?.computedEnumRuntimeValueProofProvider ?? options.computedEnumRuntimeValueProofProvider,
+        computedEnumRuntimeValueTraceProvider: input.options?.computedEnumRuntimeValueTraceProvider ?? options.computedEnumRuntimeValueTraceProvider,
+        computedEnumRuntimeValueTraces: input.options?.computedEnumRuntimeValueTraces ?? options.computedEnumRuntimeValueTraces,
+        adapterId: options.id ?? 'frontier.typescript-compiler-native-importer'
       });
     }
   };

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

@@ -0,0 +1,80 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER = '<dynamic-import>';
+
+export function dynamicImportExpressionMetadata(argument, moduleSpecifier) {
+  const staticSpecifier = Boolean(moduleSpecifier && moduleSpecifier !== UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER);
+  const expressionText = expressionSourceText(argument);
+  const specifierKind = dynamicImportSpecifierKind(argument, expressionText, staticSpecifier);
+  return compactRecord({
+    dynamicImportSpecifierKind: specifierKind,
+    dynamicImportExpressionText: expressionText,
+    dynamicImportExpressionHash: hashSemanticValue({ kind: specifierKind, text: expressionText ?? '', staticSpecifier }),
+    dynamicImportStaticSpecifierEvidence: staticSpecifier,
+    dynamicImportRuntimeResolutionClaim: false,
+    dynamicImportResolutionProofRequired: !staticSpecifier
+  });
+}
+
+export function dynamicImportExpressionEdgeFields(metadata) {
+  return compactRecord({
+    dynamicImport: metadata?.dynamicImport,
+    dynamicImportSpecifierKind: metadata?.dynamicImportSpecifierKind,
+    dynamicImportExpressionText: metadata?.dynamicImportExpressionText,
+    dynamicImportExpressionHash: metadata?.dynamicImportExpressionHash,
+    dynamicImportStaticSpecifierEvidence: metadata?.dynamicImportStaticSpecifierEvidence,
+    dynamicImportRuntimeResolutionClaim: metadata?.dynamicImportRuntimeResolutionClaim,
+    dynamicImportResolutionProofRequired: metadata?.dynamicImportResolutionProofRequired
+  });
+}
+
+function dynamicImportSpecifierKind(node, text, staticSpecifier) {
+  if (staticSpecifier) return 'literal';
+  const kind = String(node?.type ?? node?.kindName ?? node?.kind ?? '');
+  if (/Template/.test(kind) || text?.startsWith('`')) return 'template';
+  if (/CallExpression/.test(kind) || node?.callee || (node?.expression && Array.isArray(node?.arguments)) || /\)\s*$/.test(text ?? '')) return 'call';
+  if (/Identifier/.test(kind) || /^[A-Za-z_$][\w$]*$/.test(text ?? '') || typeof node?.escapedText === 'string') return 'identifier';
+  if (/MemberExpression|PropertyAccessExpression|ElementAccessExpression/.test(kind) || node?.property || node?.name) return 'member';
+  if (/BinaryExpression|LogicalExpression/.test(kind) || node?.left && node?.right) return 'binary';
+  if (/ConditionalExpression/.test(kind) || node?.test && node?.consequent && node?.alternate) return 'conditional';
+  return kind ? kind.replace(/Expression$/, '').toLowerCase() : 'expression';
+}
+
+function expressionSourceText(node) {
+  if (!node) return undefined;
+  if (typeof node.getText === 'function') {
+    try {
+      const text = node.getText();
+      if (typeof text === 'string' && text.trim()) return text.trim();
+    } catch {}
+  }
+  if (typeof node.value === 'string') return JSON.stringify(node.value);
+  if (typeof node.raw === 'string') return node.raw;
+  if (typeof node.name === 'string') return node.name;
+  if (typeof node.escapedText === 'string') return node.escapedText;
+  if (typeof node.text === 'string') return node.text;
+  if (node.type === 'TemplateLiteral' && Array.isArray(node.quasis)) return templateLiteralText(node);
+  if (node.type === 'MemberExpression') return memberExpressionText(node);
+  if (node.type === 'CallExpression') return `${expressionSourceText(node.callee) ?? 'call'}(...)`;
+  if (node.left && node.right && node.operator) return `${expressionSourceText(node.left) ?? 'left'} ${node.operator} ${expressionSourceText(node.right) ?? 'right'}`;
+  return String(node.type ?? node.kindName ?? node.kind ?? 'expression');
+}
+
+function templateLiteralText(node) {
+  const parts = [];
+  for (let index = 0; index < node.quasis.length; index += 1) {
+    parts.push(node.quasis[index]?.value?.raw ?? '');
+    if (node.expressions?.[index]) parts.push('${', expressionSourceText(node.expressions[index]) ?? 'expression', '}');
+  }
+  return `\`${parts.join('')}\``;
+}
+
+function memberExpressionText(node) {
+  const object = expressionSourceText(node.object) ?? 'object';
+  const property = expressionSourceText(node.property) ?? 'property';
+  return node.computed ? `${object}[${property}]` : `${object}.${property}`;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -0,0 +1,176 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER = '<host-dependency>';
+
+export function importMetaUrlDependencyMetadata(node, options = {}) {
+  if (!isNewUrlExpression(node, options)) return undefined;
+  const args = nodeArguments(node);
+  const firstArgument = args[0];
+  const secondArgument = args[1];
+  const moduleSpecifier = literalString(firstArgument);
+  if (!firstArgument || !isImportMetaUrl(secondArgument)) return undefined;
+  const expressionText = expressionTextForNode(node) ?? `new URL(${JSON.stringify(moduleSpecifier)}, import.meta.url)`;
+  return hostDependencyRecord(moduleSpecifier ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, 'import-meta-url', 'import.meta.url', expressionText, {
+    staticSpecifier: Boolean(moduleSpecifier)
+  });
+}
+
+export function hostModuleDependencyMetadata(node, options = {}) {
+  const importMetaUrl = importMetaUrlDependencyMetadata(node, options);
+  if (importMetaUrl) return [importMetaUrl];
+  if (isNewExpression(node, options)) return workerConstructorDependencyMetadata(node);
+  if (isCallExpression(node, options)) return callExpressionDependencyMetadata(node);
+  return [];
+}
+
+export function hostDependencyEdgeFields(metadata) {
+  return compactRecord({
+    hostDependency: metadata?.hostDependency,
+    hostDependencyKind: metadata?.hostDependencyKind,
+    hostDependencyBase: metadata?.hostDependencyBase,
+    hostDependencyExpressionText: metadata?.hostDependencyExpressionText,
+    hostDependencyExpressionHash: metadata?.hostDependencyExpressionHash,
+    hostDependencyStaticSpecifierEvidence: metadata?.hostDependencyStaticSpecifierEvidence,
+    hostDependencyRuntimeResolutionClaim: metadata?.hostDependencyRuntimeResolutionClaim,
+    hostDependencyResolutionProofRequired: metadata?.hostDependencyResolutionProofRequired
+  });
+}
+
+function isNewUrlExpression(node, options) {
+  return isNewExpression(node, options) && expressionTextForNode(node.expression ?? node.callee) === 'URL';
+}
+
+function isNewExpression(node, options = {}) {
+  return nodeArguments(node).length > 0 && (options.kind === 'NewExpression' || node?.type === 'NewExpression' || node?.kindName === 'NewExpression');
+}
+
+function isCallExpression(node, options = {}) {
+  return nodeArguments(node).length > 0 && (options.kind === 'CallExpression' || node?.type === 'CallExpression');
+}
+
+function workerConstructorDependencyMetadata(node) {
+  const callee = expressionTextForNode(node.expression ?? node.callee);
+  const kind = callee === 'Worker' ? 'worker-constructor' : callee === 'SharedWorker' ? 'shared-worker-constructor' : undefined;
+  const firstArgument = nodeArguments(node)[0];
+  if (!kind || !firstArgument || isNewUrlExpression(firstArgument, {}) || expressionTextForNode(firstArgument)?.startsWith('new URL(')) return [];
+  const moduleSpecifier = literalString(firstArgument);
+  return [hostDependencyRecord(moduleSpecifier ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, kind, callee, expressionTextForNode(node), {
+    staticSpecifier: Boolean(moduleSpecifier)
+  })];
+}
+
+function callExpressionDependencyMetadata(node) {
+  const callee = expressionTextForNode(node.expression ?? node.callee);
+  const args = nodeArguments(node);
+  if (callee === 'importScripts') return args.map((argument) =>
+    hostDependencyRecord(literalString(argument) ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, 'worker-import-scripts', 'importScripts', expressionTextForNode(node), {
+      staticSpecifier: Boolean(literalString(argument))
+    })).filter(Boolean);
+  const first = literalString(args[0]);
+  if (!args[0]) return [];
+  if (callee === 'import.meta.resolve') return [hostDependencyRecord(first ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, 'import-meta-resolve', 'import.meta', expressionTextForNode(node), { staticSpecifier: Boolean(first) })];
+  if (callee === 'require.resolve') return [hostDependencyRecord(first ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, 'require-resolve', 'require', expressionTextForNode(node), { staticSpecifier: Boolean(first) })];
+  if (callee?.endsWith('.register') && callee.includes('serviceWorker')) return [hostDependencyRecord(first ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, 'service-worker-register', callee.replace(/\.register$/, ''), expressionTextForNode(node), { staticSpecifier: Boolean(first) })];
+  if (callee?.endsWith('.addModule') && /worklet/i.test(callee)) return [hostDependencyRecord(first ?? UNKNOWN_HOST_DEPENDENCY_MODULE_SPECIFIER, 'worklet-add-module', callee.replace(/\.addModule$/, ''), expressionTextForNode(node), { staticSpecifier: Boolean(first) })];
+  return [];
+}
+
+function nodeArguments(node) {
+  return node?.arguments && typeof node.arguments.length === 'number' ? Array.from(node.arguments) : [];
+}
+
+function hostDependencyRecord(moduleSpecifier, kind, base, expressionText, options = {}) {
+  const staticSpecifier = options.staticSpecifier !== false;
+  return {
+    moduleSpecifier,
+    metadata: {
+      importKind: kind,
+      hostDependency: true,
+      hostDependencyKind: kind,
+      hostDependencyBase: base,
+      hostDependencyExpressionText: expressionText,
+      hostDependencyExpressionHash: hashSemanticValue({ kind, moduleSpecifier, base, expressionText }),
+      hostDependencyStaticSpecifierEvidence: staticSpecifier,
+      hostDependencyRuntimeResolutionClaim: false,
+      hostDependencyResolutionProofRequired: !staticSpecifier
+    }
+  };
+}
+
+function isImportMetaUrl(node) {
+  const text = expressionTextForNode(node);
+  if (text?.replace(/\s+/g, '') === 'import.meta.url') return true;
+  const property = propertyName(node.property ?? node.name);
+  if (property !== 'url') return false;
+  const object = node.object ?? node.expression;
+  if (String(object?.type ?? object?.kindName ?? '') === 'MetaProperty') return importMetaText(object) === 'import.meta';
+  return expressionTextForNode(object)?.replace(/\s+/g, '') === 'import.meta';
+}
+
+function importMetaText(node) {
+  const meta = propertyName(node.meta);
+  const property = propertyName(node.property);
+  return meta && property ? `${meta}.${property}` : expressionTextForNode(node);
+}
+
+function literalString(node) {
+  if (!node) return undefined;
+  if (typeof node.value === 'string') return node.value;
+  if (node.type === 'TemplateLiteral' && (node.expressions ?? []).length === 0 && (node.quasis ?? []).length === 1) {
+    return node.quasis[0]?.value?.cooked ?? node.quasis[0]?.value?.raw;
+  }
+  if (typeof node.text === 'string' && !/^[A-Za-z_$][\w$]*$/.test(node.text)) return node.text;
+  return undefined;
+}
+
+function propertyName(node) {
+  if (!node) return undefined;
+  if (typeof node === 'string') return node;
+  if (typeof node.name === 'string') return node.name;
+  if (typeof node.escapedText === 'string') return node.escapedText;
+  if (typeof node.text === 'string') return node.text;
+  return undefined;
+}
+
+function expressionTextForNode(node) {
+  if (!node) return undefined;
+  if (typeof node.getText === 'function') {
+    try {
+      const text = node.getText();
+      if (typeof text === 'string' && text.trim()) return text.trim();
+    } catch {}
+  }
+  if (node.type === 'MetaProperty') return importMetaText(node);
+  if (node.type === 'MemberExpression') {
+    const object = expressionTextForNode(node.object);
+    const property = expressionTextForNode(node.property);
+    return object && property ? node.computed ? `${object}[${property}]` : `${object}.${property}` : undefined;
+  }
+  if (node.expression && node.name) {
+    const object = expressionTextForNode(node.expression);
+    const property = expressionTextForNode(node.name);
+    return object && property ? `${object}.${property}` : undefined;
+  }
+  if (node.type === 'CallExpression') return `${expressionTextForNode(node.callee) ?? 'call'}(${argumentText(node)})`;
+  if (node.expression && Array.isArray(node.arguments)) return `${expressionTextForNode(node.expression) ?? 'call'}(${argumentText(node)})`;
+  if (node.type === 'NewExpression') return `new ${expressionTextForNode(node.callee) ?? 'constructor'}(${argumentText(node)})`;
+  if (node.type === 'TemplateLiteral' && Array.isArray(node.quasis)) return templateLiteralText(node);
+  return propertyName(node);
+}
+
+function argumentText(node) {
+  return nodeArguments(node).map((argument) => expressionTextForNode(argument) ?? 'expression').join(', ');
+}
+
+function templateLiteralText(node) {
+  const parts = [];
+  for (let index = 0; index < node.quasis.length; index += 1) {
+    parts.push(node.quasis[index]?.value?.raw ?? '');
+    if (node.expressions?.[index]) parts.push('${', expressionTextForNode(node.expressions[index]) ?? 'expression', '}');
+  }
+  return `\`${parts.join('')}\``;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -14,9 +14,8 @@ export function importNativeSource(input) {
     ? createNativeSourcePreservation({
       language,
       sourcePath,
-      sourceHash: declaredSourceHash,
-      sourceText: input.sourceText,
-      metadata: { importIdPart }
+      sourceHash: declaredSourceHash, sourceText: input.sourceText,
+      parserTriviaEvidence: input.parserTriviaEvidence ?? input.nativeAst?.metadata?.parserTriviaEvidence ?? input.nativeAstMetadata?.parserTriviaEvidence, metadata: { importIdPart }
     })
     : undefined);
   const lightweight = !input.nativeAst && !input.nodes && input.sourceText