@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.43

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

@@ -0,0 +1,10 @@
+export function kotlinPsiProblemNode(node, kind) {
+  return Boolean(
+    node.hasError
+    || node.containsDiagnostics
+    || node.containsSkippedText
+    || node.isMissing
+    || kind === 'PsiErrorElement'
+    || kind === 'KtErrorElement'
+  );
+}

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

@@ -0,0 +1,5 @@
+export function kotlinPsiRecoveredKind(kind) {
+  return kind === 'PsiErrorElement'
+    || kind === 'KtErrorElement'
+    || /Error|Recovery|Incomplete|Missing|Skipped/.test(String(kind));
+}

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

@@ -0,0 +1,15 @@
+import{isKotlinPsiNode}from'./isKotlinPsiNode.js';
+export function kotlinPsiRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isKotlinPsiNode(value)) return value;
+  if (isKotlinPsiNode(value.ast)) return value.ast;
+  if (isKotlinPsiNode(value.root)) return value.root;
+  if (isKotlinPsiNode(value.rootNode)) return value.rootNode;
+  if (isKotlinPsiNode(value.ktFile)) return value.ktFile;
+  if (isKotlinPsiNode(value.file)) return value.file;
+  if (isKotlinPsiNode(value.sourceFile)) return value.sourceFile;
+  if (Array.isArray(value.declarations) || Array.isArray(value.imports) || value.packageDirective) {
+    return { kind: 'KtFile', ...value };
+  }
+  return undefined;
+}

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

@@ -0,0 +1,5 @@
+export function kotlinPsiTypeDeclarationKind(kind) {
+  return kind === 'KtClass'
+    || kind === 'KtClassOrObject'
+    || kind === 'KtObjectDeclaration';
+}

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

@@ -0,0 +1,8 @@
+export function kotlinPsiTypeDeclarationSymbolKind(node, kind) {
+  const classKind = String(node.classKind ?? node.kindKeyword ?? '').toLowerCase();
+  if (kind === 'KtObjectDeclaration') return 'class';
+  if (classKind.includes('interface')) return 'interface';
+  if (classKind.includes('enum')) return 'enum';
+  if (classKind.includes('annotation')) return 'type';
+  return 'class';
+}

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

@@ -0,0 +1,18 @@
+import{kotlinPsiName}from'./kotlinPsiName.js';
+export function kotlinPsiTypeName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.text === 'string') return value.text.trim();
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.fqName === 'string') return value.fqName;
+  if (value.typeElement) return kotlinPsiTypeName(value.typeElement);
+  if (value.typeReference) return kotlinPsiTypeName(value.typeReference);
+  if (value.referencedName) return kotlinPsiName(value.referencedName);
+  if (value.constructorReferenceExpression) return kotlinPsiTypeName(value.constructorReferenceExpression);
+  if (Array.isArray(value.typeArguments) || Array.isArray(value.arguments)) {
+    const base = kotlinPsiName(value.name ?? value.referencedName ?? value.constructorReferenceExpression);
+    const args = (value.typeArguments ?? value.arguments).map((entry) => kotlinPsiTypeName(entry.typeReference ?? entry)).filter(Boolean);
+    return base ? `${base}<${args.join(', ')}>` : undefined;
+  }
+  return kotlinPsiName(value);
+}

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

@@ -0,0 +1,7 @@
+import{kotlinPsiDeclarationName}from'./kotlinPsiDeclarationName.js';import{kotlinPsiName}from'./kotlinPsiName.js';
+export function kotlinPsiVariableNames(node) {
+  const variables = node.variables ?? node.entries ?? node.declarations;
+  if (Array.isArray(variables)) return variables.map(kotlinPsiDeclarationName).filter(Boolean);
+  const name = kotlinPsiName(node.nameIdentifier ?? node.identifier ?? node.name);
+  return name ? [name] : [];
+}

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

@@ -0,0 +1,22 @@
+import{idFragment}from'../../native-import-utils.js';
+import{kotlinEvidenceSummary}from'./kotlinEvidenceSummary.js';
+export function kotlinScriptLoss(input, nodeId, span, options = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_script_semantics`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'unsupportedSemantic',
+    message: 'Kotlin script source was imported; script templates, implicit receivers, dependencies, and host execution environment require build/runtime evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      feature: 'script',
+      unsupportedSemanticKind: 'kotlin.scriptContext',
+      script: true,
+      buildVariantEvidence: kotlinEvidenceSummary(options.buildVariantEvidence)
+    }
+  };
+}

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

@@ -0,0 +1,23 @@
+import{idFragment}from'../../native-import-utils.js';
+import{kotlinEvidenceSummary}from'./kotlinEvidenceSummary.js';
+export function kotlinUnsupportedSemanticLoss(input, nodeId, span, options = {}, metadata = {}) {
+  return {
+    id: `loss_${idFragment(nodeId ?? input.sourcePath ?? 'kotlin')}_kotlin_${idFragment(metadata.feature ?? 'semantic')}`,
+    severity: 'warning',
+    phase: 'parse',
+    sourceFormat: input.language,
+    kind: 'unsupportedSemantic',
+    message: metadata.message ?? 'Kotlin semantic feature requires host compiler evidence.',
+    span,
+    nodeId,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      unsupportedSemanticKind: metadata.unsupportedSemanticKind ?? `kotlin.${idFragment(metadata.feature ?? 'semantic')}`,
+      analysisApiEvidence: kotlinEvidenceSummary(options.analysisApiEvidence),
+      firEvidence: kotlinEvidenceSummary(options.firEvidence),
+      multiplatformEvidence: kotlinEvidenceSummary(options.multiplatformEvidence),
+      ...metadata
+    }
+  };
+}

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

@@ -0,0 +1,15 @@
+export function lineColumnForOffset(source, offset) {
+  const text = String(source ?? '');
+  const safeOffset = Math.max(0, Math.min(offset, text.length));
+  let line = 1;
+  let column = 1;
+  for (let index = 0; index < safeOffset; index += 1) {
+    if (text[index] === '\n') {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}

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

@@ -0,0 +1,4 @@
+export function literalSyntaxValue(node) {
+  if (node.value === null || typeof node.value === 'string' || typeof node.value === 'number' || typeof node.value === 'boolean') return node.value;
+  return undefined;
+}

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

@@ -0,0 +1,6 @@
+export const lossSeverityRank = Object.freeze({
+  none: 0,
+  info: 1,
+  warning: 2,
+  error: 3
+});

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

@@ -0,0 +1,19 @@
+export const lspSymbolKindByNumber = Object.freeze({
+  1: 'file',
+  2: 'module',
+  3: 'namespace',
+  4: 'package',
+  5: 'class',
+  6: 'method',
+  7: 'property',
+  8: 'field',
+  9: 'constructor',
+  10: 'enum',
+  11: 'interface',
+  12: 'function',
+  13: 'variable',
+  14: 'constant',
+  22: 'enumMember',
+  23: 'struct',
+  26: 'typeParameter'
+});

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

@@ -0,0 +1,39 @@
+import{hashNativeSpanText}from'./hashNativeSpanText.js';import{nativeDiffSymbolKey}from'./nativeDiffSymbolKey.js';import{nativeImportSourceText}from'./nativeImportSourceText.js';
+export function mapDiffSymbols(imported, sidecar) {
+  const symbolsById = new Map((imported?.semanticIndex?.symbols ?? []).map((symbol) => [symbol.id, symbol]));
+  const mappingsBySymbolId = new Map((imported?.sourceMaps ?? [])
+    .flatMap((sourceMap) => sourceMap.mappings ?? [])
+    .filter((mapping) => mapping.semanticSymbolId)
+    .map((mapping) => [mapping.semanticSymbolId, mapping]));
+  const sourceText = nativeImportSourceText(imported);
+  const entries = sidecar?.symbols?.length
+    ? sidecar.symbols
+    : (imported?.semanticIndex?.symbols ?? []).map((symbol) => ({ id: symbol.id, name: symbol.name, kind: symbol.kind, sourceSpan: symbol.definitionSpan }));
+  const result = new Map();
+  for (const entry of entries) {
+    const symbol = symbolsById.get(entry.id) ?? {};
+    const mapping = mappingsBySymbolId.get(entry.id);
+    const sourceSpan = entry.sourceSpan ?? mapping?.sourceSpan ?? symbol.definitionSpan;
+    const key = nativeDiffSymbolKey(entry, imported);
+    result.set(key, {
+      key,
+      id: entry.id,
+      name: entry.name ?? symbol.name,
+      kind: entry.kind ?? symbol.kind,
+      language: entry.language ?? symbol.language ?? imported?.language,
+      nativeAstNodeId: entry.nativeAstNodeId ?? symbol.nativeAstNodeId ?? mapping?.nativeAstNodeId,
+      semanticOccurrenceId: entry.semanticOccurrenceId ?? mapping?.semanticOccurrenceId,
+      sourceMapMappingId: entry.sourceMapMappingId ?? mapping?.id,
+      sourceSpan,
+      signatureHash: entry.signatureHash ?? symbol.signatureHash,
+      ownershipRegionId: entry.ownershipRegionId ?? symbol.metadata?.ownershipRegionId ?? mapping?.ownershipRegionId,
+      ownershipKey: entry.ownershipKey ?? symbol.metadata?.ownershipRegionKey ?? mapping?.ownershipRegionKey,
+      ownershipRegionKind: entry.ownershipRegionKind ?? symbol.metadata?.ownershipRegionKind ?? mapping?.ownershipRegionKind,
+      spanHash: hashNativeSpanText(sourceText, sourceSpan),
+      sourcePath: sourceSpan?.path ?? imported?.sourcePath,
+      sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash,
+      readiness: entry.readiness ?? imported?.metadata?.semanticMergeReadiness ?? imported?.mergeCandidates?.[0]?.readiness ?? 'needs-review'
+    });
+  }
+  return result;
+}

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

@@ -0,0 +1,4 @@
+import{nativeTargetProjectionAdapterMatches}from'./nativeTargetProjectionAdapterMatches.js';
+export function matchingNativeTargetProjectionAdapter(input, adapters = []) {
+  return adapters.find((adapter) => nativeTargetProjectionAdapterMatches(adapter, input));
+}

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

@@ -0,0 +1,6 @@
+export function maxSemanticCoverageLevel(left, right) {
+  const ranks = { 'native-ast': 0, 'declaration-index': 1, 'semantic-index': 2 };
+  const leftRank = ranks[left] ?? 0;
+  const rightRank = ranks[right] ?? 0;
+  return rightRank > leftRank ? right : left;
+}

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

@@ -0,0 +1,12 @@
+export function mergeNativeLosses(primary = [], secondary = []) {
+  const seen = new Set();
+  const losses = [];
+  for (const loss of [...primary, ...secondary]) {
+    if (!loss) continue;
+    const id = loss.id ?? `loss_${losses.length + 1}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    losses.push(loss.id ? loss : { ...loss, id });
+  }
+  return losses;
+}

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

@@ -0,0 +1,19 @@
+import{createSemanticIndexRecord}from'@shapeshift-labs/frontier-lang-kernel';
+export function mergeSemanticIndexes(imports, input, idPart) {
+  const indexes = imports.map((result) => result.semanticIndex ?? result.universalAst?.semanticIndex).filter(Boolean);
+  if (!indexes.length) return undefined;
+  return createSemanticIndexRecord({
+    id: input.semanticIndexId ?? `index_${idPart}_project`,
+    documents: indexes.flatMap((index) => index.documents ?? []),
+    symbols: indexes.flatMap((index) => index.symbols ?? []),
+    occurrences: indexes.flatMap((index) => index.occurrences ?? []),
+    relations: indexes.flatMap((index) => index.relations ?? []),
+    facts: indexes.flatMap((index) => index.facts ?? []),
+    evidence: indexes.flatMap((index) => index.evidence ?? []),
+    metadata: {
+      projectRoot: input.projectRoot,
+      sourceCount: imports.length,
+      mergedIndexCount: indexes.length
+    }
+  });
+}

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

@@ -0,0 +1,16 @@
+export function mergeSemanticSliceSymbols(symbols) {
+  const byId = new Map();
+  for (const symbol of symbols ?? []) {
+    if (!symbol?.id) continue;
+    const existing = byId.get(symbol.id);
+    byId.set(symbol.id, {
+      ...(existing ?? {}),
+      ...symbol,
+      metadata: {
+        ...(existing?.metadata ?? {}),
+        ...(symbol.metadata ?? {})
+      }
+    });
+  }
+  return [...byId.values()];
+}

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

@@ -0,0 +1,51 @@
+import{idFragment}from'../../native-import-utils.js';
+export function missingInjectedParserResult(input, details) {
+  const rootId = `native_${idFragment(details.adapterId ?? details.parser)}_missing_parser`;
+  const diagnostic = {
+    severity: 'error',
+    code: 'adapter.parser.missing',
+    phase: 'parse',
+    kind: 'unsupportedSyntax',
+    message: details.message,
+    path: input.sourcePath,
+    metadata: {
+      adapterId: details.adapterId,
+      parser: details.parser
+    }
+  };
+  return {
+    rootId,
+    nodes: {
+      [rootId]: {
+        id: rootId,
+        kind: 'MissingInjectedParser',
+        languageKind: `${input.language}.missingInjectedParser`,
+        value: details.parser,
+        metadata: {
+          adapterId: details.adapterId,
+          parser: details.parser,
+          reason: 'missing-injected-parser'
+        }
+      }
+    },
+    diagnostics: [diagnostic],
+    losses: [{
+      id: `loss_${idFragment(rootId)}`,
+      severity: 'error',
+      phase: 'parse',
+      sourceFormat: input.language,
+      kind: 'unsupportedSyntax',
+      message: details.message,
+      nodeId: rootId,
+      metadata: {
+        adapterId: details.adapterId,
+        parser: details.parser
+      }
+    }],
+    metadata: {
+      parser: details.parser,
+      adapterId: details.adapterId,
+      missingInjectedParser: true
+    }
+  };
+}

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

@@ -0,0 +1,10 @@
+export function nameFromExternalSymbol(symbol) {
+  const value = String(symbol ?? 'symbol');
+  const cleaned = value
+    .replace(/^symbol:[^:]+:/, '')
+    .replace(/[`'"]/g, '')
+    .split(/[\/#.:() +]+/)
+    .filter(Boolean)
+    .at(-1);
+  return cleaned || value;
+}

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

@@ -0,0 +1,5 @@
+import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';import{nativeNodeId}from'./nativeNodeId.js';
+export function namedDeclaration(input, nativeNodeId, nameNode, symbolKind) {
+  const name = identifierName(nameNode);
+  return name ? declarationRecord(input, nativeNodeId, name, symbolKind, 'definition') : undefined;
+}

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

@@ -0,0 +1,4 @@
+export function nativeAstNodes(nativeAst) {
+  if (!nativeAst?.nodes) return [];
+  return Object.values(nativeAst.nodes);
+}

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

@@ -0,0 +1,17 @@
+import{sourceSpanPathMatches}from'./sourceSpanPathMatches.js';
+export function nativeChangeMappingTouchesRegion(mapping, region, symbols) {
+  if (!mapping || !region) return false;
+  const symbolIds = new Set((symbols ?? []).map((symbol) => symbol.id).filter(Boolean));
+  const occurrenceIds = new Set((symbols ?? []).map((symbol) => symbol.semanticOccurrenceId).filter(Boolean));
+  const mappingIds = new Set((symbols ?? []).map((symbol) => symbol.sourceMapMappingId).filter(Boolean));
+  if (mappingIds.has(mapping.id)) return true;
+  if (region.id && mapping.ownershipRegionId === region.id) return true;
+  if (region.key && mapping.ownershipRegionKey === region.key) return true;
+  if (region.nativeAstNodeId && mapping.nativeAstNodeId === region.nativeAstNodeId) return true;
+  if (symbolIds.has(mapping.semanticSymbolId)) return true;
+  if (occurrenceIds.has(mapping.semanticOccurrenceId)) return true;
+  if (region.granularity === 'file') {
+    return !region.sourcePath || sourceSpanPathMatches(mapping.sourceSpan, region.sourcePath);
+  }
+  return false;
+}

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

@@ -0,0 +1,28 @@
+import{nativeChangeMappingTouchesRegion}from'./nativeChangeMappingTouchesRegion.js';import{nativeImportSourcePreservationRecord}from'./nativeImportSourcePreservationRecord.js';
+export function nativeChangeProjectionEndpoint(imported, sidecar, region, side) {
+  if (!imported && !region) return undefined;
+  const preservation = nativeImportSourcePreservationRecord(imported);
+  const sourceMaps = imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? [];
+  const regionMappings = sourceMaps
+    .flatMap((sourceMap) => (sourceMap?.mappings ?? []).map((mapping) => ({ sourceMap, mapping })))
+    .filter(({ mapping }) => nativeChangeMappingTouchesRegion(mapping, region, []));
+  return {
+    side,
+    importId: imported?.id,
+    sidecarId: sidecar?.id,
+    nativeSourceId: imported?.nativeSource?.id,
+    nativeAstId: imported?.nativeAst?.id,
+    semanticIndexId: imported?.semanticIndex?.id,
+    universalAstId: imported?.universalAst?.id,
+    sourcePath: imported?.sourcePath ?? region?.sourcePath,
+    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? region?.sourceHash,
+    sourcePreservationId: preservation?.id,
+    exactSourceAvailable: preservation?.summary?.exactSourceAvailable === true,
+    ownershipRegionId: region?.id,
+    ownershipKey: region?.key,
+    ownershipRegionKind: region?.regionKind,
+    sourceSpan: region?.sourceSpan,
+    sourceMapIds: sourceMaps.map((sourceMap) => sourceMap?.id).filter(Boolean),
+    sourceMapMappingIds: regionMappings.map(({ mapping }) => mapping?.id).filter(Boolean)
+  };
+}

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

@@ -0,0 +1,33 @@
+import{nativeChangeMappingTouchesRegion}from'./nativeChangeMappingTouchesRegion.js';
+export function nativeChangeProjectionSourceMapLinks(imported, side, region, symbols) {
+  if (!imported) return [];
+  const sourceMaps = imported.sourceMaps ?? imported.universalAst?.sourceMaps ?? [];
+  const links = [];
+  for (const sourceMap of sourceMaps) {
+    for (const mapping of sourceMap?.mappings ?? []) {
+      if (!nativeChangeMappingTouchesRegion(mapping, region, symbols)) continue;
+      links.push({
+        id: `${side}:${sourceMap.id}:${mapping.id}`,
+        side,
+        sourceMapId: sourceMap.id,
+        sourceMapMappingId: mapping.id,
+        sourcePath: mapping.sourceSpan?.path ?? sourceMap.sourcePath ?? imported.sourcePath,
+        sourceHash: sourceMap.sourceHash ?? imported.nativeSource?.sourceHash ?? imported.nativeAst?.sourceHash,
+        targetPath: mapping.generatedSpan?.targetPath ?? sourceMap.targetPath,
+        targetHash: mapping.generatedSpan?.targetHash ?? sourceMap.targetHash,
+        semanticSymbolId: mapping.semanticSymbolId,
+        semanticOccurrenceId: mapping.semanticOccurrenceId,
+        semanticNodeId: mapping.semanticNodeId,
+        nativeSourceId: mapping.nativeSourceId,
+        nativeAstNodeId: mapping.nativeAstNodeId,
+        precision: mapping.precision,
+        sourceSpan: mapping.sourceSpan,
+        generatedSpan: mapping.generatedSpan,
+        ownershipRegionId: mapping.ownershipRegionId,
+        ownershipRegionKey: mapping.ownershipRegionKey,
+        ownershipRegionKind: mapping.ownershipRegionKind
+      });
+    }
+  }
+  return links;
+}

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

@@ -0,0 +1,37 @@
+import{idFragment,uniqueRecordsById}from'../../native-import-utils.js';
+import{nativeChangedRegionProjectionSpanMetadata}from'./nativeChangedRegionProjectionSpanMetadata.js';
+export function nativeChangeSpans(changedSymbols, changedRegions, input) {
+  const symbolSpans = changedSymbols
+    .filter((symbol) => symbol.sourceSpan)
+    .map((symbol) => ({
+      id: `native_span_${idFragment(symbol.id ?? symbol.key)}`,
+      sourceId: symbol.sourceSpan?.sourceId,
+      path: symbol.sourceSpan?.path ?? input.sourcePath,
+      language: symbol.language ?? input.language,
+      nativeAstNodeId: symbol.nativeAstNodeId,
+      symbolId: symbol.id,
+      span: symbol.sourceSpan,
+      conflictKey: symbol.conflictKey,
+      metadata: { changeKind: symbol.changeKind }
+    }));
+  const regionSpans = changedRegions
+    .filter((region) => region.sourceSpan || region.sourcePath)
+    .map((region) => ({
+      id: `native_span_${idFragment(region.id)}`,
+      path: region.sourceSpan?.path ?? region.sourcePath ?? input.sourcePath,
+      language: region.language ?? input.language,
+      nativeAstNodeId: region.nativeAstNodeId,
+      symbolId: region.symbolId,
+      span: region.sourceSpan,
+      conflictKey: region.conflictKey ?? `region:${region.key ?? region.id}`,
+      metadata: {
+        changeKind: region.changeKind,
+        regionKind: region.regionKind,
+        granularity: region.granularity,
+        ...(region.metadata?.changedRegionProjection ? {
+          changedRegionProjection: nativeChangedRegionProjectionSpanMetadata(region.metadata.changedRegionProjection)
+        } : {})
+      }
+    }));
+  return uniqueRecordsById([...symbolSpans, ...regionSpans]);
+}

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

@@ -0,0 +1,10 @@
+export function nativeChangeSymbolTouchesRegion(symbol, region) {
+  return Boolean(symbol && region && (
+    (region.id && symbol.ownershipRegionId === region.id) ||
+    (region.key && (
+      symbol.ownershipKey === region.key ||
+      symbol.beforeOwnershipKey === region.key ||
+      symbol.afterOwnershipKey === region.key
+    ))
+  ));
+}

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

@@ -0,0 +1,21 @@
+export function nativeChangeTouchedSymbol(symbol) {
+  return {
+    id: symbol.id ?? symbol.key,
+    name: symbol.name,
+    kind: symbol.kind,
+    nativeAstNodeId: symbol.nativeAstNodeId,
+    span: symbol.sourceSpan,
+    conflictKey: symbol.conflictKey,
+    metadata: {
+      changeKind: symbol.changeKind,
+      beforeSignatureHash: symbol.beforeSignatureHash,
+      afterSignatureHash: symbol.afterSignatureHash,
+      beforeSpanHash: symbol.beforeSpanHash,
+      afterSpanHash: symbol.afterSpanHash,
+      beforeNativeAstNodeId: symbol.beforeNativeAstNodeId,
+      afterNativeAstNodeId: symbol.afterNativeAstNodeId,
+      ownershipRegionId: symbol.ownershipRegionId,
+      ownershipRegionKind: symbol.ownershipRegionKind
+    }
+  };
+}

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

@@ -0,0 +1,7 @@
+export function nativeChangedRegionProjectionAction(region, readiness) {
+  if (readiness === 'blocked') return 'rerun-or-human-port';
+  if (region.changeKind === 'added') return 'review-addition';
+  if (region.changeKind === 'removed') return 'review-removal';
+  if (region.granularity === 'file') return 'review-file';
+  return 'review-port';
+}

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

@@ -0,0 +1,49 @@
+import{idFragment,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+import{findSemanticImportRegion}from'./findSemanticImportRegion.js';import{nativeChangedRegionProjectionAction}from'./nativeChangedRegionProjectionAction.js';import{nativeChangeProjectionEndpoint}from'./nativeChangeProjectionEndpoint.js';import{nativeChangeProjectionSourceMapLinks}from'./nativeChangeProjectionSourceMapLinks.js';import{nativeChangeSymbolTouchesRegion}from'./nativeChangeSymbolTouchesRegion.js';
+export function nativeChangedRegionProjectionMetadata(region, context) {
+  const beforeRegion = findSemanticImportRegion(context.beforeSidecar, region);
+  const afterRegion = findSemanticImportRegion(context.afterSidecar, region);
+  const regionSymbols = (context.changedSymbols ?? []).filter((symbol) => nativeChangeSymbolTouchesRegion(symbol, region));
+  const sourceMapLinks = uniqueRecordsById([
+    ...nativeChangeProjectionSourceMapLinks(context.before, 'before', beforeRegion ?? region, regionSymbols),
+    ...nativeChangeProjectionSourceMapLinks(context.after, 'after', afterRegion ?? region, regionSymbols)
+  ]).slice(0, 24);
+  const action = nativeChangedRegionProjectionAction(region, context.readiness);
+  const conflictKeys = uniqueStrings([
+    region.conflictKey,
+    region.key ? `region:${region.key}` : undefined,
+    region.id ? `region:${region.id}` : undefined,
+    ...regionSymbols.map((symbol) => symbol.conflictKey)
+  ].filter(Boolean));
+  return {
+    schema: 'frontier.lang.changedRegionProjection.v1',
+    id: `changed_region_projection_${idFragment(region.conflictKey ?? region.key ?? region.id)}`,
+    reviewRequired: true,
+    autoMergeClaim: false,
+    changeKind: region.changeKind,
+    language: region.language ?? context.language,
+    sourcePath: region.sourcePath ?? context.sourcePath,
+    conflictKey: region.conflictKey,
+    region: {
+      id: region.id,
+      key: region.key,
+      kind: region.regionKind,
+      granularity: region.granularity,
+      precision: region.precision,
+      sourceSpan: region.sourceSpan,
+      nativeAstNodeId: region.nativeAstNodeId,
+      symbolId: region.symbolId,
+      symbolName: region.symbolName,
+      symbolKind: region.symbolKind
+    },
+    before: nativeChangeProjectionEndpoint(context.before, context.beforeSidecar, beforeRegion ?? (region.changeKind === 'added' ? undefined : region), 'before'),
+    after: nativeChangeProjectionEndpoint(context.after, context.afterSidecar, afterRegion ?? (region.changeKind === 'removed' ? undefined : region), 'after'),
+    sourceMapLinks,
+    admission: {
+      readiness: context.readiness,
+      action,
+      reasons: context.reasons ?? [],
+      conflictKeys
+    }
+  };
+}

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

@@ -0,0 +1,12 @@
+export function nativeChangedRegionProjectionSpanMetadata(projection) {
+  return {
+    schema: projection.schema,
+    id: projection.id,
+    reviewRequired: projection.reviewRequired,
+    autoMergeClaim: projection.autoMergeClaim,
+    beforeSourceHash: projection.before?.sourceHash,
+    afterSourceHash: projection.after?.sourceHash,
+    sourceMapLinks: projection.sourceMapLinks?.length ?? 0,
+    admission: projection.admission
+  };
+}

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

@@ -0,0 +1,10 @@
+import{normalizeNativeLanguageId}from'../../native-import-utils.js';
+export function nativeCompileSourceLanguage(importResult, input) {
+  return normalizeNativeLanguageId(
+    importResult.language
+      ?? importResult.nativeSource?.language
+      ?? importResult.nativeAst?.language
+      ?? importResult.nativeSource?.ast?.language
+      ?? input?.language
+  ) || String(importResult.language ?? input?.language ?? 'source');
+}

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

@@ -0,0 +1,10 @@
+import{nativeLanguageCompileTarget,normalizeProjectionMatrixTargets}from'../../coverage-matrix-profiles.js';
+import{compileTargetLanguage}from'./compileTargetLanguage.js';import{nativeCompileSourceLanguage}from'./nativeCompileSourceLanguage.js';
+export function nativeCompileTarget(input, importResult, options) {
+  const targetInput = options.target
+    ?? compileTargetLanguage(input?.target)
+    ?? compileTargetLanguage(importResult.nativeSource?.target)
+    ?? nativeLanguageCompileTarget(nativeCompileSourceLanguage(importResult, input))
+    ?? 'typescript';
+  return normalizeProjectionMatrixTargets([targetInput])[0] ?? String(targetInput ?? 'typescript').toLowerCase();
+}

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

@@ -0,0 +1,7 @@
+export function nativeDiffSymbolChanged(before, after) {
+  if ((before.signatureHash ?? '') !== (after.signatureHash ?? '')) return true;
+  if ((before.spanHash ?? '') !== (after.spanHash ?? '')) return true;
+  if ((before.ownershipKey ?? '') !== (after.ownershipKey ?? '')) return true;
+  if ((before.nativeAstNodeId ?? '') !== (after.nativeAstNodeId ?? '')) return true;
+  return false;
+}

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

@@ -0,0 +1,7 @@
+export function nativeDiffSymbolKey(symbol, imported) {
+  return [
+    symbol.language ?? imported?.language,
+    symbol.kind ?? 'symbol',
+    symbol.name ?? symbol.id
+  ].map((part) => String(part ?? '').trim()).join(':');
+}

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

@@ -0,0 +1,6 @@
+export const nativeFeatureEvidenceRiskRank = Object.freeze({
+  low: 0,
+  medium: 1,
+  high: 2,
+  critical: 3
+});