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

package/dist/declarations/universal-conversion-plan.d.ts

@@ -9,6 +9,13 @@ import type { NativeParserFeatureCategory } from './native-parser-features.js';
 import type { ProjectionSourceProjectionCoverage, ProjectionTargetCoverageEntry } from './projection-coverage.js';
 import type { ProjectionReadinessTargetCell } from './projection-readiness.js';
 import type { UniversalCapabilityMatrix, UniversalCapabilityMatrixOptions } from './universal-capability.js';
+import type {
+  UniversalRuntimeAdapterRequirement,
+  UniversalRuntimeCapabilityKind,
+  UniversalRuntimeCapabilityMatrix,
+  UniversalRuntimeCapabilityRoute,
+  UniversalRuntimeHostProfile
+} from './universal-runtime-capabilities.js';
 
 export type UniversalConversionRouteMode =
   | 'preserve-source'
@@ -76,6 +83,19 @@ export interface UniversalConversionRouteEvidence {
   readonly targetLossKinds: readonly NativeImportKnownLossKind[];
 }
 
+export interface UniversalConversionRouteRuntime {
+  readonly routeId?: string;
+  readonly source?: UniversalRuntimeCapabilityRoute['source'];
+  readonly target?: UniversalRuntimeCapabilityRoute['target'];
+  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[];
+}
+
 export interface UniversalConversionRouteMergeRefs {
   readonly planId: string;
   readonly routeId: string;
@@ -122,6 +142,8 @@ export interface UniversalConversionRoute {
     readonly stubs: ProjectionSourceProjectionCoverage;
   };
   readonly projectionReadiness?: ProjectionReadinessTargetCell;
+  readonly runtime: UniversalConversionRouteRuntime;
+  readonly runtimeAdapterRequirements: readonly UniversalRuntimeAdapterRequirement[];
   readonly evidence: UniversalConversionRouteEvidence;
   readonly missingEvidence: readonly string[];
   readonly blockers: readonly string[];
@@ -153,6 +175,8 @@ export interface UniversalConversionPlan {
     readonly stubOnlyRoutes: number;
     readonly semanticIndexOnlyRoutes: number;
     readonly missingEvidence: number;
+    readonly runtimeAdapterRequirements: number;
+    readonly runtimeRoutesWithAdapters: number;
     readonly blockers: number;
     readonly reviewReasons: number;
     readonly autoMergeClaims: 0;
@@ -160,6 +184,7 @@ export interface UniversalConversionPlan {
   };
   readonly matrices: {
     readonly universalCapability: UniversalCapabilityMatrix;
+    readonly runtimeCapabilities: UniversalRuntimeCapabilityMatrix;
     readonly projectionReadiness?: UniversalCapabilityMatrix['matrices']['projectionReadiness'];
     readonly projectionTargets?: UniversalCapabilityMatrix['matrices']['projectionTargets'];
   };
@@ -175,6 +200,40 @@ export interface UniversalConversionPlan {
 export interface UniversalConversionPlanOptions extends UniversalCapabilityMatrixOptions {
   readonly id?: string;
   readonly universalCapabilityMatrix?: UniversalCapabilityMatrix;
+  readonly universalRuntimeCapabilityMatrix?: UniversalRuntimeCapabilityMatrix;
+  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
+    | {
+      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[];
+    }
+  )[];
+  readonly requiredRuntimeCapabilities?: UniversalConversionPlanOptions['runtimeRequirements'];
+  readonly effects?: UniversalConversionPlanOptions['runtimeRequirements'];
   readonly evidence?: readonly EvidenceRecord[];
 }
 

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,6 +8,7 @@ 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';

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';

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

@@ -100,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/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;
       }