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

package/dist/js-ts-semantic-scope-use-def.js

@@ -0,0 +1,217 @@
+import { collectBindings } from './js-ts-semantic-scope-use-def-bindings.js';
+import {
+  createBraceDepthIndex,
+  isPropertyAccess,
+  likelyTypeReference,
+  maskNonCode,
+  tokenize
+} from './js-ts-semantic-scope-use-def-scan.js';
+import {
+  LexicalUseDefReasonCodes,
+  compactRecord,
+  identifierRegExp,
+  lineNumber,
+  namespaceOverlap,
+  namespacesForDeclarationKind,
+  namespacesForImportRemoval,
+  normalizeNamespaces,
+  normalizeRanges,
+  rangeAllowed,
+  rangeKey,
+  spanRange,
+  uniqueStrings
+} from './js-ts-semantic-scope-use-def-utils.js';
+
+function analyzeTopLevelRenameUseDefEvidence(input) {
+  const namespaces = namespacesForDeclarationKind(input.declarationKind);
+  return lexicalEvidenceRecord({
+    operation: 'top-level-rename',
+    sourcePath: input.sourcePath,
+    bindingName: input.fromName,
+    targetName: input.toName,
+    namespaces,
+    checks: [
+      check(input.baseSourceText, input, 'base-from-binding', input.fromName, namespaces, [spanRange(input.fromEntry)]),
+      check(input.headSourceText, input, 'head-from-binding', input.fromName, namespaces, [spanRange(input.headEntry ?? input.fromEntry)]),
+      check(input.workerSourceText, input, 'worker-old-binding', input.fromName, namespaces),
+      check(input.baseSourceText, input, 'base-target-name', input.toName, namespaces),
+      check(input.headSourceText, input, 'head-target-name', input.toName, namespaces),
+      check(input.workerSourceText, input, 'worker-target-binding', input.toName, namespaces, [spanRange(input.toEntry)])
+    ]
+  });
+}
+
+function analyzeImportRemovalUseDefEvidence(input) {
+  const namespaces = namespacesForImportRemoval(input);
+  return lexicalEvidenceRecord({
+    operation: 'import-specifier-removal',
+    sourcePath: input.sourcePath,
+    bindingName: input.localName,
+    importedName: input.importedName,
+    removedSpecifier: input.removedSpecifier,
+    moduleSpecifier: input.moduleSpecifier,
+    namespaces,
+    checks: [check(input.sourceText, input, 'worker-import-removal', input.localName, namespaces)]
+  });
+}
+
+function check(sourceText, input, phase, bindingName, namespaces, allowedBindingRanges) {
+  return analyzeJsTsLexicalBindingReferences(sourceText, {
+    sourcePath: input.sourcePath,
+    phase,
+    bindingName,
+    namespaces,
+    allowedBindingRanges
+  });
+}
+
+function analyzeJsTsLexicalBindingReferences(sourceText, input = {}) {
+  const bindingName = String(input.bindingName ?? input.name ?? '');
+  const namespaces = normalizeNamespaces(input.namespaces ?? input.namespace);
+  if (!identifierRegExp.test(bindingName)) return blockedCheck(input, bindingName, namespaces, [LexicalUseDefReasonCodes.invalidIdentifier]);
+
+  const masked = maskNonCode(sourceText);
+  const tokens = tokenize(masked.code);
+  const depthAt = createBraceDepthIndex(masked.code);
+  const bindings = collectBindings(masked.code, tokens, depthAt);
+  const bindingKeys = new Set(bindings.map((binding) => rangeKey(binding)));
+  const allowedRanges = normalizeRanges(input.allowedBindingRanges);
+  const matchingBindings = bindings.filter((binding) => binding.name === bindingName && namespaceOverlap(binding.namespaces, namespaces));
+  const nonAllowedBindings = matchingBindings.filter((binding) => !rangeAllowed(binding, allowedRanges));
+  const namespaceConflicts = bindings.filter((binding) => binding.name === bindingName
+    && !namespaceOverlap(binding.namespaces, namespaces)
+    && !rangeAllowed(binding, allowedRanges));
+  const references = tokens
+    .map((token, index) => ({ ...token, index, depth: depthAt[token.start] ?? 0 }))
+    .filter((token) => token.value === bindingName)
+    .filter((token) => !bindingKeys.has(rangeKey(token)))
+    .filter((token) => !isPropertyAccess(masked.code, token.start))
+    .map((token) => referenceRecord(sourceText, masked, tokens, token, namespaces));
+
+  const reasonCodes = uniqueStrings([
+    ...(masked.unsupportedTemplateLiteral ? [LexicalUseDefReasonCodes.templateLiteralUnsupported] : []),
+    ...(references.length ? [LexicalUseDefReasonCodes.liveReference] : []),
+    ...(references.some((reference) => reference.closure) ? [LexicalUseDefReasonCodes.closureReference] : []),
+    ...(nonAllowedBindings.some((binding) => binding.depth > 0 || binding.kind === 'param') ? [LexicalUseDefReasonCodes.shadowedBinding] : []),
+    ...(nonAllowedBindings.some((binding) => binding.depth === 0 && binding.kind !== 'param') ? [LexicalUseDefReasonCodes.bindingConflict] : []),
+    ...(namespaceConflicts.length ? [LexicalUseDefReasonCodes.typeValueNamespaceConflict] : [])
+  ]);
+  const status = reasonCodes.length ? 'blocked' : 'no-live-references';
+  return compactRecord({
+    kind: 'frontier.lang.jsTsLexicalUseDefCheck',
+    version: 1,
+    status,
+    phase: input.phase,
+    sourcePath: input.sourcePath,
+    bindingName,
+    namespaces,
+    reasonCodes: status === 'blocked' ? reasonCodes : [LexicalUseDefReasonCodes.noLiveReferences],
+    summary: checkSummary(references, nonAllowedBindings, namespaceConflicts),
+    references: references.slice(0, 12),
+    shadowedBindings: filteredBindings(nonAllowedBindings, true).map(bindingRecord),
+    bindingConflicts: filteredBindings(nonAllowedBindings, false).map(bindingRecord),
+    namespaceConflicts: namespaceConflicts.slice(0, 12).map(bindingRecord)
+  });
+}
+
+function lexicalEvidenceRecord(input) {
+  const blockedReasonCodes = uniqueStrings(input.checks
+    .filter((item) => item.status === 'blocked')
+    .flatMap((item) => item.reasonCodes ?? [])
+    .filter((code) => code !== LexicalUseDefReasonCodes.noLiveReferences));
+  const status = blockedReasonCodes.length ? 'blocked' : 'no-live-references';
+  return compactRecord({
+    kind: 'frontier.lang.jsTsLexicalUseDefEvidence',
+    version: 1,
+    operation: input.operation,
+    status,
+    sourcePath: input.sourcePath,
+    bindingName: input.bindingName,
+    targetName: input.targetName,
+    importedName: input.importedName,
+    removedSpecifier: input.removedSpecifier,
+    moduleSpecifier: input.moduleSpecifier,
+    namespaces: input.namespaces,
+    reasonCodes: status === 'blocked' ? blockedReasonCodes : [LexicalUseDefReasonCodes.noLiveReferences],
+    summary: evidenceSummary(input.checks),
+    checks: input.checks
+  });
+}
+
+function checkSummary(references, bindings, namespaceConflicts) {
+  return {
+    references: references.length,
+    closureReferences: references.filter((reference) => reference.closure).length,
+    templateLiteralReferences: references.filter((reference) => reference.templateLiteralInterpolation).length,
+    shadowedBindings: filteredBindings(bindings, true).length,
+    bindingConflicts: filteredBindings(bindings, false).length,
+    namespaceConflicts: namespaceConflicts.length
+  };
+}
+
+function evidenceSummary(checks) {
+  return {
+    checks: checks.length,
+    references: sum(checks, 'references'),
+    closureReferences: sum(checks, 'closureReferences'),
+    templateLiteralReferences: sum(checks, 'templateLiteralReferences'),
+    shadowedBindings: sum(checks, 'shadowedBindings'),
+    bindingConflicts: sum(checks, 'bindingConflicts'),
+    namespaceConflicts: sum(checks, 'namespaceConflicts')
+  };
+}
+
+function referenceRecord(sourceText, masked, tokens, token, namespaces) {
+  const templateExpression = templateExpressionRangeForOffset(masked.templateExpressionRanges, token.start);
+  return compactRecord({
+    name: token.value,
+    start: token.start,
+    end: token.end,
+    line: lineNumber(sourceText, token.start),
+    namespace: likelyTypeReference(masked.code, tokens, token.index) ? 'type' : 'value',
+    namespaces,
+    referenceKind: templateExpression ? 'template-literal-interpolation' : undefined,
+    templateLiteralInterpolation: templateExpression ? true : undefined,
+    templateExpressionStart: templateExpression?.start,
+    templateExpressionEnd: templateExpression?.end,
+    closure: token.depth > 0,
+    depth: token.depth
+  });
+}
+
+function bindingRecord(binding) {
+  return { kind: binding.kind, name: binding.name, start: binding.start, end: binding.end, depth: binding.depth, namespaces: binding.namespaces };
+}
+
+function filteredBindings(bindings, shadowed) {
+  return bindings.filter((binding) => shadowed ? binding.depth > 0 || binding.kind === 'param' : binding.depth === 0 && binding.kind !== 'param').slice(0, 12);
+}
+
+function sum(checks, field) {
+  return checks.reduce((total, item) => total + (item.summary?.[field] ?? 0), 0);
+}
+
+function blockedCheck(input, bindingName, namespaces, reasonCodes) {
+  return {
+    kind: 'frontier.lang.jsTsLexicalUseDefCheck',
+    version: 1,
+    status: 'blocked',
+    phase: input.phase,
+    sourcePath: input.sourcePath,
+    bindingName,
+    namespaces,
+    reasonCodes,
+    summary: { references: 0, closureReferences: 0, templateLiteralReferences: 0, shadowedBindings: 0, bindingConflicts: 0, namespaceConflicts: 0 }
+  };
+}
+
+function templateExpressionRangeForOffset(ranges = [], offset) {
+  return ranges.find((range) => offset >= range.start && offset < range.end);
+}
+
+export {
+  LexicalUseDefReasonCodes,
+  analyzeImportRemovalUseDefEvidence,
+  analyzeJsTsLexicalBindingReferences,
+  analyzeTopLevelRenameUseDefEvidence
+};

package/dist/lightweight-dependency-effects.js

@@ -1,8 +1,13 @@
 function lightweightEffectKinds(line) {
   const kinds = [];
-  if (/\bawait\b|import\s*\(/.test(line)) kinds.push('async');
+  if (hasTaggedTemplate(line)) kinds.push('tagged-template');
+  else if (hasTemplateInterpolation(line)) kinds.push('template-interpolation');
+  else if (hasTemplateLiteral(line)) kinds.push('template-literal');
+  if (/\b(await|async)\b|import\s*\(/.test(line)) kinds.push('async');
+  if (/\byield\b|\bfunction\s*\*/.test(line)) kinds.push('generator');
   if (hasGlobalNetworkCall(line)) kinds.push('network');
   if (/\b(localStorage|sessionStorage|indexedDB|caches|cookie)\b/.test(line)) kinds.push('storage');
+  if (hasImportMetaHostContext(line)) kinds.push('host-context');
   if (hasGlobalSchedulerCall(line)) kinds.push('scheduler');
   if (/\b(console|process|Deno|Bun)\s*\./.test(line)) kinds.push('host');
   if (hasBrowserEffect(line)) kinds.push('browser');
@@ -32,20 +37,39 @@ function hasGlobalSchedulerCall(line) {
 }
 
 function hasBrowserEffect(line) {
-  return /\b(document|window|navigator|location|history)\s*\./.test(line)
+  return /\b(document|window|navigator|location|history)\s*(?:\.|\?\.|\[)/.test(line)
     || hasGlobalConstructorCall(line, ['Worker', 'SharedWorker']);
 }
 
+function hasImportMetaHostContext(line) { return /\bimport\s*\.\s*meta\b/.test(line); }
+
+function hasTaggedTemplate(line) {
+  const tick = String(line ?? '').indexOf('`');
+  if (tick < 0) return false;
+  const match = /([A-Za-z_$][\w$]*(?:(?:\s*\.\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)$/.exec(line.slice(0, tick).trimEnd());
+  return Boolean(match && !templatePrefixKeywords.has(match[1].trim()));
+}
+
+function hasTemplateInterpolation(line) {
+  return /`[^`]*\$\{/.test(line);
+}
+
+function hasTemplateLiteral(line) {
+  return /`/.test(line);
+}
+
 function hasBareCall(line, names) {
-  return names.some((name) => new RegExp(`(?:^|[^\\w$.])${name}\\s*\\(`).test(line));
+  return names.some((name) => new RegExp(`(?:^|[^\\w$.])${name}\\s*(?:\\?\\.)?\\s*\\(`).test(line));
 }
 
 function hasGlobalPropertyCall(line, names) {
-  return names.some((name) => new RegExp(`\\b(?:window|globalThis|self)\\s*\\.\\s*${name}\\s*\\(`).test(line));
+  return names.some((name) => new RegExp(`\\b(?:window|globalThis|self)\\s*(?:(?:\\.|\\?\\.)\\s*${name}|(?:\\?\\.)?\\s*\\[\\s*['"\`]${name}['"\`]\\s*\\])\\s*(?:\\?\\.)?\\s*\\(`).test(line));
 }
 
 function hasGlobalConstructorCall(line, names) {
   return names.some((name) => new RegExp(`(?:^|[^\\w$.])new\\s+(?:(?:window|globalThis|self)\\s*\\.\\s*)?${name}\\s*\\(`).test(line));
 }
 
+const templatePrefixKeywords = new Set(['return', 'yield', 'await', 'throw', 'case', 'delete', 'typeof', 'void', 'new']);
+
 export { lightweightEffectKinds };

package/dist/lightweight-dependency-relations.js

@@ -8,6 +8,7 @@ import {
   maskDependencyLine
 } from './lightweight-dependency-language.js';
 import { lightweightEffectKinds } from './lightweight-dependency-effects.js';
+import { lightweightTopLevelRuntimeFacts } from './lightweight-dependency-top-level.js';
 import { sourceLines } from './native-region-scanner-core.js';
 
 export function lightweightDependencyRelations(input, declarations, documentId) {
@@ -18,6 +19,7 @@ export function lightweightDependencyRelations(input, declarations, documentId)
   for (const scan of dependencyScanRanges(input, declarations, lines)) {
     scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records);
   }
+  records.facts.push(...lightweightTopLevelRuntimeFacts(input, documentId, lines));
   return {
     relations: records.relations,
     occurrences: records.occurrences,
@@ -71,8 +73,9 @@ function scanDeclarationDependencies(input, documentId, scan, identifiers, lines
   const state = { inBlockComment: false };
   const factState = { braceDepth: 0, pendingSwitch: false, switchDepth: 0 };
   for (let lineNumber = scan.startLine; lineNumber <= scan.endLine; lineNumber += 1) {
-    const scanLine = maskDependencyLine(input, lines[lineNumber - 1]?.line ?? '', state);
-    addLightweightSemanticFacts(input, documentId, scan.declaration, scanLine, lineNumber, records, factState);
+    const rawLine = lines[lineNumber - 1]?.line ?? '';
+    const scanLine = maskDependencyLine(input, rawLine, state);
+    addLightweightSemanticFacts(input, documentId, scan.declaration, scanLine, lineNumber, records, factState, rawLine);
     for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
       const name = match[0];
       if (!isDependencyIdentifier(name) || !identifiers.has(name)) continue;
@@ -90,17 +93,17 @@ function scanDeclarationDependencies(input, documentId, scan, identifiers, lines
   }
 }
 
-function addLightweightSemanticFacts(input, documentId, declaration, line, lineNumber, records, factState) {
+function addLightweightSemanticFacts(input, documentId, declaration, line, lineNumber, records, factState, rawLine) {
   if (!shouldScanRuntimeFacts(input, declaration)) return;
   const text = String(line ?? '').trim();
   if (!text) return;
   for (const item of lightweightControlFlowKinds(text, factState)) {
     addFactRecord(input, documentId, declaration, 'controlFlow', item, lineNumber, records);
   }
-  for (const item of lightweightEffectKinds(text)) {
+  for (const item of lightweightEffectKinds(rawLine ?? text)) {
     addFactRecord(input, documentId, declaration, 'effect', item, lineNumber, records);
   }
-  for (const item of lightweightMutationKinds(text)) {
+  for (const item of lightweightMutationKinds(text, rawLine ?? text)) {
     addFactRecord(input, documentId, declaration, 'mutation', item, lineNumber, records);
   }
   updateLightweightFactState(text, factState);
@@ -149,17 +152,20 @@ function lightweightControlFlowKinds(line, state = {}) {
   if (hasBranchSyntax(line, state)) kinds.push('branch');
   if (/\b(for|while|do)\b/.test(line)) kinds.push('loop');
   if (/\b(return|yield)\b/.test(line)) kinds.push('exit');
+  if (/\b(break|continue)\b/.test(line)) kinds.push('transfer');
   if (/\b(throw|catch|finally|try)\b/.test(line)) kinds.push('exception');
   if (/\b(await|async)\b/.test(line)) kinds.push('async');
   return kinds;
 }
 
-function lightweightMutationKinds(line) {
+function lightweightMutationKinds(line, rawLine = line) {
   const kinds = [];
+  const sourceLine = String(rawLine ?? line);
   if (/\bdelete\s+[A-Za-z_$][\w$.[\]]*/.test(line)) kinds.push('delete');
   if (hasRuntimeAssignment(line)) kinds.push('assignment');
   if (/\+\+|--|(?:\+=|-=|\*=|\/=|%=|\|\|=|&&=|\?\?=)/.test(line)) kinds.push('update');
-  if (/\.(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\s*\(/.test(line)) kinds.push('mutating-call');
+  if (/(?:\.|\?\.)\s*(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\s*(?:\?\.)?\s*\(/.test(line)
+    || /(?:\?\.|\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*|\s*\[[^\]]+\])*)\s*\[\s*(['"`])(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\1\s*\]\s*(?:\?\.)?\s*\(/.test(sourceLine)) kinds.push('mutating-call');
   return kinds;
 }
 

package/dist/lightweight-dependency-top-level.js

@@ -0,0 +1,63 @@
+import { idFragment } from './native-import-utils.js';
+import { lightweightEffectKinds } from './lightweight-dependency-effects.js';
+import { maskDependencyLine } from './lightweight-dependency-language.js';
+
+function lightweightTopLevelRuntimeFacts(input, documentId, lines) {
+  if (!isJavaScriptLike(input)) return [];
+  const records = [];
+  const state = { inBlockComment: false };
+  let braceDepth = 0;
+  for (const { line, number } of lines ?? []) {
+    const scanLine = maskDependencyLine(input, line, state);
+    const text = scanLine.trim();
+    if (braceDepth === 0 && hasTopLevelAwait(text)) {
+      for (const kind of ['async', ...lightweightEffectKinds(line).filter((item) => item !== 'async')]) {
+        records.push(topLevelFact(input, documentId, 'effect', kind, number));
+      }
+      records.push(topLevelFact(input, documentId, 'controlFlow', 'async', number));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(scanLine));
+  }
+  return records;
+}
+
+function topLevelFact(input, documentId, predicate, kind, lineNumber) {
+  const subjectId = `symbol:${input.language ?? 'javascript'}:module:${idFragment(documentId)}`;
+  return {
+    id: `fact_${idFragment(subjectId)}_${predicate}_${idFragment(kind)}_${lineNumber}`,
+    predicate,
+    subjectId,
+    value: {
+      kind,
+      line: lineNumber,
+      sourcePath: input.sourcePath,
+      documentId,
+      confidence: 'lexical-source-scan',
+      runtimeScope: 'module',
+      subjectName: '<module>',
+      topLevelAwait: true
+    }
+  };
+}
+
+function hasTopLevelAwait(text) {
+  const index = String(text ?? '').search(/\bawait\b/);
+  if (index < 0) return false;
+  const before = text.slice(0, index);
+  return !/\bfunction\b|=>/.test(before) && braceDelta(before) === 0;
+}
+
+function braceDelta(text) {
+  let delta = 0;
+  for (const char of String(text ?? '')) {
+    if (char === '{') delta += 1;
+    else if (char === '}') delta -= 1;
+  }
+  return delta;
+}
+
+function isJavaScriptLike(input) {
+  return ['javascript', 'typescript'].includes(String(input?.language ?? '').toLowerCase());
+}
+
+export { lightweightTopLevelRuntimeFacts };

package/dist/native-import-language-profiles.js

@@ -33,6 +33,30 @@ export const NativeImportLanguageProfiles = Object.freeze([
       '.tsx sources are classified as typescript for declaration scanning; JSX element trees remain opaque without host parser evidence'
     ]
   }),
+  nativeImportLanguageProfile('html', {
+    aliases: ['htm'],
+    extensions: ['.html', '.htm'],
+    supportsLightweightScan: false,
+    defaultReadiness: 'blocked',
+    parserAdapters: ['parse5', 'htmlparser2', 'rehype', 'tree-sitter-html'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'browserRuntime', 'hydrationRuntime'],
+    notes: [
+      'HTML semantic merge evidence is tree/attribute/source-span oriented; browser DOM normalization, custom elements, slots, templates, and hydration remain host-owned evidence',
+      'layout/render equivalence requires browser evidence and should remain fail-closed when only parser evidence is present'
+    ]
+  }),
+  nativeImportLanguageProfile('css', {
+    extensions: ['.css'],
+    supportsLightweightScan: false,
+    defaultReadiness: 'blocked',
+    parserAdapters: ['postcss', 'csstree', 'css-tree', 'lightningcss', 'tree-sitter-css'],
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'cascadeRuntime', 'browserRuntime', 'cssModuleTransform', 'cssModuleUseSiteGraph'],
+    notes: [
+      'CSS semantic merge evidence is selector/declaration/cascade oriented; computed style, inheritance, layout, and browser-specific normalization remain host-owned evidence',
+      'CSS Modules require exported local class, ICSS, composes, generated class-name, and JS/TS/JSX use-site graph evidence before equivalence can be claimed',
+      'cascade/render equivalence requires browser evidence and should remain fail-closed when only parser evidence is present'
+    ]
+  }),
   nativeImportLanguageProfile('python', {
     aliases: ['py'],
     extensions: ['.py', '.pyi'],
@@ -100,7 +124,7 @@ function nativeImportLanguageProfile(language, input = {}) {
 
 
 export function normalizeProjectionMatrixTargets(targets) {
-  const canonicalTargets = { ts: 'typescript', js: 'javascript', rs: 'rust', py: 'python', h: 'c' };
+  const canonicalTargets = { ts: 'typescript', js: 'javascript', rs: 'rust', py: 'python', h: 'c', htm: 'html' };
   return uniqueStrings((Array.isArray(targets) ? targets : [targets])
     .map((target) => {
       if (target === undefined || target === null) return undefined;
@@ -115,6 +139,8 @@ export function nativeLanguageCompileTarget(language, aliases = []) {
   const ids = [language, ...aliases].map(normalizeNativeLanguageId);
   if (ids.includes('typescript')) return 'typescript';
   if (ids.includes('javascript')) return 'javascript';
+  if (ids.includes('html')) return 'html';
+  if (ids.includes('css')) return 'css';
   if (ids.includes('rust')) return 'rust';
   if (ids.includes('python')) return 'python';
   if (ids.includes('c')) return 'c';

package/dist/native-js-ts-importers.js

@@ -12,19 +12,19 @@ function createJavaScriptSyntaxImporterAdapter(options, deps) {
     language: options.language,
     parser: options.parser,
     version: options.version,
-    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', 'tokens', 'trivia', 'parserTriviaExactness', ...(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 ESTree/Babel-compatible AST into native AST nodes and declaration-level semantic index records.',
-        'The wrapper ignores parser token/trivia/comment arrays unless a host adapter explicitly maps them into preservation evidence.'
+        'When parser token/comment arrays include exact ranges for the current source, they become exact source-preservation evidence.'
       ]
     }, options.coverage),
     supportedExtensions: options.supportedExtensions,
@@ -43,7 +43,11 @@ function createJavaScriptSyntaxImporterAdapter(options, deps) {
         parser: options.parser,
         astFormat: options.astFormat,
         maxNodes: options.maxNodes,
-        diagnostics: parseDiagnostics
+        diagnostics: parseDiagnostics,
+        includeTokens: options.includeTokens,
+        includeTrivia: options.includeTrivia,
+        maxTokens: options.maxTokens,
+        maxTrivia: options.maxTrivia
       });
     }
   };

package/dist/native-parser-ast-format-profiles.js

@@ -1,6 +1,9 @@
 import {
   uniqueStrings
 } from './native-import-utils.js';
+import {
+  HtmlCssNativeParserAstFormatProfileInputs
+} from './native-parser-html-css-format-profiles.js';
 
 export const NativeParserFeatureCategories = Object.freeze([
   'syntax',
@@ -55,6 +58,7 @@ export const NativeParserAstFormatProfiles = Object.freeze([
     supportsErrorRecovery: true,
     notes: ['TypeScript SourceFile trees can be parsed without a full Program; richer type/checker evidence remains host-owned.']
   }),
+  ...HtmlCssNativeParserAstFormatProfileInputs.map(([id, input]) => nativeParserAstFormatProfile(id, input)),
   nativeParserAstFormatProfile('python-ast', {
     kind: 'abstract-ast',
     languages: ['python'],
@@ -241,6 +245,14 @@ export function normalizeParserAstFormatId(format) {
 export function parserAstFormatIdForParser(parser) {
   const text = normalizeParserAstFormatId(parser);
   if (text.includes('typescript')) return 'typescript-compiler-api';
+  if (text.includes('parse5')) return 'parse5';
+  if (text.includes('htmlparser') || text.includes('domhandler')) return 'htmlparser2';
+  if (text.includes('rehype') || text === 'hast' || text.includes('unified-rehype')) return 'rehype';
+  if (text.includes('tree-sitter-html') || text.includes('treesitter-html')) return 'tree-sitter-html';
+  if (text.includes('postcss')) return 'postcss';
+  if (text.includes('csstree') || text.includes('css-tree')) return 'csstree';
+  if (text.includes('lightningcss') || text.includes('lightning-css')) return 'lightningcss';
+  if (text.includes('tree-sitter-css') || text.includes('treesitter-css')) return 'tree-sitter-css';
   if (text.includes('python') && text.includes('ast')) return 'python-ast';
   if (text === 'syn' || text.includes('rust-syn')) return 'rust-syn';
   if (text.includes('rust-analyzer') || text.includes('rowan')) return 'rust-analyzer-rowan';

package/dist/native-parser-html-css-format-profiles.js

@@ -0,0 +1,85 @@
+export const HtmlCssNativeParserAstFormatProfileInputs = Object.freeze([
+  ['parse5', {
+    aliases: ['parse5-html', 'html-parse5'],
+    kind: 'concrete-syntax-tree',
+    languages: ['html'],
+    parserAdapters: ['parse5'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'source-code-location-info',
+    preservesTrivia: true,
+    supportsErrorRecovery: true,
+    notes: ['parse5 exposes spec-oriented HTML tree construction and source locations; rendered DOM, custom elements, templates, slots, scripts, styles, and hydration remain host-owned evidence.']
+  }],
+  ['htmlparser2', {
+    aliases: ['htmlparser', 'domhandler'],
+    kind: 'concrete-syntax-tree',
+    languages: ['html'],
+    parserAdapters: ['htmlparser2'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'start-end-index',
+    supportsErrorRecovery: true,
+    notes: ['htmlparser2/DOMHandler trees provide fast HTML element and text structure; spec tree-construction edge cases, trivia, and browser DOM normalization remain host-owned evidence.']
+  }],
+  ['rehype', {
+    aliases: ['hast', 'unified-rehype'],
+    kind: 'concrete-syntax-tree',
+    languages: ['html'],
+    parserAdapters: ['rehype', 'hast'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'unist-position',
+    preservesTrivia: true,
+    supportsErrorRecovery: true,
+    notes: ['rehype/HAST is useful for HTML/MDX-like tree transforms; browser semantics, scripts/styles, and hydration boundaries remain host-owned evidence.']
+  }],
+  ['tree-sitter-html', {
+    aliases: ['treesitter-html'],
+    kind: 'concrete-syntax-tree',
+    languages: ['html'],
+    parserAdapters: ['tree-sitter-html'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'row-column',
+    supportsIncremental: true,
+    supportsErrorRecovery: true,
+    notes: ['Tree-sitter HTML exposes incremental concrete syntax for HTML files; browser DOM construction, templates, slots, scripts/styles, and hydration remain host-owned evidence.']
+  }],
+  ['postcss', {
+    kind: 'concrete-syntax-tree',
+    languages: ['css'],
+    parserAdapters: ['postcss'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'line-column',
+    preservesTrivia: true,
+    supportsErrorRecovery: true,
+    notes: ['PostCSS exposes CSS rule/declaration structure and source locations; cascade resolution, browser normalization, layout, and computed style remain host-owned evidence.']
+  }],
+  ['csstree', {
+    aliases: ['css-tree', 'css-tree-ast'],
+    kind: 'concrete-syntax-tree',
+    languages: ['css'],
+    parserAdapters: ['csstree', 'css-tree'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'offset-line-column',
+    supportsErrorRecovery: true,
+    notes: ['CSSTree provides detailed CSS grammar ASTs; cascade layers, browser normalization, and computed/rendered effects remain host-owned evidence.']
+  }],
+  ['lightningcss', {
+    aliases: ['lightning-css'],
+    kind: 'compiler-ast',
+    languages: ['css'],
+    parserAdapters: ['lightningcss', 'lightning-css'],
+    exactness: 'loss-aware-native-ast',
+    sourceRangeModel: 'source-location',
+    notes: ['Lightning CSS can parse and transform CSS with browser-target lowering; transformation settings, minification, and rendered cascade equivalence remain host-owned evidence.']
+  }],
+  ['tree-sitter-css', {
+    aliases: ['treesitter-css'],
+    kind: 'concrete-syntax-tree',
+    languages: ['css'],
+    parserAdapters: ['tree-sitter-css'],
+    exactness: 'parser-tree',
+    sourceRangeModel: 'row-column',
+    supportsIncremental: true,
+    supportsErrorRecovery: true,
+    notes: ['Tree-sitter CSS exposes incremental concrete syntax for CSS files; cascade resolution, browser normalization, and computed/rendered effects remain host-owned evidence.']
+  }]
+]);

package/dist/native-region-scanner-core.js

@@ -1,4 +1,4 @@
-import { idFragment } from './native-import-utils.js';
+import { caseSensitiveIdFragment, idFragment } from './native-import-utils.js';
 
 function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fields = {}, hasBody = false, options = {}) {
   const nodeId = `native_${idFragment(languageKind)}_${lineNumber}_${idFragment(name)}`;
@@ -43,7 +43,7 @@ function nativeImportDeclaration(input, lineNumber, importPath, languageKind, sy
     languageKind: `${input.language}.${languageKind}`,
     name,
     symbolKind,
-    symbolId: options.symbolId ?? `symbol:${input.language}:import:${idFragment(name)}`,
+    symbolId: options.symbolId ?? `symbol:${input.language}:import:${idFragment(symbolKind === 'module' ? `${languageKind}:${lineNumber}:${name}` : name)}`,
     role: options.role ?? 'import',
     importPath: String(importPath),
     span: options.span ?? spanForLine(input, lineNumber),
@@ -59,13 +59,14 @@ function nativeImportBindingDeclaration(input, lineNumber, importPath, binding,
   const importKind = binding.importKind ?? 'named';
   return nativeImportDeclaration(input, lineNumber, importPath, options.languageKind ?? 'ImportBinding', binding.symbolKind ?? 'import', {
     name: localName,
-    symbolId: options.symbolId ?? `symbol:${input.language}:import:${idFragment(`${importPath}:${localName}`)}`,
+    symbolId: options.symbolId ?? `symbol:${input.language}:import:${caseSensitiveIdFragment(`${importPath}:${localName}:${importedName}`)}`,
     span: options.span,
     fields: {
       localName,
       importedName,
       importKind,
       importPath: String(importPath),
+      ...(binding.namespace ? { namespace: binding.namespace } : {}),
       ...(binding.exportedName ? { exportedName: binding.exportedName } : {}),
       ...(binding.typeOnly ? { typeOnly: true } : {})
     },
@@ -76,6 +77,7 @@ function nativeImportBindingDeclaration(input, lineNumber, importPath, binding,
       localName,
       importedName,
       importKind,
+      ...(binding.namespace ? { namespace: binding.namespace } : {}),
       ...(binding.exportedName ? { exportedName: binding.exportedName } : {}),
       ...(binding.typeOnly ? { typeOnly: true } : {}),
       ...options.metadata