@shapeshift-labs/frontier-lang-compiler 0.2.64 → 0.2.66

package/README.md

@@ -36,17 +36,19 @@ npm run build
 node examples/native-js-to-rust-demo.mjs
 ```
 
-Run the interactive Frontier-style workbench with editable TypeScript and Rust panes:
+Run the interactive Frontier-style workbench with a submitted TypeScript source pane,
+Frontier graph/JSON pane, and independent Rust/Python projection panes:
 
 ```sh
 npm run demo:ts-rust -- --port 4177
 ```
 
 The workbench converts only when `Run` is pressed. TypeScript edits project through
-the Frontier semantic graph into Rust scaffolding; Rust edits project back through
-the graph into TypeScript scaffolding. The middle pane shows symbols, relations,
-source maps, readiness, losses, patch hints, and the explicit supported/review-only/
-unsupported bounds for the current direction.
+the Frontier semantic graph into Rust and Python scaffolding. The middle pane shows
+symbols, relations, source maps, readiness, losses, patch hints, and the explicit
+supported/review-only/unsupported bounds for the projection. Run
+`npm run demo:ts-rust:smoke` to verify the conversion output and layout scaffold
+without starting the server.
 
 The demo prints JavaScript source, the Frontier universal AST/semantic-index summary,
 Rust declaration stubs, a host-adapter Rust projection, and a direct Frontier-source
@@ -117,11 +119,12 @@ const importedIndex = importExternalSemanticIndex({
 });
 
 console.log(importedIndex.semanticIndex.symbols.length);
+console.log(importedIndex.ownershipRegions[0]?.key);
 console.log(importedIndex.summary.sourceMapMappings);
 console.log(importedIndex.readiness.readiness); // "ready-with-losses" or review-required
 ```
 
-External semantic-index imports create Frontier `SemanticIndexRecord`, `SourceMapRecord`, evidence, losses, ownership facts, and a universal AST envelope. They are a bridge from existing language servers/indexers into semantic merge tooling; they do not claim full parser AST coverage, macro expansion, type checking, comments/trivia preservation, or lossless cross-language code generation by themselves.
+External semantic-index imports create Frontier `SemanticIndexRecord`, `SourceMapRecord`, evidence, losses, ownership facts, first-class `ownershipRegions`, and a universal AST envelope. They are a bridge from existing language servers/indexers into semantic merge tooling; they do not claim full parser AST coverage, macro expansion, type checking, comments/trivia preservation, or lossless cross-language code generation by themselves.
 
 Native imports include source maps, semantic merge candidates, and a loss summary for admission queues and dashboards. Informational losses produce `ready-with-losses`, warning losses produce `needs-review`, and error losses or failed import evidence produce `blocked`:
 
@@ -137,6 +140,28 @@ console.log(readiness.readiness);
 
 The loss taxonomy separates broad scanner limits from specific round-trip risks such as conditional compilation, reflection, overload/type-inference gaps, comments/trivia preservation, source-map approximation, parser diagnostics, and target projection loss. These records are evidence labels for merge admission; they are not claims that the lightweight scanner expanded macros, evaluated inactive branches, resolved overloads, or ran a type checker.
 
+Semantic merge candidates also expose compiler-normalized admission records for coordinator queues:
+
+```js
+import {
+  createSemanticMergeCandidateAdmissionRecord,
+  querySemanticMergeCandidateAdmissionOverlaps,
+  sortSemanticMergeCandidateAdmissionRecords
+} from '@shapeshift-labs/frontier-lang-compiler';
+
+const record = createSemanticMergeCandidateAdmissionRecord(changeSet);
+
+console.log(record.changedSemanticRegions);
+console.log(record.sourceHashes.baseHash, record.sourceHashes.targetHash);
+console.log(record.conflictKeys, record.evidenceIds);
+console.log(record.projectionRisk, record.readiness, record.readinessSortKey);
+
+const queue = sortSemanticMergeCandidateAdmissionRecords([record, otherRecord]);
+const overlaps = querySemanticMergeCandidateAdmissionOverlaps(queue);
+```
+
+These candidate records are compact merge-admission evidence. They preserve changed semantic regions, source/base/target hashes, conflict keys, evidence IDs, projection risk, readiness, and overlap pairs so swarm coordinators can sort likely-ready candidates first and detect conflicting regions before patch review.
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js

package/dist/declarations/import-adapter-core.d.ts

@@ -154,6 +154,8 @@ export interface ExternalSemanticIndexImportSummary {
   readonly occurrences: number;
   readonly relations: number;
   readonly facts: number;
+  readonly ownershipRegions: number;
+  readonly ownershipRegionKinds: readonly string[];
   readonly sourceMapMappings: number;
   readonly losses: number;
   readonly readiness: SemanticMergeReadiness;
@@ -170,6 +172,7 @@ export interface ExternalSemanticIndexImportResult {
   readonly semanticIndex: SemanticIndexRecord;
   readonly universalAst: FrontierUniversalAstEnvelope;
   readonly sourceMaps: readonly SourceMapRecord[];
+  readonly ownershipRegions: readonly SemanticImportOwnershipRegion[];
   readonly losses: readonly NativeAstLossRecord[];
   readonly evidence: readonly EvidenceRecord[];
   readonly readiness: NativeImportReadinessClassification;

package/dist/declarations/native-project-admission.d.ts

@@ -2,6 +2,7 @@ import type { FrontierSourceLanguage, SemanticMergeReadiness } from '@shapeshift
 import type { NativeImportLossSummary } from './native-import-losses.js';
 import type { NativeImportResultContract } from './native-import-contracts.js';
 import type { NativeProjectImportResult } from './native-project.js';
+import type { SemanticMergeCandidateAdmissionRecord, SemanticMergeCandidateOverlapRecord, SemanticMergeCandidateProjectionRisk } from './semantic-merge-candidates.js';
 
 export type NativeProjectImportAdmissionAction = 'admit' | 'prioritize' | 'reject';
 export type NativeProjectImportAdmissionPriority = 'low' | 'normal' | 'high' | 'critical' | 'blocker';
@@ -78,10 +79,27 @@ export interface NativeProjectAdmissionMergeCandidates {
   readonly highestRisk: NativeProjectImportAdmissionRisk;
   readonly byRisk: Readonly<Record<string, number>>;
   readonly byReadiness: Readonly<Record<string, number>>;
+  readonly byProjectionRisk: Readonly<Record<string, number>>;
   readonly highRiskCandidateIds: readonly string[];
   readonly reviewCandidateIds: readonly string[];
   readonly blockedCandidateIds: readonly string[];
+  readonly highProjectionRiskCandidateIds: readonly string[];
   readonly conflictKeys: readonly string[];
+  readonly readinessOrderCandidateIds: readonly string[];
+  readonly changedSemanticRegions: {
+    readonly total: number;
+    readonly byKind: Readonly<Record<string, number>>;
+    readonly conflictKeys: readonly string[];
+  };
+  readonly overlaps: {
+    readonly total: number;
+    readonly candidateIds: readonly string[];
+    readonly conflictKeys: readonly string[];
+    readonly sourcePaths: readonly string[];
+    readonly pairs: readonly SemanticMergeCandidateOverlapRecord[];
+  };
+  readonly records: readonly SemanticMergeCandidateAdmissionRecord[];
+  readonly projectionRisk?: SemanticMergeCandidateProjectionRisk;
   readonly patchRisk?: NativeProjectImportAdmissionRisk;
 }
 

package/dist/declarations/semantic-merge-candidates.d.ts

@@ -0,0 +1,200 @@
+import type {
+  EvidenceRecord,
+  FrontierSourceLanguage,
+  SemanticMergeCandidateRecord,
+  SemanticMergeReadiness,
+  SourceSpan
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticMergeConflictSummary } from './semantic-merge-conflicts.js';
+
+export type SemanticMergeCandidateProjectionRisk = 'low' | 'medium' | 'high' | 'unknown';
+
+export interface SemanticMergeCandidateChangedRegion {
+  readonly id?: string;
+  readonly key?: string;
+  readonly conflictKey?: string;
+  readonly changeKind?: NativeSourceChangeKind | string;
+  readonly regionKind?: string;
+  readonly granularity?: string;
+  readonly precision?: string;
+  readonly projectionRisk?: SemanticMergeCandidateProjectionRisk;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly symbolKind?: string;
+  readonly semanticNodeId?: string;
+  readonly nativeAstNodeId?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly sourceMapLinkIds?: readonly string[];
+  readonly sourceMapIds?: readonly string[];
+  readonly sourceMapMappingIds?: readonly string[];
+  readonly admission?: {
+    readonly readiness?: SemanticMergeReadiness | string;
+    readonly action?: string;
+    readonly reasonCodes?: readonly string[];
+    readonly conflictKeys?: readonly string[];
+  };
+}
+
+export interface SemanticMergeCandidateOverlapRecord {
+  readonly schema: 'frontier.lang.semanticMergeCandidateOverlap.v1';
+  readonly id: string;
+  readonly overlapKind: 'conflict-key' | 'region-key' | 'source-span' | string;
+  readonly risk: 'medium' | 'high' | string;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly recordIds: readonly string[];
+  readonly candidateIds: readonly string[];
+  readonly regionIds: readonly string[];
+  readonly regionKeys: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly sourcePath?: string;
+  readonly leftRegion: Partial<SemanticMergeCandidateChangedRegion>;
+  readonly rightRegion: Partial<SemanticMergeCandidateChangedRegion>;
+}
+
+export interface SemanticMergeCandidateAdmissionRecord {
+  readonly kind: 'frontier.lang.semanticMergeCandidateAdmissionRecord';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.semanticMergeCandidateAdmissionRecord.v1';
+  readonly id: string;
+  readonly candidateId?: string;
+  readonly importResultId?: string;
+  readonly patchId?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly readinessSortKey: number;
+  readonly projectionRisk: SemanticMergeCandidateProjectionRisk;
+  readonly sourceHashes: {
+    readonly baseHash?: string;
+    readonly targetHash?: string;
+    readonly values: readonly string[];
+  };
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly changedSemanticRegions: readonly SemanticMergeCandidateChangedRegion[];
+  readonly conflictKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly overlapSummary: {
+    readonly total: number;
+    readonly hasOverlaps: boolean;
+    readonly byKind: Readonly<Record<string, number>>;
+    readonly conflictKeys: readonly string[];
+    readonly pairs: readonly SemanticMergeCandidateOverlapRecord[];
+  };
+  readonly admission: {
+    readonly readiness: SemanticMergeReadiness | string;
+    readonly reviewRequired: boolean;
+    readonly action: 'admit' | 'prioritize-review' | 'block' | string;
+    readonly sortKey: number;
+    readonly reasonCodes: readonly string[];
+    readonly conflictKeys: readonly string[];
+  };
+  readonly index: {
+    readonly candidateIds: readonly string[];
+    readonly importResultIds: readonly string[];
+    readonly patchIds: readonly string[];
+    readonly sourcePaths: readonly string[];
+    readonly sourceHashes: readonly string[];
+    readonly baseHashes: readonly string[];
+    readonly targetHashes: readonly string[];
+    readonly regionIds: readonly string[];
+    readonly regionKeys: readonly string[];
+    readonly regionKinds: readonly string[];
+    readonly conflictKeys: readonly string[];
+    readonly evidenceIds: readonly string[];
+    readonly proofIds: readonly string[];
+    readonly readinesses: readonly string[];
+    readonly projectionRisks: readonly string[];
+  };
+  readonly summary: {
+    readonly changedSemanticRegions: number;
+    readonly conflictKeys: number;
+    readonly evidenceIds: number;
+    readonly proofIds: number;
+    readonly overlaps: number;
+    readonly readiness: SemanticMergeReadiness | string;
+    readonly projectionRisk: SemanticMergeCandidateProjectionRisk;
+    readonly reviewRequired: boolean;
+  };
+  readonly metadata?: Record<string, unknown> & {
+    readonly conflictSummary?: SemanticMergeConflictSummary;
+  };
+}
+
+export type SemanticMergeCandidateAdmissionInput =
+  | NativeSourceChangeSet
+  | SemanticMergeCandidateRecord
+  | SemanticMergeCandidateAdmissionRecord
+  | Record<string, unknown>;
+
+export interface CreateSemanticMergeCandidateAdmissionRecordOptions {
+  readonly id?: string;
+  readonly changeSet?: NativeSourceChangeSet;
+  readonly candidate?: SemanticMergeCandidateRecord | Record<string, unknown>;
+  readonly patch?: unknown;
+  readonly candidateId?: string;
+  readonly importResultId?: string;
+  readonly patchId?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceHashes?: readonly string[] | string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly readiness?: SemanticMergeReadiness | string;
+  readonly projectionRisk?: SemanticMergeCandidateProjectionRisk | string;
+  readonly changedRegions?: readonly unknown[] | unknown;
+  readonly conflictKeys?: readonly string[] | string;
+  readonly evidence?: readonly EvidenceRecord[] | EvidenceRecord;
+  readonly evidenceIds?: readonly string[] | string;
+  readonly proofIds?: readonly string[] | string;
+  readonly reasonCodes?: readonly string[] | string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export type SemanticMergeCandidateWithAdmission = SemanticMergeCandidateRecord & {
+  readonly changedSemanticRegions?: readonly SemanticMergeCandidateChangedRegion[];
+  readonly sourceHashes?: SemanticMergeCandidateAdmissionRecord['sourceHashes'];
+  readonly evidenceIds?: readonly string[];
+  readonly proofIds?: readonly string[];
+  readonly projectionRisk?: SemanticMergeCandidateProjectionRisk;
+  readonly readinessSortKey?: number;
+  readonly mergeAdmission?: SemanticMergeCandidateAdmissionRecord;
+};
+
+export interface SemanticMergeCandidateAdmissionOverlapQuery {
+  readonly id?: string | readonly string[];
+  readonly ids?: readonly string[];
+  readonly candidateId?: string | readonly string[];
+  readonly candidateIds?: readonly string[];
+  readonly recordId?: string | readonly string[];
+  readonly recordIds?: readonly string[];
+  readonly regionId?: string | readonly string[];
+  readonly regionIds?: readonly string[];
+  readonly regionKey?: string | readonly string[];
+  readonly regionKeys?: readonly string[];
+  readonly conflictKey?: string | readonly string[];
+  readonly conflictKeys?: readonly string[];
+  readonly sourcePath?: string | readonly string[];
+  readonly sourcePaths?: readonly string[];
+  readonly overlapKind?: string | readonly string[];
+  readonly overlapKinds?: readonly string[];
+  readonly readiness?: SemanticMergeReadiness | string | readonly string[];
+  readonly readinesses?: readonly string[];
+  readonly risk?: string | readonly string[];
+  readonly risks?: readonly string[];
+}
+
+export declare const SemanticMergeCandidateProjectionRisks: readonly SemanticMergeCandidateProjectionRisk[];
+export declare function createSemanticMergeCandidateAdmissionRecord(input?: SemanticMergeCandidateAdmissionInput, options?: CreateSemanticMergeCandidateAdmissionRecordOptions): SemanticMergeCandidateAdmissionRecord;
+export declare function decorateSemanticMergeCandidateForAdmission<T extends SemanticMergeCandidateRecord | Record<string, unknown>>(input?: T, options?: CreateSemanticMergeCandidateAdmissionRecordOptions): T & SemanticMergeCandidateWithAdmission;
+export declare function querySemanticMergeCandidateAdmissionOverlaps(records: SemanticMergeCandidateAdmissionInput | readonly SemanticMergeCandidateAdmissionInput[], query?: SemanticMergeCandidateAdmissionOverlapQuery): readonly SemanticMergeCandidateOverlapRecord[];
+export declare function semanticMergeCandidateReadinessSortKey(candidateOrRecord: Partial<SemanticMergeCandidateAdmissionRecord> | Partial<SemanticMergeCandidateWithAdmission>): number;
+export declare function sortSemanticMergeCandidateAdmissionRecords<T extends SemanticMergeCandidateAdmissionInput>(records: readonly T[], options?: { readonly desc?: boolean }): readonly SemanticMergeCandidateAdmissionRecord[];

package/dist/declarations/semantic-merge-conflicts.d.ts

@@ -3,6 +3,11 @@ import type {
   SemanticMergeCandidateRecord,
   SemanticMergeReadiness
 } from '@shapeshift-labs/frontier-lang-kernel';
+import type {
+  SemanticMergeCandidateAdmissionRecord,
+  SemanticMergeCandidateChangedRegion,
+  SemanticMergeCandidateProjectionRisk
+} from './semantic-merge-candidates.js';
 
 export type SemanticMergeConflictClass =
   | 'same-symbol-edit'
@@ -45,6 +50,13 @@ export interface SemanticMergeConflictSummary {
 }
 
 export type SemanticMergeCandidateWithConflicts = SemanticMergeCandidateRecord & {
+  readonly changedSemanticRegions?: readonly SemanticMergeCandidateChangedRegion[];
+  readonly sourceHashes?: SemanticMergeCandidateAdmissionRecord['sourceHashes'];
+  readonly evidenceIds?: readonly string[];
+  readonly proofIds?: readonly string[];
+  readonly projectionRisk?: SemanticMergeCandidateProjectionRisk;
+  readonly readinessSortKey?: number;
+  readonly mergeAdmission?: SemanticMergeCandidateAdmissionRecord;
   readonly conflictClasses?: readonly SemanticMergeConflictClassRecord[];
   readonly conflictSummary?: SemanticMergeConflictSummary;
   readonly metadata?: SemanticMergeCandidateRecord['metadata'] & {

package/dist/declarations/semantic-sidecar.d.ts

@@ -25,6 +25,7 @@ import type {
   UniversalAstLayerRecord
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { SemanticImportSidecarAdmission, SemanticImportSidecarQuality } from './semantic-sidecar-admission.js';
+import type { SemanticMergeCandidateAdmissionRecord, SemanticMergeCandidateProjectionRisk } from './semantic-merge-candidates.js';
 import type { SemanticMergeConflictClass, SemanticMergeConflictSummary } from './semantic-merge-conflicts.js';
 import type { SemanticImportImpactSummary } from './semantic-impact.js';
 import type { Diagnostic } from '@shapeshift-labs/frontier-lang-checker';
@@ -274,6 +275,12 @@ export interface SemanticImportSidecar {
     readonly reasons: readonly string[];
     readonly conflictClasses?: readonly SemanticMergeConflictClass[];
     readonly conflictSummary?: SemanticMergeConflictSummary;
+    readonly changedSemanticRegions?: number;
+    readonly sourceHashes?: SemanticMergeCandidateAdmissionRecord['sourceHashes'];
+    readonly evidenceIds?: readonly string[];
+    readonly projectionRisk?: SemanticMergeCandidateProjectionRisk;
+    readonly readinessSortKey?: number;
+    readonly overlapSummary?: SemanticMergeCandidateAdmissionRecord['overlapSummary'];
     readonly risk?: string;
     readonly operationCount: number;
   }[];
@@ -309,7 +316,5 @@ export interface SemanticImportSidecar {
     readonly semanticImportExpected: boolean; readonly semanticImportExpectedSatisfied: boolean; readonly semanticImportExpectedMissingReasonCodes: readonly string[];
     readonly readiness: SemanticMergeReadiness; readonly emptySemanticIndex: boolean;
   };
-  readonly metadata?: Record<string, unknown>;
-}
-
+  readonly metadata?: Record<string, unknown>; }
 export interface SemanticImportSidecarOptions { readonly id?: string; readonly generatedAt?: number; readonly regionPrefix?: string; readonly targetPath?: string; readonly expected?: boolean; readonly semanticImportExpected?: boolean; readonly metadata?: Record<string, unknown>; }

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export * from './declarations/language-adapter-package-contracts.js';
 export * from './declarations/native-import-contracts.js';
 export * from './declarations/source-preservation.js';
 export * from './declarations/semantic-sidecar-admission.js';
+export * from './declarations/semantic-merge-candidates.js';
 export * from './declarations/semantic-merge-conflicts.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';

package/dist/index.js

@@ -64,6 +64,7 @@ export { projectNativeImportToSource } from './internal/index-impl/projectNative
 export { queryNativeParserFeatureMatrix } from './internal/index-impl/queryNativeParserFeatureMatrix.js';
 export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProjectionReadinessMatrix.js';
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
+export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandidateForAdmission, querySemanticMergeCandidateAdmissionOverlaps, SemanticMergeCandidateProjectionRisks, semanticMergeCandidateReadinessSortKey, sortSemanticMergeCandidateAdmissionRecords } from './internal/index-impl/semanticMergeCandidateRecords.js';
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';
 export { queryUniversalConversionPlan } from './internal/index-impl/queryUniversalConversionPlan.js';
 export { createSemanticHistoryRecord, querySemanticHistoryRecordOverlaps, SemanticHistoryAdmissionStatuses, SemanticHistoryConflictReasons, SemanticHistoryOverlapKinds, SemanticHistoryReviewerStatuses, semanticHistoryRecordsConflict, semanticHistoryRecordsOverlap } from './internal/index-impl/semanticHistoryRecords.js';

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

@@ -1,7 +1,9 @@
-import{idFragment}from'../../native-import-utils.js';import{semanticRegionKindForSymbol,semanticRegionMergePolicy}from'../../semantic-import-regions.js';
+import{idFragment,uniqueRecordsById}from'../../native-import-utils.js';import{semanticRegionKindForSymbol,semanticRegionMergePolicy}from'../../semantic-import-regions.js';
 import{externalRelationPredicateForOccurrence}from'./externalRelationPredicateForOccurrence.js';
 export function attachExternalOwnership(result, context) {
   const occurrencesBySymbol = new Map();
+  const documentsById = new Map((result.documents ?? []).map((document) => [document.id, document]));
+  const ownershipRegions = [];
   for (const occurrence of result.occurrences) {
     if (!occurrencesBySymbol.has(occurrence.symbolId)) occurrencesBySymbol.set(occurrence.symbolId, []);
     occurrencesBySymbol.get(occurrence.symbolId).push(occurrence);
@@ -21,24 +23,28 @@ export function attachExternalOwnership(result, context) {
   result.symbols = result.symbols.map((symbol) => {
     const occurrences = occurrencesBySymbol.get(symbol.id) ?? [];
     const definition = occurrences.find((occurrence) => occurrence.role === 'definition') ?? occurrences[0];
+    const document = documentsById.get(definition?.documentId);
     const sourceSpan = symbol.definitionSpan ?? definition?.span;
     const regionKind = semanticRegionKindForSymbol(symbol, undefined, undefined);
+    const sourcePath = sourceSpan?.path ?? document?.path ?? context.sourcePath;
+    const language = symbol.language ?? document?.language ?? context.language;
+    const normalizedRegionKind = symbol.metadata?.ownershipRegionKind ?? regionKind;
     const key = [
       'external',
-      symbol.language ?? context.language ?? 'unknown',
-      sourceSpan?.path ?? context.sourcePath ?? 'memory',
-      regionKind,
+      language ?? 'unknown',
+      sourcePath ?? 'memory',
+      normalizedRegionKind,
       symbol.name ?? symbol.id
     ].join('#');
     const region = {
-      id: `region_${idFragment(key)}`,
-      key,
-      regionKind,
+      id: symbol.metadata?.ownershipRegionId ?? `region_${idFragment(key)}`,
+      key: symbol.metadata?.ownershipRegionKey ?? key,
+      regionKind: normalizedRegionKind,
       granularity: 'symbol',
-      language: symbol.language ?? context.language,
+      language,
       documentId: definition?.documentId,
-      sourcePath: sourceSpan?.path ?? context.sourcePath,
-      sourceHash: context.sourceHash,
+      sourcePath,
+      sourceHash: sourceSpan?.sourceId ?? document?.sourceHash ?? context.sourceHash,
       symbolId: symbol.id,
       symbolName: symbol.name,
       symbolKind: symbol.kind,
@@ -50,6 +56,7 @@ export function attachExternalOwnership(result, context) {
         source: 'external-semantic-index'
       }
     };
+    ownershipRegions.push(region);
     result.facts.push({
       id: `fact_${idFragment(symbol.id)}_ownership_region`,
       predicate: 'semanticOwnershipRegion',
@@ -76,4 +83,5 @@ export function attachExternalOwnership(result, context) {
       }
     };
   });
+  result.ownershipRegions = uniqueRecordsById([...(result.ownershipRegions ?? []), ...ownershipRegions]);
 }

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

@@ -84,6 +84,12 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       reasons: candidate.reasons ?? [],
       conflictClasses: (candidate.conflictClasses ?? candidate.metadata?.conflictClasses ?? []).map((record) => record.class).filter(Boolean),
       conflictSummary: candidate.conflictSummary ?? candidate.metadata?.conflictSummary,
+      changedSemanticRegions: candidate.changedSemanticRegions?.length ?? candidate.mergeAdmission?.changedSemanticRegions?.length ?? 0,
+      sourceHashes: candidate.sourceHashes ?? candidate.mergeAdmission?.sourceHashes,
+      evidenceIds: candidate.evidenceIds ?? candidate.mergeAdmission?.evidenceIds ?? [],
+      projectionRisk: candidate.projectionRisk ?? candidate.mergeAdmission?.projectionRisk,
+      readinessSortKey: candidate.readinessSortKey ?? candidate.mergeAdmission?.readinessSortKey,
+      overlapSummary: candidate.mergeAdmission?.overlapSummary,
       risk: candidate.risk,
       operationCount: candidate.operations?.length ?? candidate.patch?.operations?.length ?? 0
     })),

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

@@ -1,5 +1,6 @@
 import{idFragment,uniqueStrings}from'../../native-import-utils.js';import{createSemanticMergeCandidateRecord}from'@shapeshift-labs/frontier-lang-kernel';
 import{createSemanticImportSidecar}from'./createSemanticImportSidecar.js';import{nativeNodeId}from'./nativeNodeId.js';import{readStringArray}from'./readStringArray.js';import{selectSemanticSliceRecords}from'./selectSemanticSliceRecords.js';import{semanticSliceContext}from'./semanticSliceContext.js';import{semanticSliceExpectedAssertions}from'./semanticSliceExpectedAssertions.js';import{semanticSliceReadiness}from'./semanticSliceReadiness.js';import{semanticSliceReasons}from'./semanticSliceReasons.js';import{semanticSliceRecords}from'./semanticSliceRecords.js';import{semanticSliceSourceFiles}from'./semanticSliceSourceFiles.js';import{semanticSliceSourceMapLinks}from'./semanticSliceSourceMapLinks.js';import{semanticSliceSourceSpans}from'./semanticSliceSourceSpans.js';import{semanticSliceTouchedSymbol}from'./semanticSliceTouchedSymbol.js';
+import{decorateSemanticMergeCandidateForAdmission}from'./semanticMergeCandidateRecords.js';
 export function createSemanticSlice(input, options = {}) {
   const context = semanticSliceContext(input, options);
   const sidecar = context.sidecar ?? (context.importResult ? createSemanticImportSidecar(context.importResult, {
@@ -50,7 +51,7 @@ export function createSemanticSlice(input, options = {}) {
       sidecarId: sidecar?.id
     }
   }];
-  const mergeCandidate = createSemanticMergeCandidateRecord({
+  const mergeCandidate = decorateSemanticMergeCandidateForAdmission(createSemanticMergeCandidateRecord({
     id: options.mergeCandidateId ?? `merge_candidate_${idPart}_semantic_slice`,
     importResultId: context.importResult?.id,
     language: context.language,
@@ -70,7 +71,7 @@ export function createSemanticSlice(input, options = {}) {
       dependencyRelationIds: selection.relations.map((relation) => relation.id).filter(Boolean),
       autoMergeClaim: false
     }
-  });
+  }),{evidence,sourceHash:sourceFiles[0]?.sourceHash,metadata:{source:'createSemanticSlice'}});
   return {
     kind: 'frontier.lang.semanticSlice',
     version: 1,

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

@@ -1,5 +1,6 @@
 import{idFragment,maxSemanticMergeReadiness,uniqueByLossId,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';import{createPatch,createSemanticMergeCandidateRecord}from'@shapeshift-labs/frontier-lang-kernel';
 import{attachNativeChangeRegionProjectionMetadata}from'./attachNativeChangeRegionProjectionMetadata.js';import{classifyNativeSourceMergeConflicts}from'./semanticMergeConflicts.js';import{createSemanticImportSidecar}from'./createSemanticImportSidecar.js';import{diffNativeOwnershipRegions}from'./diffNativeOwnershipRegions.js';import{diffNativeSymbols}from'./diffNativeSymbols.js';import{fileLevelNativeChangeRegion}from'./fileLevelNativeChangeRegion.js';import{mapDiffSymbols}from'./mapDiffSymbols.js';import{nativeChangeSpans}from'./nativeChangeSpans.js';import{nativeChangeTouchedSymbol}from'./nativeChangeTouchedSymbol.js';import{nativeImportReadiness}from'./nativeImportReadiness.js';import{nativeSourceChangeReasons}from'./nativeSourceChangeReasons.js';import{nativeSourceChangeSummary}from'./nativeSourceChangeSummary.js';import{normalizeNativeDiffImport}from'./normalizeNativeDiffImport.js';import{summarizeNativeChangedRegionProjections}from'./summarizeNativeChangedRegionProjections.js';
+import{decorateSemanticMergeCandidateForAdmission}from'./semanticMergeCandidateRecords.js';
 export function diffNativeSourceImports(input) {
   const before = normalizeNativeDiffImport(input.before, input, 'before');
   const after = normalizeNativeDiffImport(input.after, input, 'after');
@@ -104,7 +105,7 @@ export function diffNativeSourceImports(input) {
       semanticMergeConflictSummary: mergeConflictProfile.conflictSummary
     }
   });
-  const mergeCandidate = createSemanticMergeCandidateRecord({
+  const mergeCandidate = decorateSemanticMergeCandidateForAdmission(createSemanticMergeCandidateRecord({
     id: input.mergeCandidateId ?? `merge_candidate_${idPart}_native_source_diff`,
     importResultId: after?.id ?? before?.id,
     patchId: patch.id,
@@ -131,7 +132,7 @@ export function diffNativeSourceImports(input) {
       conflictClasses: mergeConflictProfile.conflictClasses,
       conflictSummary: mergeConflictProfile.conflictSummary
     }
-  });
+  }),{changedRegions,evidence,patch,baseHash:beforeHash,targetHash:afterHash,metadata:{source:'diffNativeSourceImports'}});
   return {
     kind: 'frontier.lang.nativeSourceChangeSet',
     version: 1,

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

@@ -7,6 +7,7 @@ export function externalSemanticBase(context, metadata = {}) {
     occurrences: [],
     relations: [],
     facts: [],
+    ownershipRegions: [],
     evidence: [externalSemanticEvidence(context, 'passed', `Imported ${context.format} semantic index payload.`)],
     losses: [externalSemanticCoverageLoss(context)],
     semanticStatus: 'external-semantic-index',

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

@@ -18,6 +18,7 @@ export function importExternalSemanticIndex(input) {
     metadata: input?.metadata ?? {}
   };
   const normalized = normalizeExternalSemanticIndexPayload(payload, context);
+  const ownershipRegions = normalized.ownershipRegions ?? [];
   const evidence = attachNativeImportLossSummary(
     uniqueByEvidenceId([...(normalized.evidence ?? []), ...(input?.evidence ?? [])]),
     summarizeNativeImportLosses(normalized.losses ?? [], {
@@ -116,6 +117,7 @@ export function importExternalSemanticIndex(input) {
     semanticIndex,
     universalAst,
     sourceMaps,
+    ownershipRegions,
     losses,
     evidence,
     readiness,
@@ -125,6 +127,8 @@ export function importExternalSemanticIndex(input) {
       occurrences: semanticIndex.occurrences.length,
       relations: semanticIndex.relations.length,
       facts: semanticIndex.facts.length,
+      ownershipRegions: ownershipRegions.length,
+      ownershipRegionKinds: [...new Set(ownershipRegions.map((region) => region.regionKind).filter(Boolean))],
       sourceMapMappings: sourceMaps.reduce((sum, sourceMap) => sum + (sourceMap.mappings?.length ?? 0), 0),
       losses: losses.length,
       readiness: readiness.readiness

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

@@ -1,4 +1,5 @@
 import{countBy,maxSemanticMergeReadiness,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+import{createSemanticMergeCandidateAdmissionRecord,querySemanticMergeCandidateAdmissionOverlaps,sortSemanticMergeCandidateAdmissionRecords}from'./semanticMergeCandidateRecords.js';
 
 const riskRank=Object.freeze({low:0,medium:1,unknown:2,high:3});
 const preservationRank=Object.freeze({exact:0,lossy:1,missing:2,stale:3,empty:4});
@@ -155,21 +156,45 @@ export function admissionMergeCandidates(projectResult,imports,mergeCandidates,l
     projectResult?.patch,
     ...imports.map((imported)=>imported?.patch)
   ].filter((patch)=>patch?.id).map((patch)=>[patch.id,patch]));
-  const risks=mergeCandidates.map((candidate)=>candidateRisk(candidate,patchById.get(candidate.patchId)));
+  const records=sortSemanticMergeCandidateAdmissionRecords(mergeCandidates.map((candidate)=>createSemanticMergeCandidateAdmissionRecord(candidate,{patch:patchById.get(candidate.patchId)})));
+  const recordByCandidateId=new Map(records.map((record)=>[record.candidateId,record]));
+  const overlaps=querySemanticMergeCandidateAdmissionOverlaps(records);
+  const risks=mergeCandidates.map((candidate)=>{
+    const record=recordByCandidateId.get(candidate.id);
+    return maxRisk(candidateRisk(candidate,patchById.get(candidate.patchId)),record?.projectionRisk??'low');
+  });
   const readiness=mergeCandidates.reduce(
-    (current,candidate)=>maxSemanticMergeReadiness(current,candidate.readiness),
+    (current,candidate)=>maxSemanticMergeReadiness(current,recordByCandidateId.get(candidate.id)?.readiness??candidate.readiness),
     lossSummary?.semanticMergeReadiness??'ready'
   );
+  const overlapCandidateIds=uniqueStrings(overlaps.flatMap((overlap)=>overlap.candidateIds??[]));
   return {
     total:mergeCandidates.length,
     readiness,
     highestRisk:risks.reduce(maxRisk,'low'),
+    projectionRisk:records.reduce((current,record)=>maxRisk(current,record.projectionRisk??'unknown'),'low'),
     byRisk:countBy(risks),
-    byReadiness:countBy(mergeCandidates.map((candidate)=>candidate.readiness??'needs-review')),
+    byReadiness:countBy(records.map((record)=>record.readiness??'needs-review')),
+    byProjectionRisk:countBy(records.map((record)=>record.projectionRisk??'unknown')),
     highRiskCandidateIds:mergeCandidates.filter((candidate,index)=>risks[index]==='high').map((candidate)=>candidate.id).filter(Boolean),
-    reviewCandidateIds:mergeCandidates.filter((candidate)=>candidate.readiness==='needs-review').map((candidate)=>candidate.id).filter(Boolean),
-    blockedCandidateIds:mergeCandidates.filter((candidate)=>candidate.readiness==='blocked').map((candidate)=>candidate.id).filter(Boolean),
-    conflictKeys:uniqueStrings(mergeCandidates.flatMap((candidate)=>candidate.conflictKeys??[])),
+    reviewCandidateIds:records.filter((record)=>record.readiness==='needs-review'||record.admission.reviewRequired).map((record)=>record.candidateId).filter(Boolean),
+    blockedCandidateIds:records.filter((record)=>record.readiness==='blocked'||record.admission.action==='block').map((record)=>record.candidateId).filter(Boolean),
+    highProjectionRiskCandidateIds:records.filter((record)=>record.projectionRisk==='high').map((record)=>record.candidateId).filter(Boolean),
+    conflictKeys:uniqueStrings(records.flatMap((record)=>record.conflictKeys??[])),
+    readinessOrderCandidateIds:records.map((record)=>record.candidateId).filter(Boolean),
+    changedSemanticRegions:{
+      total:records.reduce((sum,record)=>sum+record.changedSemanticRegions.length,0),
+      byKind:countBy(records.flatMap((record)=>record.changedSemanticRegions.map((region)=>region.regionKind??'unknown'))),
+      conflictKeys:uniqueStrings(records.flatMap((record)=>record.changedSemanticRegions.map((region)=>region.conflictKey)))
+    },
+    overlaps:{
+      total:overlaps.length,
+      candidateIds:overlapCandidateIds,
+      conflictKeys:uniqueStrings(overlaps.flatMap((overlap)=>overlap.conflictKeys??[])),
+      sourcePaths:uniqueStrings(overlaps.map((overlap)=>overlap.sourcePath).filter(Boolean)),
+      pairs:overlaps
+    },
+    records,
     patchRisk:normalizeRisk(projectResult?.patch?.risk)
   };
 }

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

@@ -71,7 +71,7 @@ export async function runNativeImporterAdapter(adapter, input = {}) {
     sourcePath: parseResult.sourcePath ?? input.sourcePath,
     sourceHash: parseResult.sourceHash ?? sourceHash
   });
-  const evidence = [...(parseResult.evidence ?? []), sourceEvidence];
+  const evidence = [...(input.evidence ?? []), ...(parseResult.evidence ?? []), sourceEvidence];
   const importInput = {
     ...input,
     ...parseResult,