@shapeshift-labs/frontier-lang-compiler 0.2.65 → 0.2.67

package/dist/declarations/universal-runtime-capabilities.d.ts

@@ -0,0 +1,171 @@
+import type {
+  FrontierSourceLanguage,
+  SemanticMergeReadiness
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { FrontierCompileTarget } from './compile.js';
+import type { NativeImportLanguageProfile } from './native-import-losses.js';
+import type { NativeSourceImportResult } from './import-adapter-core.js';
+
+export type UniversalRuntimeCapabilityKind =
+  | 'fetch'
+  | 'timers'
+  | 'storage'
+  | 'filesystem'
+  | 'threading'
+  | 'dom'
+  | 'async'
+  | 'ffi'
+  | string;
+
+export type UniversalRuntimeCapabilitySupport = 'native' | 'adapter' | 'unavailable' | string;
+
+export interface UniversalRuntimeCapabilitySupportRecord {
+  readonly kind: UniversalRuntimeCapabilityKind;
+  readonly support: UniversalRuntimeCapabilitySupport;
+  readonly binding: string;
+  readonly notes: readonly string[];
+}
+
+export interface UniversalRuntimeHostProfile {
+  readonly id: string;
+  readonly language: FrontierSourceLanguage | string;
+  readonly aliases?: readonly string[];
+  readonly languageIds?: readonly string[];
+  readonly runtime: string;
+  readonly host: string;
+  readonly target: FrontierCompileTarget | string;
+  readonly capabilities: Readonly<Record<UniversalRuntimeCapabilityKind, UniversalRuntimeCapabilitySupportRecord>>;
+  readonly notes?: readonly string[];
+}
+
+export interface UniversalRuntimeHostSummary extends UniversalRuntimeHostProfile {
+  readonly aliases: readonly string[];
+  readonly languageIds: readonly string[];
+  readonly notes?: readonly string[];
+}
+
+export interface UniversalRuntimeRequirementInput {
+  readonly capability?: UniversalRuntimeCapabilityKind;
+  readonly kind?: UniversalRuntimeCapabilityKind;
+  readonly capabilities?: readonly UniversalRuntimeCapabilityKind[];
+  readonly requiredCapabilities?: readonly UniversalRuntimeCapabilityKind[];
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourceRuntime?: string;
+  readonly runtime?: string;
+  readonly sourceHost?: string | UniversalRuntimeHostProfile;
+  readonly sourceRuntimeHost?: string | UniversalRuntimeHostProfile;
+  readonly target?: FrontierCompileTarget | string;
+  readonly targetRuntime?: string;
+  readonly targetHost?: string | UniversalRuntimeHostProfile;
+  readonly targetRuntimeHost?: string | UniversalRuntimeHostProfile;
+  readonly reason?: string;
+  readonly evidenceIds?: readonly string[];
+}
+
+export interface UniversalRuntimeAdapterRequirement {
+  readonly id: string;
+  readonly capability: UniversalRuntimeCapabilityKind;
+  readonly adapterKind: string;
+  readonly sourceHost: string;
+  readonly targetHost: string;
+  readonly sourceBinding: string;
+  readonly targetBinding: string;
+  readonly required: true;
+  readonly reason: string;
+  readonly evidenceIds: readonly string[];
+}
+
+export interface UniversalRuntimeCapabilityRoute {
+  readonly id: string;
+  readonly source: UniversalRuntimeHostSummary;
+  readonly target: UniversalRuntimeHostSummary;
+  readonly requiredCapabilities: readonly UniversalRuntimeCapabilityKind[];
+  readonly satisfiedCapabilities: readonly UniversalRuntimeCapabilityKind[];
+  readonly adapterRequirements: readonly UniversalRuntimeAdapterRequirement[];
+  readonly missingCapabilities: readonly UniversalRuntimeCapabilityKind[];
+  readonly readiness: SemanticMergeReadiness;
+  readonly blockers: readonly string[];
+  readonly review: readonly string[];
+  readonly metadata: Record<string, unknown>;
+}
+
+export interface UniversalRuntimeCapabilityMatrix {
+  readonly kind: 'frontier.lang.universalRuntimeCapabilityMatrix';
+  readonly version: 1;
+  readonly generatedAt: number;
+  readonly hostProfiles: readonly UniversalRuntimeHostProfile[];
+  readonly routes: readonly UniversalRuntimeCapabilityRoute[];
+  readonly summary: {
+    readonly routes: number;
+    readonly routesWithAdapters: number;
+    readonly adapterRequirements: number;
+    readonly missingCapabilities: number;
+    readonly byReadiness: Readonly<Record<SemanticMergeReadiness, number>>;
+    readonly byCapability: Readonly<Record<UniversalRuntimeCapabilityKind, number>>;
+    readonly byAdapterKind: Readonly<Record<string, number>>;
+  };
+  readonly metadata: {
+    readonly capabilityKinds: readonly UniversalRuntimeCapabilityKind[];
+    readonly sourceHosts: readonly string[];
+    readonly targetHosts: readonly string[];
+    readonly note: string;
+  };
+}
+
+export interface UniversalRuntimeCapabilityMatrixOptions {
+  readonly generatedAt?: number;
+  readonly imports?: readonly NativeSourceImportResult[];
+  readonly languages?: readonly (NativeImportLanguageProfile | FrontierSourceLanguage | string)[];
+  readonly sourceLanguages?: readonly (NativeImportLanguageProfile | FrontierSourceLanguage | string)[];
+  readonly targets?: readonly (FrontierCompileTarget | string)[];
+  readonly hostProfiles?: readonly UniversalRuntimeHostProfile[];
+  readonly runtimeHosts?: readonly UniversalRuntimeHostProfile[];
+  readonly sourceHosts?: readonly (string | UniversalRuntimeHostProfile)[] | Readonly<Record<string, string | UniversalRuntimeHostProfile>>;
+  readonly sourceRuntimeHosts?: readonly (string | UniversalRuntimeHostProfile)[] | Readonly<Record<string, string | UniversalRuntimeHostProfile>>;
+  readonly targetHosts?: readonly (string | UniversalRuntimeHostProfile)[] | Readonly<Record<string, string | UniversalRuntimeHostProfile>>;
+  readonly targetRuntimeHosts?: readonly (string | UniversalRuntimeHostProfile)[] | Readonly<Record<string, string | UniversalRuntimeHostProfile>>;
+  readonly sourceRuntime?: string;
+  readonly targetRuntime?: string;
+  readonly sourceRuntimes?: Readonly<Record<string, string>>;
+  readonly targetRuntimes?: Readonly<Record<string, string>>;
+  readonly runtimeRequirements?:
+    | readonly (UniversalRuntimeCapabilityKind | UniversalRuntimeRequirementInput)[]
+    | Readonly<Record<string, readonly UniversalRuntimeCapabilityKind[]>>;
+  readonly requiredRuntimeCapabilities?:
+    | readonly (UniversalRuntimeCapabilityKind | UniversalRuntimeRequirementInput)[]
+    | Readonly<Record<string, readonly UniversalRuntimeCapabilityKind[]>>;
+  readonly effects?:
+    | readonly (UniversalRuntimeCapabilityKind | UniversalRuntimeRequirementInput)[]
+    | Readonly<Record<string, readonly UniversalRuntimeCapabilityKind[]>>;
+}
+
+export interface UniversalRuntimeCapabilityMatrixQuery {
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly target?: FrontierCompileTarget | string;
+  readonly sourceRuntime?: string;
+  readonly targetRuntime?: string;
+  readonly runtime?: string;
+  readonly capability?: UniversalRuntimeCapabilityKind;
+  readonly requiresAdapter?: boolean;
+}
+
+export interface UniversalRuntimeCapabilityMatrixQueryResult {
+  readonly kind: 'frontier.lang.universalRuntimeCapabilityMatrixQuery';
+  readonly version: 1;
+  readonly found: boolean;
+  readonly routes: readonly UniversalRuntimeCapabilityRoute[];
+  readonly bestRoute?: UniversalRuntimeCapabilityRoute;
+  readonly reasons: readonly string[];
+}
+
+export declare const UniversalRuntimeCapabilityKinds: readonly UniversalRuntimeCapabilityKind[];
+export declare const UniversalRuntimeHostProfiles: readonly UniversalRuntimeHostProfile[];
+export declare function createUniversalRuntimeCapabilityMatrix(
+  options?: UniversalRuntimeCapabilityMatrixOptions
+): UniversalRuntimeCapabilityMatrix;
+export declare function queryUniversalRuntimeCapabilityMatrix(
+  matrixOrOptions?: UniversalRuntimeCapabilityMatrix | UniversalRuntimeCapabilityMatrixOptions,
+  query?: UniversalRuntimeCapabilityMatrixQuery
+): UniversalRuntimeCapabilityMatrixQueryResult;

package/dist/index.d.ts

@@ -8,11 +8,13 @@ export * from './declarations/projection-readiness.js';
 export * from './declarations/universal-capability.js';
 export * from './declarations/universal-conversion-artifacts.js';
 export * from './declarations/universal-conversion-plan.js';
+export * from './declarations/universal-runtime-capabilities.js';
 export * from './declarations/universal-dialects.js';
 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

@@ -32,6 +32,7 @@ export { createUniversalCapabilityMatrix } from './internal/index-impl/createUni
 export { createUniversalConversionArtifacts } from './internal/index-impl/createUniversalConversionArtifacts.js';
 export { queryUniversalConversionArtifacts } from './universal-conversion-artifacts.js';
 export { createUniversalConversionPlan } from './internal/index-impl/createUniversalConversionPlan.js';
+export { createUniversalRuntimeCapabilityMatrix, queryUniversalRuntimeCapabilityMatrix, UniversalRuntimeCapabilityKinds, UniversalRuntimeHostProfiles } from './universal-runtime-capabilities.js';
 export { attachUniversalDialectRegistry, createUniversalDialectRecord, createUniversalDialectRegistry, createUniversalExternRecord, summarizeUniversalDialectRegistry, UniversalDialectConstructKinds, UniversalDialectProjectionDispositions } from './universal-dialect-registry.js';
 export { diffNativeSourceImports } from './internal/index-impl/diffNativeSourceImports.js';
 export { diffNativeSources } from './internal/index-impl/diffNativeSources.js';
@@ -64,6 +65,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/createNativeRoundtripEvidence.js

@@ -1,6 +1,7 @@
 import{validateUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
 import{countBy,idFragment,maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
 import{nativeImportEntries}from'./nativeImportEntries.js';import{nativeImportHasExactAstCoverage}from'./nativeImportHasExactAstCoverage.js';
+import{createRoundtripAudit}from'./nativeRoundtripAudit.js';
 const precisionRank=Object.freeze({exact:0,line:1,declaration:2,estimated:3,unknown:4,none:5});
 export function createNativeRoundtripEvidence(importResult,options={}) {
   if(!importResult||typeof importResult!=='object') throw new Error('createNativeRoundtripEvidence requires a native import result');
@@ -28,6 +29,8 @@ export function createNativeRoundtripEvidence(importResult,options={}) {
   const sourceMapEvidence=summarizeSourceMaps(hasOutputSourceMaps?outputSourceMaps:universalSourceMaps);
   const sourceLanguage=projection?.language??importResult.language;
   const target=options.target??options.targetCoverage?.target??options.targetProjection?.target;
+  const sourcePreservation=summarizeSourcePreservation(importResult,universalSourceMaps);
+  const hashChecks=summarizeHashChecks({importResult,projection,targetProjection:options.targetProjection,sourceHashVerified});
   const audit=createRoundtripAudit({
     status,
     semanticMerge,
@@ -35,6 +38,7 @@ export function createNativeRoundtripEvidence(importResult,options={}) {
     target,
     sameLanguage:Boolean(sourceLanguage&&target&&String(sourceLanguage)===String(target)),
     outputMode,
+    projection,
     projectionMode:projection?.mode,
     sourceHashVerified,
     hasOutputSourceMaps,
@@ -42,7 +46,9 @@ export function createNativeRoundtripEvidence(importResult,options={}) {
     universalSourceMapEvidence,
     targetProjection:options.targetProjection,
     targetCoverage:options.targetCoverage,
-    lossSummary
+    lossSummary,
+    sourcePreservation,
+    hashChecks
   });
   const metadata={
     schema:'frontier.lang.nativeRoundtripEvidence',
@@ -135,55 +141,54 @@ function summarizeSourceMaps(sourceMaps){
 }
 function normalizePrecision(value){const precision=String(value??'unknown');return Object.prototype.hasOwnProperty.call(precisionRank,precision)?precision:'unknown';}
 function worstPrecision(precisions){if(!precisions.length)return'none';return precisions.reduce((worst,next)=>precisionRank[next]>precisionRank[worst]?next:worst,'exact');}
-function createRoundtripAudit(input){
-  const disposition=roundtripAuditDisposition(input);
+function summarizeSourcePreservation(importResult,sourceMaps){
+  const preservation=importResult.metadata?.sourcePreservation??importResult.nativeSource?.metadata?.sourcePreservation??importResult.nativeAst?.metadata?.sourcePreservation??importResult.universalAst?.metadata?.sourcePreservation;
+  const summary=preservation?.summary??importResult.metadata?.sourcePreservationSummary??importResult.nativeSource?.metadata?.sourcePreservationSummary??importResult.nativeAst?.metadata?.sourcePreservationSummary??importResult.universalAst?.metadata?.sourcePreservationSummary??{};
+  const kernelSummary=importResult.metadata?.kernelSourcePreservationSummary??importResult.universalAst?.metadata?.kernelSourcePreservationSummary??{};
+  const records=asArray(importResult.metadata?.kernelSourcePreservationRecords??importResult.metadata?.sourcePreservationRecords??importResult.universalAst?.metadata?.kernelSourcePreservationRecords??importResult.universalAst?.metadata?.sourcePreservationRecords);
+  const mappings=(sourceMaps??[]).flatMap((sourceMap)=>sourceMap?.mappings??[]);
   return{
-    schema:'frontier.lang.nativeRoundtripAuditSignal',
-    version:1,
-    disposition,
-    claim:roundtripAuditClaim(disposition),
-    sourceLanguage:input.sourceLanguage,
-    target:input.target,
-    sameLanguage:input.sameLanguage,
-    outputMode:input.outputMode,
-    projectionMode:input.projectionMode,
-    sourceHashVerified:input.sourceHashVerified,
-    outputSourceMapPrecision:input.sourceMapEvidence.precision,
-    universalSourceMapPrecision:input.universalSourceMapEvidence.precision,
-    targetProjectionAdapterId:input.targetProjection?.adapter?.id,
-    targetCoverageLossClass:input.targetCoverage?.lossClass,
-    reviewRequired:input.semanticMerge!=='ready',
-    semanticMergeReadiness:input.semanticMerge,
-    semanticEquivalenceClaim:false,
-    autoMergeClaim:false,
-    blockingLossCount:input.lossSummary.blockingLossIds.length,
-    reviewLossCount:input.lossSummary.reviewLossIds.length,
-    reasonCodes:uniqueStrings([
-      `status:${input.status}`,
-      `semantic:${input.semanticMerge}`,
-      `output:${input.outputMode??'unknown'}`,
-      `projection:${input.projectionMode??'unknown'}`,
-      input.sourceHashVerified?'source-hash:verified':'source-hash:unverified',
-      `output-source-map:${input.sourceMapEvidence.precision}`,
-      `universal-source-map:${input.universalSourceMapEvidence.precision}`,
-      input.targetCoverage?.lossClass?`target-loss:${input.targetCoverage.lossClass}`:undefined,
-      input.targetProjection?.adapter?.id?`target-adapter:${input.targetProjection.adapter.id}`:undefined,
-      input.lossSummary.blockingLossIds.length?'losses:blocking':undefined,
-      input.lossSummary.reviewLossIds.length?'losses:review':undefined
-    ])
+    id:preservation?.id??importResult.metadata?.sourcePreservationId??importResult.nativeSource?.metadata?.sourcePreservationId??importResult.universalAst?.metadata?.sourcePreservationId,
+    exactSourceAvailable:Boolean(summary.exactSourceAvailable??preservation?.summary?.exactSourceAvailable??preservation?.sourceText),
+    sourceTextAvailable:typeof preservation?.sourceText==='string',
+    recordCount:numeric(kernelSummary.total,records.length||(preservation?1:0)),
+    byLevel:kernelSummary.byLevel??countBy(records.map((record)=>record?.level??'unknown')),
+    exactRecords:numeric(kernelSummary.exact),
+    declarationRecords:numeric(kernelSummary.declaration),
+    estimatedRecords:numeric(kernelSummary.estimated),
+    blockedRecords:numeric(kernelSummary.blocked),
+    sourcePaths:uniqueStrings([...(asArray(kernelSummary.sourcePaths)),preservation?.sourcePath,importResult.sourcePath]),
+    sourceMapIds:uniqueStrings([...(asArray(kernelSummary.sourceMapIds)),...(sourceMaps??[]).map((sourceMap)=>sourceMap?.id)]),
+    mappingPreservation:countBy(mappings.map((mapping)=>mapping?.preservation??'unknown')),
+    comments:numeric(summary.comments),
+    trivia:numeric(summary.trivia),
+    directives:numeric(summary.directives),
+    tokens:numeric(summary.tokens),
+    whitespace:numeric(summary.whitespace),
+    truncated:Boolean(summary.truncated)
   };
 }
-function roundtripAuditDisposition(input){
-  if(input.outputMode==='target-adapter')return'adapter-projected';
-  if(input.projectionMode==='native-source-stubs'||input.outputMode==='target-stubs')return'stub-only';
-  if(input.sourceHashVerified&&input.outputMode==='preserved-source'&&input.hasOutputSourceMaps&&input.sourceMapEvidence.precision==='exact')return'reversible';
-  if(input.sourceHashVerified||input.projectionMode==='preserved-source')return'preserved-source';
-  return'review-required';
-}
-function roundtripAuditClaim(disposition){
-  if(disposition==='reversible')return'source-text-reversible';
-  if(disposition==='preserved-source')return'source-preserved';
-  if(disposition==='stub-only')return'declaration-stubs-only';
-  if(disposition==='adapter-projected')return'host-adapter-projected';
-  return'review-required';
+function summarizeHashChecks(input){
+  const importResult=input.importResult;
+  const sourceHash=importResult.nativeSource?.sourceHash??importResult.nativeAst?.sourceHash??importResult.sourceHash;
+  const declaredSourceHash=importResult.metadata?.declaredSourceHash??importResult.nativeSource?.metadata?.declaredSourceHash??importResult.nativeAst?.metadata?.declaredSourceHash;
+  const expectedSourceHash=input.projection?.sourceHash??sourceHash;
+  const projectionOutputHash=input.projection?.outputHash;
+  const targetOutputHash=input.targetProjection?.outputHash;
+  const outputHash=targetOutputHash??projectionOutputHash;
+  return{
+    sourceHashPresent:Boolean(sourceHash),
+    declaredSourceHashPresent:Boolean(declaredSourceHash),
+    declaredSourceHashVerified:declaredSourceHash?declaredSourceHash===sourceHash&&importResult.metadata?.sourceHashVerified!==false:undefined,
+    expectedSourceHashPresent:Boolean(expectedSourceHash),
+    outputHashPresent:Boolean(outputHash),
+    projectionOutputHashPresent:Boolean(projectionOutputHash),
+    targetOutputHashPresent:Boolean(targetOutputHash),
+    sourceHashVerified:input.sourceHashVerified,
+    projectionOutputMatchesSourceHash:Boolean(projectionOutputHash&&expectedSourceHash&&projectionOutputHash===expectedSourceHash),
+    targetOutputMatchesSourceHash:Boolean(targetOutputHash&&expectedSourceHash&&targetOutputHash===expectedSourceHash),
+    outputMatchesSourceHash:Boolean(outputHash&&expectedSourceHash&&outputHash===expectedSourceHash)
+  };
 }
+function asArray(value){return Array.isArray(value)?value:[];}
+function numeric(value,fallback=0){const number=Number(value);return Number.isFinite(number)?number:fallback;}

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,
@@ -99,7 +100,7 @@ export function createSemanticSlice(input, options = {}) {
     verification: {
       focusedCommands: readStringArray(options.focusedCommands),
       fixtureHints: readStringArray(options.fixtureHints),
-      expectedAssertions: semanticSliceExpectedAssertions(selection, unresolvedEntryRefs)
+      expectedAssertions: semanticSliceExpectedAssertions(selection, unresolvedEntryRefs, options)
     },
     summary: {
       symbols: selection.symbols.length,

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

@@ -1,5 +1,6 @@
-import{idFragment,maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{idFragment,maxSemanticMergeReadiness,uniqueByEvidenceId,uniqueStrings}from'../../native-import-utils.js';
 import{testSemanticSlice}from'./testSemanticSlice.js';
+import{semanticSliceAdmissionSelectedSurface,semanticSliceSelectedSurfaceEvidence}from'./semanticSliceAdmissionSurface.js';
 
 const readinessScore=Object.freeze({ready:100,'ready-with-losses':78,'needs-review':48,blocked:0});
 const readinessRank=Object.freeze({ready:3,'ready-with-losses':2,'needs-review':1,blocked:0});
@@ -19,6 +20,12 @@ export function createSemanticSliceAdmissionRecord(slice,options={}){
   const value=mergeScoreValue(components,readiness);
   const action=admissionAction(slice,readiness,components,testResult);
   const risk=admissionRisk(readiness,components,testResult);
+  const selectedSurface=semanticSliceAdmissionSelectedSurface(slice);
+  const evidence=uniqueByEvidenceId([
+    ...(slice?.evidence??[]),
+    ...(options.evidence??[]),
+    semanticSliceSelectedSurfaceEvidence(slice,selectedSurface,testResult,readiness,action)
+  ]);
   return{
     kind:'frontier.lang.semanticSliceAdmission',
     version:1,
@@ -61,6 +68,8 @@ export function createSemanticSliceAdmissionRecord(slice,options={}){
     conflictKeys:uniqueStrings(slice?.mergeAdmission?.conflictKeys??[]),
     ownershipKeys:uniqueStrings(slice?.mergeAdmission?.ownershipKeys??[]),
     sourceHashes:slice?.mergeAdmission?.sourceHashes??[],
+    selectedSurface,
+    evidence,
     testResult,
     reasons:uniqueStrings([
       ...(slice?.mergeAdmission?.reasons??[]),

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/expandSemanticSliceSelection.js

@@ -41,7 +41,6 @@ export function expandSemanticSliceSelection(records, selection) {
       }
       for (const node of records.nativeNodes) {
         if (!selection.selectedNativeNodes.has(node.id)) continue;
-        for (const child of node.children ?? []) changed = addSet(selection.selectedNativeNodes, child) || changed;
         const parent = childToParent.get(node.id);
         if (parent) changed = addSet(selection.selectedNativeNodes, parent) || changed;
       }

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