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

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

@@ -0,0 +1,70 @@
+import{expandSemanticSliceSelection}from'./expandSemanticSliceSelection.js';import{semanticSliceMappingMatchesRef}from'./semanticSliceMappingMatchesRef.js';import{semanticSliceNativeNodeMatchesRef}from'./semanticSliceNativeNodeMatchesRef.js';import{semanticSliceRegionMatchesRef}from'./semanticSliceRegionMatchesRef.js';import{semanticSliceSpanTouchesSelection}from'./semanticSliceSpanTouchesSelection.js';import{semanticSliceSymbolMatchesRef}from'./semanticSliceSymbolMatchesRef.js';
+export function selectSemanticSliceRecords(records, options) {
+  const selectedSymbols = new Set();
+  const selectedRegions = new Set();
+  const selectedNativeNodes = new Set();
+  const selectedMappings = new Set();
+  const selectedRelations = new Set();
+  const selectedOccurrences = new Set();
+  const matchedEntryRefs = [];
+  const entryRefs = options.entryRefs ?? [];
+  if (entryRefs.length === 0) {
+    for (const symbol of records.symbols) selectedSymbols.add(symbol.id);
+    for (const region of records.regions) selectedRegions.add(region.id);
+    for (const node of records.nativeNodes) selectedNativeNodes.add(node.id);
+    for (const mapping of records.mappings) selectedMappings.add(mapping.id);
+  } else {
+    for (const ref of entryRefs) {
+      let matched = false;
+      for (const symbol of records.symbols) {
+        if (!semanticSliceSymbolMatchesRef(symbol, ref)) continue;
+        selectedSymbols.add(symbol.id);
+        matched = true;
+      }
+      for (const region of records.regions) {
+        if (!semanticSliceRegionMatchesRef(region, ref)) continue;
+        selectedRegions.add(region.id);
+        matched = true;
+      }
+      for (const node of records.nativeNodes) {
+        if (!semanticSliceNativeNodeMatchesRef(node, ref)) continue;
+        selectedNativeNodes.add(node.id);
+        matched = true;
+      }
+      for (const mapping of records.mappings) {
+        if (!semanticSliceMappingMatchesRef(mapping, ref)) continue;
+        selectedMappings.add(mapping.id);
+        matched = true;
+      }
+      if (matched) matchedEntryRefs.push(ref);
+    }
+  }
+  expandSemanticSliceSelection(records, {
+    selectedSymbols,
+    selectedRegions,
+    selectedNativeNodes,
+    selectedMappings,
+    selectedRelations,
+    selectedOccurrences,
+    includeDependencies: options.includeDependencies,
+    maxDependencyDepth: options.maxDependencyDepth
+  });
+  const symbols = records.symbols.filter((symbol) => selectedSymbols.has(symbol.id));
+  const regions = records.regions.filter((region) => selectedRegions.has(region.id));
+  const nativeNodes = records.nativeNodes.filter((node) => selectedNativeNodes.has(node.id));
+  const mappings = records.mappings.filter((mapping) => selectedMappings.has(mapping.id));
+  const relations = records.relations.filter((relation) => selectedRelations.has(relation.id));
+  const occurrences = records.occurrences.filter((occurrence) => selectedOccurrences.has(occurrence.id));
+  const selectedNodeIds = new Set(nativeNodes.map((node) => node.id));
+  const losses = records.losses.filter((loss) => !loss.nodeId || selectedNodeIds.has(loss.nodeId) || semanticSliceSpanTouchesSelection(loss.span, mappings, regions));
+  return {
+    matchedEntryRefs,
+    symbols,
+    regions,
+    nativeNodes,
+    mappings,
+    relations,
+    occurrences,
+    losses
+  };
+}

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

@@ -0,0 +1,5 @@
+export function semanticDbOccurrenceRole(value) {
+  const role = String(value ?? 'reference').toLowerCase();
+  if (role === '2' || role.includes('definition')) return 'definition';
+  return 'reference';
+}

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

@@ -0,0 +1,15 @@
+import{idFragment}from'../../native-import-utils.js';
+export function semanticDbSymbolFacts(symbolInfo, symbolId) {
+  const facts = [];
+  for (const key of ['signature', 'properties', 'annotations', 'access', 'language']) {
+    if (symbolInfo[key] !== undefined) {
+      facts.push({
+        id: `fact_${idFragment(symbolId)}_${idFragment(key)}`,
+        predicate: key,
+        subjectId: symbolId,
+        value: symbolInfo[key]
+      });
+    }
+  }
+  return facts;
+}

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

@@ -0,0 +1,7 @@
+import{idFragment}from'../../native-import-utils.js';
+export function semanticDbSymbolId(symbol, context, documentId) {
+  if (!symbol) return `symbol:semanticdb:${context.idPart}:unknown`;
+  if (String(symbol).startsWith('symbol:')) return String(symbol);
+  const scope = /^local\d+$/i.test(String(symbol)) ? `${documentId}:` : '';
+  return `symbol:semanticdb:${idFragment(scope + symbol)}`;
+}

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

@@ -0,0 +1,233 @@
+import{ idFragment, maxSemanticMergeReadiness, normalizeSemanticMergeReadiness, uniqueStrings as uniqueRawStrings }from'../../native-import-utils.js';
+
+export const SemanticHistoryAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
+export const SemanticHistoryReviewerStatuses=Object.freeze(['unreviewed','approved','changes-requested','reviewed','rejected']);
+export const SemanticHistoryOverlapKinds=Object.freeze(['ownership','conflict-key','source','source-path','import','semantic-candidate','evidence','proof','replay','base-hash','target-hash']);
+export const SemanticHistoryConflictReasons=Object.freeze(['ownership-overlap','semantic-conflict-key-overlap','base-hash-mismatch','target-hash-mismatch','admission-blocked','reviewer-rejected','source-path-overlap']);
+
+export function createSemanticHistoryRecord(input={},options={}){
+  const imported=input.importResult??input.imported;
+  const sources=normalizeSources(input,imported);
+  const ownershipRegions=normalizeOwnershipRegions([...(array(input.ownershipRegions)),...(array(input.changedRegions)),...(array(input.changeSet?.changedRegions)),...(array(imported?.ownershipRegions))]);
+  const semanticCandidates=normalizeSemanticCandidates([...(array(input.semanticCandidates)),...(array(input.mergeCandidates)),...(array(input.mergeCandidate)),...(array(input.changeSet?.mergeCandidate)),...(array(imported?.mergeCandidates))]);
+  const replayLinks=normalizeReplayLinks(input.replayLinks??input.replay);
+  const baseHash=firstString(input.baseHash,input.beforeHash,...sources.map((source)=>source.baseHash),...semanticCandidates.map((candidate)=>candidate.baseHash));
+  const targetHash=firstString(input.targetHash,input.afterHash,...sources.map((source)=>source.targetHash),...semanticCandidates.map((candidate)=>candidate.targetHash));
+  const evidenceIds=uniqueStrings([...(strings(input.evidenceIds)),...(array(input.evidence)).map((record)=>record?.id),...(array(imported?.evidence)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.evidenceIds),...(strings(input.reviewer?.evidenceIds)),...(strings(input.admission?.evidenceIds))]);
+  const proofIds=uniqueStrings([...(strings(input.proofIds)),...(array(input.proofs)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.proofIds)]);
+  const sourceIds=uniqueStrings([input.sourceId,...strings(input.sourceIds),...sources.map((source)=>source.id)]);
+  const importIds=uniqueStrings([input.importId,input.importResultId,imported?.id,...strings(input.importIds),...sources.map((source)=>source.importId),...semanticCandidates.map((candidate)=>candidate.importResultId)]);
+  const sourcePaths=uniqueStrings([input.sourcePath,imported?.sourcePath,...sources.map((source)=>source.sourcePath),...ownershipRegions.map((region)=>region.sourcePath),...semanticCandidates.map((candidate)=>candidate.sourcePath)]);
+  const sourceHashes=uniqueStrings([input.sourceHash,imported?.sourceHash,...sources.map((source)=>source.sourceHash),...ownershipRegions.map((region)=>region.sourceHash)]);
+  const conflictKeys=uniqueStrings([...(strings(input.conflictKeys)),...semanticCandidates.flatMap((candidate)=>candidate.conflictKeys)]);
+  const reviewer=normalizeReviewer(input.reviewer);
+  const admission=normalizeAdmission(input.admission,semanticCandidates,reviewer);
+  return{
+    kind:'frontier.lang.semanticHistoryRecord',
+    version:1,
+    id:input.id??options.id??`semantic_history_${idFragment(firstString(sourcePaths[0],importIds[0],sourceIds[0],'record'))}`,
+    createdAt:input.createdAt??options.createdAt??Date.now(),
+    baseHash,
+    targetHash,
+    language:input.language??imported?.language??sources.find((source)=>source.language)?.language,
+    sourcePath:input.sourcePath??imported?.sourcePath??sourcePaths[0],
+    sourceIds,
+    importIds,
+    sources,
+    ownershipRegions,
+    semanticCandidates,
+    evidenceIds,
+    proofIds,
+    reviewer,
+    admission,
+    replayLinks,
+    index:{
+      baseHashes:uniqueStrings([baseHash,...sources.map((source)=>source.baseHash),...semanticCandidates.map((candidate)=>candidate.baseHash)]),
+      targetHashes:uniqueStrings([targetHash,...sources.map((source)=>source.targetHash),...semanticCandidates.map((candidate)=>candidate.targetHash)]),
+      sourceIds,
+      importIds,
+      sourcePaths,
+      sourceHashes,
+      ownershipKeys:uniqueStrings([...ownershipRegions.map((region)=>region.key),...semanticCandidates.flatMap((candidate)=>candidate.ownershipKeys)]),
+      semanticCandidateIds:uniqueStrings(semanticCandidates.map((candidate)=>candidate.id)),
+      conflictKeys,
+      evidenceIds,
+      proofIds,
+      replayIds:uniqueStrings(replayLinks.map((link)=>link.id))
+    },
+    metadata:compactRecord(input.metadata)
+  };
+}
+
+export function querySemanticHistoryRecordOverlaps(records,options={}){
+  const list=array(records).filter(Boolean);
+  const overlaps=[];
+  for(let leftIndex=0;leftIndex<list.length;leftIndex+=1){
+    for(let rightIndex=leftIndex+1;rightIndex<list.length;rightIndex+=1){
+      const overlap=semanticHistoryOverlap(list[leftIndex],list[rightIndex],options);
+      if(overlap.overlapKinds.length||overlap.conflictReasons.length)overlaps.push(overlap);
+    }
+  }
+  return overlaps.sort((left,right)=>Number(right.conflict)-Number(left.conflict)||left.leftId.localeCompare(right.leftId)||left.rightId.localeCompare(right.rightId));
+}
+
+export function semanticHistoryRecordsOverlap(left,right,options={}){
+  return semanticHistoryOverlap(left,right,options).overlapKinds.length>0;
+}
+
+export function semanticHistoryRecordsConflict(left,right,options={}){
+  return semanticHistoryOverlap(left,right,options).conflict;
+}
+
+function semanticHistoryOverlap(left,right,options){
+  const leftIndex=historyIndex(left);
+  const rightIndex=historyIndex(right);
+  const overlap=compactRecord({
+    ownership:intersect(leftIndex.ownershipKeys,rightIndex.ownershipKeys),
+    'conflict-key':intersect(leftIndex.conflictKeys,rightIndex.conflictKeys),
+    source:intersect(leftIndex.sourceIds,rightIndex.sourceIds),
+    'source-path':options.includeSourcePaths===false?[]:intersect(leftIndex.sourcePaths,rightIndex.sourcePaths),
+    import:intersect(leftIndex.importIds,rightIndex.importIds),
+    'semantic-candidate':intersect(leftIndex.semanticCandidateIds,rightIndex.semanticCandidateIds),
+    evidence:options.includeEvidence?intersect(leftIndex.evidenceIds,rightIndex.evidenceIds):[],
+    proof:options.includeProofs?intersect(leftIndex.proofIds,rightIndex.proofIds):[],
+    replay:options.includeReplay?intersect(leftIndex.replayIds,rightIndex.replayIds):[],
+    'base-hash':options.includeBaseHashes?intersect(leftIndex.baseHashes,rightIndex.baseHashes):[],
+    'target-hash':options.includeTargetHashes?intersect(leftIndex.targetHashes,rightIndex.targetHashes):[]
+  });
+  const overlapKinds=Object.keys(overlap);
+  const semanticOverlap=Boolean(overlap.ownership?.length||overlap['conflict-key']?.length||overlap.source?.length||overlap['source-path']?.length||overlap.import?.length);
+  const conflictReasons=uniqueStrings([
+    overlap.ownership?.length?'ownership-overlap':undefined,
+    overlap['conflict-key']?.length?'semantic-conflict-key-overlap':undefined,
+    semanticOverlap&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
+    (overlap.ownership?.length||overlap['conflict-key']?.length)&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined,
+    semanticOverlap&&(blockedAdmission(left)||blockedAdmission(right))?'admission-blocked':undefined,
+    semanticOverlap&&(rejectedReview(left)||rejectedReview(right))?'reviewer-rejected':undefined,
+    options.conflictOnSourcePath&&overlap['source-path']?.length?'source-path-overlap':undefined
+  ]);
+  return{
+    schema:'frontier.lang.semanticHistoryOverlap.v1',
+    leftId:String(left?.id??'left'),
+    rightId:String(right?.id??'right'),
+    overlap,
+    overlapKinds,
+    conflict:conflictReasons.length>0,
+    conflictReasons,
+    admission:{left:left?.admission?.status,right:right?.admission?.status},
+    reviewer:{left:left?.reviewer?.status,right:right?.reviewer?.status}
+  };
+}
+
+function normalizeSources(input,imported){
+  const entries=[...(array(input.sources)),...(array(input.sourceRefs)),...(array(input.source)),...(array(imported))];
+  if(entries.length===0&&(input.sourcePath||input.sourceHash||input.baseHash||input.targetHash||input.sourceId||input.importId)){
+    entries.push(input);
+  }
+  return entries.map((source,index)=>compactRecord({
+    id:source?.id??source?.sourceId,
+    importId:source?.importId??source?.importResultId??(source?.kind==='frontier.lang.importResult'?source.id:undefined),
+    language:source?.language??input.language,
+    sourcePath:source?.sourcePath??source?.path??input.sourcePath,
+    sourceHash:source?.sourceHash??source?.hash,
+    baseHash:source?.baseHash??source?.beforeHash??input.baseHash??input.beforeHash,
+    targetHash:source?.targetHash??source?.afterHash??input.targetHash??input.afterHash,
+    metadata:source?.metadata,
+    ordinal:index
+  })).filter((source)=>source.id||source.importId||source.sourcePath||source.sourceHash||source.baseHash||source.targetHash);
+}
+
+function normalizeOwnershipRegions(regions){
+  const seen=new Set();
+  const normalized=[];
+  for(const region of regions){
+    const key=firstString(region?.key,region?.ownershipKey,region?.conflictKey,region?.id);
+    if(!key||seen.has(key))continue;
+    seen.add(key);
+    normalized.push(compactRecord({
+      id:region?.id,
+      key,
+      regionKind:region?.regionKind??region?.ownershipRegionKind,
+      granularity:region?.granularity??'semantic',
+      language:region?.language,
+      sourcePath:region?.sourcePath,
+      sourceHash:region?.sourceHash,
+      symbolId:region?.symbolId,
+      symbolName:region?.symbolName??region?.name,
+      sourceSpan:region?.sourceSpan??region?.span,
+      metadata:region?.metadata
+    }));
+  }
+  return normalized;
+}
+
+function normalizeSemanticCandidates(candidates){
+  return candidates.filter(Boolean).map((candidate,index)=>compactRecord({
+    id:candidate.id??candidate.candidateId??`semantic_candidate_${index+1}`,
+    importResultId:candidate.importResultId,
+    patchId:candidate.patchId,
+    sourcePath:candidate.sourcePath,
+    baseHash:candidate.baseHash,
+    targetHash:candidate.targetHash,
+    readiness:normalizeSemanticMergeReadiness(candidate.readiness)??candidate.readiness,
+    conflictKeys:uniqueStrings([...(strings(candidate.conflictKeys)),...(array(candidate.touchedSymbols)).map((entry)=>entry?.conflictKey),...(array(candidate.touchedSemanticNodes)).map((entry)=>entry?.conflictKey),...(array(candidate.nativeSpans)).map((entry)=>entry?.conflictKey),...(array(candidate.conflictClasses??candidate.metadata?.conflictClasses)).flatMap((entry)=>entry?.conflictKeys??[]),...(candidate.conflictSummary?.conflictKeys??candidate.metadata?.conflictSummary?.conflictKeys??[])]),
+    ownershipKeys:uniqueStrings([...(strings(candidate.ownershipKeys)),...(strings(candidate.regionKeys))]),
+    evidenceIds:uniqueStrings([...(strings(candidate.evidenceIds)),...(array(candidate.evidence)).map((record)=>record?.id),...(array(candidate.conflictClasses??candidate.metadata?.conflictClasses)).flatMap((entry)=>entry?.evidenceIds??[])]),
+    proofIds:uniqueStrings([...(strings(candidate.proofIds)),...(array(candidate.evidence)).filter((record)=>record?.kind==='proof').map((record)=>record?.id)]),
+    replayIds:uniqueStrings([...(strings(candidate.replayIds)),...(array(candidate.evidence)).filter((record)=>record?.kind==='replay').map((record)=>record?.id)]),
+    metadata:compactRecord({risk:candidate.risk,reasons:candidate.reasons,...candidate.metadata})
+  }));
+}
+
+function normalizeReplayLinks(value){
+  return array(value).filter(Boolean).map((link,index)=>{
+    const text=typeof link==='string'?link:undefined;
+    return compactRecord({
+      id:link?.id??(text?`replay_${idFragment(text)}`:`replay_${index+1}`),
+      kind:link?.kind??'replay',
+      href:link?.href??(text&&/^[a-z][a-z0-9+.-]*:/i.test(text)?text:undefined),
+      path:link?.path??(text&&!/^[a-z][a-z0-9+.-]*:/i.test(text)?text:undefined),
+      command:link?.command,
+      hash:link?.hash,
+      targetId:link?.targetId,
+      metadata:link?.metadata
+    });
+  });
+}
+
+function normalizeReviewer(reviewer){
+  if(typeof reviewer==='string')return{status:reviewer,evidenceIds:[]};
+  return compactRecord({status:reviewer?.status??'unreviewed',reviewerId:reviewer?.reviewerId??reviewer?.id,reviewedAt:reviewer?.reviewedAt,evidenceIds:uniqueStrings(reviewer?.evidenceIds),metadata:reviewer?.metadata});
+}
+
+function normalizeAdmission(admission,candidates,reviewer){
+  const readiness=candidates.reduce((current,candidate)=>maxSemanticMergeReadiness(current,normalizeSemanticMergeReadiness(candidate.readiness)??'needs-review'),normalizeSemanticMergeReadiness(admission?.readiness)??'ready');
+  return compactRecord({status:admission?.status??'proposed',readiness,admittedAt:admission?.admittedAt,reviewerId:admission?.reviewerId??reviewer.reviewerId,reasonCodes:uniqueStrings(admission?.reasonCodes),evidenceIds:uniqueStrings(admission?.evidenceIds),metadata:admission?.metadata});
+}
+
+function historyIndex(record){
+  return record?.index??{
+    baseHashes:uniqueStrings([record?.baseHash]),
+    targetHashes:uniqueStrings([record?.targetHash]),
+    sourceIds:uniqueStrings(record?.sourceIds),
+    importIds:uniqueStrings(record?.importIds),
+    sourcePaths:uniqueStrings([record?.sourcePath,...(record?.sources??[]).map((source)=>source.sourcePath)]),
+    sourceHashes:uniqueStrings((record?.sources??[]).map((source)=>source.sourceHash)),
+    ownershipKeys:uniqueStrings((record?.ownershipRegions??[]).map((region)=>region.key)),
+    semanticCandidateIds:uniqueStrings((record?.semanticCandidates??[]).map((candidate)=>candidate.id)),
+    conflictKeys:uniqueStrings((record?.semanticCandidates??[]).flatMap((candidate)=>candidate.conflictKeys??[])),
+    evidenceIds:uniqueStrings(record?.evidenceIds),
+    proofIds:uniqueStrings(record?.proofIds),
+    replayIds:uniqueStrings((record?.replayLinks??[]).map((link)=>link.id))
+  };
+}
+
+function blockedAdmission(record){return ['blocked','rejected'].includes(String(record?.admission?.status??''));}
+function rejectedReview(record){return ['rejected','changes-requested'].includes(String(record?.reviewer?.status??''));}
+function intersect(left,right){const rightSet=new Set(right??[]);return uniqueStrings((left??[]).filter((value)=>rightSet.has(value)));}
+function disjointNonEmpty(left,right){return Boolean(left?.length&&right?.length&&intersect(left,right).length===0);}
+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 uniqueStrings(values){return uniqueRawStrings((values??[]).filter((entry)=>entry!==undefined&&entry!==null&&String(entry)!==''));}
+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/semanticIndexFromNativeDeclarations.js

@@ -0,0 +1,127 @@
+import{idFragment}from'../../native-import-utils.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{relationPredicateForDeclaration}from'./relationPredicateForDeclaration.js';
+export function semanticIndexFromNativeDeclarations(declarations, input, options) {
+  const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`;
+  const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_${idFragment(options.astFormat ?? options.parser)}_import`;
+  const symbols = [];
+  const occurrences = [];
+  const relations = [];
+  const facts = [];
+  const mappings = [];
+  for (const declaration of declarations) {
+    const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${idFragment(declaration.name)}`;
+    const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
+    const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
+      ...declaration,
+      nodeId: declaration.nativeNode.id,
+      kind: declaration.nativeNode.kind,
+      languageKind: declaration.nativeNode.languageKind,
+      span: declaration.nativeNode.span,
+      symbolId
+    }, documentId);
+    declaration.nativeNode.metadata = {
+      ...declaration.nativeNode.metadata,
+      ownershipRegionId: ownershipRegion.id,
+      ownershipRegionKey: ownershipRegion.key,
+      ownershipRegionKind: ownershipRegion.regionKind
+    };
+    symbols.push({
+      id: symbolId,
+      scheme: 'frontier',
+      name: declaration.name,
+      kind: declaration.symbolKind,
+      language: input.language,
+      nativeAstNodeId: declaration.nativeNode.id,
+      signatureHash: hashSemanticValue([input.language, declaration.nativeNode.kind, declaration.name, declaration.nativeNode.fields ?? {}]),
+      definitionSpan: declaration.nativeNode.span,
+      metadata: {
+        ownershipRegionId: ownershipRegion.id,
+        ownershipRegionKey: ownershipRegion.key,
+        ownershipRegionKind: ownershipRegion.regionKind
+      }
+    });
+    occurrences.push({
+      id: occurrenceId,
+      documentId,
+      symbolId,
+      role: declaration.role ?? 'definition',
+      span: declaration.nativeNode.span,
+      nativeAstNodeId: declaration.nativeNode.id
+    });
+    relations.push({
+      id: `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`,
+      sourceId: documentId,
+      predicate: relationPredicateForDeclaration(declaration),
+      targetId: symbolId
+    });
+    facts.push({
+      id: `fact_${idFragment(declaration.nativeNode.id)}_kind`,
+      predicate: 'nativeKind',
+      subjectId: symbolId,
+      value: declaration.nativeNode.languageKind
+    }, {
+      id: `fact_${idFragment(declaration.nativeNode.id)}_ownership_region`,
+      predicate: 'semanticOwnershipRegion',
+      subjectId: symbolId,
+      value: ownershipRegion
+    }, {
+      id: `fact_${idFragment(declaration.nativeNode.id)}_ownership_region_taxonomy`,
+      predicate: 'semanticOwnershipRegionTaxonomy',
+      subjectId: symbolId,
+      value: {
+        regionKind: ownershipRegion.regionKind,
+        granularity: ownershipRegion.granularity,
+        key: ownershipRegion.key
+      }
+    });
+    mappings.push({
+      id: `map_${idFragment(declaration.nativeNode.id)}`,
+      nativeAstNodeId: declaration.nativeNode.id,
+      semanticSymbolId: symbolId,
+      semanticOccurrenceId: occurrenceId,
+      sourceSpan: declaration.nativeNode.span,
+      evidenceIds: [evidenceId],
+      lossIds: [],
+      ownershipRegionId: ownershipRegion.id,
+      ownershipRegionKey: ownershipRegion.key,
+      ownershipRegionKind: ownershipRegion.regionKind,
+      precision: declaration.nativeNode.span ? 'declaration' : 'unknown'
+    });
+  }
+  const evidence = [{
+    id: evidenceId,
+    kind: 'import',
+    status: 'passed',
+    path: input.sourcePath,
+    summary: `Normalized ${options.astFormat ?? options.parser} native AST with ${declarations.length} declaration(s).`,
+    metadata: {
+      parser: options.parser,
+      astFormat: options.astFormat,
+      language: input.language,
+      sourceHash: input.sourceHash
+    }
+  }];
+  return {
+    semanticIndex: createSemanticIndexRecord({
+      id: `index_${idFragment(input.sourcePath ?? input.language)}_${idFragment(options.astFormat ?? options.parser)}`,
+      documents: [{
+        id: documentId,
+        path: input.sourcePath ?? `${input.language}:memory`,
+        language: input.language,
+        sourceHash: input.sourceHash
+      }],
+      symbols,
+      occurrences,
+      relations,
+      facts,
+      evidence,
+      metadata: {
+        parser: options.parser,
+        astFormat: options.astFormat,
+        coverage: 'native-ast-declarations'
+      }
+    }),
+    mappings,
+    evidence
+  };
+}

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

@@ -0,0 +1,5 @@
+export function semanticMergeAdmissionForSeverity(severity) {
+  if (severity === 'error') return 'blocked';
+  if (severity === 'warning') return 'review';
+  return 'disclose';
+}

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

@@ -0,0 +1,116 @@
+import{countBy,idFragment,maxSemanticMergeReadiness,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+
+export const SemanticMergeConflictClasses=Object.freeze(['same-symbol-edit','delete-modify','shifted-code','duplicate-signature','dependency-drift','behavior-evidence-needed']);
+const riskRank=Object.freeze({low:1,medium:2,high:3});
+const readinessRank=Object.freeze({ready:0,'ready-with-losses':1,'needs-review':2,blocked:3});
+const classWeight=Object.freeze({'behavior-evidence-needed':10,'shifted-code':20,'same-symbol-edit':30,'dependency-drift':40,'duplicate-signature':50,'delete-modify':60});
+const dependencyPredicates=/(?:import|call|depend|use|refer|require|include|extend|implement)/i;
+const behaviorEvidenceKinds=/(?:test|trace|proof|verify|verification|benchmark|behavior|runtime|simulation|contract)/i;
+
+export function classifyNativeSourceMergeConflicts(input){
+  const conflictClasses=dedupeConflictRecords([
+    ...sameSymbolEditConflicts(input),
+    ...deleteModifyConflicts(input),
+    ...shiftedCodeConflicts(input),
+    ...duplicateSignatureConflicts(input),
+    ...dependencyDriftConflicts(input),
+    ...behaviorEvidenceNeededConflicts(input)
+  ]);
+  return{conflictClasses,conflictSummary:summarizeSemanticMergeConflicts(conflictClasses,{readiness:input.readiness,conflictKeys:input.conflictKeys,sourcePath:input.sourcePath,language:input.language})};
+}
+
+export function summarizeSemanticMergeConflicts(conflictClasses=[],context={}){
+  const records=(conflictClasses??[]).filter(Boolean);
+  const readiness=records.reduce((current,record)=>maxSemanticMergeReadiness(current,normalizeSemanticMergeReadiness(record.readiness)??'ready'),normalizeSemanticMergeReadiness(context.readiness)??'ready');
+  return{schema:'frontier.lang.semanticMergeConflictSummary.v1',total:records.length,classes:uniqueStrings(records.map((record)=>record.class)),byClass:countBy(records.map((record)=>record.class)),byRisk:countBy(records.map((record)=>record.risk??'medium')),highestRisk:highestRisk(records),readiness,riskScore:semanticMergeConflictRiskScore({conflictClasses:records,conflictSummary:{readiness}}),conflictKeys:uniqueStrings([...(context.conflictKeys??[]),...records.flatMap((record)=>record.conflictKeys??[])]),language:context.language,sourcePath:context.sourcePath};
+}
+
+export function semanticMergeConflictRiskScore(candidateOrSummary){
+  const records=candidateOrSummary?.conflictClasses??candidateOrSummary?.metadata?.conflictClasses??[];
+  const summary=candidateOrSummary?.conflictSummary??candidateOrSummary?.metadata?.conflictSummary??candidateOrSummary;
+  const classScore=Math.max(0,...records.map((record)=>classWeight[record.class]??1));
+  const riskScore=Math.max(0,...records.map((record)=>riskRank[record.risk]??2));
+  const readinessScore=readinessRank[summary?.readiness??candidateOrSummary?.readiness]??2;
+  return classScore*100+riskScore*10+readinessScore;
+}
+
+export function querySemanticMergeConflictClasses(candidates,options={}){
+  const list=Array.isArray(candidates)?candidates:[candidates].filter(Boolean);
+  const classes=new Set(queryList(options.class??options.classes));
+  const risks=new Set(queryList(options.risk??options.risks));
+  const readinesses=new Set(queryList(options.readiness??options.readinesses));
+  const conflictKey=options.conflictKey?String(options.conflictKey):undefined;
+  const records=[];
+  for(const candidate of list){
+    for(const record of candidate?.conflictClasses??candidate?.metadata?.conflictClasses??[]){
+      if(classes.size&&!classes.has(record.class))continue;
+      if(risks.size&&!risks.has(record.risk))continue;
+      if(readinesses.size&&!readinesses.has(record.readiness))continue;
+      if(conflictKey&&!(record.conflictKeys??[]).includes(conflictKey))continue;
+      records.push({...record,candidateId:candidate.id,candidateReadiness:candidate.readiness,candidateRiskScore:semanticMergeConflictRiskScore(candidate)});
+    }
+  }
+  return options.sort===false?records:records.sort(compareConflictClassRecords);
+}
+
+export function sortSemanticMergeCandidatesByConflictRisk(candidates,options={}){
+  const sorted=[...(candidates??[])].sort((left,right)=>semanticMergeConflictRiskScore(right)-semanticMergeConflictRiskScore(left)||(readinessRank[right?.readiness]??2)-(readinessRank[left?.readiness]??2)||String(left?.id??'').localeCompare(String(right?.id??'')));
+  return options.desc===false?sorted.reverse():sorted;
+}
+
+function sameSymbolEditConflicts(input){
+  return(input.changedSymbols??[]).filter((symbol)=>symbol.changeKind==='modified').map((symbol)=>conflictRecord('same-symbol-edit',{id:`conflict_${idFragment(symbol.id??symbol.key)}_same_symbol_edit`,risk:'medium',readiness:symbol.readiness,conflictKeys:[symbol.conflictKey],symbolIds:[symbol.id],regionKeys:[symbol.beforeOwnershipKey,symbol.afterOwnershipKey,symbol.ownershipKey],evidenceIds:evidenceIds(input.evidence),reasonCode:'same-symbol-edited',language:input.language,sourcePath:input.sourcePath,metadata:{changeKind:symbol.changeKind,beforeSignatureHash:symbol.beforeSignatureHash,afterSignatureHash:symbol.afterSignatureHash,signatureChanged:hashChanged(symbol.beforeSignatureHash,symbol.afterSignatureHash),spanChanged:hashChanged(symbol.beforeSpanHash,symbol.afterSpanHash),ownershipChanged:(symbol.beforeOwnershipKey??'')!==(symbol.afterOwnershipKey??''),nativeAstNodeChanged:(symbol.beforeNativeAstNodeId??'')!==(symbol.afterNativeAstNodeId??'')}}));
+}
+
+function deleteModifyConflicts(input){
+  const records=(input.changedSymbols??[]).filter((symbol)=>symbol.changeKind==='removed').map((symbol)=>conflictRecord('delete-modify',{id:`conflict_${idFragment(symbol.id??symbol.key)}_delete_modify`,risk:'high',readiness:symbol.readiness,conflictKeys:[symbol.conflictKey],symbolIds:[symbol.id],regionKeys:[symbol.beforeOwnershipKey,symbol.ownershipKey],evidenceIds:evidenceIds(input.evidence),reasonCode:'symbol-deleted',language:input.language,sourcePath:input.sourcePath,metadata:{changeKind:symbol.changeKind,beforeSignatureHash:symbol.beforeSignatureHash}}));
+  for(const region of(input.changedRegions??[]).filter((entry)=>entry.changeKind==='removed'))records.push(conflictRecord('delete-modify',{id:`conflict_${idFragment(region.id??region.key)}_region_delete_modify`,risk:'high',readiness:input.readiness,conflictKeys:[region.conflictKey],symbolIds:[region.symbolId],regionKeys:[region.key],evidenceIds:evidenceIds(input.evidence),reasonCode:'ownership-region-deleted',language:input.language,sourcePath:input.sourcePath,metadata:{changeKind:region.changeKind,regionKind:region.regionKind}}));
+  if(input.before&&!input.after&&records.length===0)records.push(conflictRecord('delete-modify',{id:`conflict_${idFragment(input.sourcePath??input.language??'source')}_source_delete_modify`,risk:'high',readiness:input.readiness,conflictKeys:input.conflictKeys,evidenceIds:evidenceIds(input.evidence),reasonCode:'source-deleted',language:input.language,sourcePath:input.sourcePath,metadata:{beforeImportId:input.before?.id}}));
+  return records;
+}
+
+function shiftedCodeConflicts(input){
+  const records=(input.changedSymbols??[]).filter((symbol)=>symbol.changeKind==='modified'&&!hashChanged(symbol.beforeSignatureHash,symbol.afterSignatureHash)).filter((symbol)=>hashChanged(symbol.beforeSpanHash,symbol.afterSpanHash)||(symbol.beforeSourceSpan?.startLine??0)!==(symbol.afterSourceSpan?.startLine??0)||(symbol.beforeNativeAstNodeId??'')!==(symbol.afterNativeAstNodeId??'')||(symbol.beforeOwnershipKey??'')!==(symbol.afterOwnershipKey??'')).map((symbol)=>conflictRecord('shifted-code',{id:`conflict_${idFragment(symbol.id??symbol.key)}_shifted_code`,risk:'medium',readiness:symbol.readiness,conflictKeys:[symbol.conflictKey],symbolIds:[symbol.id],regionKeys:[symbol.beforeOwnershipKey,symbol.afterOwnershipKey,symbol.ownershipKey],evidenceIds:evidenceIds(input.evidence),reasonCode:'same-signature-location-shifted',language:input.language,sourcePath:input.sourcePath,metadata:{beforeSpanHash:symbol.beforeSpanHash,afterSpanHash:symbol.afterSpanHash,beforeLine:symbol.beforeSourceSpan?.startLine,afterLine:symbol.afterSourceSpan?.startLine,beforeNativeAstNodeId:symbol.beforeNativeAstNodeId,afterNativeAstNodeId:symbol.afterNativeAstNodeId}}));
+  if(input.sourceChanged&&(input.changedSymbols??[]).length===0)records.push(conflictRecord('shifted-code',{id:`conflict_${idFragment(input.sourcePath??input.language??'source')}_file_shifted_code`,risk:'medium',readiness:input.readiness,conflictKeys:input.conflictKeys,evidenceIds:evidenceIds(input.evidence),reasonCode:'source-hash-changed-without-symbol-anchor',language:input.language,sourcePath:input.sourcePath,metadata:{beforeHash:input.beforeHash,afterHash:input.afterHash}}));
+  return records;
+}
+
+function duplicateSignatureConflicts(input){
+  const changedKeys=new Set((input.changedSymbols??[]).map((symbol)=>symbol.key));
+  return duplicateSignatureGroups(input.afterSymbols??[]).filter((group)=>group.symbols.some((symbol)=>changedKeys.size===0||changedKeys.has(symbol.key))).map((group)=>conflictRecord('duplicate-signature',{id:`conflict_${idFragment(group.signatureHash)}_duplicate_signature`,risk:'high',readiness:input.readiness,conflictKeys:group.symbols.map((symbol)=>symbol.conflictKey),symbolIds:group.symbols.map((symbol)=>symbol.id),regionKeys:group.symbols.map((symbol)=>symbol.ownershipKey),evidenceIds:evidenceIds(input.evidence),reasonCode:'duplicate-signature-hash',language:input.language,sourcePath:input.sourcePath,metadata:{signatureHash:group.signatureHash,symbolNames:group.symbols.map((symbol)=>symbol.name).filter(Boolean),symbolCount:group.symbols.length}}));
+}
+
+function dependencyDriftConflicts(input){
+  const before=dependencyFingerprints(input.before);
+  const after=dependencyFingerprints(input.after);
+  const added=after.filter((fingerprint)=>!before.includes(fingerprint));
+  const removed=before.filter((fingerprint)=>!after.includes(fingerprint));
+  return!added.length&&!removed.length?[]:[conflictRecord('dependency-drift',{id:`conflict_${idFragment(input.sourcePath??input.language??'source')}_dependency_drift`,risk:'medium',readiness:input.readiness,conflictKeys:input.conflictKeys,evidenceIds:evidenceIds(input.evidence),reasonCode:'semantic-dependency-fingerprint-changed',language:input.language,sourcePath:input.sourcePath,metadata:{addedFingerprints:added,removedFingerprints:removed,beforeDependencyCount:before.length,afterDependencyCount:after.length}})];
+}
+
+function behaviorEvidenceNeededConflicts(input){
+  const changedSymbols=(input.changedSymbols??[]).filter((symbol)=>symbol.changeKind!=='unchanged');
+  if((!changedSymbols.length&&!input.sourceChanged)||hasBehaviorEvidence(input.evidence))return[];
+  return[conflictRecord('behavior-evidence-needed',{id:`conflict_${idFragment(input.sourcePath??input.language??'source')}_behavior_evidence_needed`,risk:'medium',readiness:maxSemanticMergeReadiness(input.readiness??'ready','needs-review'),conflictKeys:input.conflictKeys,symbolIds:changedSymbols.map((symbol)=>symbol.id),regionKeys:uniqueStrings([...changedSymbols.map((symbol)=>symbol.beforeOwnershipKey),...changedSymbols.map((symbol)=>symbol.afterOwnershipKey),...(input.changedRegions??[]).map((region)=>region.key)]),evidenceIds:evidenceIds(input.evidence),reasonCode:'missing-behavior-evidence',language:input.language,sourcePath:input.sourcePath,metadata:{changedSymbols:changedSymbols.length,changedRegions:input.changedRegions?.length??0,acceptedEvidenceKinds:['test','trace','proof','verification','benchmark','behavior']}})];
+}
+
+function conflictRecord(conflictClass,input){
+  return{schema:'frontier.lang.semanticMergeConflictClass.v1',id:input.id,class:conflictClass,risk:input.risk,readiness:normalizeSemanticMergeReadiness(input.readiness)??riskReadiness(input.risk),conflictKeys:uniqueStrings(input.conflictKeys),symbolIds:uniqueStrings(input.symbolIds),regionKeys:uniqueStrings(input.regionKeys),evidenceIds:uniqueStrings(input.evidenceIds),reasonCode:input.reasonCode,language:input.language,sourcePath:input.sourcePath,metadata:compactRecord(input.metadata)};
+}
+
+function dedupeConflictRecords(records){
+  const seen=new Set();
+  const result=[];
+  for(const record of records){const key=`${record.class}:${record.id}:${record.conflictKeys.join('|')}`;if(seen.has(key))continue;seen.add(key);result.push(record);}
+  return result.sort(compareConflictClassRecords);
+}
+function compareConflictClassRecords(left,right){return(riskRank[right.risk]??2)-(riskRank[left.risk]??2)||(classWeight[right.class]??1)-(classWeight[left.class]??1)||String(left.id??'').localeCompare(String(right.id??''));}
+function duplicateSignatureGroups(symbols){const groups=new Map();for(const symbol of symbols??[]){if(!symbol?.signatureHash)continue;groups.set(symbol.signatureHash,[...(groups.get(symbol.signatureHash)??[]),symbol]);}return[...groups.entries()].filter(([,values])=>values.length>1).map(([signatureHash,values])=>({signatureHash,symbols:values}));}
+function dependencyFingerprints(imported){return uniqueStrings((imported?.semanticIndex?.relations??[]).filter((relation)=>dependencyPredicates.test(String(relation.predicate??''))).map((relation)=>[relation.sourceId,relation.predicate,relation.targetId,relation.metadata?.module,relation.metadata?.importPath].map((part)=>String(part??'')).join('|'))).sort();}
+function hasBehaviorEvidence(evidence){return(evidence??[]).some((record)=>record?.status!=='failed'&&(behaviorEvidenceKinds.test(String(record?.kind??record?.metadata?.kind??''))||record?.metadata?.behaviorEvidence===true||(Array.isArray(record?.metadata?.evidenceKinds)&&record.metadata.evidenceKinds.some((value)=>behaviorEvidenceKinds.test(String(value))))));}
+function evidenceIds(evidence){return uniqueStrings((evidence??[]).map((record)=>record?.id));}
+function highestRisk(records){const max=Math.max(0,...records.map((record)=>riskRank[record.risk]??2));return Object.keys(riskRank).find((risk)=>riskRank[risk]===max)??'low';}
+function riskReadiness(risk){return risk==='high'||risk==='medium'?'needs-review':'ready-with-losses';}
+function hashChanged(before,after){return Boolean(before||after)&&(before??'')!==(after??'');}
+function queryList(value){if(value===undefined||value===null)return[];return Array.isArray(value)?value.map(String):[String(value)];}
+function compactRecord(value){return Object.fromEntries(Object.entries(value??{}).filter(([,entry])=>entry!==undefined));}