@shapeshift-labs/frontier-lang-compiler 0.2.99 → 0.2.101

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

@@ -0,0 +1,127 @@
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+
+export function normalizeSources(entries, context) {
+  return entries.filter(Boolean).map((entry, index) => compactRecord({
+    id: entry.id ?? entry.sourceId,
+    side: entry.side,
+    importId: entry.importId ?? entry.importResultId,
+    language: entry.language ?? context.language,
+    sourcePath: entry.sourcePath ?? context.sourcePath,
+    sourceHash: entry.sourceHash ?? entry.hash,
+    baseHash: entry.baseHash ?? entry.beforeHash ?? context.baseHash ?? context.beforeHash,
+    targetHash: entry.targetHash ?? entry.afterHash ?? context.targetHash ?? context.afterHash,
+    nativeSourceId: entry.nativeSourceId,
+    nativeAstId: entry.nativeAstId,
+    semanticIndexId: entry.semanticIndexId,
+    universalAstId: entry.universalAstId,
+    sourceMapIds: uniqueStrings(entry.sourceMapIds),
+    ordinal: index
+  })).filter((entry) => entry.importId || entry.sourcePath || entry.sourceHash || entry.baseHash || entry.targetHash);
+}
+
+export function sourceRef(importResult, side, sourceHash) {
+  if (!importResult) return undefined;
+  return compactRecord({
+    id: `${side}_${importResult.id ?? idFragment(importResult.sourcePath ?? 'source')}`,
+    side,
+    importId: importResult.id,
+    language: importResult.language,
+    sourcePath: importResult.sourcePath,
+    sourceHash: sourceHash ?? importResult.nativeSource?.sourceHash ?? importResult.nativeAst?.sourceHash ?? importResult.sourceHash,
+    nativeSourceId: importResult.nativeSource?.id,
+    nativeAstId: importResult.nativeAst?.id,
+    semanticIndexId: importResult.semanticIndex?.id,
+    universalAstId: importResult.universalAst?.id,
+    sourceMapIds: uniqueStrings((importResult.sourceMaps ?? []).map((map) => map.id))
+  });
+}
+
+export function normalizeRegions(regions, context) {
+  return regions.filter(Boolean).map((region, index) => {
+    const projection = region.metadata?.changedRegionProjection ?? region.projection;
+    const projected = projection?.region ?? {};
+    const key = firstString(region.key, region.ownershipKey, projected.key, region.conflictKey, region.id);
+    const conflictKey = firstString(region.conflictKey, projection?.conflictKey, key);
+    const links = array(projection?.sourceMapLinks ?? region.sourceMapLinks);
+    return compactRecord({
+      id: region.id ?? projected.id ?? `changed_region_${index + 1}`,
+      key,
+      conflictKey,
+      changeKind: region.changeKind ?? projection?.changeKind,
+      regionKind: region.regionKind ?? region.ownershipRegionKind ?? projected.kind,
+      granularity: region.granularity ?? projected.granularity,
+      precision: region.precision ?? projected.precision,
+      language: region.language ?? projection?.language ?? context.language,
+      sourcePath: region.sourcePath ?? projection?.sourcePath ?? context.sourcePath,
+      sourceHash: region.sourceHash ?? projection?.after?.sourceHash ?? projection?.before?.sourceHash,
+      symbolId: region.symbolId ?? projected.symbolId,
+      symbolName: region.symbolName ?? region.name ?? projected.symbolName,
+      symbolKind: region.symbolKind ?? projected.symbolKind,
+      sourceSpan: region.sourceSpan ?? projected.sourceSpan,
+      sourceMapLinkIds: uniqueStrings([...strings(region.sourceMapLinkIds), ...links.map((link) => link.id)]),
+      sourceMapIds: uniqueStrings([...strings(region.sourceMapIds), ...links.map((link) => link.sourceMapId)]),
+      sourceMapMappingIds: uniqueStrings([...strings(region.sourceMapMappingIds), ...links.map((link) => link.sourceMapMappingId)]),
+      lineageResolutionIds: uniqueStrings([...strings(region.lineageResolutionIds), ...strings(projection?.lineageResolutionIds), ...strings(region.metadata?.bidirectionalTargetChange?.lineageResolutionIds), ...strings(region.metadata?.semanticHistoryLineageResolution?.lineageResolutionIds), region.metadata?.semanticHistoryLineageResolution?.id]),
+      lineageEventIds: uniqueStrings([...strings(region.lineageEventIds), ...strings(projection?.lineageEventIds), ...strings(region.metadata?.semanticHistoryLineageResolution?.lineageEventIds)]),
+      lineageSourcePaths: uniqueStrings([...strings(region.lineageSourcePaths), ...strings(projection?.lineageSourcePaths), ...strings(region.metadata?.semanticHistoryLineageResolution?.sourcePaths)]),
+      lineageEvidenceIds: uniqueStrings([...strings(region.lineageEvidenceIds), ...strings(projection?.lineageEvidenceIds), ...strings(region.metadata?.semanticHistoryLineageResolution?.evidenceIds)]),
+      lineageProofIds: uniqueStrings([...strings(region.lineageProofIds), ...strings(projection?.lineageProofIds), ...strings(region.metadata?.semanticHistoryLineageResolution?.proofIds)]),
+      lineageReasonCodes: uniqueStrings([...strings(region.lineageReasonCodes), ...strings(projection?.lineageReasonCodes), ...strings(region.metadata?.semanticHistoryLineageResolution?.reasonCodes)]),
+      admission: compactRecord({
+        readiness: projection?.admission?.readiness ?? region.admission?.readiness,
+        action: projection?.admission?.action ?? region.admission?.action,
+        reasonCodes: uniqueStrings([...strings(region.admission?.reasonCodes), ...strings(projection?.admission?.reasons)]),
+        conflictKeys: uniqueStrings([...strings(region.admission?.conflictKeys), ...strings(projection?.admission?.conflictKeys)])
+      }),
+      metadata: region.metadata
+    });
+  });
+}
+
+export function normalizeSourceMapLinks(links) {
+  const seen = new Set();
+  const result = [];
+  for (const link of links.filter(Boolean)) {
+    const id = link.id ?? `source_map_link_${result.length + 1}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    result.push(compactRecord({
+      id,
+      side: link.side,
+      sourceMapId: link.sourceMapId,
+      sourceMapMappingId: link.sourceMapMappingId,
+      sourcePath: link.sourcePath,
+      sourceHash: link.sourceHash,
+      targetPath: link.targetPath,
+      targetHash: link.targetHash,
+      semanticSymbolId: link.semanticSymbolId,
+      semanticOccurrenceId: link.semanticOccurrenceId,
+      semanticNodeId: link.semanticNodeId,
+      nativeSourceId: link.nativeSourceId,
+      nativeAstNodeId: link.nativeAstNodeId,
+      precision: link.precision,
+      sourceSpan: link.sourceSpan,
+      generatedSpan: link.generatedSpan,
+      regionKey: link.ownershipRegionKey,
+      regionKind: link.ownershipRegionKind
+    }));
+  }
+  return result;
+}
+
+function array(value) {
+  if (value === undefined || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function strings(value) {
+  return array(value).map((entry) => String(entry ?? '')).filter(Boolean);
+}
+
+function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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

@@ -1,5 +1,12 @@
 export function sourcePreservationFromProjectionContext(context) {
-  return context.nativeSource?.metadata?.sourcePreservation
+  return context.sourcePreservation
+    ?? context.metadata?.sourcePreservation
+    ?? context.importResult?.metadata?.sourcePreservation
+    ?? context.importResult?.nativeSource?.metadata?.sourcePreservation
+    ?? context.importResult?.nativeAst?.metadata?.sourcePreservation
+    ?? context.nativeSource?.metadata?.sourcePreservation
     ?? context.nativeAst?.metadata?.sourcePreservation
-    ?? context.nativeSource?.ast?.metadata?.sourcePreservation;
+    ?? context.nativeSource?.ast?.metadata?.sourcePreservation
+    ?? context.universalAst?.metadata?.sourcePreservation
+    ?? context.importResult?.universalAst?.metadata?.sourcePreservation;
 }

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

@@ -1,12 +1,7 @@
+import { spanOffsets } from './semanticEditSourceRanges.js';
+
 export function sourceTextForSpan(sourceText, span) {
   if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) {
-    return sourceText.slice(span.start, span.end);
-  }
-  if (typeof span.startLine === 'number') {
-    const lines = sourceText.split(/\r?\n/);
-    const endLine = typeof span.endLine === 'number' && span.endLine >= span.startLine ? span.endLine : span.startLine;
-    return lines.slice(span.startLine - 1, endLine).join('\n');
-  }
-  return undefined;
+  const range = spanOffsets(sourceText, span);
+  return range ? sourceText.slice(range.start, range.end) : undefined;
 }

package/dist/lightweight-dependency-relations.js

@@ -68,12 +68,14 @@ function addIdentifierTarget(map, identifier, target) {
 
 function scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records) {
   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);
+    addLightweightSemanticFacts(input, documentId, scan.declaration, scanLine, lineNumber, records, factState);
     for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
       const name = match[0];
       if (!isDependencyIdentifier(name) || !identifiers.has(name)) continue;
+      if (isIgnoredDependencyOccurrence(input, scanLine, match.index, name)) continue;
       const targets = identifiers.get(name).filter((target) => target.symbolId !== scan.declaration.symbolId);
       for (const target of targets) {
         addDependencyRecord(input, documentId, scan.declaration, target, {
@@ -87,10 +89,11 @@ function scanDeclarationDependencies(input, documentId, scan, identifiers, lines
   }
 }
 
-function addLightweightSemanticFacts(input, documentId, declaration, line, lineNumber, records) {
+function addLightweightSemanticFacts(input, documentId, declaration, line, lineNumber, records, factState) {
+  if (!shouldScanRuntimeFacts(input, declaration)) return;
   const text = String(line ?? '').trim();
   if (!text) return;
-  for (const item of lightweightControlFlowKinds(text)) {
+  for (const item of lightweightControlFlowKinds(text, factState)) {
     addFactRecord(input, documentId, declaration, 'controlFlow', item, lineNumber, records);
   }
   for (const item of lightweightEffectKinds(text)) {
@@ -99,11 +102,45 @@ function addLightweightSemanticFacts(input, documentId, declaration, line, lineN
   for (const item of lightweightMutationKinds(text)) {
     addFactRecord(input, documentId, declaration, 'mutation', item, lineNumber, records);
   }
+  updateLightweightFactState(text, factState);
 }
 
-function lightweightControlFlowKinds(line) {
+function shouldScanRuntimeFacts(input, declaration) {
+  if (!isJavaScriptLike(input)) return true;
+  if (declaration?.fields?.typeKind) return false;
+  if (/^Type(?:Alias|Method|Property|FunctionProperty)/.test(String(declaration?.kind ?? ''))) return false;
+  return !['interface', 'type'].includes(String(declaration?.symbolKind ?? '').toLowerCase());
+}
+
+function isJavaScriptLike(input) {
+  return ['javascript', 'typescript'].includes(String(input?.language ?? '').toLowerCase());
+}
+
+function isIgnoredDependencyOccurrence(input, line, startIndex, name) {
+  if (!isJavaScriptLike(input)) return false;
+  const endIndex = startIndex + String(name).length;
+  const previous = previousNonSpace(line, startIndex - 1);
+  const next = nextNonSpace(line, endIndex);
+  return previous === '.' || next === ':';
+}
+
+function previousNonSpace(line, index) {
+  for (let cursor = index; cursor >= 0; cursor -= 1) {
+    if (!/\s/.test(line[cursor])) return line[cursor];
+  }
+  return '';
+}
+
+function nextNonSpace(line, index) {
+  for (let cursor = index; cursor < line.length; cursor += 1) {
+    if (!/\s/.test(line[cursor])) return line[cursor];
+  }
+  return '';
+}
+
+function lightweightControlFlowKinds(line, state = {}) {
   const kinds = [];
-  if (/\b(if|else|switch|case|default)\b/.test(line)) kinds.push('branch');
+  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(throw|catch|finally|try)\b/.test(line)) kinds.push('exception');
@@ -114,7 +151,7 @@ function lightweightControlFlowKinds(line) {
 function lightweightEffectKinds(line) {
   const kinds = [];
   if (/\bawait\b|import\s*\(/.test(line)) kinds.push('async');
-  if (/\b(fetch|XMLHttpRequest|WebSocket|EventSource)\s*\(/.test(line)) kinds.push('network');
+  if (hasGlobalNetworkCall(line)) kinds.push('network');
   if (/\b(localStorage|sessionStorage|indexedDB|caches|cookie)\b/.test(line)) kinds.push('storage');
   if (/\b(setTimeout|setInterval|requestAnimationFrame|queueMicrotask)\s*\(/.test(line)) kinds.push('scheduler');
   if (/\b(console|process|Deno|Bun)\s*\./.test(line)) kinds.push('host');
@@ -125,12 +162,81 @@ function lightweightEffectKinds(line) {
 function lightweightMutationKinds(line) {
   const kinds = [];
   if (/\bdelete\s+[A-Za-z_$][\w$.[\]]*/.test(line)) kinds.push('delete');
-  if (/(?:^|[^=!<>])=(?!=|>)/.test(line)) kinds.push('assignment');
+  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');
   return kinds;
 }
 
+function hasBranchSyntax(line, state) {
+  return /\bif\s*\(/.test(line)
+    || /(?:^|[}\s;])else\b(?:\s+if\s*\(|\s*[{;]|$)/.test(line)
+    || /\bswitch\s*\(/.test(line)
+    || ((state?.switchDepth ?? 0) > 0 && /^\s*(?:case\b[^:]*|default)\s*:/.test(line));
+}
+
+function updateLightweightFactState(line, state = {}) {
+  const hadSwitch = /\bswitch\s*\(/.test(line);
+  const beforeDepth = state.braceDepth ?? 0;
+  const delta = blockBraceDelta(line);
+  if (hadSwitch) state.pendingSwitch = true;
+  state.braceDepth = Math.max(0, beforeDepth + delta);
+  if (state.pendingSwitch && state.braceDepth > beforeDepth) {
+    state.switchDepth = state.braceDepth;
+    state.pendingSwitch = false;
+  }
+  if ((state.switchDepth ?? 0) > 0 && state.braceDepth < state.switchDepth) {
+    state.switchDepth = 0;
+  }
+}
+
+function blockBraceDelta(line) {
+  let delta = 0;
+  for (const char of String(line ?? '')) {
+    if (char === '{') delta += 1;
+    else if (char === '}') delta -= 1;
+  }
+  return delta;
+}
+
+function hasGlobalNetworkCall(line) {
+  return hasBareCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource'])
+    || hasGlobalPropertyCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource']);
+}
+
+function hasBareCall(line, names) {
+  return names.some((name) => new RegExp(`(?:^|[^\\w$.])${name}\\s*\\(`).test(line));
+}
+
+function hasGlobalPropertyCall(line, names) {
+  return names.some((name) => new RegExp(`\\b(?:window|globalThis|self)\\s*\\.\\s*${name}\\s*\\(`).test(line));
+}
+
+function hasRuntimeAssignment(line) {
+  const text = String(line ?? '');
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] !== '=' || !isPlainAssignmentOperator(text, index)) continue;
+    if (!isLocalDeclarationInitializer(text, index)) return true;
+  }
+  return false;
+}
+
+function isPlainAssignmentOperator(text, index) {
+  const previous = text[index - 1] ?? '';
+  const next = text[index + 1] ?? '';
+  if (next === '=' || next === '>') return false;
+  return !['=', '!', '<', '>', '+', '-', '*', '/', '%', '&', '|', '?', '^'].includes(previous);
+}
+
+function isLocalDeclarationInitializer(text, index) {
+  const prefix = text.slice(0, index);
+  const statementStart = Math.max(prefix.lastIndexOf(';'), prefix.lastIndexOf('{'), prefix.lastIndexOf('}'));
+  const statement = prefix.slice(statementStart + 1).trim();
+  return /^(?:export\s+)?(?:declare\s+)?(?:const|let|var|using)\b/.test(statement)
+    || /^for\s*\([^;)]*(?:const|let|var)\b/.test(statement)
+    || /^(?:export\s+)?type\s+[A-Za-z_$][\w$]*(?:\s*<[^>]+>)?\s*$/.test(statement);
+}
+
 function addFactRecord(input, documentId, declaration, predicate, factKind, lineNumber, records) {
   const key = `${declaration.symbolId}|${predicate}|${factKind}|${lineNumber}`;
   if (records.seen.has(key)) return;

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

@@ -17,13 +17,21 @@ export const NativeImportLanguageProfiles = Object.freeze([
     aliases: ['js', 'mjs', 'cjs', 'jsx'],
     extensions: ['.js', '.mjs', '.cjs', '.jsx'],
     parserAdapters: ['estree', 'babel', 'tree-sitter'],
-    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'dynamicRuntime']
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'dynamicRuntime'],
+    notes: [
+      'lightweight scanner records declarations only; exact parser adapters must be injected by the host',
+      '.jsx sources are classified as javascript for declaration scanning; JSX element trees remain opaque without host parser evidence'
+    ]
   }),
   nativeImportLanguageProfile('typescript', {
     aliases: ['ts', 'tsx'],
     extensions: ['.ts', '.tsx'],
     parserAdapters: ['typescript-compiler-api', 'babel', 'tree-sitter'],
-    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'unsupportedSyntax']
+    lossKinds: ['declarationOnlyCoverage', 'opaqueNative', 'sourceMapApproximation', 'sourcePreservation', 'unsupportedSyntax'],
+    notes: [
+      'lightweight scanner records declarations only; exact parser adapters must be injected by the host',
+      '.tsx sources are classified as typescript for declaration scanning; JSX element trees remain opaque without host parser evidence'
+    ]
   }),
   nativeImportLanguageProfile('python', {
     aliases: ['py'],

package/dist/native-import-utils.js

@@ -1,5 +1,5 @@
 export function uniqueStrings(values) {
-  return [...new Set((values ?? []).map((value) => String(value)).filter(Boolean))];
+  return [...new Set((values ?? []).filter((value) => value !== undefined && value !== null).map((value) => String(value)).filter(Boolean))];
 }
 
 export function uniqueRecordsById(records) {
@@ -141,3 +141,17 @@ export function idFragment(value) {
     .replace(/^_+|_+$/g, '')
     .slice(0, 80) || 'native';
 }
+
+export function caseSensitiveIdFragment(value) {
+  const text = String(value ?? 'native');
+  return `${idFragment(text)}_${caseSensitiveHash(text)}`;
+}
+
+function caseSensitiveHash(value) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(36);
+}

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

@@ -4,7 +4,6 @@ import {
   splitParameters
 } from './native-region-scanner-core.js';
 import { jsImportDeclarations } from './native-region-scanner-js-imports.js';
-
 function jsCommentOnlyLine(trimmed) {
   return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
 }
@@ -121,10 +120,71 @@ function jsRegionKindForDeclarationName(name, source = '') {
 function jsExportedContainerDeclaration(input, lineNumber, trimmed) {
   let match = trimmed.match(/^export\s+default\s+(.+)$/);
   if (match) return jsContainerExport(input, lineNumber, 'ExportDefaultContainer', 'default', match[1], { exportDefault: true });
-  match = trimmed.match(/^(?:module\.)?exports(?:\.([A-Za-z_$][\w$]*))?\s*=\s*(.+)$/);
+  match = trimmed.match(/^(module\.exports|exports)(?:\.([A-Za-z_$][\w$]*))?\s*=\s*(.+)$/);
+  if (!match) return undefined;
+  const name = match[2] ? `${match[1]}.${match[2]}` : 'module.exports';
+  return jsContainerExport(input, lineNumber, 'CommonJsContainerExport', name, match[3], { export: 'commonjs' });
+}
+
+function jsExportedFunctionWrapperDeclaration(input, lineNumber, trimmed) {
+  const match = trimmed.match(/^export\s+default\s+((?:React\.)?(?:forwardRef|memo|lazy|observer)|Object\.freeze)\s*(?:<[^>]+>)?\s*\(\s*(.+)$/);
+  if (!match) return undefined;
+  const wrapper = match[1];
+  const argument = match[2].trim();
+  let functionMatch = argument.match(/^(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)/);
+  if (functionMatch) {
+    return nativeDeclaration(input, lineNumber, 'ExportDefaultFunctionWrapperDeclaration', 'function', functionMatch[1] ?? 'default', {
+      exportDefault: true,
+      wrapper,
+      parameters: splitParameters(functionMatch[2])
+    }, true);
+  }
+  functionMatch = argument.match(/^(?:async\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*(?::\s*[^=]+)?=>/);
+  if (functionMatch) {
+    return nativeDeclaration(input, lineNumber, 'ExportDefaultFunctionWrapperDeclaration', 'function', 'default', {
+      exportDefault: true,
+      wrapper,
+      parameters: splitParameters(functionMatch[1] ?? functionMatch[2])
+    }, true);
+  }
+  const classMatch = argument.match(/^(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/);
+  if (classMatch) {
+    return nativeDeclaration(input, lineNumber, 'ExportDefaultClassWrapperDeclaration', 'class', classMatch[1] ?? 'default', {
+      exportDefault: true,
+      wrapper
+    }, true);
+  }
+  const aliasMatch = argument.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*(?:[,)]|$)/);
+  if (!aliasMatch) return undefined;
+  return nativeDeclaration(input, lineNumber, 'ExportDefaultWrappedAlias', 'variable', 'default', {
+    exportDefault: true,
+    wrapper,
+    alias: aliasMatch[1],
+    initializerKind: 'function-wrapper'
+  }, false, {
+    metadata: { exportDefault: true, wrapper, alias: aliasMatch[1], initializerKind: 'function-wrapper' }
+  });
+}
+
+function jsExportAliasDeclaration(input, lineNumber, trimmed) {
+  let match = trimmed.match(/^export\s+default\s+([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*;?$/);
+  if (match) return jsAliasExport(input, lineNumber, 'ExportDefaultAlias', 'default', match[1], { exportDefault: true }, trimmed);
+  match = trimmed.match(/^module\.exports\s*=\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*;?$/);
+  if (match) return jsAliasExport(input, lineNumber, 'CommonJsAliasExport', 'module.exports', match[1], { export: 'commonjs' }, trimmed);
+  match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*;?$/);
   if (!match) return undefined;
-  const name = match[1] ? `exports.${match[1]}` : 'module.exports';
-  return jsContainerExport(input, lineNumber, 'CommonJsContainerExport', name, match[2], { export: 'commonjs' });
+  return jsAliasExport(input, lineNumber, 'CommonJsAliasExport', match[1], match[2], { export: 'commonjs' }, trimmed);
+}
+
+function jsAliasExport(input, lineNumber, languageKind, name, alias, fields, source) {
+  const regionKind = jsRegionKindForDeclarationName(name, source);
+  return nativeDeclaration(input, lineNumber, languageKind, 'variable', name, {
+    ...fields,
+    alias
+  }, false, {
+    regionKind,
+    metadata: { ...fields, alias }
+  });
 }
 
 function jsContainerExport(input, lineNumber, languageKind, name, initializer, fields) {
@@ -254,17 +314,7 @@ function findUnescapedBacktick(text, startIndex) {
   return -1;
 }
 
-export {
-  jsCommentOnlyLine,
-  jsContainerDelta,
-  jsDeclarationScanLine,
-  jsExportedContainerDeclaration,
-  jsInitializerKind,
-  jsImportDeclarations,
-  jsObjectPropertyDeclaration,
-  jsObjectRegionContext,
-  jsRegionKindForDeclarationName,
-  jsRouteRecordDeclaration,
-  jsVariableHasBody,
-  jsVariableSymbolKind
-};
+export { jsCommentOnlyLine, jsContainerDelta, jsDeclarationScanLine };
+export { jsExportAliasDeclaration, jsExportedContainerDeclaration, jsExportedFunctionWrapperDeclaration };
+export { jsInitializerKind, jsImportDeclarations, jsObjectPropertyDeclaration, jsObjectRegionContext };
+export { jsRegionKindForDeclarationName, jsRouteRecordDeclaration, jsVariableHasBody, jsVariableSymbolKind };

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

@@ -44,6 +44,13 @@ export function jsImportDeclarations(input, lineNumber, trimmed) {
     importedName: 'default',
     importKind: trimmed.includes('import') ? 'dynamic-import-binding' : 'commonjs-require'
   }]);
+  const sideEffectRequireMatch = trimmed.match(/^require\s*\(\s*(['"])([^'"]+)\1\s*\)\s*;?$/);
+  if (sideEffectRequireMatch) {
+    return jsImportModuleDeclarations(input, lineNumber, sideEffectRequireMatch[2], 'CommonJsSideEffectRequireDeclaration', [], {
+      sideEffectOnly: true,
+      importKind: 'commonjs-require'
+    });
+  }
   return [];
 }
 

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

@@ -10,7 +10,9 @@ import {
   jsCommentOnlyLine,
   jsContainerDelta,
   jsDeclarationScanLine,
+  jsExportAliasDeclaration,
   jsExportedContainerDeclaration,
+  jsExportedFunctionWrapperDeclaration,
   jsInitializerKind,
   jsImportDeclarations,
   jsObjectPropertyDeclaration,
@@ -75,11 +77,13 @@ function scanJavaScriptLike(input) {
       pushDeclaration(nativeDeclaration(input, number, 'FunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, declarationLine.includes('{')));
     } else if ((match = trimmed.match(/^export\s+default\s+(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?/))) {
       pushDeclaration(nativeDeclaration(input, number, 'ExportDefaultFunctionDeclaration', 'function', match[1] ?? 'default', { parameters: splitParameters(match[2]), exportDefault: true }, trimmed.includes('{')));
-    } else if ((match = declarationLine.match(/^(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/))) {
-      pushDeclaration(nativeDeclaration(input, number, declarationLine.startsWith('default ') ? 'ExportDefaultClassDeclaration' : 'ClassDeclaration', 'class', match[1], { exportDefault: declarationLine.startsWith('default ') || undefined }, declarationLine.includes('{')));
-      pushDeclarations(jsInlineClassMemberDeclarations(input, number, declarationLine, match[1]));
+    } else if ((match = declarationLine.match(/^(default\s+)?(?:abstract\s+)?class\b(?:\s+(?!(?:extends|implements)\b)([A-Za-z_$][\w$]*))?/)) && (match[1] || match[2])) {
+      const className = match[2] ?? 'default';
+      const exportDefault = Boolean(match[1]);
+      pushDeclaration(nativeDeclaration(input, number, exportDefault ? 'ExportDefaultClassDeclaration' : 'ClassDeclaration', 'class', className, { exportDefault: exportDefault || undefined }, declarationLine.includes('{')));
+      pushDeclarations(jsInlineClassMemberDeclarations(input, number, declarationLine, className));
       if (jsStructureDelta(declarationLine).value > 0) {
-        currentClass = match[1];
+        currentClass = className;
         classDepth = 0;
       }
     } else if ((match = declarationLine.match(/^interface\s+([A-Za-z_$][\w$]*)/))) {
@@ -109,27 +113,31 @@ function scanJavaScriptLike(input) {
       pushDeclarations(jsInlineNestedObjectDeclarations(input, number, declarationLine, declarations[declarations.length - 1]));
       const objectContext = jsObjectRegionContext(match[1], declarationLine, number, regionKind);
       if (objectContext) objectStack.push(objectContext);
+    } else if ((match = jsExportedFunctionWrapperDeclaration(input, number, trimmed))) {
+      pushDeclaration(match);
     } else if ((match = jsExportedContainerDeclaration(input, number, trimmed))) {
       pushDeclaration(match.declaration);
       pushDeclarations(jsInlineNestedObjectDeclarations(input, number, trimmed, match.declaration));
       if (match.context) objectStack.push(match.context);
+    } else if ((match = jsExportAliasDeclaration(input, number, trimmed))) {
+      pushDeclaration(match);
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
       const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
       pushDeclaration(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
         methodName: match[1],
         owner: currentClass,
         parameters: splitParameters(match[2])
       }, declarationLine.includes('{') || declarationLine.includes('=>')));
-    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*([A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
+    } else if (currentClass && (match = declarationLine.match(/^(?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*(#?[A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'PropertyDefinition', 'property', `${currentClass}.${match[1]}`, {
         propertyName: match[1],
         owner: currentClass,
         valueType: match[2]?.trim()
-      }, false));
+      }, false, { regionKind: 'property' }));
     }
     if (currentClass) {
       classDepth += braceDelta(trimmed);
@@ -263,7 +271,7 @@ function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, cla
   if (open < 0 || close <= open) return [];
   const body = declarationLine.slice(open + 1, close);
   const declarations = [];
-  for (const match of body.matchAll(/(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
+  for (const match of body.matchAll(/(?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g)) {
     if (jsControlKeyword(match[1])) continue;
     declarations.push(nativeDeclaration(input, lineNumber, 'MethodDefinition', 'method', `${className}.${match[1]}`, {
       methodName: match[1],

package/dist/native-region-scanner.js

@@ -26,6 +26,7 @@ import {
   scanHaskell,
   scanR
 } from './native-region-scanner-functional.js';
+import { normalizeNativeLanguageId } from './native-import-utils.js';
 export { lightweightCoverageLosses } from './native-region-scanner-core.js';
 export {
   detectNewlineStyle,
@@ -34,7 +35,7 @@ export {
 } from './native-source-preservation-scanner.js';
 
 function scanNativeDeclarations(input) {
-  const language = String(input.language).toLowerCase();
+  const language = normalizeNativeLanguageId(input.language) || String(input.language).toLowerCase();
   if (language === 'javascript' || language === 'typescript') return scanJavaScriptLike(input);
   if (language === 'python') return scanPython(input);
   if (language === 'rust') return scanRust(input);

package/dist/semantic-import-regions.js

@@ -1,4 +1,4 @@
-import { idFragment, uniqueStrings } from './native-import-utils.js';
+import { caseSensitiveIdFragment, idFragment, uniqueStrings } from './native-import-utils.js';
 
 const NativeImportRegionTaxonomyKinds = Object.freeze([
   'symbol',
@@ -20,20 +20,20 @@ function semanticOwnershipRegionForSymbol(imported, symbol, mapping, nativeNode,
   const language = symbol.language ?? imported?.language ?? imported?.nativeAst?.language ?? imported?.nativeSource?.language;
   const sourceSpan = mapping?.sourceSpan ?? symbol.definitionSpan ?? nativeNode?.span;
   const regionKind = semanticRegionKindForSymbol(symbol, mapping, nativeNode);
-  const key = [
+  const key = symbol?.metadata?.ownershipRegionKey ?? [
     options.regionPrefix ?? 'source',
     sourcePath ?? `${language}:memory`,
     regionKind,
     symbol.name ?? symbol.id
   ].map((part) => String(part).replace(/\s+/g, ' ').trim()).join('#');
   return {
-    id: `region_${idFragment(key)}`,
+    id: symbol?.metadata?.ownershipRegionId ?? `region_${caseSensitiveIdFragment(key)}`,
     key,
     regionKind,
     granularity: 'symbol',
     language,
     sourcePath,
-    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash,
+    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? imported?.sourceHash,
     symbolId: symbol.id,
     symbolName: symbol.name,
     symbolKind: symbol.kind,
@@ -54,7 +54,7 @@ function semanticOwnershipRegionForDeclaration(input, declaration, documentId) {
   const regionKind = semanticRegionKindForDeclaration(declaration);
   const key = ['source', sourcePath, regionKind, name].map((part) => String(part).replace(/\s+/g, ' ').trim()).join('#');
   return {
-    id: `region_${idFragment(key)}`,
+    id: `region_${caseSensitiveIdFragment(key)}`,
     key,
     regionKind,
     granularity: 'symbol',
@@ -76,17 +76,19 @@ function semanticOwnershipRegionForDeclaration(input, declaration, documentId) {
 }
 
 function semanticPatchHintForRegion(region, readiness, options = {}) {
+  const supportedOperations = semanticRegionSupportedOperations(region);
   return {
     id: `hint_${idFragment(region.id)}`,
     kind: 'source-region-patch',
     ownershipRegionId: region.id,
     ownershipKey: region.key,
+    operation: supportedOperations[0] ?? 'replace-region',
     sourcePath: region.sourcePath,
     sourceHash: region.sourceHash,
     sourceSpan: region.sourceSpan,
     readiness,
     precision: region.precision,
-    supportedOperations: semanticRegionSupportedOperations(region),
+    supportedOperations,
     projection: {
       sourceLanguage: region.language,
       targetPath: options.targetPath ?? region.sourcePath,