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

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

@@ -0,0 +1,240 @@
+import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+
+export const SemanticPatchBundleAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
+
+export function createSemanticPatchBundleRecord(input={},options={}){
+  const source=input?.changeSet??input;
+  const patch=options.patch??source.patch??source.semanticPatch??source.patchBundle;
+  const mergeCandidate=options.mergeCandidate??source.mergeCandidate??source.candidate;
+  const regionInputs=array(options.changedRegions??source.changedRegions??source.regions);
+  const sourceMapLinks=normalizeSourceMapLinks([
+    ...array(options.sourceMapLinks??source.sourceMapLinks),
+    ...regionInputs.flatMap((region)=>array(region?.metadata?.changedRegionProjection?.sourceMapLinks??region?.sourceMapLinks))
+  ]);
+  const changedRegions=normalizeRegions(regionInputs,{...source,sourceMapLinks});
+  const sources=normalizeSources([
+    ...array(options.sources??source.sources),
+    sourceRef(source.before,'before',source.beforeHash),
+    sourceRef(source.after,'after',source.afterHash)
+  ],source);
+  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence)];
+  const patchId=firstString(options.patchId,source.patchId,patch?.id,mergeCandidate?.patchId);
+  const mergeCandidateId=firstString(options.mergeCandidateId,source.mergeCandidateId,mergeCandidate?.id);
+  const baseHash=firstString(options.baseHash,source.baseHash,source.beforeHash,patch?.baseHash,mergeCandidate?.baseHash,...sources.map((item)=>item.baseHash));
+  const targetHash=firstString(options.targetHash,source.targetHash,source.afterHash,patch?.targetHash,mergeCandidate?.targetHash,...sources.map((item)=>item.targetHash));
+  const readiness=normalizeSemanticMergeReadiness(firstString(options.readiness,source.readiness,source.admission?.readiness,mergeCandidate?.readiness))
+    ?? firstString(options.readiness,source.readiness,source.admission?.readiness,mergeCandidate?.readiness,'needs-review');
+  const evidenceIds=uniqueStrings([...strings(options.evidenceIds),...strings(source.evidenceIds),...evidenceRecords.map((record)=>record?.id),...strings(mergeCandidate?.evidenceIds)]);
+  const proofIds=uniqueStrings([...strings(options.proofIds),...strings(source.proofIds),...evidenceRecords.filter((record)=>record?.kind==='proof').map((record)=>record.id),...strings(mergeCandidate?.proofIds)]);
+  const historyIds=uniqueStrings([...strings(options.historyIds),...strings(options.historyId),...strings(source.historyIds),...strings(source.historyId)]);
+  const conflictKeys=uniqueStrings([
+    ...strings(options.conflictKeys),
+    ...strings(source.conflictKeys),
+    ...strings(mergeCandidate?.conflictKeys),
+    ...changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),
+    ...(source.metadata?.semanticMergeConflictSummary?.conflictKeys??[])
+  ]);
+  const admission=normalizeAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate});
+  const id=options.id??(source.kind==='frontier.lang.semanticPatchBundleRecord'?source.id:undefined)
+    ??`semantic_patch_bundle_${idFragment(firstString(source.id,patchId,mergeCandidateId,source.sourcePath,source.language,'record'))}`;
+  const language=options.language??source.language??mergeCandidate?.language??sources.find((item)=>item.language)?.language;
+  const sourcePath=options.sourcePath??source.sourcePath??mergeCandidate?.sourcePath??sources.find((item)=>item.sourcePath)?.sourcePath;
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,patchId,mergeCandidateId,admission});
+  return{
+    kind:'frontier.lang.semanticPatchBundleRecord',
+    version:1,
+    schema:'frontier.lang.semanticPatchBundleRecord.v1',
+    id,
+    createdAt:options.createdAt??source.createdAt,
+    patchId,
+    mergeCandidateId,
+    language,
+    sourcePath,
+    baseHash,
+    targetHash,
+    sources,
+    changedRegions,
+    sourceMapLinks,
+    evidenceIds,
+    proofIds,
+    historyIds,
+    admission,
+    index,
+    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
+    metadata:compactRecord({
+      sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
+      patchRisk:patch?.risk,
+      nativeChangeSummary:source.summary,
+      changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary,
+      semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
+      ...options.metadata
+    })
+  };
+}
+
+export function querySemanticPatchBundleRecords(records,query={}){
+  return array(records).filter(Boolean).filter((record)=>matchesRecord(record,query)).sort((left,right)=>String(left.id).localeCompare(String(right.id)));
+}
+
+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);
+}
+
+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))
+  });
+}
+
+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)]),
+      admission:compactRecord({
+        readiness:projection?.admission?.readiness,
+        action:projection?.admission?.action,
+        reasonCodes:uniqueStrings(projection?.admission?.reasons),
+        conflictKeys:uniqueStrings(projection?.admission?.conflictKeys)
+      })
+    });
+  });
+}
+
+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 normalizeAdmission(input={},context){
+  const readiness=normalizeSemanticMergeReadiness(input.readiness??context.readiness)??input.readiness??context.readiness;
+  const status=input.status??admissionStatusForReadiness(readiness);
+  return compactRecord({
+    status,
+    readiness,
+    reviewRequired:input.reviewRequired??status!=='admitted',
+    autoMergeClaim:false,
+    reasonCodes:uniqueStrings([...strings(input.reasonCodes),...strings(context.source.reasons),...strings(context.mergeCandidate?.reasons)]),
+    conflictKeys:uniqueStrings([...strings(input.conflictKeys),...context.conflictKeys]),
+    admittedAt:input.admittedAt,
+    reviewerId:input.reviewerId,
+    evidenceIds:uniqueStrings(input.evidenceIds),
+    metadata:input.metadata
+  });
+}
+
+function recordIndex(parts){
+  return{
+    baseHashes:uniqueStrings([parts.baseHash,...parts.sources.map((item)=>item.baseHash)]),
+    targetHashes:uniqueStrings([parts.targetHash,...parts.sources.map((item)=>item.targetHash)]),
+    sourceHashes:uniqueStrings(parts.sources.map((item)=>item.sourceHash)),
+    sourcePaths:uniqueStrings(parts.sources.map((item)=>item.sourcePath)),
+    regionKeys:uniqueStrings(parts.changedRegions.map((region)=>region.key)),
+    regionKinds:uniqueStrings(parts.changedRegions.map((region)=>region.regionKind)),
+    conflictKeys:uniqueStrings(parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)])),
+    sourceMapIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapId),...parts.changedRegions.flatMap((region)=>region.sourceMapIds??[])]),
+    sourceMapMappingIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapMappingId),...parts.changedRegions.flatMap((region)=>region.sourceMapMappingIds??[])]),
+    sourceMapLinkIds:uniqueStrings(parts.sourceMapLinks.map((link)=>link.id)),
+    evidenceIds:parts.evidenceIds,
+    proofIds:parts.proofIds,
+    historyIds:parts.historyIds,
+    patchIds:uniqueStrings([parts.patchId]),
+    mergeCandidateIds:uniqueStrings([parts.mergeCandidateId]),
+    readinesses:uniqueStrings([parts.admission.readiness,...parts.changedRegions.map((region)=>region.admission?.readiness)]),
+    admissionStatuses:uniqueStrings([parts.admission.status])
+  };
+}
+
+function matchesRecord(record,query){
+  const index=record.index??recordIndex({...record,baseHash:record.baseHash,targetHash:record.targetHash,sources:record.sources??[],changedRegions:record.changedRegions??[],sourceMapLinks:record.sourceMapLinks??[],evidenceIds:record.evidenceIds??[],proofIds:record.proofIds??[],historyIds:record.historyIds??[],patchId:record.patchId,mergeCandidateId:record.mergeCandidateId,admission:record.admission??{}});
+  return matchAny(queryValues(query.id,query.ids),[record.id])
+    &&matchAny(queryValues(query.patchId,query.patchIds),index.patchIds)
+    &&matchAny(queryValues(query.mergeCandidateId,query.mergeCandidateIds),index.mergeCandidateIds)
+    &&matchAny(queryValues(query.sourcePath,query.sourcePaths),[record.sourcePath,...index.sourcePaths])
+    &&matchAny(queryValues(query.sourceHash,query.sourceHashes),index.sourceHashes)
+    &&matchAny(queryValues(query.baseHash,query.baseHashes),[record.baseHash,...index.baseHashes])
+    &&matchAny(queryValues(query.targetHash,query.targetHashes),[record.targetHash,...index.targetHashes])
+    &&matchAny(queryValues(query.regionKey,query.regionKeys),index.regionKeys)
+    &&matchAny(queryValues(query.regionKind,query.regionKinds),index.regionKinds)
+    &&matchAny(queryValues(query.conflictKey,query.conflictKeys),index.conflictKeys)
+    &&matchAny(queryValues(query.sourceMapId,query.sourceMapIds),index.sourceMapIds)
+    &&matchAny(queryValues(query.sourceMapMappingId,query.sourceMapMappingIds),index.sourceMapMappingIds)
+    &&matchAny(queryValues(query.sourceMapLinkId,query.sourceMapLinkIds),index.sourceMapLinkIds)
+    &&matchAny(queryValues(query.evidenceId,query.evidenceIds),index.evidenceIds)
+    &&matchAny(queryValues(query.proofId,query.proofIds),index.proofIds)
+    &&matchAny(queryValues(query.historyId,query.historyIds),index.historyIds)
+    &&matchAny(queryValues(query.readiness,query.readinesses),index.readinesses)
+    &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
+}
+
+function admissionStatusForReadiness(readiness){return readiness==='blocked'?'blocked':readiness==='needs-review'?'needs-review':'proposed';}
+function queryValues(...values){return uniqueStrings(values.flatMap((value)=>strings(value)));}
+function matchAny(filters,values){if(filters.length===0)return true;const valueSet=new Set(strings(values));return filters.some((filter)=>valueSet.has(filter));}
+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/semanticPredicateMatches.js

@@ -0,0 +1,4 @@
+export function semanticPredicateMatches(value, fragments) {
+  const predicate = String(value ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '');
+  return fragments.some((fragment) => predicate.includes(fragment));
+}

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

@@ -0,0 +1,8 @@
+export function semanticSliceAssertion(id, ok, summary, metadata = {}) {
+  return {
+    id,
+    status: ok ? 'passed' : 'failed',
+    summary,
+    metadata
+  };
+}

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

@@ -0,0 +1,24 @@
+import{semanticSliceImportResult}from'./semanticSliceImportResult.js';import{semanticSliceSourceHashMap}from'./semanticSliceSourceHashMap.js';import{semanticSliceSourceTextMap}from'./semanticSliceSourceTextMap.js';
+export function semanticSliceContext(input, options = {}) {
+  const value = input?.importResult ?? input?.import ?? input?.source ?? input;
+  const imported = semanticSliceImportResult(value, options);
+  const universalAst = imported?.universalAst ?? (value?.kind === 'frontier.lang.universalAst' ? value : value?.universalAst);
+  const sidecar = value?.kind === 'frontier.lang.semanticImportSidecar' ? value : input?.sidecar ?? options.sidecar;
+  const nativeSource = imported?.nativeSource ?? universalAst?.nativeSources?.[0];
+  const nativeAst = imported?.nativeAst ?? nativeSource?.ast;
+  const semanticIndex = imported?.semanticIndex ?? universalAst?.semanticIndex;
+  const language = options.language ?? imported?.language ?? universalAst?.metadata?.sourceLanguage ?? nativeSource?.language ?? sidecar?.language;
+  const sourcePath = options.sourcePath ?? imported?.sourcePath ?? universalAst?.metadata?.sourcePath ?? nativeSource?.sourcePath ?? semanticIndex?.documents?.[0]?.path;
+  return {
+    importResult: imported,
+    universalAst,
+    sidecar,
+    nativeSource,
+    nativeAst,
+    semanticIndex,
+    language,
+    sourcePath,
+    sourceTexts: semanticSliceSourceTextMap(imported, universalAst, value, options),
+    sourceHashes: semanticSliceSourceHashMap(imported, universalAst, value, options)
+  };
+}

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

@@ -0,0 +1,4 @@
+export function semanticSliceCurrentSource(currentSources, path) {
+  if (currentSources instanceof Map) return currentSources.get(path);
+  return currentSources[path] ?? currentSources[`./${path}`];
+}

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

@@ -0,0 +1,8 @@
+export function semanticSliceExpectedAssertions(selection, unresolvedEntryRefs) {
+  return [
+    { id: 'entryRefsResolved', expected: unresolvedEntryRefs.length === 0 },
+    { id: 'nonEmptySelection', expected: selection.symbols.length + selection.regions.length + selection.nativeNodes.length > 0 },
+    { id: 'sourceMapLinks', expected: selection.mappings.length > 0 },
+    { id: 'conflictKeys', expected: true }
+  ];
+}

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

@@ -0,0 +1,30 @@
+import{idFragment}from'../../native-import-utils.js';
+import{importNativeSource}from'./importNativeSource.js';
+export function semanticSliceImportResult(value, options = {}) {
+  if (!value) return undefined;
+  if (value.kind === 'frontier.lang.importResult') return value;
+  if (value.kind === 'frontier.lang.universalAst') {
+    const nativeSource = value.nativeSources?.[0];
+    return {
+      kind: 'frontier.lang.importResult',
+      version: 1,
+      id: value.metadata?.nativeImportId ?? `import_${idFragment(value.id)}`,
+      language: value.metadata?.sourceLanguage ?? nativeSource?.language ?? options.language,
+      sourcePath: value.metadata?.sourcePath ?? nativeSource?.sourcePath ?? options.sourcePath,
+      document: value.document,
+      nativeSource,
+      nativeAst: nativeSource?.ast,
+      semanticIndex: value.semanticIndex,
+      universalAst: value,
+      sourceMaps: value.sourceMaps ?? [],
+      losses: value.losses ?? [],
+      evidence: value.evidence ?? [],
+      mergeCandidates: value.mergeCandidates ?? [],
+      metadata: value.metadata ?? {}
+    };
+  }
+  if (value.kind === 'frontier.lang.semanticImportSidecar') return undefined;
+  if (value.universalAst || value.semanticIndex || value.nativeSource || value.nativeAst) return value;
+  if (value.sourceText || value.nodes || value.nativeAst) return importNativeSource(value);
+  return undefined;
+}

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

@@ -0,0 +1,15 @@
+import{normalizeSemanticSliceRef}from'./normalizeSemanticSliceRef.js';import{semanticSliceValueMatches}from'./semanticSliceValueMatches.js';
+export function semanticSliceMappingMatchesRef(mapping, ref) {
+  const pathRef = normalizeSemanticSliceRef(ref, 'path');
+  const normalized = normalizeSemanticSliceRef(ref, 'mapping');
+  return [
+    mapping.id,
+    mapping.semanticSymbolId,
+    mapping.semanticOccurrenceId,
+    mapping.semanticNodeId,
+    mapping.nativeAstNodeId,
+    mapping.ownershipRegionId,
+    mapping.ownershipRegionKey
+  ].filter(Boolean).some((value) => semanticSliceValueMatches(value, normalized))
+    || semanticSliceValueMatches(mapping.sourceSpan?.path ?? mapping.sourceMapSourcePath, pathRef);
+}

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

@@ -0,0 +1,7 @@
+export function semanticSliceMappingTouchesSets(mapping, selection) {
+  return selection.selectedMappings.has(mapping.id)
+    || selection.selectedSymbols.has(mapping.semanticSymbolId)
+    || selection.selectedNativeNodes.has(mapping.nativeAstNodeId)
+    || selection.selectedRegions.has(mapping.ownershipRegionId)
+    || selection.selectedRegions.has(mapping.ownershipRegionKey);
+}

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

@@ -0,0 +1,12 @@
+import{normalizeSemanticSliceRef}from'./normalizeSemanticSliceRef.js';import{semanticSliceValueMatches}from'./semanticSliceValueMatches.js';
+export function semanticSliceNativeNodeMatchesRef(node, ref) {
+  const normalized = normalizeSemanticSliceRef(ref, 'native');
+  return [
+    node.id,
+    node.nodeId,
+    node.name,
+    node.symbolId,
+    node.kind,
+    node.languageKind
+  ].filter(Boolean).some((value) => semanticSliceValueMatches(value, normalized));
+}

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

@@ -0,0 +1,7 @@
+export function semanticSliceNativeParentMap(nativeNodes) {
+  const parents = new Map();
+  for (const node of nativeNodes ?? []) {
+    for (const child of node.children ?? []) parents.set(child, node.id);
+  }
+  return parents;
+}

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

@@ -0,0 +1,14 @@
+import{maxSemanticMergeReadiness}from'../../native-import-utils.js';
+import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function semanticSliceReadiness(context, selection, unresolvedEntryRefs) {
+  if (unresolvedEntryRefs.length) return 'blocked';
+  if (selection.symbols.length + selection.regions.length + selection.nativeNodes.length === 0) return 'blocked';
+  const lossReadiness = summarizeNativeImportLosses(selection.losses, { evidence: context.importResult?.evidence }).semanticMergeReadiness;
+  return [
+    context.importResult?.metadata?.semanticMergeReadiness,
+    context.importResult?.metadata?.nativeImportLossSummary?.semanticMergeReadiness,
+    context.sidecar?.summary?.readiness,
+    ...(context.importResult?.mergeCandidates ?? []).map((candidate) => candidate.readiness),
+    lossReadiness
+  ].reduce((current, value) => maxSemanticMergeReadiness(current, value ?? 'ready'), 'ready');
+}

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

@@ -0,0 +1,11 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+export function semanticSliceReasons(context, selection, unresolvedEntryRefs, readiness) {
+  return uniqueStrings([
+    unresolvedEntryRefs.length ? `Unresolved semantic slice entry refs: ${unresolvedEntryRefs.join(', ')}` : undefined,
+    selection.symbols.length + selection.regions.length + selection.nativeNodes.length === 0 ? 'Semantic slice selected no reviewable records.' : undefined,
+    selection.mappings.length === 0 ? 'Semantic slice has no source-map links; source review may need file-level fallback.' : undefined,
+    selection.losses.length ? `Semantic slice carries ${selection.losses.length} native import loss record(s).` : undefined,
+    readiness !== 'ready' ? `Semantic slice readiness is ${readiness}.` : undefined,
+    context.importResult?.metadata?.nativeImportLossSummary?.semanticMergeReadiness === 'needs-review' ? 'Parent native import requires review.' : undefined
+  ].filter(Boolean));
+}

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

@@ -0,0 +1,62 @@
+import{uniqueByEvidenceId,uniqueByLossId,uniqueRecordsById}from'../../native-import-utils.js';
+import{mergeSemanticSliceSymbols}from'./mergeSemanticSliceSymbols.js';import{nativeAstNodes}from'./nativeAstNodes.js';import{nativeImportEntries}from'./nativeImportEntries.js';import{semanticSliceRegionFromMapping}from'./semanticSliceRegionFromMapping.js';import{semanticSliceRegionFromSymbol}from'./semanticSliceRegionFromSymbol.js';import{uniqueSemanticSliceNativeNodes}from'./uniqueSemanticSliceNativeNodes.js';import{uniqueSemanticSliceRegions}from'./uniqueSemanticSliceRegions.js';
+export function semanticSliceRecords(context, sidecar) {
+  const imports = context.importResult ? nativeImportEntries(context.importResult) : [];
+  const universalAst = context.universalAst;
+  const semanticIndexes = [
+    context.semanticIndex,
+    universalAst?.semanticIndex,
+    ...imports.map((imported) => imported?.semanticIndex ?? imported?.universalAst?.semanticIndex)
+  ].filter(Boolean);
+  const sourceMaps = uniqueRecordsById([
+    ...(context.importResult?.sourceMaps ?? []),
+    ...(universalAst?.sourceMaps ?? []),
+    ...imports.flatMap((imported) => imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? [])
+  ]);
+  const symbols = mergeSemanticSliceSymbols([
+    ...(sidecar?.symbols ?? []),
+    ...semanticIndexes.flatMap((index) => index.symbols ?? [])
+  ]);
+  const regions = uniqueSemanticSliceRegions([
+    ...(sidecar?.ownershipRegions ?? []),
+    ...symbols.map((symbol) => semanticSliceRegionFromSymbol(symbol, context)).filter(Boolean),
+    ...sourceMaps.flatMap((sourceMap) => (sourceMap.mappings ?? []).map((mapping) => semanticSliceRegionFromMapping(mapping, context)).filter(Boolean))
+  ]);
+  const nativeNodes = uniqueSemanticSliceNativeNodes([
+    ...imports.flatMap((imported) => nativeAstNodes(imported?.nativeAst ?? imported?.nativeSource?.ast)),
+    ...nativeAstNodes(context.nativeAst),
+    ...((universalAst?.nativeSources ?? []).flatMap((source) => nativeAstNodes(source?.ast)))
+  ]);
+  const mappings = sourceMaps.flatMap((sourceMap) => (sourceMap.mappings ?? []).map((mapping) => ({
+    ...mapping,
+    sourceMapId: mapping.sourceMapId ?? sourceMap.id,
+    sourceMapSourcePath: sourceMap.sourcePath,
+    sourceMapSourceHash: sourceMap.sourceHash,
+    sourceMapTargetPath: sourceMap.targetPath,
+    sourceMapTargetHash: sourceMap.targetHash
+  })));
+  const losses = uniqueByLossId([
+    ...(context.importResult?.losses ?? []),
+    ...(universalAst?.losses ?? []),
+    ...imports.flatMap((imported) => imported?.losses ?? imported?.nativeAst?.losses ?? [])
+  ]);
+  const evidence = uniqueByEvidenceId([
+    ...(context.importResult?.evidence ?? []),
+    ...(universalAst?.evidence ?? []),
+    ...imports.flatMap((imported) => imported?.evidence ?? [])
+  ]);
+  return {
+    symbols,
+    symbolById: new Map(symbols.map((symbol) => [symbol.id, symbol])),
+    regions,
+    nativeNodes,
+    nativeNodeById: new Map(nativeNodes.map((node) => [node.id, node])),
+    mappings,
+    sourceMaps,
+    relations: uniqueRecordsById(semanticIndexes.flatMap((index) => index.relations ?? [])),
+    occurrences: uniqueRecordsById(semanticIndexes.flatMap((index) => index.occurrences ?? [])),
+    losses,
+    evidence,
+    sidecar
+  };
+}

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

@@ -0,0 +1,16 @@
+export function semanticSliceRegionFromMapping(mapping, context) {
+  if (!mapping.ownershipRegionId && !mapping.ownershipRegionKey) return undefined;
+  return {
+    id: mapping.ownershipRegionId,
+    key: mapping.ownershipRegionKey,
+    regionKind: mapping.ownershipRegionKind,
+    granularity: 'source-map',
+    language: context.language,
+    sourcePath: mapping.sourceSpan?.path ?? context.sourcePath,
+    sourceSpan: mapping.sourceSpan,
+    symbolId: mapping.semanticSymbolId,
+    nativeAstNodeId: mapping.nativeAstNodeId,
+    precision: mapping.precision,
+    mergePolicy: 'source-map-region-review'
+  };
+}

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

@@ -0,0 +1,21 @@
+import{semanticSliceSymbolSpan}from'./semanticSliceSymbolSpan.js';
+export function semanticSliceRegionFromSymbol(symbol, context) {
+  const regionId = symbol.ownershipRegionId ?? symbol.metadata?.ownershipRegionId;
+  const regionKey = symbol.ownershipKey ?? symbol.metadata?.ownershipRegionKey;
+  if (!regionId && !regionKey) return undefined;
+  return {
+    id: regionId,
+    key: regionKey,
+    regionKind: symbol.ownershipRegionKind ?? symbol.metadata?.ownershipRegionKind ?? symbol.kind,
+    granularity: 'symbol',
+    language: symbol.language ?? context.language,
+    sourcePath: semanticSliceSymbolSpan(symbol)?.path ?? context.sourcePath,
+    sourceSpan: semanticSliceSymbolSpan(symbol),
+    symbolId: symbol.id,
+    symbolName: symbol.name,
+    symbolKind: symbol.kind,
+    nativeAstNodeId: symbol.nativeAstNodeId,
+    precision: 'symbol',
+    mergePolicy: 'semantic-region-review'
+  };
+}

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

@@ -0,0 +1,12 @@
+import{normalizeSemanticSliceRef}from'./normalizeSemanticSliceRef.js';import{semanticSliceValueMatches}from'./semanticSliceValueMatches.js';
+export function semanticSliceRegionMatchesRef(region, ref) {
+  const normalized = normalizeSemanticSliceRef(ref, 'region');
+  return [
+    region.id,
+    region.key,
+    region.symbolId,
+    region.symbolName,
+    region.nativeAstNodeId,
+    region.sourcePath
+  ].filter(Boolean).some((value) => semanticSliceValueMatches(value, normalized));
+}

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

@@ -0,0 +1,6 @@
+export function semanticSliceRegionTouchesSets(region, selection) {
+  return selection.selectedRegions.has(region.id)
+    || selection.selectedRegions.has(region.key)
+    || selection.selectedSymbols.has(region.symbolId)
+    || selection.selectedNativeNodes.has(region.nativeAstNodeId);
+}

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

@@ -0,0 +1,35 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{sourceTextForSpan}from'./sourceTextForSpan.js';
+export function semanticSliceSourceFiles(spans, context, options = {}) {
+  const byPath = new Map();
+  const includeExcerpts = options.includeSourceText !== false;
+  const maxExcerptBytes = Number.isFinite(options.maxExcerptBytes) ? Math.max(0, Math.floor(options.maxExcerptBytes)) : 4000;
+  for (const span of spans) {
+    const path = span.path ?? span.sourceId ?? context.sourcePath ?? 'unknown';
+    const record = byPath.get(path) ?? {
+      path,
+      sourceHash: context.sourceHashes.get(path) ?? context.sourceHashes.get('') ?? span.sourceHash,
+      spans: [],
+      excerpts: []
+    };
+    record.spans.push(span);
+    const sourceText = context.sourceTexts.get(path) ?? context.sourceTexts.get('');
+    const excerpt = includeExcerpts ? sourceTextForSpan(sourceText, span) : undefined;
+    if (typeof excerpt === 'string') {
+      const clipped = excerpt.length > maxExcerptBytes ? excerpt.slice(0, maxExcerptBytes) : excerpt;
+      record.excerpts.push({
+        span,
+        text: clipped,
+        textHash: hashSemanticValue(excerpt),
+        truncated: clipped.length !== excerpt.length
+      });
+    }
+    byPath.set(path, record);
+  }
+  return [...byPath.values()].map((file) => ({
+    ...file,
+    spanCount: file.spans.length,
+    excerptCount: file.excerpts.length,
+    sourceTextAvailable: file.excerpts.length > 0
+  }));
+}

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

@@ -0,0 +1,27 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{semanticSliceCurrentSource}from'./semanticSliceCurrentSource.js';
+export function semanticSliceSourceHashAssertions(slice, currentSources) {
+  if (!currentSources) return [];
+  const assertions = [];
+  for (const file of slice?.sourceFiles ?? []) {
+    if (!file.sourceHash || !file.path) continue;
+    const currentSource = semanticSliceCurrentSource(currentSources, file.path);
+    if (typeof currentSource !== 'string') {
+      assertions.push({
+        id: `sourceHash:${file.path}`,
+        status: 'warning',
+        summary: `Current source text was not supplied for ${file.path}.`,
+        metadata: { path: file.path, expectedSourceHash: file.sourceHash }
+      });
+      continue;
+    }
+    const actualSourceHash = hashSemanticValue(currentSource);
+    assertions.push({
+      id: `sourceHash:${file.path}`,
+      status: actualSourceHash === file.sourceHash ? 'passed' : 'failed',
+      summary: actualSourceHash === file.sourceHash ? `Source hash matched for ${file.path}.` : `Source hash changed for ${file.path}.`,
+      metadata: { path: file.path, expectedSourceHash: file.sourceHash, actualSourceHash }
+    });
+  }
+  return assertions;
+}

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

@@ -0,0 +1,18 @@
+import{nativeImportEntries}from'./nativeImportEntries.js';
+export function semanticSliceSourceHashMap(imported, universalAst, value, options) {
+  const entries = new Map();
+  const add = (path, sourceHash) => {
+    if (!sourceHash) return;
+    entries.set(path ?? '', sourceHash);
+  };
+  add(options.sourcePath, options.sourceHash);
+  add(value?.sourcePath, value?.sourceHash);
+  for (const item of [imported, ...(imported ? nativeImportEntries(imported) : [])]) {
+    add(item?.sourcePath, item?.nativeSource?.sourceHash ?? item?.nativeAst?.sourceHash ?? item?.sourceHash);
+  }
+  for (const nativeSource of universalAst?.nativeSources ?? []) {
+    add(nativeSource?.sourcePath, nativeSource?.sourceHash ?? nativeSource?.ast?.sourceHash);
+  }
+  for (const sourceMap of universalAst?.sourceMaps ?? []) add(sourceMap.sourcePath, sourceMap.sourceHash);
+  return entries;
+}

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

@@ -0,0 +1,21 @@
+export function semanticSliceSourceMapLinks(selection) {
+  return selection.mappings.map((mapping) => ({
+    id: mapping.id,
+    sourceMapId: mapping.sourceMapId,
+    sourcePath: mapping.sourceSpan?.path ?? mapping.sourceMapSourcePath,
+    sourceHash: mapping.sourceMapSourceHash,
+    targetPath: mapping.generatedSpan?.targetPath ?? mapping.sourceMapTargetPath,
+    targetHash: mapping.generatedSpan?.targetHash ?? mapping.sourceMapTargetHash,
+    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
+  }));
+}

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

@@ -0,0 +1,9 @@
+import{semanticSliceSymbolSpan}from'./semanticSliceSymbolSpan.js';import{uniqueSemanticSliceSpans}from'./uniqueSemanticSliceSpans.js';
+export function semanticSliceSourceSpans(selection) {
+  return uniqueSemanticSliceSpans([
+    ...selection.symbols.map(semanticSliceSymbolSpan),
+    ...selection.regions.map((region) => region.sourceSpan),
+    ...selection.nativeNodes.map((node) => node.span ?? node.sourceSpan),
+    ...selection.mappings.map((mapping) => mapping.sourceSpan)
+  ].filter(Boolean));
+}