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

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

@@ -7,11 +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,
-    htmlExplicitIdentityEvidenceFiles: htmlFiles.filter(hasHtmlExplicitIdentityEvidence).length, htmlPathOnlyIdentityResidualFiles: htmlFiles.filter(hasHtmlPathOnlyIdentityResidual).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
   };
 }
@@ -32,46 +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; }
-function hasHtmlFrameworkBoundaryEvidence(file) { return (file?.result?.identityEvidence?.frameworkBoundaryElements ?? 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; }
+function hasCssScopedCascadeScope(file) {
+  return cssScopedRuleCount(file) > 0 || hasCssScopedCascadeProofReason(file) || file?.result?.parserEvidence?.scopedCascadeGraphHashPresent === false;
+}
 function hasCssScopedCascadeEvidence(file) {
-  return hasCssScopedCascadeScope(file) && file?.result?.parserEvidence?.scopedCascadeGraphHashPresent === true;
+  return hasCssScopedCascadeScope(file) && !hasCssScopedCascadeMissingProof(file) && file?.result?.parserEvidence?.scopedCascadeGraphHashPresent === true;
 }
 function hasCssScopedCascadeMissingProof(file) {
-  return hasCssScopedCascadeScope(file) && (file?.result?.conflicts ?? file?.conflicts ?? []).some((conflict) => ScopedCascadeMissingProofReasonCodes.has(conflict?.details?.reasonCode));
+  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);
   }

package/package.json

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