@shapeshift-labs/frontier-lang-compiler 0.2.161 → 0.2.163

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

@@ -8,6 +8,7 @@ import { nearestPublicOwnerForOffset } from './projectSymbolGraphScopeUseDefOwne
 import { readStaticMemberLiteral } from './staticMemberLiteral.js';
 
 const jsTsKeywords = new Set('abstract as async await break case catch class const continue debugger declare default delete do else enum export extends false finally for from function if implements import in infer instanceof interface keyof let module namespace new null of package private protected public readonly return satisfies static super switch this throw true try type typeof undefined unique unknown var void while with yield'.split(' '));
+const namespaceComputedMemberDynamicUnsupportedReason = 'lexical-scope-namespace-computed-member-dynamic-unsupported', namespaceComputedMemberUnresolvedReason = 'lexical-scope-namespace-computed-member-unresolved';
 
 function lexicalScopeRecordsForImport(sourceText, context) {
   const masked = maskNonCode(sourceText);
@@ -230,15 +231,17 @@ function namespacePropertyAccess(code, token, binding, context) {
 
 function namespaceComputedPropertyAccess(sourceText, code, tokenStart, open) {
   const close = findMatchingBracket(code, open);
-  if (close === -1) return blockedNamespaceComputedPropertyAccess();
+  if (close === -1) return blockedNamespaceComputedPropertyAccess(undefined, [namespaceComputedMemberUnresolvedReason]);
   const writeOperation = namespaceMemberWriteOperation(code, tokenStart, close + 1);
   let index = open + 1;
   while (index < close && /\s/.test(sourceText[index])) index += 1;
+  if (index >= close) return blockedNamespaceComputedPropertyAccess(writeOperation, [namespaceComputedMemberUnresolvedReason]);
   const literal = readStaticMemberLiteral(sourceText, index, close);
-  if (!literal) return blockedNamespaceComputedPropertyAccess(writeOperation);
+  if (!literal) return blockedNamespaceComputedPropertyAccess(writeOperation, [namespaceComputedMemberDynamicUnsupportedReason]);
   let afterLiteral = literal.end + 1;
   while (afterLiteral < close && /\s/.test(sourceText[afterLiteral])) afterLiteral += 1;
-  if (afterLiteral !== close || !identifierRegExp.test(literal.value)) return blockedNamespaceComputedPropertyAccess(writeOperation);
+  if (afterLiteral !== close) return blockedNamespaceComputedPropertyAccess(writeOperation, [namespaceComputedMemberDynamicUnsupportedReason]);
+  if (!identifierRegExp.test(literal.value)) return blockedNamespaceComputedPropertyAccess(writeOperation);
   if (writeOperation) {
     return blockedNamespaceMemberWrite('namespace-computed-property-write', {
       memberName: literal.value,
@@ -252,31 +255,18 @@ function namespaceComputedPropertyAccess(sourceText, code, tokenStart, open) {
   return { referenceKind: 'namespace-computed-property-read', memberName: literal.value, memberStart: literal.start, memberEnd: literal.end, memberComputed: true, memberLiteralKind: literal.literalKind };
 }
 
-function blockedNamespaceComputedPropertyAccess(writeOperation) {
+function blockedNamespaceComputedPropertyAccess(writeOperation, reasonCodes = []) {
   return {
     referenceKind: writeOperation ? 'namespace-computed-property-write' : 'namespace-computed-property-read',
     memberComputed: true,
     writeOperation,
     status: 'blocked',
-    reasonCodes: [
-      LexicalUseDefReasonCodes.namespaceComputedMemberUnsupported,
-      ...(writeOperation ? [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported] : [])
-    ]
+    reasonCodes: uniqueReasonCodes([LexicalUseDefReasonCodes.namespaceComputedMemberUnsupported, ...reasonCodes, ...(writeOperation ? [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported] : [])])
   };
 }
 
 function blockedNamespaceMemberWrite(referenceKind, fields = {}) {
-  return {
-    referenceKind,
-    memberName: fields.memberName,
-    memberStart: fields.memberStart,
-    memberEnd: fields.memberEnd,
-    memberComputed: fields.memberComputed,
-    memberLiteralKind: fields.memberLiteralKind,
-    status: 'blocked',
-    reasonCodes: [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported],
-    writeOperation: fields.writeOperation
-  };
+  return { referenceKind, memberName: fields.memberName, memberStart: fields.memberStart, memberEnd: fields.memberEnd, memberComputed: fields.memberComputed, memberLiteralKind: fields.memberLiteralKind, status: 'blocked', reasonCodes: [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported], writeOperation: fields.writeOperation };
 }
 
 function namespaceMemberWriteOperation(code, tokenStart, accessEnd) {
@@ -317,4 +307,6 @@ function findMatchingBracket(code, open) {
   return -1;
 }
 
+function uniqueReasonCodes(reasonCodes) { return [...new Set(reasonCodes.filter(Boolean))]; }
+
 export { lexicalScopeRecordsForImport };

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

@@ -5,6 +5,7 @@ import {
 } from './syntaxCommonJsModuleDeclarationEntries.js';
 import { dynamicImportExpressionMetadata } from './dynamicImportExpressionMetadata.js';
 import { hostModuleDependencyMetadata } from './importMetaUrlDependencyMetadata.js';
+import { moduleHostResourceImportMetadata } from './moduleHostResourceImportMetadata.js';
 import { moduleImportAttributeMetadata } from './moduleImportAttributeMetadata.js';
 import {
   declarationName,
@@ -38,10 +39,15 @@ function importDeclarationEntries(node, nativeNodeId, input) {
   if (!moduleSpecifier) return [];
   const typeOnly = node.importKind === 'type';
   const bindings = (node.specifiers ?? []).map((specifier) => importSpecifierBinding(specifier, typeOnly)).filter(Boolean);
+  const importKind = bindings.length === 0 ? 'side-effect' : 'module';
   return importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
     typeOnly,
     sideEffectOnly: bindings.length === 0,
-    importKind: bindings.length === 0 ? 'side-effect' : 'module',
+    importKind,
+    ...moduleHostResourceImportMetadata(moduleSpecifier, {
+      hostDependencyBase: 'module-import',
+      expressionText: `import ${JSON.stringify(moduleSpecifier)}`
+    }),
     ...moduleImportAttributeMetadata(node)
   });
 }
@@ -54,6 +60,10 @@ function dynamicImportExpressionEntries(node, nativeNodeId, input) {
     importKind: 'dynamic-import',
     dynamicImport: true,
     ...dynamicImportExpressionMetadata(importArgument, moduleSpecifier),
+    ...moduleHostResourceImportMetadata(moduleSpecifier, {
+      hostDependencyBase: 'dynamic-import',
+      expressionText: `import(${JSON.stringify(moduleSpecifier)})`
+    }),
     ...moduleImportAttributeMetadata(node)
   });
 }
@@ -75,12 +85,20 @@ function exportNamedDeclarationEntries(node, nativeNodeId, input) {
       typeOnly,
       reexport: true,
       importKind: 'reexport',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     }) : []),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       reExport: Boolean(moduleSpecifier),
       exportKind: typeOnly ? 'type-named' : 'named',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     })
   ];
@@ -107,6 +125,10 @@ function exportAllDeclarationEntries(node, nativeNodeId, input) {
       reexport: true,
       exportStar: !exportedName,
       importKind: exportedName ? 'namespace-reexport' : 'reexport',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     }),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
@@ -114,6 +136,10 @@ function exportAllDeclarationEntries(node, nativeNodeId, input) {
       reExport: true,
       exportStar: !exportedName,
       exportKind: exportedName ? 'namespace-reexport' : 'export-star',
+      ...moduleHostResourceImportMetadata(moduleSpecifier, {
+        hostDependencyBase: 'module-reexport',
+        expressionText: `export from ${JSON.stringify(moduleSpecifier)}`
+      }),
       ...moduleImportAttributeMetadata(node)
     })
   ];

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

@@ -80,10 +80,18 @@ function exactBranchProjectSemanticEditAdmission(options) {
     if (requireOtherBranchUnchanged && !otherProjectBranchUnchanged(file, classification.branch, { requireBase: requireBaseForOtherBranchUnchanged })) return undefined;
   }
   const outputHash = hashProjectSourceText(branchText);
+  const admissionOutcome = 'safe';
+  const admissionOutcomeReasonCode = exactMergedOutput && allowExistingExactOutput
+    ? 'existing-exact-branch-output'
+    : typeof branchText === 'string'
+      ? 'exact-branch-output-other-branch-unchanged'
+      : 'exact-branch-deletion-other-branch-unchanged';
   const admission = {
     id: safeProjectEvidenceId(`${classification.details?.conflictKey ?? classification.code}_${file.sourcePath}`),
     kind: admissionKind,
     status: 'passed',
+    admissionOutcome,
+    admissionOutcomeReasonCode,
     branch: classification.branch,
     ...(admissionFields(classification) ?? {}),
     sourcePath: file.sourcePath,
@@ -94,6 +102,8 @@ function exactBranchProjectSemanticEditAdmission(options) {
       ...(details(classification) ?? {}),
       sourcePath: file.sourcePath,
       outputHash,
+      admissionOutcome,
+      admissionOutcomeReasonCode,
       exactBranchOutput: true,
       deletedOutput: typeof branchText !== 'string' || undefined,
       autoMergeClaim: false,

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

@@ -21,7 +21,7 @@ function fileAdmissionEvidenceRecords(files = []) {
   return files.flatMap((file) => [
     ...recordArraysWithSuffix(file.summary, 'AdmissionEvidence'),
     ...recordArraysWithSuffix(file.metadata, 'Admissions')
-  ]);
+  ].map(admissionEvidenceRecordWithOutcome));
 }
 
 function recordArraysWithSuffix(record, suffix) {
@@ -32,7 +32,35 @@ function recordArraysWithSuffix(record, suffix) {
     .filter((value) => value?.kind && value?.id);
 }
 
+function admissionEvidenceRecordWithOutcome(record) {
+  const admissionOutcome = admissionEvidenceOutcome(record);
+  return compactRecord({
+    ...record,
+    admissionOutcome,
+    admissionOutcomeReasonCode: admissionEvidenceOutcomeReasonCode(record, admissionOutcome)
+  });
+}
+
+function admissionEvidenceOutcome(record) {
+  if (['safe', 'review', 'blocked'].includes(record?.admissionOutcome)) return record.admissionOutcome;
+  const routeStatus = record?.admissionRoute?.status;
+  if (record?.status === 'passed' && (!routeStatus || routeStatus === 'passed')) return 'safe';
+  if (record?.status === 'failed' || routeStatus === 'failed' || routeStatus === 'blocked') return 'blocked';
+  return 'review';
+}
+
+function admissionEvidenceOutcomeReasonCode(record, admissionOutcome) {
+  if (typeof record?.admissionOutcomeReasonCode === 'string' && record.admissionOutcomeReasonCode.length > 0) return record.admissionOutcomeReasonCode;
+  const routeReasonCode = record?.admissionRoute?.reasonCodes?.[0];
+  if (typeof record?.details?.reasonCode === 'string' && record.details.reasonCode.length > 0) return record.details.reasonCode;
+  if (typeof routeReasonCode === 'string' && routeReasonCode.length > 0) return routeReasonCode;
+  if (admissionOutcome === 'safe' && record?.details?.exactBranchOutput === true) return 'passed-exact-branch-output';
+  if (admissionOutcome === 'safe') return 'passed-admission-evidence';
+  if (admissionOutcome === 'blocked') return 'failed-admission-evidence';
+  return 'review-admission-evidence';
+}
+
 function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
 
-export { failedEvidenceMissingItems, fileAdmissionEvidenceRecords };
+export { admissionEvidenceOutcome, failedEvidenceMissingItems, fileAdmissionEvidenceRecords };

package/dist/js-ts-safe-project-merge-graph-delta-compiler-conflicts.js

@@ -117,6 +117,8 @@ function missingSharedCompilerTypeEquivalenceEvidence(workerRecord, headRecord)
       enumMemberCount: record.enumMemberCount,
       enumComputedMemberCount: record.enumComputedMemberCount,
       typeEquivalenceEnumRuntimeShapeHash: record.typeEquivalenceEnumRuntimeShapeHash,
+      advancedTypeProofRequirement: record.advancedTypeProofRequirement,
+      advancedTypeMissingProof: record.advancedTypeMissingProof,
       typeEquivalenceSignatureSetHash: record.typeEquivalenceSignatureSetHash,
       typeEquivalenceCallSignatureSetHash: record.typeEquivalenceCallSignatureSetHash, typeEquivalenceConstructSignatureSetHash: record.typeEquivalenceConstructSignatureSetHash,
       typeEquivalenceTypeParameterSetHash: record.typeEquivalenceTypeParameterSetHash,
@@ -169,9 +171,14 @@ function hasPassedCompilerTypeEquivalenceProof(record) {
   ];
   return Boolean(record?.typeEquivalenceStatus === 'compiler-backed-equivalent'
     && record?.typeEquivalenceProof?.status === 'passed'
+    && !hasMissingAdvancedTypeProof(record)
     && requiredHashes.every(([required, hash]) => !required || hash)
     && record?.apiSignatureHash);
 }
+function hasMissingAdvancedTypeProof(record) {
+  const status = record?.advancedTypeMissingProof?.status ?? record?.advancedTypeProofRequirement?.status;
+  return status === 'missing-compiler-evidence' || status === 'requires-review';
+}
 function recordsByIdentityKey(records, identityKey) { const result = new Map(); for (const record of records ?? []) { const key = identityKey(record); if (!key || result.has(key)) continue; result.set(key, record); } return result; }
 function optionalFingerprint(record, fingerprint) { return record ? fingerprint(record) : undefined; }
 function stableKey(parts) { const values = parts.map((part) => part === undefined || part === null ? '' : String(part)); return values.some(Boolean) ? values.join('#') : undefined; }

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

@@ -5,6 +5,7 @@ const HtmlCssProjectMergeMissingSignals = Object.freeze({
   cssSelectorTargetEvidence: 'css-selector-target-evidence-missing',
   htmlStructuralMerge: 'html-structural-merge-proof-blocked',
   cssCascadeMerge: 'css-cascade-merge-proof-blocked',
+  cssDependencyGraphEvidence: 'css-dependency-graph-evidence-missing',
   htmlCssBrowserRuntimeProof: 'html-css-browser-runtime-proof-not-available'
 });
 
@@ -16,6 +17,7 @@ function htmlCssProjectMergeMissingEvidenceRoutes(route, signals) {
     [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.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')
   };
 }
@@ -28,6 +30,7 @@ function htmlCssProjectMergeAdmissionMatrixRows(matrixRow, signals) {
     matrixRow('css-selector-target-evidence', 'bounded-evidence', ['css-selector-target-evidence'], [signals.cssSelectorTargetEvidence]),
     matrixRow('html-structural-merge-admission', 'partial', ['html-structural-merge'], [signals.htmlStructuralMerge]),
     matrixRow('css-cascade-merge-admission', 'partial', ['css-cascade-merge'], [signals.cssCascadeMerge]),
+    matrixRow('css-dependency-graph-evidence', 'bounded-evidence', ['css-dependency-graph'], [signals.cssDependencyGraphEvidence]),
     matrixRow('html-css-browser-runtime-proof', 'bounded-evidence', ['browser-runtime-proof'], [signals.htmlCssBrowserRuntimeProof])
   ];
 }
@@ -36,10 +39,11 @@ function htmlCssProjectMergeMissingEvidenceItems(summary, signals, missingEviden
   const items = [];
   if (summary.htmlFiles && summary.htmlParserEvidenceFiles !== summary.htmlFiles) items.push(missingEvidenceItem({ code: signals.htmlParserEvidence, scope: 'layout-markup-parser', kind: 'html-parser-source-evidence', proofLevel: 'html-parser-source-evidence', action: 'review', summary: `HTML project merge has parser/source evidence for ${summary.htmlParserEvidenceFiles}/${summary.htmlFiles} file(s); require parse5 source spans, zero parse errors, and attribute/trivia spans when those surfaces are present before parser evidence admission.` }));
   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); require parser-backed structural spans and stable explicit/path identity accounting before structural 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.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); supply parser/cascade/scope evidence and keep browser claims false until runtime proof passes.` }));
+  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 } }));
   return items;
 }
@@ -51,6 +55,7 @@ function htmlCssProjectMergeMatrixProofStatus(level, summary) {
   if (level === 'css-selector-target-evidence') return summary.cssFiles ? (summary.cssSelectorTargetConflictFiles ? 'failed' : summary.cssSelectorTargetEvidenceFiles === summary.cssFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'html-structural-merge') return summary.htmlFiles ? (summary.htmlBlockedFiles ? 'failed' : summary.htmlMergedFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'css-cascade-merge') return summary.cssFiles ? (summary.cssBlockedFiles ? 'failed' : summary.cssMergedFiles ? 'passed' : 'missing') : 'absent';
+  if (level === 'css-dependency-graph') return summary.cssDependencySurfaceFiles ? (summary.cssDependencyGraphBlockedFiles ? 'failed' : summary.cssDependencyGraphEvidenceFiles === summary.cssDependencySurfaceFiles ? 'passed' : 'missing') : 'absent';
   if (level === 'browser-runtime-proof') return summary.htmlCssFiles ? (summary.htmlCssBrowserRuntimeProofs ? 'passed' : 'missing') : 'absent';
   return undefined;
 }

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

@@ -7,8 +7,13 @@ function htmlCssProjectSummary(files) {
     htmlParserEvidenceFiles: htmlFiles.filter(hasHtmlParserEvidence).length, cssParserEvidenceFiles: cssFiles.filter(hasCssParserEvidence).length, htmlCssParserEvidenceFiles: htmlCssFiles.filter((file) => hasHtmlParserEvidence(file) || hasCssParserEvidence(file)).length,
     htmlParserEvidenceFailedFiles: htmlFiles.filter(hasParserEvidenceFailure).length, cssParserEvidenceFailedFiles: cssFiles.filter(hasParserEvidenceFailure).length, htmlCssParserEvidenceFailedFiles: htmlCssFiles.filter(hasParserEvidenceFailure).length,
     htmlIdentityEvidenceFiles: htmlFiles.filter(hasHtmlIdentityEvidence).length, cssSelectorTargetEvidenceFiles: cssFiles.filter(hasCssSelectorTargetEvidence).length, htmlCssStructuralTargetEvidenceFiles: htmlCssFiles.filter((file) => hasHtmlIdentityEvidence(file) || hasCssSelectorTargetEvidence(file)).length,
+    cssSelectorTargetGraphEvidenceFiles: cssFiles.filter(hasCssSelectorTargetGraphEvidence).length, cssSelectorSpecificityEvidenceFiles: cssFiles.filter(hasCssSelectorSpecificityEvidence).length, cssSelectorTargetMoveFiles: cssFiles.filter(hasCssSelectorTargetMove).length,
+    htmlExplicitIdentityEvidenceFiles: htmlFiles.filter(hasHtmlExplicitIdentityEvidence).length, htmlPathOnlyIdentityResidualFiles: htmlFiles.filter(hasHtmlPathOnlyIdentityResidual).length, htmlDuplicateIdentityEvidenceFiles: htmlFiles.filter(hasHtmlDuplicateIdentityEvidence).length, htmlDuplicateIdentityKeys: htmlFiles.reduce((sum, file) => sum + htmlDuplicateIdentityKeyCount(file), 0),
+    htmlRuntimeBoundaryEvidenceFiles: htmlFiles.filter(hasHtmlRuntimeBoundaryEvidence).length, htmlFrameworkBoundaryEvidenceFiles: htmlFiles.filter(hasHtmlFrameworkBoundaryEvidence).length, htmlProofGapBlockedFiles: htmlFiles.filter(hasHtmlProofGapBlockedConflict).length,
     htmlIdentityEvidenceFailedFiles: htmlFiles.filter(hasHtmlIdentityEvidenceFailure).length, cssSelectorTargetConflictFiles: cssFiles.filter(hasCssSelectorTargetConflict).length, htmlCssStructuralTargetEvidenceFailedFiles: htmlCssFiles.filter((file) => hasHtmlIdentityEvidenceFailure(file) || hasCssSelectorTargetConflict(file)).length,
     cssSelectorTargetRebasedFiles: cssFiles.filter(hasCssSelectorTargetRebase).length,
+    cssScopedCascadeFiles: cssFiles.filter(hasCssScopedCascadeScope).length, cssScopedCascadeEvidenceFiles: cssFiles.filter(hasCssScopedCascadeEvidence).length, cssScopedCascadeBlockedFiles: cssFiles.filter(hasCssScopedCascadeMissingProof).length,
+    cssDependencySurfaceFiles: cssFiles.filter(hasCssDependencySurface).length, cssDependencyGraphEvidenceFiles: cssFiles.filter((file) => hasCssDependencySurface(file) && hasCssDependencyGraphEvidence(file)).length, cssDependencyGraphMissingProofFiles: cssFiles.filter(hasCssDependencyGraphMissingProof).length, cssDependencyGraphBlockedFiles: cssFiles.filter(hasCssDependencyGraphBlockedConflict).length,
     htmlCssBrowserRuntimeProofs: htmlCssFiles.filter(hasBrowserRuntimeProof).length
   };
 }
@@ -29,23 +34,126 @@ function hasCssParserEvidence(file) {
 function hasParserEvidenceFailure(file) { return (file?.result?.parserEvidence?.parseErrors ?? 0) > 0; }
 function hasHtmlIdentityEvidence(file) {
   const evidence = file?.result?.identityEvidence;
-  return evidence?.parserBackedStructuralSpans === true && evidence.structuralAddressability === true;
+  return evidence?.parserBackedStructuralSpans === true && evidence.structuralAddressability === true && !hasDuplicateExplicitIdentityKeys(evidence);
+}
+function hasHtmlExplicitIdentityEvidence(file) {
+  const evidence = file?.result?.identityEvidence;
+  return hasHtmlIdentityEvidence(file) && evidence.explicitIdentityAvailable === true;
+}
+function hasHtmlPathOnlyIdentityResidual(file) { return (file?.result?.identityEvidence?.pathOnlyIdentityElements ?? 0) > 0; }
+function hasHtmlRuntimeBoundaryEvidence(file) {
+  return (file?.result?.identityEvidence?.runtimeBoundaryElements ?? 0) > 0 || hasRuntimeBoundaryConflict(file);
+}
+function hasHtmlFrameworkBoundaryEvidence(file) {
+  return (file?.result?.identityEvidence?.frameworkBoundaryElements ?? 0) > 0 || hasFrameworkBoundaryConflict(file);
 }
 function hasHtmlIdentityEvidenceFailure(file) {
   const evidence = file?.result?.identityEvidence;
-  return Boolean(evidence) && (evidence.parserBackedStructuralSpans !== true || evidence.structuralAddressability !== true);
+  return Boolean(evidence) && (evidence.parserBackedStructuralSpans !== true || evidence.structuralAddressability !== true || hasDuplicateExplicitIdentityKeys(evidence));
 }
 function hasCssSelectorTargetEvidence(file) {
   const evidence = file?.result?.selectorTargetEvidence;
   return evidence?.parserBackedRuleSpans === true;
 }
+function hasCssSelectorTargetGraphEvidence(file) {
+  return file?.result?.selectorTargetEvidence?.selectorTargetGraphHashPresent === true;
+}
+function hasCssSelectorSpecificityEvidence(file) {
+  const sides = Object.values(file?.result?.selectorTargetEvidence?.sides ?? {});
+  return sides.length > 0 && sides.every((side) => (side?.ruleCount ?? 0) === 0 || (side?.selectorSpecificityRecords ?? 0) >= side.ruleCount);
+}
+function hasCssSelectorTargetMove(file) {
+  return (file?.result?.selectorTargetEvidence?.selectorMoveCount ?? 0) > 0;
+}
 function hasCssSelectorTargetConflict(file) {
   return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => conflict.code === 'css-selector-target-conflict');
 }
+function hasHtmlProofGapBlockedConflict(file) {
+  return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => conflict.code === 'html-proof-gap-blocked');
+}
+function hasRuntimeBoundaryConflict(file) {
+  return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => HtmlRuntimeBoundaryReasonCodes.has(conflict?.details?.reasonCode));
+}
+function hasFrameworkBoundaryConflict(file) {
+  return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => HtmlFrameworkBoundaryReasonCodes.has(conflict?.details?.reasonCode));
+}
 function hasCssSelectorTargetRebase(file) { return (file?.result?.selectorTargetEvidence?.rebasedChangeCount ?? 0) > 0; }
+function hasCssScopedCascadeScope(file) {
+  return cssScopedRuleCount(file) > 0 || hasCssScopedCascadeProofReason(file) || file?.result?.parserEvidence?.scopedCascadeGraphHashPresent === false;
+}
+function hasCssScopedCascadeEvidence(file) {
+  return hasCssScopedCascadeScope(file) && !hasCssScopedCascadeMissingProof(file) && file?.result?.parserEvidence?.scopedCascadeGraphHashPresent === true;
+}
+function hasCssScopedCascadeMissingProof(file) {
+  return hasCssScopedCascadeProofReason(file);
+}
+function hasCssScopedCascadeProofReason(file) {
+  return (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => ScopedCascadeMissingProofReasonCodes.has(conflict?.details?.reasonCode));
+}
+function cssScopedRuleCount(file) {
+  const sides = Object.values(file?.result?.selectorTargetEvidence?.sides ?? {});
+  return sides.reduce((count, side) => Math.max(count, side?.scopedRuleCount ?? 0), 0);
+}
+function hasCssDependencySurface(file) {
+  return hasCssDependencyEvidenceSurface(file) || hasCssDependencyTextSurface(file) || hasCssDependencyConflictSurface(file);
+}
+function hasCssDependencyGraphEvidence(file) {
+  return cssDependencyEvidenceRecords(file).some((evidence) => evidence.dependencyGraphHashPresent === true || evidence.cssDependencyGraphHashPresent === true || typeof evidence.dependencyGraphHash === 'string' || typeof evidence.cssDependencyGraphHash === 'string' || typeof evidence.graphHash === 'string' || typeof evidence.customPropertyGraphHash === 'string' || typeof evidence.animationGraphHash === 'string' || typeof evidence.fontFaceGraphHash === 'string' || typeof evidence.assetGraphHash === 'string');
+}
+function hasCssDependencyGraphMissingProof(file) { return hasCssDependencySurface(file) && !hasCssDependencyGraphEvidence(file); }
+function hasCssDependencyEvidenceSurface(file) {
+  return cssDependencyEvidenceRecords(file).some((evidence) => evidence.hasDependencySurface === true || (evidence.dependencySurfaceCount ?? 0) > 0 || (evidence.customPropertyDefinitions ?? 0) > 0 || (evidence.customPropertyReferences ?? 0) > 0 || (evidence.varReferences ?? 0) > 0 || (evidence.varFallbackReferences ?? 0) > 0 || (evidence.animationNameLinks ?? 0) > 0 || (evidence.keyframeLinks ?? 0) > 0 || (evidence.fontFaceLinks ?? 0) > 0 || (evidence.urlAssetReferences ?? 0) > 0);
+}
+function hasCssDependencyTextSurface(file) {
+  const sourceText = cssDependencySourceText(file);
+  return sourceText.length > 0 && CssDependencySurfacePatterns.some((pattern) => pattern.test(sourceText));
+}
+function hasCssDependencyConflictSurface(file) {
+  return cssFileConflicts(file).some(isCssDependencyConflict);
+}
+function hasCssDependencyGraphBlockedConflict(file) {
+  return cssFileConflicts(file).some((conflict) => isCssDependencyConflict(conflict) || CssDependencyMissingProofReasonCodes.has(conflict?.details?.reasonCode));
+}
+function cssDependencyEvidenceRecords(file) {
+  const result = file?.result ?? {};
+  return [result.dependencyEvidence, result.cssDependencyEvidence, result.dependencyGraphEvidence, result.cssDependencyGraphEvidence, result.parserEvidence?.dependencyEvidence, result.parserEvidence?.cssDependencyEvidence, result.parserEvidence?.dependencyGraphEvidence, result.parserEvidence?.cssDependencyGraphEvidence].filter(isPlainObject);
+}
+function cssDependencySourceText(file) {
+  return [file?.outputSourceText, file?.sourceText, file?.result?.mergedSourceText].filter((value) => typeof value === 'string').join('\n');
+}
+function cssFileConflicts(file) { return file?.result?.conflicts ?? file?.conflicts ?? []; }
+function isCssDependencyConflict(conflict) {
+  const details = conflict?.details ?? {};
+  const codes = [conflict?.code, details.reasonCode, details.proofGap?.code].map((value) => String(value ?? ''));
+  return codes.some((code) => CssDependencyCodeFragments.some((fragment) => code.includes(fragment))) || isCssDependencyAtRule(details.before) || isCssDependencyAtRule(details.after);
+}
+function isCssDependencyAtRule(shape) { return CssDependencyAtRuleNames.has(String(shape?.atRuleName ?? '').toLowerCase()); }
 function hasBrowserRuntimeProof(file) {
   const admission = file?.result?.admission ?? file?.admission ?? {};
   return admission.browserRuntimeEquivalenceClaim === true || admission.browserCascadeEquivalenceClaim === true || admission.browserRenderEquivalenceClaim === true;
 }
+function hasHtmlDuplicateIdentityEvidence(file) { return hasDuplicateExplicitIdentityKeys(file?.result?.identityEvidence); }
+function htmlDuplicateIdentityKeyCount(file) {
+  return duplicateExplicitIdentityKeys(file?.result?.identityEvidence).length;
+}
+function hasDuplicateExplicitIdentityKeys(evidence) {
+  return duplicateExplicitIdentityKeys(evidence).length > 0;
+}
+function duplicateExplicitIdentityKeys(evidence) {
+  return Object.values(evidence?.sides ?? {}).flatMap((side) => {
+    const counts = new Map();
+    for (const key of side?.explicitIdentityKeys ?? []) counts.set(key, (counts.get(key) ?? 0) + 1);
+    return [...counts.entries()].filter(([, count]) => count > 1).map(([key]) => key);
+  });
+}
+
+const ScopedCascadeMissingProofReasonCodes = new Set(['css-scoped-cascade-equivalence-unproved', 'css-media-cascade-scope-unproved', 'css-supports-cascade-scope-unproved', 'css-container-cascade-scope-unproved', 'css-layer-cascade-scope-unproved', 'css-scope-cascade-scope-unproved']);
+const HtmlRuntimeBoundaryReasonCodes = new Set(['script-runtime-boundary', 'style-runtime-boundary', 'template-runtime-boundary', 'slot-runtime-boundary', 'custom-element-runtime-boundary', 'event-handler-runtime-boundary', 'inline-style-runtime-boundary', 'iframe-runtime-boundary', 'iframe-srcdoc-runtime-boundary']);
+const HtmlFrameworkBoundaryReasonCodes = new Set(['framework-directive-boundary', 'custom-element-runtime-boundary']);
+const CssDependencyMissingProofReasonCodes = new Set(['css-dependency-graph-evidence-missing', 'css-custom-property-dependency-graph-unproved', 'css-var-fallback-dependency-graph-unproved', 'css-animation-name-keyframes-graph-unproved', 'css-font-face-dependency-graph-unproved', 'css-url-asset-dependency-graph-unproved']);
+const CssDependencyAtRuleNames = new Set(['keyframes', 'font-face']);
+const CssDependencyCodeFragments = ['custom-property', 'var-fallback', 'variable-dependency', 'dependency-graph', 'keyframes', 'animation-name', 'font-face', 'url-asset', 'asset-dependency'];
+const CssDependencySurfacePatterns = [/(^|[;{\s])--[-_A-Za-z][\w-]*\s*:/, /\bvar\s*\(/i, /@(?:-[\w]+-)?keyframes\b/i, /(^|[;{\s])animation(?:-name)?\s*:/i, /@font-face\b/i, /\burl\s*\(/i];
+function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
 
 export { htmlCssProjectSummary };

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

@@ -1,7 +1,7 @@
 import { safeMergeCssSource } from '@shapeshift-labs/frontier-lang-css';
 import { safeMergeHtmlSource } from '@shapeshift-labs/frontier-lang-html';
 import { compactRecord } from './js-ts-safe-merge-context.js';
-import { hashText, safeId } from './js-ts-safe-project-merge-core.js';
+import { hashText, safeId, uniqueStrings } from './js-ts-safe-project-merge-core.js';
 
 function projectFileLanguage(file, input) {
   return file.language ?? inferLanguageFromPath(file.sourcePath) ?? input.language ?? 'typescript';
@@ -12,8 +12,12 @@ function maybeMergeHtmlCssProjectFile(options) {
   const language = String(context.language ?? '').toLowerCase();
   const merge = language === 'html' ? safeMergeHtmlSource : language === 'css' ? safeMergeCssSource : undefined;
   if (!merge) return undefined;
-  const result = merge({ ...sourceInput, ...htmlCssMergeOptionsForProjectFile(input, file.sourcePath, language), ...context, id: `${projectId}_${safeId(file.sourcePath)}`, baseSourceText: base, workerSourceText: worker, headSourceText: head });
-  return result.status === 'merged' ? mergedHtmlCssFile(file, context, result, language) : blockedHtmlCssFile(file, context, result);
+  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 admittedResult = language === 'html' && result.status === 'merged'
+    ? blockHtmlProofGapChanges({ result, id: resultId, sourcePath: file.sourcePath, base, worker, head }) ?? result
+    : result;
+  return admittedResult.status === 'merged' ? mergedHtmlCssFile(file, context, admittedResult, language) : blockedHtmlCssFile(file, context, admittedResult);
 }
 
 function inferLanguageFromPath(sourcePath) {
@@ -32,6 +36,136 @@ 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 }) {
+  const conflicts = [
+    htmlDuplicateIdentityConflict(result),
+    ...htmlRuntimeBoundaryChanges(base, worker, head).map((change) => htmlProofGapConflict(id, sourcePath, change.reasonCode, change))
+  ].filter(Boolean);
+  if (!conflicts.length) return undefined;
+  const allConflicts = [...(result.conflicts ?? []), ...conflicts];
+  const { mergedSourceText, mergedSourceHash, ...rest } = result;
+  return compactRecord({
+    ...rest,
+    status: 'blocked',
+    operation: 'blocked',
+    conflicts: allConflicts,
+    admission: blockedHtmlProofGapAdmission(result.admission, allConflicts),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    browserRuntimeEquivalenceClaim: false
+  });
+}
+
+function htmlDuplicateIdentityConflict(result) {
+  const duplicates = duplicateHtmlExplicitIdentityKeys(result?.identityEvidence);
+  if (!duplicates.length) return undefined;
+  return htmlProofGapConflict(result.id, result.sourcePath, 'html-duplicate-explicit-identity', {
+    boundary: 'html-explicit-identity',
+    duplicateIdentityKeys: duplicates
+  }, 'html-duplicate-identity-blocked');
+}
+
+function duplicateHtmlExplicitIdentityKeys(identityEvidence) {
+  return Object.entries(identityEvidence?.sides ?? {}).flatMap(([side, evidence]) => {
+    const counts = new Map();
+    for (const key of evidence?.explicitIdentityKeys ?? []) counts.set(key, (counts.get(key) ?? 0) + 1);
+    return [...counts.entries()]
+      .filter(([, count]) => count > 1)
+      .map(([key, count]) => ({ side, key, count }));
+  });
+}
+
+function htmlRuntimeBoundaryChanges(base, worker, head) {
+  const baseEventHandlers = htmlEventHandlerBoundaryFingerprint(base);
+  return [
+    htmlRuntimeBoundaryChange('worker', base, worker, baseEventHandlers),
+    htmlRuntimeBoundaryChange('head', base, head, baseEventHandlers)
+  ].filter(Boolean);
+}
+
+function htmlRuntimeBoundaryChange(side, base, sourceText, baseEventHandlers) {
+  if (sourceText === base) return undefined;
+  const eventHandlers = htmlEventHandlerBoundaryFingerprint(sourceText);
+  if (eventHandlers === baseEventHandlers) return undefined;
+  return {
+    side,
+    reasonCode: 'event-handler-runtime-boundary',
+    boundary: 'html-event-handler-attribute',
+    boundaryAttributes: htmlEventHandlerBoundaryAttributeNames(sourceText)
+  };
+}
+
+function htmlEventHandlerBoundaryFingerprint(sourceText) {
+  return htmlEventHandlerBoundaryAttributes(sourceText)
+    .map((attribute) => `${attribute.tagName}:${attribute.name}=${String(attribute.value)}`)
+    .sort()
+    .join('\n');
+}
+
+function htmlEventHandlerBoundaryAttributeNames(sourceText) {
+  return uniqueStrings(htmlEventHandlerBoundaryAttributes(sourceText).map((attribute) => attribute.name));
+}
+
+function htmlEventHandlerBoundaryAttributes(sourceText) {
+  const attributes = [];
+  for (const tag of String(sourceText ?? '').matchAll(/<[A-Za-z][\w:-]*(?:\s+[^<>]*?)?\/?>/g)) {
+    const parsed = /^<([A-Za-z][\w:-]*)([\s\S]*?)\/?>$/.exec(tag[0]);
+    if (!parsed) continue;
+    const tagName = parsed[1].toLowerCase();
+    for (const attribute of parseHtmlAttributes(parsed[2] ?? '')) {
+      if (/^on[\w:.-]+$/i.test(attribute.name)) attributes.push({ ...attribute, name: attribute.name.toLowerCase(), tagName });
+    }
+  }
+  return attributes;
+}
+
+function parseHtmlAttributes(text) {
+  const attributes = [];
+  const pattern = /([:@A-Za-z_][\w:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  for (const match of text.matchAll(pattern)) attributes.push({ name: match[1], value: match[2] ?? match[3] ?? match[4] ?? true });
+  return attributes;
+}
+
+function htmlProofGapConflict(id, sourcePath, reasonCode, details = {}, code = 'html-proof-gap-blocked') {
+  return {
+    code,
+    gateId: 'html-semantic-merge',
+    sourcePath,
+    details: compactRecord({
+      reasonCode,
+      conflictKey: `html#${id}#${reasonCode}#${details.side ?? details.duplicateIdentityKeys?.[0]?.key ?? sourcePath ?? 'source'}`,
+      proofGap: {
+        code: reasonCode,
+        status: 'not-claimed',
+        summary: htmlProofGapSummary(reasonCode),
+        failClosed: true,
+        semanticEquivalenceClaim: false
+      },
+      ...details
+    })
+  };
+}
+
+function htmlProofGapSummary(reasonCode) {
+  if (reasonCode === 'html-duplicate-explicit-identity') return 'Duplicate explicit HTML identity keys make structural target admission ambiguous.';
+  if (reasonCode === 'event-handler-runtime-boundary') return 'HTML event handler attributes execute in the browser runtime and require source-bound host evidence.';
+  return 'HTML proof gap requires source-bound evidence before structural merge admission.';
+}
+
+function blockedHtmlProofGapAdmission(admission = {}, conflicts = []) {
+  return {
+    ...admission,
+    status: 'blocked',
+    action: 'human-review',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    browserRuntimeEquivalenceClaim: false,
+    reasonCodes: uniqueStrings([...(admission.reasonCodes ?? []), ...conflicts.map((conflict) => conflict.details?.reasonCode ?? conflict.code)])
+  };
+}
+
 function mergedHtmlCssFile(file, context, result, language) {
   return compactRecord({
     kind: 'frontier.lang.jsTsProjectSafeMergeFile', version: 1, sourcePath: file.sourcePath, language: context.language, status: 'merged', operation: `merged-${language}-source`,

package/dist/js-ts-safe-project-merge-jsx-graph-conflict-details.js

@@ -98,6 +98,15 @@ function jsxPropDetails(record) {
     propValueReferenceRoot: record.propValueReferenceRoot, propValueReferencePath: record.propValueReferencePath,
     propValueOptionalReference: record.propValueOptionalReference, propValueOptionalReferenceSegments: record.propValueOptionalReferenceSegments,
     propValueOptionalReferenceSegmentIndexes: record.propValueOptionalReferenceSegmentIndexes, propValueOptionalNullishBoundaryCount: record.propValueOptionalNullishBoundaryCount,
+    propValueClaimScope: record.propValueClaimScope, propValueRenderEquivalenceClaim: record.propValueRenderEquivalenceClaim,
+    propValueStaticSpreadSourceKind: record.propValueStaticSpreadSourceKind, propValueStaticSpreadSourceName: record.propValueStaticSpreadSourceName,
+    propValueStaticSpreadPropEntries: record.propValueStaticSpreadPropEntries, propValueStaticSpreadPropNames: record.propValueStaticSpreadPropNames,
+    propValueStaticSpreadPropCount: record.propValueStaticSpreadPropCount,
+    propValueStaticSpreadEffectivePropEntries: record.propValueStaticSpreadEffectivePropEntries, propValueStaticSpreadEffectivePropNames: record.propValueStaticSpreadEffectivePropNames,
+    propValueStaticSpreadExplicitOverridePropNames: record.propValueStaticSpreadExplicitOverridePropNames,
+    propValueStaticSpreadOverridesExplicitPropNames: record.propValueStaticSpreadOverridesExplicitPropNames,
+    propValueStaticSpreadDuplicatePropNames: record.propValueStaticSpreadDuplicatePropNames,
+    propValueStaticSpreadPrecedenceStatus: record.propValueStaticSpreadPrecedenceStatus,
     propValueDynamicText: record.propValueDynamicText, propValueDynamicBlockerReasonCode: record.propValueDynamicBlockerReasonCode,
     propValueExpressionHash: record.propValueExpressionHash, propValueSignatureHash: record.propValueSignatureHash,
     componentPropRenderFlowStatus: record.componentPropRenderFlowStatus, componentPropRenderFlowReasonCode: record.componentPropRenderFlowReasonCode,

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

@@ -259,6 +259,9 @@ function mergeProjectFile(file, input, projectId, projectSymbolRenames) {
     policy: file.policy ?? file.mergePolicy ?? policyForFile(input, file.sourcePath)
   });
   if (result.status !== 'merged') {
+    if (base === worker && base === head) {
+      return syntheticFile(file, context, base, 'unchanged-identical');
+    }
     return maybeMergeImportSpecifierRemovalFile(file, context, result, input)
       ?? mergeBlockedFile(file, context, result);
   }