@shapeshift-labs/frontier-lang-compiler 0.2.164 → 0.2.165

package/README.md

@@ -547,6 +547,15 @@ Current JS/TS semantic-merge status matrix:
 
 | Surface | Status | Current evidence |
 | --- | --- | --- |
+| Source-text merge candidate | baseline | Project admission records the conservative concrete source merge candidate before semantic proof rows run. `sourceTextMergeCandidateStatus`, `sourceTextMergeCandidateFiles`, `sourceTextMergeBlockedFiles`, `sourceTextMergeOutputFiles`, `source-text-merge-candidate` evidence, and the `confidence.admissionMatrixAudit` `source-text-merge-candidate` surface make the baseline machine-checkable. Failed source-text candidates block before semantic admission; this row is not a semantic-equivalence or browser-runtime claim. |
+| HTML parser/source evidence | bounded-evidence | HTML project files are counted separately through `htmlFiles`, `htmlMergedFiles`, `htmlBlockedFiles`, parser evidence counters, and `html-parser-source-evidence` matrix proof statuses. Current evidence is parser/source-span bounded around parse5-style source locations, parser-backed spans, and fail-closed parser evidence failures; it does not claim browser DOM, hydration, or render equivalence. |
+| CSS parser/source evidence | bounded-evidence | CSS project files are counted separately through `cssFiles`, `cssMergedFiles`, `cssBlockedFiles`, parser evidence counters, and `css-parser-source-evidence` matrix proof statuses. Current evidence is parser/source-span bounded around PostCSS-style rule/declaration spans, raw trivia hashes, parse-error blockers, and source preservation; it does not claim cascade or browser runtime equivalence. |
+| HTML identity evidence | bounded-evidence | HTML identity proof uses `htmlIdentityEvidenceFiles`, explicit/path identity residual counters, duplicate identity counters, runtime/framework boundary counters, `htmlProofGapBlockedFiles`, and the `html-identity-evidence` proof status. Parser-backed stable identity can support later structural admission, while duplicate identity, runtime boundaries, framework boundaries, or missing proof gaps stay review/blocking evidence. |
+| CSS selector target evidence | bounded-evidence | CSS selector target proof uses `cssSelectorTargetEvidenceFiles`, selector target graph/specificity/move counters, selector conflict/rebase counters, and the `css-selector-target-evidence` proof status. Target evidence remains bounded to parser-backed selector/target/rebase facts and does not claim cascade or browser runtime equivalence. |
+| HTML structural merge admission | partial | HTML structural admission uses `html-structural-merge` proof statuses plus parser and identity evidence. It can admit bounded structural source merges when files merge cleanly and required identity/parser evidence is present; blocked files route to `admit-html-structural-merge` and browser/runtime proof remains a separate row. |
+| CSS cascade merge admission | partial | CSS cascade admission uses `css-cascade-merge` proof statuses plus parser, selector, scoped cascade, dependency, and CSS Module use-site evidence. It remains partial: generated class maps, bundler transform identity, source-map proof, scoped cascade proof, dependency proof, and dynamic use sites stay fail-closed when absent. |
+| CSS dependency graph evidence | bounded-evidence | CSS dependency graph proof uses `cssDependencySurfaceFiles`, `cssDependencyGraphEvidenceFiles`, missing-proof/blocker counters, and the `css-dependency-graph` proof status for custom property, `var()` fallback, animation, font, and asset dependency surfaces. It is absent when no dependency surface is present and does not claim cascade/browser equivalence. |
+| HTML/CSS browser runtime proof | bounded-evidence | HTML/CSS browser proof is an explicit separate row tracked by `htmlCssBrowserRuntimeProofs`, the `html-css-browser-runtime-proof` surface, and the `browser-runtime-proof` proof status. Structural source merges keep browser/render/cascade equivalence claims false unless a bounded browser proof bundle is attached; missing proof routes to `prove-html-css-browser-runtime`. |
 | Parser/source-span/trivia evidence | Partial | Source preservation, source hashes, runtime directive-prologue entries, directives, comments/trivia summaries, project `sourceFileRecords` / `sourceSpanRecords`, protected-span hashes, shebang file-entrypoint directive ownership anchors, `sourceMappingURL` and `sourceURL` generated-boundary source-map spans, deterministic source-map generated-boundary ownership keys from supplied exact source/generated spans and hashes, generated-boundary position conflict evidence, deterministic ownership anchors, source-span/trivia ownership blockers, exact parser-trivia ownership records for directive prologues plus leading/trailing comments and JSDoc/block-comment spans when parser evidence matches the source hash, TypeScript `SourceFile` compiler-scanner exact token/trivia source-preservation evidence for JS/TS/JSX/TSX imports, ESTree/Babel parser token/comment range evidence when the supplied AST covers every non-whitespace byte of the current source, fail-closed scanner/ledger spoof blockers, source-span delta conflicts, parser roundtrip proof records, failed source-span roundtrip proof admission blockers, project-merge stage parser-trivia evidence from supplied parser-backed imports for base/worker/head/output, metadata-only exactness blockers for scanner fallbacks, and fixture corpus checks. Parser-backed exactness also requires contiguous current-source token/comment/trivia coverage with no gaps, overlaps, truncation, or text mismatches; truncated coverage blocks exact token/comment ownership. Adapters without token/comment ranges remain approximate/caller evidence, not exact parser trivia. |
 | Scope/use-def graph | Partial | Lightweight lexical scope/use-def scans, destructuring alias binding records, object/array/nested/rest/default-initializer parameter binding evidence for function and arrow parameters, default import alias reads through re-export chains when a stable default-export local binding is observed, fail-closed `lexical-scope-import-alias-target-unresolved` records when an alias target cannot be tied to a lexical binding, namespace import dot and literal/static-template computed member-read evidence, blocked evidence for ambiguous computed namespace reads and namespace member writes, `this`/`super` receiver member read/write evidence including computed string and static-template members, optional chaining markers, and TypeScript checker-backed receiver-member reference proof for full `this`/`super` access spans including private identifiers, template-literal interpolation live-reference records with expression hashes plus tagged-template site/tag root/member metadata, caller-supplied ESTree/scope-manager structural evidence normalization, closure-capture depth/owner/reference hashes, binding-level closure capture hashes, project `scopeBindingRecords` / `scopeReferenceRecords`, public owner use hashes, public scope-use and reference-site delta conflicts with alias target route/use-hash evidence, TypeScript compiler reference relations when a checker is supplied, exact compiler reference-site proof hashes on scope reference records, fail-closed `typescript-compiler-reference-site-ambiguous`, `typescript-compiler-reference-lexical-binding-mismatch`, and `typescript-compiler-reference-import-alias-target-mismatch` records when compiler alias evidence cannot be reconciled with the lexical route or re-export/import target, and dependency-sensitive fixture coverage. Full whole-program binding/control-flow resolution is still caller/compiler-evidence bounded. |
 | Module/export/import graph | Partial | Project graph stages, module resolution, runtime-neutral package manifest conversion from in-memory `package.json` objects/text, duplicate workspace-root package-name ambiguity diagnostics and fail-closed `package-workspace-root-ambiguous-missing` edges with `packageWorkspaceRoots` evidence, package exports/imports including wildcard package export key/target evidence, fail-closed package `imports` condition misses, runtime-ambiguous `import`/`require` condition blockers, caller-supplied package type runtime-condition evidence for `.js`/`.ts` package exports/imports, caller-supplied package environment-condition evidence such as `browser`, fail-closed `package-export-environment-ambiguous-missing` / `package-import-environment-ambiguous-missing` blockers with condition candidates when environment targets such as `browser` and `node` diverge without explicit evidence, and fail-closed host-runtime ambiguity blockers for non-resolver host package specifiers with divergent `import`/`require` targets, re-export identities including static TypeScript-style CommonJS bare and `tslib_1.__...` member-form `__exportStar(require("./dep"), exports)` fanout and `__createBinding(exports, require("./dep"), "name", "alias")` named re-export fanout, same-document CommonJS require-alias getter re-export identities for descriptor `get: function () { return dep.name; }`, named descriptor `get: function getName() { return dep.name; }`, shorthand `get() { return dep.name; }`, and block-bodied arrow `get: () => { return dep.name; }`, TypeScript-style CommonJS bare and `tslib_1.__...` member-form `__importDefault(require("./dep"))` and `__importStar(require("./dep"))` helper import edges, CommonJS `module.exports` default-import interop when no direct `default` export exists, literal computed CommonJS export properties such as `exports["default"]`, static `module.exports = { named }`, `Object.assign(exports, { named })`, `Object.defineProperty(exports, "named", { value/get })`, and `Object.defineProperties(exports, { named: { value/get } })` export maps in lightweight and AST-backed imports, ESTree/Babel no-expression `TemplateLiteral` normalization for CommonJS `require`, computed export keys, descriptor export specifiers, dynamic `import()`, CommonJS helper re-export specifiers, and host dependency specifiers while expression-bearing templates stay unresolved, TypeScript compiler no-substitution dynamic import and host dependency template evidence, `exports.__esModule` marker filtering, import-target deltas for head-introduced CommonJS export assignments, namespace/ambient module/global augmentation/export-assignment static shape records with proof hashes and no runtime-equivalence claim, fail-closed namespace/export-assignment shape delta conflicts, non-literal dynamic `import()` pseudo-specifiers with expression kind/text/hash evidence and fail-closed resolution evidence, static `new URL(specifier, import.meta.url)`, `Worker`, `SharedWorker`, `serviceWorker.register`, worklet `addModule`, `importScripts`, `import.meta.resolve`, and `require.resolve` host dependency edges with expression hashes and no runtime-resolution claim, dynamic host dependency targets emitted as `<host-dependency>` with expression hashes, `hostDependencyStaticSpecifierEvidence: false`, and proof-required unresolved evidence, import-attribute/import-assertion normalized key/value/count/hash evidence on static imports, dynamic imports, and re-exports, import-attribute delta conflicts, output graph unresolved-module conflicts that preserve edge-level fail-closed package, host, dynamic import, and import-attribute value evidence, and output graph resolved-module missing-export conflicts that preserve edge-level package and import-attribute evidence. Host filesystem/package graph crawling, namespace runtime evaluation, ambient/global compatibility, and CommonJS runtime interop equivalence remain out of the root API. |

package/dist/declarations/js-ts-project-merge-proof-levels.d.ts

@@ -62,12 +62,14 @@ export interface JsTsProjectMergeProofEvidenceSummary {
   readonly failed: number;
   readonly skipped: number;
   readonly unknown: number;
+  readonly levelStatuses: Readonly<Record<string, JsTsProjectMergeProofEvidenceRecordStatus>>;
   readonly evidenceLevels: readonly JsTsProjectMergeProofLevel[];
   readonly passedLevels: readonly JsTsProjectMergeProofLevel[];
   readonly failedLevels: readonly JsTsProjectMergeProofLevel[];
   readonly skippedLevels: readonly JsTsProjectMergeProofLevel[];
   readonly unknownLevels: readonly JsTsProjectMergeProofLevel[];
   readonly missingLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly missingSignals: readonly string[];
   readonly unsupportedSurfaceEvidenceCount?: number;
   readonly unsupportedSurfaceKinds?: readonly string[];
   readonly unsupportedSurfaceReasonCodes?: readonly string[];
@@ -82,6 +84,7 @@ export interface JsTsProjectMergeProofEvidenceSummary {
   readonly nextMissingEvidence?: JsTsProjectMergeProofMissingEvidence;
   readonly semanticEquivalenceLevel: 'semantic-equivalence-unknown' | string;
   readonly semanticEquivalenceClaim: boolean;
+  readonly semanticEquivalenceUnknown: boolean;
   readonly evidenceOnly: true;
   readonly proofClaims: number;
 }
@@ -102,6 +105,7 @@ export interface JsTsProjectMergeProofEvidence {
     readonly evidenceOnly?: true;
     readonly proofClaims?: number;
     readonly missingLevels?: readonly JsTsProjectMergeProofLevel[];
+    readonly missingSignals?: readonly string[];
     readonly nextMissingEvidence?: JsTsProjectMergeProofMissingEvidence;
     readonly autoMergeClaim?: false;
     readonly semanticEquivalenceClaim?: boolean;

package/dist/declarations/js-ts-project-merge-summary.d.ts

@@ -1,16 +1,21 @@
 import type { JsTsProjectMergeProofLevel } from './js-ts-project-merge-proof-levels.js';
 import type { JsTsProjectSafeMergeMissingEvidenceTelemetry } from './js-ts-project-merge-confidence.js';
 
+export type JsTsProjectSourceTextMergeCandidateStatus = 'passed' | 'failed' | 'absent' | string;
+export type JsTsProjectMergeSummaryProofStatus = 'passed' | 'failed' | 'skipped' | 'unknown' | 'missing' | 'absent' | string;
+
 export interface JsTsProjectSafeMergeSummary {
   readonly files: number; readonly mergedFiles: number; readonly blockedFiles: number; readonly outputFiles: number;
+  readonly sourceTextMergeCandidateFiles: number; readonly sourceTextMergeBlockedFiles: number; readonly sourceTextMergeOutputFiles: number; readonly sourceTextMergeCandidateStatus: JsTsProjectSourceTextMergeCandidateStatus;
   readonly htmlFiles:number; readonly cssFiles:number; readonly htmlCssFiles:number; readonly htmlMergedFiles:number; readonly cssMergedFiles:number; readonly htmlCssMergedFiles:number; readonly htmlBlockedFiles:number; readonly cssBlockedFiles:number; readonly htmlCssBlockedFiles:number; readonly htmlCssBrowserRuntimeProofs:number;
   readonly htmlParserEvidenceFiles:number; readonly cssParserEvidenceFiles:number; readonly htmlCssParserEvidenceFiles:number; readonly htmlParserEvidenceFailedFiles:number; readonly cssParserEvidenceFailedFiles:number; readonly htmlCssParserEvidenceFailedFiles:number;
-  readonly htmlIdentityEvidenceFiles:number; readonly cssSelectorTargetEvidenceFiles:number; readonly htmlCssStructuralTargetEvidenceFiles:number; readonly htmlIdentityEvidenceFailedFiles:number; readonly cssSelectorTargetConflictFiles:number; readonly htmlCssStructuralTargetEvidenceFailedFiles:number; readonly cssSelectorTargetRebasedFiles:number;
-  readonly projectGraphConflicts: number; readonly projectGraphDeltaEvidenceIncluded: number; readonly outputProjectGraphConflicts:number; readonly projectGraphCssModuleUseSiteConflicts:number; readonly projectGraphDeltaConflicts: number; readonly projectGraphLimitConflicts: number; readonly projectGraphPublicContractConflicts: number; readonly projectGraphSourceSpanConflicts: number;
+  readonly htmlIdentityEvidenceFiles:number; readonly cssSelectorTargetEvidenceFiles:number; readonly htmlCssStructuralTargetEvidenceFiles:number; readonly cssSelectorTargetGraphEvidenceFiles:number; readonly cssSelectorSpecificityEvidenceFiles:number; readonly cssSelectorTargetMoveFiles:number; readonly htmlExplicitIdentityEvidenceFiles:number; readonly htmlPathOnlyIdentityResidualFiles:number; readonly htmlDuplicateIdentityEvidenceFiles:number; readonly htmlDuplicateIdentityKeys:number; readonly htmlRuntimeBoundaryEvidenceFiles:number; readonly htmlFrameworkBoundaryEvidenceFiles:number; readonly htmlProofGapBlockedFiles:number; readonly htmlIdentityEvidenceFailedFiles:number; readonly cssSelectorTargetConflictFiles:number; readonly htmlCssStructuralTargetEvidenceFailedFiles:number; readonly cssSelectorTargetRebasedFiles:number;
+  readonly cssScopedCascadeFiles:number; readonly cssScopedCascadeEvidenceFiles:number; readonly cssScopedCascadeBlockedFiles:number; readonly cssDependencySurfaceFiles:number; readonly cssDependencyGraphEvidenceFiles:number; readonly cssDependencyGraphMissingProofFiles:number; readonly cssDependencyGraphBlockedFiles:number;
+  readonly projectGraphConflicts: number; readonly projectGraphDeltaEvidenceIncluded: number; readonly projectGraphEvidenceIncluded: number; readonly outputProjectGraphConflicts:number; readonly projectGraphCssModuleUseSiteConflicts:number; readonly projectGraphDeltaConflicts: number; readonly projectGraphCssModuleUseSiteBlockers:number; readonly projectGraphLimitConflicts: number; readonly projectGraphCssModuleUseSiteGraphs:number; readonly projectGraphCssModuleUseSites:number; readonly projectGraphCssModuleImportBindings:number; readonly projectGraphPublicContractConflicts: number; readonly projectGraphSourceSpanConflicts: number;
   readonly projectGraphCompilerTypeConflicts: number; readonly projectGraphRuntimeRegionConflicts: number; readonly projectGraphScopeUseDefConflicts: number; readonly projectGraphJsxPropConflicts: number; readonly projectGraphJsxRenderRiskConflicts: number; readonly projectGraphReExportIdentityConflicts: number; readonly projectGraphModuleDeclarationShapeConflicts: number; readonly projectGraphExportAssignmentShapeConflicts: number;
   readonly projectGraphImportAttributeConflicts: number; readonly projectGraphImportTargetConflicts: number; readonly outputDiagnostics: number; readonly outputDiagnosticConflicts: number; readonly outputDiagnosticErrors: number; readonly outputDiagnosticWarnings: number; readonly outputDeclarations: number; readonly outputDeclarationBytes: number; readonly outputDeclarationConflicts: number; readonly outputDeclarationDiagnosticErrors: number; readonly outputQualityGates: number; readonly outputQualityGateConflicts: number;
-  readonly proofEvidenceRecords: number; readonly proofEvidencePassed: number; readonly proofEvidenceFailed: number; readonly proofEvidenceSkipped: number; readonly proofEvidenceUnknown: number; readonly proofEvidenceMissing: number; readonly proofEvidenceMissingLevels: readonly JsTsProjectMergeProofLevel[]; readonly semanticEquivalenceLevel: 'semantic-equivalence-unknown' | string;
-  readonly evidenceRecords: number; readonly passedEvidenceRecords: number; readonly failedEvidenceRecords: number; readonly unknownEvidenceRecords: number; readonly confidenceScore: number; readonly confidenceLevel: string; readonly confidenceDimensions: Readonly<Record<string,string>>; readonly missingEvidenceMatrix: JsTsProjectSafeMergeMissingEvidenceTelemetry; readonly missingSignals: number;
+  readonly proofEvidenceRecords: number; readonly proofEvidencePassed: number; readonly proofEvidenceFailed: number; readonly proofEvidenceSkipped: number; readonly proofEvidenceUnknown: number; readonly proofEvidenceMissing: number; readonly proofEvidenceMissingLevels: readonly JsTsProjectMergeProofLevel[]; readonly proofEvidenceMissingSignals: readonly string[]; readonly proofEvidenceNextMissingCode?: string; readonly proofEvidenceNextMissingLevel?: JsTsProjectMergeProofLevel; readonly proofEvidenceNextMissingScope?: string; readonly proofEvidenceLevelStatuses: Readonly<Record<string,JsTsProjectMergeSummaryProofStatus>>; readonly proofSyntaxIdentityStatus: JsTsProjectMergeSummaryProofStatus; readonly proofSourceSpanRoundtripStatus: JsTsProjectMergeSummaryProofStatus; readonly proofSemanticEditReplayCleanStatus: JsTsProjectMergeSummaryProofStatus; readonly proofDiagnosticsStatus: JsTsProjectMergeSummaryProofStatus; readonly proofDeclarationOutputStatus: JsTsProjectMergeSummaryProofStatus; readonly proofFocusedTestStatus: JsTsProjectMergeSummaryProofStatus; readonly proofSemanticEquivalenceStatus: JsTsProjectMergeSummaryProofStatus; readonly semanticEquivalenceLevel: 'semantic-equivalence-unknown' | string; readonly semanticEquivalenceClaim: boolean;
+  readonly evidenceRecords: number; readonly passedEvidenceRecords: number; readonly failedEvidenceRecords: number; readonly unknownEvidenceRecords: number; readonly confidenceScore: number; readonly confidenceLevel: string; readonly confidenceDimensions: Readonly<Record<string,string>>; readonly missingEvidenceMatrix: JsTsProjectSafeMergeMissingEvidenceTelemetry; readonly routingCalibration?: Readonly<Record<string,unknown>>; readonly missingSignals: number; readonly admissionMatrixPartialRows: number;
   readonly nextMissingEvidenceCode?: string; readonly nextMissingEvidenceKind?: string; readonly nextMissingEvidenceScope?: string; readonly nextMissingProofLevel?: string; readonly nextMissingEvidenceAction?: string; readonly nextMissingEvidenceRouteId?: string; readonly nextMissingEvidenceRouteLane?: string; readonly nextMissingEvidenceRouteNext?: string;
   readonly projectMoveRenameClassifications: number; readonly projectFileMoveRenameClassifications: number; readonly projectSymbolMoveClassifications: number; readonly projectExportedSymbolMoveClassifications: number; readonly projectImportedSymbolMoveClassifications: number; readonly projectSymbolMoveAdmissions: number; readonly projectExportedSymbolMoveAdmissions: number; readonly projectImportedSymbolMoveAdmissions: number; readonly projectCrossFileSymbolRenameClassifications: number; readonly projectCrossFileSymbolRenameAdmissions: number;
   readonly projectSplitMergeClassifications: number; readonly projectModuleSplitClassifications: number; readonly projectModuleMergeClassifications: number; readonly projectClassSplitClassifications: number; readonly projectClassMergeClassifications: number; readonly projectSplitMergeAdmissions: number; readonly projectModuleSplitAdmissions: number; readonly projectModuleMergeAdmissions: number; readonly projectClassSplitAdmissions: number; readonly projectClassMergeAdmissions: number;

package/dist/declarations/js-ts-safe-project-merge.d.ts

@@ -21,7 +21,7 @@ export type { JsTsProjectMergeQualityGate, JsTsProjectMergeQualityGateDecision,
 export type { JsTsProjectMergeProofEvidence, JsTsProjectMergeProofEvidenceRecord, JsTsProjectMergeProofEvidenceRecordStatus, JsTsProjectMergeProofEvidenceStatus, JsTsProjectMergeProofEvidenceSummary, JsTsProjectMergeProofLevel, JsTsProjectMergeProofMissingEvidence } from './js-ts-project-merge-proof-levels.js';
 export type { JsTsProjectSafeMergeAdmissionRoute, JsTsProjectSafeMergeAdmissionRouteSummary } from './js-ts-project-merge-admission-routes.js';
 export type { JsTsProjectSafeMergeConfidenceSummary, JsTsProjectSafeMergeMissingEvidence, JsTsProjectSafeMergeMissingEvidenceRoute, JsTsProjectSafeMergeMissingEvidenceTelemetry, JsTsProjectSafeMergeRecommendedAction } from './js-ts-project-merge-confidence.js';
-export type { JsTsProjectSafeMergeSummary } from './js-ts-project-merge-summary.js';
+export type { JsTsProjectMergeSummaryProofStatus, JsTsProjectSafeMergeSummary, JsTsProjectSourceTextMergeCandidateStatus } from './js-ts-project-merge-summary.js';
 export type { JsTsProjectCommonJsRuntimeInteropProof } from './js-ts-project-merge-commonjs-interop.js';
 export type { JsTsProjectGlobalAugmentationCompatibilityProof } from './js-ts-project-merge-global-augmentation.js'; export type { JsTsProjectJsxRenderReturnBranchArmOrigin, JsTsProjectJsxRenderReturnBranchControlKind, JsTsProjectJsxRenderReturnBranchProof } from './js-ts-project-merge-jsx-render-branch.js';
 

package/dist/js-ts-safe-project-merge-admission-routes.js

@@ -106,6 +106,7 @@ function projectAdmissionRouteFromMissingEvidence(item) {
   const routeId = item?.routeId ?? route.id;
   if (!routeId) return undefined;
   const action = normalizedRouteAction(item?.action);
+  const missingEvidence = missingEvidenceCodes(item);
   return routeRecord({
     routeId,
     routeKind: action,
@@ -118,6 +119,14 @@ function projectAdmissionRouteFromMissingEvidence(item) {
     proofLevel: item?.proofLevel,
     evidenceId: item?.evidenceId,
     reasonCodes: uniqueStrings([item?.code, ...(item?.relatedSignals ?? [])]),
+    requiredEvidence: item?.requiredEvidence ?? inferredRequiredEvidence(item),
+    presentEvidence: item?.presentEvidence ?? inferredPresentEvidence(item),
+    missingEvidence,
+    recommendedAction: item?.recommendedAction ?? recommendedActionFromMissingEvidence(item),
+    confidenceDimension: item?.confidenceDimension ?? confidenceDimensionFromMissingEvidence(item),
+    blocksSemanticEquivalence: item?.blocksSemanticEquivalence ?? semanticEquivalenceEvidenceGap(item),
+    summary: item?.summary,
+    nextAction: item?.nextAction,
     details: item
   });
 }
@@ -175,6 +184,11 @@ function routeRecord(input) {
     requiredEvidence: input.requiredEvidence,
     presentEvidence: input.presentEvidence,
     missingEvidence: input.missingEvidence,
+    recommendedAction: input.recommendedAction,
+    confidenceDimension: input.confidenceDimension,
+    blocksSemanticEquivalence: input.blocksSemanticEquivalence,
+    summary: input.summary,
+    nextAction: input.nextAction,
     details: input.details,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false
@@ -200,6 +214,45 @@ function normalizedRouteAction(action) {
   return 'review';
 }
 
+function missingEvidenceCodes(item) {
+  return uniqueStrings([item?.code, ...(item?.missingEvidence ?? []), ...(item?.missingSignals ?? [])]);
+}
+
+function inferredRequiredEvidence(item) {
+  if (semanticEquivalenceEvidenceGap(item)) return ['semantic-equivalence-external'];
+  return item?.proofLevel ? [item.proofLevel] : undefined;
+}
+
+function inferredPresentEvidence(item) {
+  if (item?.proofLevel === 'semantic-equivalence-unknown') return ['semantic-equivalence-unknown'];
+  if (item?.proofLevel === 'semantic-equivalence-external' && item?.status === 'failed') return ['semantic-equivalence-external'];
+  return undefined;
+}
+
+function recommendedActionFromMissingEvidence(item) {
+  const action = normalizedRouteAction(item?.action);
+  if (action === 'reject' || action === 'block') return 'block';
+  if (action === 'rerun') return 'rerun';
+  return 'review';
+}
+
+function confidenceDimensionFromMissingEvidence(item) {
+  if (semanticEquivalenceEvidenceGap(item)) return 'semanticEquivalence';
+  if (item?.scope === 'project-output' && item?.kind === 'diagnostics') return 'diagnostics';
+  if (item?.scope === 'project-output' && item?.kind === 'declaration-output') return 'declarations';
+  if (item?.scope === 'quality-gates') return 'quality';
+  if (item?.scope === 'project-graph') return 'graph';
+  if (item?.scope === 'source-files') return 'proof';
+  return undefined;
+}
+
+function semanticEquivalenceEvidenceGap(item) {
+  return item?.code === 'semantic-equivalence-proof-not-available'
+    || item?.code === 'semantic-equivalence-proof-failed'
+    || item?.proofLevel === 'semantic-equivalence-unknown'
+    || item?.proofLevel === 'semantic-equivalence-external';
+}
+
 function routeSpec(routeId, routeLane, routeNext) { return Object.freeze({ routeId, routeLane, routeNext }); }
 function countField(values, field) { const result = {}; for (const value of values) if (value?.[field]) result[value[field]] = (result[value[field]] ?? 0) + 1; return result; }
 function uniqueStrings(values) { return [...new Set((values ?? []).filter((value) => typeof value === 'string' && value.length > 0))]; }

package/dist/js-ts-safe-project-merge-html-css-matrix.js

@@ -15,7 +15,7 @@ function htmlCssProjectMergeMissingEvidenceRoutes(route, signals) {
     [signals.cssParserEvidence]: route('prove-css-parser-source-evidence', 'layout-style-parser', 'supply-postcss-source-span-and-trivia-evidence'),
     [signals.htmlIdentityEvidence]: route('prove-html-identity-evidence', 'layout-markup-identity', 'supply-stable-element-identity-and-structural-addressability-evidence'),
     [signals.cssSelectorTargetEvidence]: route('prove-css-selector-target-evidence', 'layout-style-targets', 'supply-selector-target-graph-and-rebase-evidence'),
-    [signals.htmlStructuralMerge]: route('admit-html-structural-merge', 'layout-markup-graph', 'supply-html-parser-reference-and-boundary-evidence'),
+    [signals.htmlStructuralMerge]: route('admit-html-structural-merge', 'layout-markup-graph', 'attach-source-bound-html-runtime-proof-or-fix-duplicate-identity'),
     [signals.cssCascadeMerge]: route('admit-css-cascade-merge', 'layout-style-graph', 'supply-css-parser-cascade-and-scope-evidence'),
     [signals.cssDependencyGraphEvidence]: route('prove-css-dependency-graph', 'layout-style-graph', 'supply-css-custom-property-animation-font-and-asset-dependency-graph'),
     [signals.htmlCssBrowserRuntimeProof]: route('prove-html-css-browser-runtime', 'browser-proof', 'attach-browser-runtime-proof-bundle')
@@ -41,7 +41,7 @@ function htmlCssProjectMergeMissingEvidenceItems(summary, signals, missingEviden
   if (summary.cssFiles && summary.cssParserEvidenceFiles !== summary.cssFiles) items.push(missingEvidenceItem({ code: signals.cssParserEvidence, scope: 'layout-style-parser', kind: 'css-parser-source-evidence', proofLevel: 'css-parser-source-evidence', action: 'review', summary: `CSS project merge has parser/source evidence for ${summary.cssParserEvidenceFiles}/${summary.cssFiles} file(s); require PostCSS rule/declaration spans, raw trivia hashes, and zero parse errors before parser evidence admission.` }));
   if (summary.htmlFiles && summary.htmlIdentityEvidenceFiles !== summary.htmlFiles) items.push(missingEvidenceItem({ code: signals.htmlIdentityEvidence, scope: 'layout-markup-identity', kind: 'html-identity-evidence', proofLevel: 'html-identity-evidence', action: 'review', summary: `HTML project merge has structural identity evidence for ${summary.htmlIdentityEvidenceFiles}/${summary.htmlFiles} file(s) with ${summary.htmlDuplicateIdentityEvidenceFiles ?? 0} duplicate identity evidence file(s); require parser-backed structural spans, unique explicit identity keys, and stable explicit/path identity accounting before structural admission.` }));
   if (summary.cssFiles && (summary.cssSelectorTargetEvidenceFiles !== summary.cssFiles || summary.cssSelectorTargetConflictFiles)) items.push(missingEvidenceItem({ code: signals.cssSelectorTargetEvidence, scope: 'layout-style-targets', kind: 'css-selector-target-evidence', proofLevel: 'css-selector-target-evidence', action: 'review', summary: `CSS project merge has selector-target evidence for ${summary.cssSelectorTargetEvidenceFiles}/${summary.cssFiles} file(s) with ${summary.cssSelectorTargetConflictFiles} selector target conflict(s); require selector target graph and proven rebase before target-moving merges.` }));
-  if (summary.htmlBlockedFiles) items.push(missingEvidenceItem({ code: signals.htmlStructuralMerge, scope: 'layout-markup-graph', kind: 'html-structural-merge-proof', proofLevel: 'html-structural-merge', action: 'review', summary: `HTML project merge has ${summary.htmlBlockedFiles} blocked file(s); supply parser/source-span evidence, stable element identity, and runtime-boundary proof before admission.` }));
+  if (summary.htmlBlockedFiles) items.push(missingEvidenceItem({ code: signals.htmlStructuralMerge, scope: 'layout-markup-graph', kind: 'html-structural-merge-proof', proofLevel: 'html-structural-merge', action: 'review', summary: `HTML project merge has ${summary.htmlBlockedFiles} blocked file(s); for runtime-boundary changes attach htmlRuntimeBoundaryProofsByPath[sourcePath] with exact base/worker/head/output binding, and for duplicate identity keys make explicit HTML identities unique before admission.`, suggestedInput: { htmlRuntimeBoundaryProofsByPath: true, htmlUniqueExplicitIdentityKeys: true } }));
   if (summary.cssBlockedFiles) items.push(missingEvidenceItem({ code: signals.cssCascadeMerge, scope: 'layout-style-graph', kind: 'css-cascade-merge-proof', proofLevel: 'css-cascade-merge', action: 'review', summary: `CSS project merge has ${summary.cssBlockedFiles} blocked file(s), including ${summary.cssScopedCascadeBlockedFiles} scoped cascade proof block(s); supply parser/cascade/scope evidence, require scopedCascadeGraphHash for changed declarations under @media/@supports/@container/@layer/@scope or nested scopes, and keep browser claims false until runtime proof passes.` }));
   if (summary.cssDependencySurfaceFiles && (summary.cssDependencyGraphEvidenceFiles !== summary.cssDependencySurfaceFiles || summary.cssDependencyGraphMissingProofFiles || summary.cssDependencyGraphBlockedFiles)) items.push(missingEvidenceItem({ code: signals.cssDependencyGraphEvidence, scope: 'layout-style-graph', kind: 'css-dependency-graph-evidence', proofLevel: 'css-dependency-graph', action: 'review', summary: `CSS project merge has dependency graph evidence for ${summary.cssDependencyGraphEvidenceFiles}/${summary.cssDependencySurfaceFiles} dependency-surface file(s), ${summary.cssDependencyGraphMissingProofFiles} missing dependency graph proof(s), and ${summary.cssDependencyGraphBlockedFiles} dependency blocker(s); require custom property, var() fallback, @keyframes/animation-name, @font-face, and url() asset graph evidence before cascade/browser equivalence claims.`, suggestedInput: { cssDependencyGraphEvidence: true } }));
   if (summary.htmlCssMergedFiles && !summary.htmlCssBrowserRuntimeProofs) items.push(missingEvidenceItem({ code: signals.htmlCssBrowserRuntimeProof, scope: 'browser-proof', kind: 'browser-runtime-proof', proofLevel: 'browser-runtime-proof', action: 'review', summary: 'HTML/CSS structural source merge was available, but browser DOM/cascade/layout/runtime proof was not attached; keep browser equivalence claims false.', suggestedInput: { browserRuntimeProof: true } }));

package/dist/js-ts-safe-project-merge-html-css-summary.js

@@ -42,7 +42,7 @@ function hasHtmlExplicitIdentityEvidence(file) {
 }
 function hasHtmlPathOnlyIdentityResidual(file) { return (file?.result?.identityEvidence?.pathOnlyIdentityElements ?? 0) > 0; }
 function hasHtmlRuntimeBoundaryEvidence(file) {
-  return (file?.result?.identityEvidence?.runtimeBoundaryElements ?? 0) > 0 || hasRuntimeBoundaryConflict(file);
+  return (file?.result?.identityEvidence?.runtimeBoundaryElements ?? 0) > 0 || hasRuntimeBoundaryConflict(file) || hasHtmlRuntimeBoundaryProof(file);
 }
 function hasHtmlFrameworkBoundaryEvidence(file) {
   return (file?.result?.identityEvidence?.frameworkBoundaryElements ?? 0) > 0 || hasFrameworkBoundaryConflict(file);
@@ -74,6 +74,9 @@ function hasHtmlProofGapBlockedConflict(file) {
 function hasRuntimeBoundaryConflict(file) {
   return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => HtmlRuntimeBoundaryReasonCodes.has(conflict?.details?.reasonCode));
 }
+function hasHtmlRuntimeBoundaryProof(file) {
+  return [...(file?.result?.runtimeBoundaryProofs ?? []), ...(file?.result?.admission?.htmlRuntimeBoundaryProofs ?? file?.admission?.htmlRuntimeBoundaryProofs ?? [])].some((proof) => proof?.status === 'passed' && HtmlRuntimeBoundaryReasonCodes.has(proof.reasonCode));
+}
 function hasFrameworkBoundaryConflict(file) {
   return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => HtmlFrameworkBoundaryReasonCodes.has(conflict?.details?.reasonCode));
 }

package/dist/js-ts-safe-project-merge-html-css.js

@@ -13,9 +13,10 @@ function maybeMergeHtmlCssProjectFile(options) {
   const merge = language === 'html' ? safeMergeHtmlSource : language === 'css' ? safeMergeCssSource : undefined;
   if (!merge) return undefined;
   const resultId = `${projectId}_${safeId(file.sourcePath)}`;
-  const result = merge({ ...sourceInput, ...htmlCssMergeOptionsForProjectFile(input, file.sourcePath, language), ...context, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head });
+  const mergeOptions = htmlCssMergeOptionsForProjectFile(input, file.sourcePath, language);
+  const result = merge({ ...sourceInput, ...mergeOptions, ...context, id: resultId, baseSourceText: base, workerSourceText: worker, headSourceText: head });
   const admittedResult = language === 'html' && result.status === 'merged'
-    ? blockHtmlProofGapChanges({ result, id: resultId, sourcePath: file.sourcePath, base, worker, head }) ?? result
+    ? blockHtmlProofGapChanges({ result, id: resultId, sourcePath: file.sourcePath, base, worker, head, runtimeBoundaryProofs: htmlRuntimeBoundaryProofCandidates(input, file.sourcePath, mergeOptions) }) ?? result
     : result;
   return admittedResult.status === 'merged' ? mergedHtmlCssFile(file, context, admittedResult, language) : blockedHtmlCssFile(file, context, admittedResult);
 }
@@ -36,12 +37,20 @@ function htmlCssMergeOptionsForProjectFile(input, sourcePath, language) {
   return compactRecord({ ...(language === 'css' ? input.cssMergeOptions ?? input.styleMergeOptions : input.htmlMergeOptions ?? input.markupMergeOptions), ...(byPath?.[sourcePath] ?? {}) });
 }
 
-function blockHtmlProofGapChanges({ result, id, sourcePath, base, worker, head }) {
+function blockHtmlProofGapChanges({ result, id, sourcePath, base, worker, head, runtimeBoundaryProofs = [] }) {
+  const binding = { sourcePath, base, worker, head, output: result.mergedSourceText };
+  const runtimeBoundaryProofRecords = [];
+  const runtimeBoundaryConflicts = [];
+  for (const change of htmlRuntimeBoundaryChanges(base, worker, head)) {
+    const proof = htmlRuntimeBoundaryProofForChange(runtimeBoundaryProofs, change, binding);
+    if (proof) runtimeBoundaryProofRecords.push(htmlRuntimeBoundaryProofRecord(proof, change, binding));
+    else runtimeBoundaryConflicts.push(htmlProofGapConflict(id, sourcePath, change.reasonCode, change));
+  }
   const conflicts = [
-    htmlDuplicateIdentityConflict(result),
-    ...htmlRuntimeBoundaryChanges(base, worker, head).map((change) => htmlProofGapConflict(id, sourcePath, change.reasonCode, change))
+    htmlDuplicateIdentityConflict(result, sourcePath),
+    ...runtimeBoundaryConflicts
   ].filter(Boolean);
-  if (!conflicts.length) return undefined;
+  if (!conflicts.length) return runtimeBoundaryProofRecords.length ? htmlRuntimeBoundaryProvenResult(result, runtimeBoundaryProofRecords) : undefined;
   const allConflicts = [...(result.conflicts ?? []), ...conflicts];
   const { mergedSourceText, mergedSourceHash, ...rest } = result;
   return compactRecord({
@@ -56,15 +65,32 @@ function blockHtmlProofGapChanges({ result, id, sourcePath, base, worker, head }
   });
 }
 
-function htmlDuplicateIdentityConflict(result) {
+function htmlDuplicateIdentityConflict(result, sourcePath) {
   const duplicates = duplicateHtmlExplicitIdentityKeys(result?.identityEvidence);
   if (!duplicates.length) return undefined;
-  return htmlProofGapConflict(result.id, result.sourcePath, 'html-duplicate-explicit-identity', {
+  return htmlProofGapConflict(result.id, result.sourcePath ?? sourcePath, 'html-duplicate-explicit-identity', {
     boundary: 'html-explicit-identity',
     duplicateIdentityKeys: duplicates
   }, 'html-duplicate-identity-blocked');
 }
 
+function htmlRuntimeBoundaryProofCandidates(input, sourcePath, mergeOptions) {
+  return [
+    input.htmlRuntimeBoundaryProof,
+    input.htmlRuntimeBoundaryProofs,
+    input.htmlRuntimeBoundaryProofsByPath?.[sourcePath],
+    input.htmlSourceBoundRuntimeBoundaryProof,
+    input.htmlSourceBoundRuntimeBoundaryProofs,
+    input.htmlSourceBoundRuntimeBoundaryProofsByPath?.[sourcePath],
+    mergeOptions.htmlRuntimeBoundaryProof,
+    mergeOptions.htmlRuntimeBoundaryProofs,
+    mergeOptions.sourceBoundRuntimeBoundaryProof,
+    mergeOptions.sourceBoundRuntimeBoundaryProofs,
+    mergeOptions.runtimeBoundaryProof,
+    mergeOptions.runtimeBoundaryProofs
+  ].flatMap(asArray).filter(Boolean);
+}
+
 function duplicateHtmlExplicitIdentityKeys(identityEvidence) {
   return Object.entries(identityEvidence?.sides ?? {}).flatMap(([side, evidence]) => {
     const counts = new Map();
@@ -95,6 +121,73 @@ function htmlRuntimeBoundaryChange(side, base, sourceText, baseEventHandlers) {
   };
 }
 
+function htmlRuntimeBoundaryProofForChange(proofs, change, binding) {
+  return proofs.find((proof) => isHtmlRuntimeBoundaryProofForChange(proof, change, binding));
+}
+
+function isHtmlRuntimeBoundaryProofForChange(proof, change, binding) {
+  return Boolean(proof && typeof proof === 'object') &&
+    HtmlRuntimeBoundaryProofKinds.has(proof.kind) &&
+    proof.status === 'passed' &&
+    proof.sourcePath === binding.sourcePath &&
+    htmlProofCoversValue(proof.reasonCode, proof.reasonCodes, change.reasonCode) &&
+    htmlProofCoversValue(proof.side, proof.sides, change.side) &&
+    proof.boundary === change.boundary &&
+    sameStringSet(proof.boundaryAttributes ?? proof.changedBoundaryAttributes, change.boundaryAttributes) &&
+    htmlRuntimeBoundaryProofSourceBound(proof, binding);
+}
+
+function htmlRuntimeBoundaryProofSourceBound(proof, binding) {
+  return htmlRuntimeBoundaryProofSourceMatches(proof, 'base', binding.base) &&
+    htmlRuntimeBoundaryProofSourceMatches(proof, 'worker', binding.worker) &&
+    htmlRuntimeBoundaryProofSourceMatches(proof, 'head', binding.head) &&
+    htmlRuntimeBoundaryProofSourceMatches(proof, 'output', binding.output);
+}
+
+function htmlRuntimeBoundaryProofSourceMatches(proof, role, sourceText) {
+  if (typeof sourceText !== 'string') return false;
+  const hash = hashText(sourceText);
+  const textFields = role === 'output' ? ['outputSourceText', 'mergedSourceText'] : [`${role}SourceText`];
+  const hashFields = role === 'output' ? ['outputSourceHash', 'mergedSourceHash'] : [`${role}SourceHash`];
+  const aliases = role === 'output' ? ['output', 'merged'] : [role];
+  return textFields.some((field) => proof[field] === sourceText) ||
+    aliases.some((alias) => proof.sourceTexts?.[alias] === sourceText || proof.sources?.[alias] === sourceText) ||
+    hashFields.some((field) => proof[field] === hash) ||
+    aliases.some((alias) => proof.sourceHashes?.[alias] === hash || proof.hashes?.[alias] === hash);
+}
+
+function htmlRuntimeBoundaryProofRecord(proof, change, binding) {
+  return compactRecord({
+    id: proof.id,
+    kind: proof.kind,
+    status: 'passed',
+    proofLevel: proof.proofLevel ?? 'html-runtime-boundary-source-bound',
+    reasonCode: change.reasonCode,
+    side: change.side,
+    boundary: change.boundary,
+    boundaryAttributes: change.boundaryAttributes,
+    sourcePath: binding.sourcePath,
+    baseSourceHash: hashText(binding.base),
+    workerSourceHash: hashText(binding.worker),
+    headSourceHash: hashText(binding.head),
+    outputSourceHash: hashText(binding.output)
+  });
+}
+
+function htmlRuntimeBoundaryProvenResult(result, runtimeBoundaryProofs) {
+  return compactRecord({
+    ...result,
+    runtimeBoundaryProofs,
+    browserRuntimeEquivalenceClaim: true,
+    admission: compactRecord({
+      ...(result.admission ?? {}),
+      browserRuntimeEquivalenceClaim: true,
+      htmlRuntimeBoundaryProofs: runtimeBoundaryProofs,
+      reasonCodes: uniqueStrings([...(result.admission?.reasonCodes ?? []), 'html-runtime-boundary-source-bound'])
+    })
+  });
+}
+
 function htmlEventHandlerBoundaryFingerprint(sourceText) {
   return htmlEventHandlerBoundaryAttributes(sourceText)
     .map((attribute) => `${attribute.tagName}:${attribute.name}=${String(attribute.value)}`)
@@ -126,6 +219,22 @@ function parseHtmlAttributes(text) {
   return attributes;
 }
 
+function htmlProofCoversValue(value, values, expected) {
+  return value === expected || (Array.isArray(values) && values.includes(expected));
+}
+
+function sameStringSet(actual, expected) {
+  const actualSet = uniqueStrings(asArray(actual).map((value) => String(value)));
+  const expectedSet = uniqueStrings(asArray(expected).map((value) => String(value)));
+  return actualSet.length === expectedSet.length && expectedSet.every((value) => actualSet.includes(value));
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : value === undefined ? [] : [value];
+}
+
+const HtmlRuntimeBoundaryProofKinds = new Set(['html-runtime-boundary-proof', 'html-source-bound-runtime-boundary-proof']);
+
 function htmlProofGapConflict(id, sourcePath, reasonCode, details = {}, code = 'html-proof-gap-blocked') {
   return {
     code,
@@ -138,6 +247,7 @@ function htmlProofGapConflict(id, sourcePath, reasonCode, details = {}, code = '
         code: reasonCode,
         status: 'not-claimed',
         summary: htmlProofGapSummary(reasonCode),
+        nextProof: htmlProofGapNextProof(reasonCode),
         failClosed: true,
         semanticEquivalenceClaim: false
       },
@@ -152,6 +262,12 @@ function htmlProofGapSummary(reasonCode) {
   return 'HTML proof gap requires source-bound evidence before structural merge admission.';
 }
 
+function htmlProofGapNextProof(reasonCode) {
+  if (reasonCode === 'html-duplicate-explicit-identity') return 'Rename duplicate explicit HTML identity keys or supply parser-backed identity evidence with unique explicitIdentityKeys on every side.';
+  if (reasonCode === 'event-handler-runtime-boundary') return 'Attach htmlRuntimeBoundaryProofsByPath[sourcePath] with kind html-source-bound-runtime-boundary-proof, status passed, sourcePath, reasonCode, side, boundary, boundaryAttributes, and exact base/worker/head/output source text or hashes.';
+  return 'Attach source-bound HTML parser, identity, and runtime-boundary evidence for the changed file before structural admission.';
+}
+
 function blockedHtmlProofGapAdmission(admission = {}, conflicts = []) {
   return {
     ...admission,

package/dist/js-ts-safe-project-merge-missing-evidence.js

@@ -15,7 +15,8 @@ const ProjectMergeMissingSignals = Object.freeze({
   unsupportedJsTsSurface: 'unsupported-js-ts-surface-proof-not-available',
   ...HtmlCssProjectMergeMissingSignals,
   cssModuleUseSiteGraph: 'css-module-use-site-graph-proof-blocked',
-  semanticEquivalenceProof: 'semantic-equivalence-proof-not-available'
+  semanticEquivalenceProof: 'semantic-equivalence-proof-not-available',
+  semanticEquivalenceProofFailed: 'semantic-equivalence-proof-failed'
 });
 
 const ProjectMergeMissingEvidenceRoutes = Object.freeze({
@@ -33,7 +34,8 @@ const ProjectMergeMissingEvidenceRoutes = Object.freeze({
   [ProjectMergeMissingSignals.unsupportedJsTsSurface]: route('prove-unsupported-js-ts-surface', 'semantic-proof', 'supply-unsupported-surface-evidence'),
   ...htmlCssProjectMergeMissingEvidenceRoutes(route, ProjectMergeMissingSignals),
   [ProjectMergeMissingSignals.cssModuleUseSiteGraph]: route('prove-css-module-use-site-graph', 'layout-style-graph', 'supply-css-module-transform-and-use-site-proof'),
-  [ProjectMergeMissingSignals.semanticEquivalenceProof]: route('external-semantic-equivalence-proof', 'semantic-proof', 'attach-external-equivalence-proof')
+  [ProjectMergeMissingSignals.semanticEquivalenceProof]: route('external-semantic-equivalence-proof', 'semantic-proof', 'attach-external-equivalence-proof'),
+  [ProjectMergeMissingSignals.semanticEquivalenceProofFailed]: route('reject-semantic-equivalence-proof', 'semantic-proof', 'inspect-external-equivalence-proof-binding')
 });
 
 const ProjectMergeAdmissionMatrixRows = Object.freeze([
@@ -48,7 +50,7 @@ const ProjectMergeAdmissionMatrixRows = Object.freeze([
   matrixRow('unsupported-js-ts-surface-coverage', 'partial', ['unsupported-js-ts-surface-review'], [ProjectMergeMissingSignals.unsupportedJsTsSurface]),
   ...htmlCssProjectMergeAdmissionMatrixRows(matrixRow, ProjectMergeMissingSignals),
   matrixRow('css-modules-use-site-graph', 'partial', ['css-module-use-site-graph', 'css-module-transform-proof', 'project-graph-evidence'], [ProjectMergeMissingSignals.cssModuleUseSiteGraph]),
-  matrixRow('semantic-equivalence-proof', 'bounded-evidence', ['semantic-equivalence-external', 'semantic-equivalence-unknown'], [ProjectMergeMissingSignals.semanticEquivalenceProof]),
+  matrixRow('semantic-equivalence-proof', 'bounded-evidence', ['semantic-equivalence-external', 'semantic-equivalence-unknown'], [ProjectMergeMissingSignals.semanticEquivalenceProof, ProjectMergeMissingSignals.semanticEquivalenceProofFailed]),
   matrixRow('cross-file-symbol-rename', 'partial', ['diagnostics-clean', 'declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.outputDiagnosticsGate, ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
   matrixRow('symbol-move-between-files', 'partial', ['diagnostics-clean', 'declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.outputDiagnosticsGate, ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
   matrixRow('split-merge-modules-classes', 'partial', ['diagnostics-clean', 'declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.outputDiagnosticsGate, ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
@@ -133,12 +135,10 @@ function missingEvidenceItems(summary, context = {}) {
     summary: 'Semantic edit artifacts were produced, but clean replay proof was not available for every semantic edit candidate.'
   }));
   if (summary.semanticEquivalenceLevel === 'semantic-equivalence-unknown') items.push(missingEvidenceItem({
-    code: ProjectMergeMissingSignals.semanticEquivalenceProof,
-    scope: 'project',
-    kind: 'semantic-equivalence',
-    proofLevel: 'semantic-equivalence-unknown',
-    action: 'review',
-    summary: 'Executable semantic equivalence is still unknown; keep semanticEquivalenceClaim false and require human or external proof for equivalence claims.'
+    code: ProjectMergeMissingSignals.semanticEquivalenceProof, scope: 'project', kind: 'semantic-equivalence', proofLevel: 'semantic-equivalence-unknown', action: 'review',
+    requiredEvidence: ['semantic-equivalence-external'], presentEvidence: ['semantic-equivalence-unknown'], recommendedAction: 'review', confidenceDimension: 'semanticEquivalence', blocksSemanticEquivalence: true,
+    summary: 'Executable semantic equivalence is still unknown; keep semanticEquivalenceClaim false and require human or external proof for equivalence claims.',
+    nextAction: 'Attach a source/output/gate-bound external semantic equivalence proof or keep the route in human review.'
   }));
   if (summary.projectGraphCssModuleUseSiteConflicts) items.push(missingEvidenceItem({
     code: ProjectMergeMissingSignals.cssModuleUseSiteGraph, scope: 'layout-style-graph', kind: 'css-module-use-site-proof', proofLevel: 'css-module-use-site-graph', action: 'review',
@@ -220,8 +220,9 @@ function missingEvidenceItem(input) {
     routeLane: route?.lane,
     routeNext: route?.next,
     relatedSignals: input.relatedSignals,
-    summary: input.summary,
-    suggestedInput: input.suggestedInput,
+    requiredEvidence: input.requiredEvidence, presentEvidence: input.presentEvidence, recommendedAction: input.recommendedAction,
+    confidenceDimension: input.confidenceDimension, blocksSemanticEquivalence: input.blocksSemanticEquivalence,
+    summary: input.summary, nextAction: input.nextAction, suggestedInput: input.suggestedInput,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false
   });

package/dist/js-ts-safe-project-merge-semantic-equivalence-proof.js

@@ -5,6 +5,12 @@ const ExternalSemanticEquivalenceLevel = 'semantic-equivalence-external';
 const ExternalSemanticEquivalenceSchema = 'frontier.lang.jsTsProjectSemanticEquivalenceProof.v1';
 const ExternalSemanticEquivalenceKind = 'frontier.lang.jsTsProjectSemanticEquivalenceProof';
 const ExternalSemanticEquivalenceClaimBoundary = 'exact-js-ts-project-source-output-and-gates';
+const FailedSemanticEquivalenceProofSignal = 'semantic-equivalence-proof-failed';
+const FailedSemanticEquivalenceProofRoute = Object.freeze({
+  id: 'reject-semantic-equivalence-proof',
+  lane: 'semantic-proof',
+  next: 'inspect-external-equivalence-proof-binding'
+});
 
 function semanticEquivalenceExternalEvidence(id, input = {}) {
   const proof = input.externalSemanticEquivalenceProof ?? input.semanticEquivalenceProof;
@@ -34,6 +40,7 @@ function semanticEquivalenceExternalEvidence(id, input = {}) {
       artifactHash: proof?.artifactHash,
       expected,
       reasonCodes,
+      nextMissingEvidence: status === 'failed' ? failedSemanticEquivalenceProofMissingEvidence(reasonCodes) : undefined,
       proofHash: proof?.proofHash,
       expectedProofHash: proof && typeof proof === 'object' ? jsTsProjectSemanticEquivalenceProofHash(proof) : undefined,
       proofClaim: status === 'passed',
@@ -43,6 +50,31 @@ function semanticEquivalenceExternalEvidence(id, input = {}) {
   };
 }
 
+function failedSemanticEquivalenceProofMissingEvidence(reasonCodes = []) {
+  return {
+    code: FailedSemanticEquivalenceProofSignal,
+    kind: 'semantic-equivalence',
+    scope: 'project',
+    status: 'failed',
+    action: 'reject-proof',
+    proofLevel: ExternalSemanticEquivalenceLevel,
+    route: FailedSemanticEquivalenceProofRoute,
+    routeId: FailedSemanticEquivalenceProofRoute.id,
+    routeLane: FailedSemanticEquivalenceProofRoute.lane,
+    routeNext: FailedSemanticEquivalenceProofRoute.next,
+    relatedSignals: reasonCodes,
+    requiredEvidence: [ExternalSemanticEquivalenceLevel],
+    presentEvidence: [ExternalSemanticEquivalenceLevel],
+    recommendedAction: 'block',
+    confidenceDimension: 'semanticEquivalence',
+    blocksSemanticEquivalence: true,
+    summary: 'External semantic equivalence proof failed validation; reject the proof and keep semanticEquivalenceClaim false.',
+    nextAction: 'Inspect the external proof binding, then attach a valid source/output/gate-bound proof before claiming semantic equivalence.',
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
 function jsTsProjectSemanticEquivalenceExpectedBinding(id, input = {}) {
   const sourceFileBindings = normalizeSourceFileBindings(input.fileResults ?? []);
   const sourceSetHash = hashSemanticValue({ kind: 'frontier.lang.jsTsProjectSemanticEquivalenceSourceSet.v1', sourceFileBindings: sourceFileBindings.map(sourceBinding) });

package/dist/js-ts-safe-project-merge-source-text-candidate.js

@@ -2,6 +2,7 @@ function sourceTextMergeSummary(files = []) {
   const mergedFiles = files.filter((file) => file.status === 'merged');
   const blockedFiles = files.filter((file) => file.status === 'blocked');
   const outputFiles = files.filter((file) => typeof file.outputSourceText === 'string');
+  const sourceTextMergeDisposition = sourceTextMergeDispositionFor(files.length, mergedFiles.length, blockedFiles.length);
   return {
     mergedFiles: mergedFiles.length,
     blockedFiles: blockedFiles.length,
@@ -9,7 +10,10 @@ function sourceTextMergeSummary(files = []) {
     sourceTextMergeCandidateFiles: mergedFiles.length,
     sourceTextMergeBlockedFiles: blockedFiles.length,
     sourceTextMergeOutputFiles: outputFiles.length,
-    sourceTextMergeCandidateStatus: files.length ? (blockedFiles.length ? 'failed' : 'passed') : 'absent'
+    sourceTextMergeCandidateStatus: files.length ? (blockedFiles.length ? 'failed' : 'passed') : 'absent',
+    sourceTextMergeDisposition,
+    sourceTextMergeAdmissionBoundary: sourceTextMergeAdmissionBoundary(sourceTextMergeDisposition),
+    sourceTextMergeFileStatusCounts: countFileStatuses(files)
   };
 }
 
@@ -28,6 +32,9 @@ function sourceTextMergeCandidateEvidenceRecord(id, summary) {
       sourceTextMergeCandidateFiles: summary.sourceTextMergeCandidateFiles,
       sourceTextMergeBlockedFiles: summary.sourceTextMergeBlockedFiles,
       sourceTextMergeOutputFiles: summary.sourceTextMergeOutputFiles,
+      sourceTextMergeDisposition: summary.sourceTextMergeDisposition,
+      sourceTextMergeAdmissionBoundary: summary.sourceTextMergeAdmissionBoundary,
+      sourceTextMergeFileStatusCounts: summary.sourceTextMergeFileStatusCounts,
       outputFiles: summary.outputFiles,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
@@ -56,9 +63,28 @@ function sourceTextMergeMatrixProofStatus(level, summary) {
 }
 
 function sourceTextMergeCandidateEvidenceSummary(summary, passed, failed) {
-  if (passed) return `Produced concrete source merge candidates for ${summary.sourceTextMergeCandidateFiles} file(s).`;
-  if (failed) return `Source merge candidate blocked for ${summary.sourceTextMergeBlockedFiles} file(s) before semantic admission.`;
-  return 'No source files were available for source text merge candidate production.';
+  if (passed) return `Produced concrete mechanical source merge candidates for ${summary.sourceTextMergeCandidateFiles} file(s); semantic review remains required for equivalence claims.`;
+  if (failed) return `Source merge candidate blocked for ${summary.sourceTextMergeBlockedFiles} overlapping file(s) before semantic admission.`;
+  return 'No source files were available; no mechanical source merge candidate was produced.';
+}
+
+function sourceTextMergeDispositionFor(files, candidateFiles, blockedFiles) {
+  if (!files) return 'absent-source-files';
+  if (blockedFiles) return 'blocked-overlap';
+  return candidateFiles === files ? 'passed-candidate' : 'incomplete-candidate';
+}
+
+function sourceTextMergeAdmissionBoundary(disposition) {
+  if (disposition === 'passed-candidate') return 'mechanical-candidate-needs-semantic-review';
+  if (disposition === 'blocked-overlap') return 'blocked-overlap-before-semantic-review';
+  if (disposition === 'absent-source-files') return 'absent-source-files-no-candidate';
+  return 'mechanical-candidate-incomplete';
+}
+
+function countFileStatuses(files) {
+  const counts = {};
+  for (const file of files) if (file?.status) counts[file.status] = (counts[file.status] ?? 0) + 1;
+  return counts;
 }
 
 function compactRecord(record) {

package/dist/js-ts-safe-project-merge-summary.js

@@ -301,11 +301,12 @@ function compactConfidenceDimensions(status, summary, context, routingCalibratio
     diagnostics: gateConfidenceDimension(context.outputDiagnosticsGate),
     declarations: gateConfidenceDimension(context.outputDeclarationGate),
     quality: gateConfidenceDimension(context.outputQualityGate),
-    proof: summary.proofEvidenceFailed ? 'failed' : summary.proofEvidenceMissing ? 'partial' : 'complete', semanticEquivalence: summary.semanticEquivalenceLevel === 'semantic-equivalence-unknown' ? 'unknown' : 'claimed', routeLane: routingCalibration.nextRouteLane, routeId: routingCalibration.nextRouteId, focusedProofGapRoute: routingCalibration.nextFocusedProofGapRouteId
+    proof: summary.proofEvidenceFailed ? 'failed' : summary.proofEvidenceMissing ? 'partial' : 'complete', semanticEquivalence: summary.semanticEquivalenceLevel === 'semantic-equivalence-unknown' ? 'unknown' : 'claimed', semanticEquivalenceProof: semanticEquivalenceProofDimension(summary), routeLane: routingCalibration.nextRouteLane, routeId: routingCalibration.nextRouteId, focusedProofGapRoute: routingCalibration.nextFocusedProofGapRouteId
   });
 }
 
 function gateConfidenceDimension(gate) { return !gate ? 'missing' : gate.status === 'passed' ? 'passed' : gate.status === 'skipped' ? 'missing' : 'failed'; }
+function semanticEquivalenceProofDimension(summary) { return summary.proofSemanticEquivalenceStatus === 'failed' ? 'failed' : summary.semanticEquivalenceLevel === 'semantic-equivalence-unknown' ? 'missing' : 'passed'; }
 
 function uniqueRecords(records) { const seen = new Set(); return records.filter((record) => !record?.id || seen.has(record.id) ? false : (seen.add(record.id), true)); }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.164",
+  "version": "0.2.165",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",