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

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-missing-evidence.js

@@ -1,5 +1,7 @@
 import { HtmlCssProjectMergeMissingSignals, htmlCssProjectMergeAdmissionMatrixRows, htmlCssProjectMergeMatrixProofStatus, htmlCssProjectMergeMissingEvidenceItems, htmlCssProjectMergeMissingEvidenceRoutes } from './js-ts-safe-project-merge-html-css-matrix.js';
+import { sourceTextMergeMatrixProofStatus, sourceTextMergeMissingEvidenceItem } from './js-ts-safe-project-merge-source-text-candidate.js';
 const ProjectMergeMissingSignals = Object.freeze({
+  sourceTextMergeCandidate: 'source-text-merge-candidate-not-produced',
   outputDiagnosticsGate: 'output-diagnostics-gate-not-run',
   declarationGate: 'declaration-gate-not-run',
   qualityGates: 'quality-gates-not-run',
@@ -17,6 +19,7 @@ const ProjectMergeMissingSignals = Object.freeze({
 });
 
 const ProjectMergeMissingEvidenceRoutes = Object.freeze({
+  [ProjectMergeMissingSignals.sourceTextMergeCandidate]: route('produce-source-text-merge-candidate', 'source-files', 'run-conservative-three-way-source-merge'),
   [ProjectMergeMissingSignals.outputDiagnosticsGate]: route('run-output-diagnostics', 'project-output', 'supply-output-diagnostics'),
   [ProjectMergeMissingSignals.declarationGate]: route('emit-output-declarations', 'project-output', 'supply-declaration-output'),
   [ProjectMergeMissingSignals.qualityGates]: route('attach-quality-gates', 'quality-gates', 'attach-passing-quality-gates'),
@@ -34,6 +37,7 @@ const ProjectMergeMissingEvidenceRoutes = Object.freeze({
 });
 
 const ProjectMergeAdmissionMatrixRows = Object.freeze([
+  matrixRow('source-text-merge-candidate', 'baseline', ['source-text-merge-candidate'], [ProjectMergeMissingSignals.sourceTextMergeCandidate]),
   matrixRow('parser-source-span-trivia', 'partial', ['source-span-roundtrip'], [ProjectMergeMissingSignals.sourceSpanRoundtrip, ProjectMergeMissingSignals.semanticArtifacts]),
   matrixRow('scope-use-def-graph', 'partial', ['project-graph-delta'], [ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
   matrixRow('module-export-import-graph', 'partial', ['project-graph-delta'], [ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
@@ -54,6 +58,8 @@ const ProjectMergeAdmissionMatrixRows = Object.freeze([
 
 function missingEvidenceItems(summary, context = {}) {
   const items = [];
+  const sourceTextMissing = sourceTextMergeMissingEvidenceItem(summary, ProjectMergeMissingSignals.sourceTextMergeCandidate, missingEvidenceItem);
+  if (sourceTextMissing) items.push(sourceTextMissing);
   if (!context.hasProjectGraphEvidence) items.push(missingEvidenceItem({
     code: ProjectMergeMissingSignals.projectGraphEvidence,
     scope: 'project-graph',
@@ -254,6 +260,8 @@ function matrixProofStatus(level, summary, proofEvidence) {
   if (levelStatuses[level]) return levelStatuses[level];
   const htmlCssStatus = htmlCssProjectMergeMatrixProofStatus(level, summary);
   if (htmlCssStatus) return htmlCssStatus;
+  const sourceTextStatus = sourceTextMergeMatrixProofStatus(level, summary);
+  if (sourceTextStatus) return sourceTextStatus;
   if (level === 'project-graph-delta') return summary.projectGraphDeltaEvidenceIncluded ? (summary.projectGraphDeltaConflicts ? 'failed' : 'passed') : 'missing';
   if (level === 'project-graph-evidence') return summary.projectGraphConflicts ? 'failed' : summary.projectGraphEvidenceIncluded || summary.projectGraphDeltaEvidenceIncluded ? 'passed' : 'missing';
   if (level === 'css-module-use-site-graph') return summary.projectGraphCssModuleUseSiteConflicts ? 'failed' : summary.projectGraphCssModuleUseSiteGraphs ? 'passed' : summary.projectGraphEvidenceIncluded ? 'absent' : 'missing';
@@ -292,12 +300,10 @@ function countField(items, field) {
 
 function countRoute(items, field = 'id') {
   const counts = {};
-  for (const item of items) {
-    const key = field === 'lane' ? item?.routeLane ?? item?.route?.lane : item?.routeId ?? item?.route?.id;
-    if (key) counts[key] = (counts[key] ?? 0) + 1;
-  }
+  for (const item of items) countRouteItem(counts, item, field);
   return counts;
 }
+function countRouteItem(counts, item, field) { const key = field === 'lane' ? item?.routeLane ?? item?.route?.lane : item?.routeId ?? item?.route?.id; if (key) counts[key] = (counts[key] ?? 0) + 1; }
 
 function route(id, lane, next) { return Object.freeze({ id, lane, next }); }
 function shouldRecommendRerun(missingEvidence = [], options = {}) {
@@ -307,13 +313,7 @@ function shouldRecommendRerun(missingEvidence = [], options = {}) {
   if (reasonCodes.length) return reasonCodes.every((code) => rerunReasonCodes.has(code));
   return missingEvidence[0]?.action === 'rerun-gate' && missingEvidence[0]?.kind === 'quality-gate';
 }
-function isSemanticEquivalenceMissing(item) {
-  return item?.proofLevel === 'semantic-equivalence-unknown'
-    || item?.code === ProjectMergeMissingSignals.semanticEquivalenceProof;
-}
-
-function compactRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
-}
+function isSemanticEquivalenceMissing(item) { return item?.proofLevel === 'semantic-equivalence-unknown' || item?.code === ProjectMergeMissingSignals.semanticEquivalenceProof; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
 
 export { compactMissingEvidenceTelemetry, confidenceRecommendedAction, createProjectMergeAdmissionMatrixAudit, missingEvidenceItems, missingEvidenceRouteForSignal, missingEvidenceSignals, prioritizedMissingEvidence };

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

@@ -0,0 +1,68 @@
+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');
+  return {
+    mergedFiles: mergedFiles.length,
+    blockedFiles: blockedFiles.length,
+    outputFiles: outputFiles.length,
+    sourceTextMergeCandidateFiles: mergedFiles.length,
+    sourceTextMergeBlockedFiles: blockedFiles.length,
+    sourceTextMergeOutputFiles: outputFiles.length,
+    sourceTextMergeCandidateStatus: files.length ? (blockedFiles.length ? 'failed' : 'passed') : 'absent'
+  };
+}
+
+function sourceTextMergeCandidateEvidenceRecord(id, summary) {
+  const passed = summary.sourceTextMergeCandidateStatus === 'passed';
+  const failed = summary.sourceTextMergeCandidateStatus === 'failed';
+  return {
+    id: `${id}_source_text_merge_candidate`,
+    kind: 'js-ts-source-text-merge-candidate',
+    level: 'source-text-merge-candidate',
+    status: passed ? 'passed' : failed ? 'failed' : 'skipped',
+    scope: 'source-files',
+    summary: sourceTextMergeCandidateEvidenceSummary(summary, passed, failed),
+    metadata: compactRecord({
+      files: summary.files,
+      sourceTextMergeCandidateFiles: summary.sourceTextMergeCandidateFiles,
+      sourceTextMergeBlockedFiles: summary.sourceTextMergeBlockedFiles,
+      sourceTextMergeOutputFiles: summary.sourceTextMergeOutputFiles,
+      outputFiles: summary.outputFiles,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+}
+
+function sourceTextMergeMissingEvidenceItem(summary, signal, missingEvidenceItem) {
+  if (!summary.files || summary.sourceTextMergeCandidateFiles || summary.sourceTextMergeBlockedFiles) return undefined;
+  return missingEvidenceItem({
+    code: signal,
+    scope: 'source-files',
+    kind: 'source-text-merge-candidate',
+    proofLevel: 'source-text-merge-candidate',
+    action: 'review',
+    summary: 'No concrete source text merge candidate was produced; run the conservative source merge substrate before semantic graph admission.',
+    suggestedInput: { baseFiles: {}, workerFiles: {}, headFiles: {} }
+  });
+}
+
+function sourceTextMergeMatrixProofStatus(level, summary) {
+  if (level !== 'source-text-merge-candidate') return undefined;
+  if (!summary.files) return 'absent';
+  if (summary.sourceTextMergeBlockedFiles) return 'failed';
+  return summary.sourceTextMergeCandidateFiles === summary.files ? 'passed' : 'missing';
+}
+
+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.';
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+export { sourceTextMergeCandidateEvidenceRecord, sourceTextMergeMatrixProofStatus, sourceTextMergeMissingEvidenceItem, sourceTextMergeSummary };

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

@@ -1,6 +1,7 @@
 import { compactMissingEvidenceTelemetry, confidenceRecommendedAction, createProjectMergeAdmissionMatrixAudit, missingEvidenceItems, missingEvidenceSignals, prioritizedMissingEvidence } from './js-ts-safe-project-merge-missing-evidence.js';
 import { failedEvidenceMissingItems, fileAdmissionEvidenceRecords } from './js-ts-safe-project-merge-evidence-routing.js'; import { compactProjectMergeRoutingCalibration } from './js-ts-safe-project-merge-routing-calibration.js';
 import { htmlCssProjectSummary } from './js-ts-safe-project-merge-html-css-summary.js';
+import { sourceTextMergeCandidateEvidenceRecord, sourceTextMergeSummary } from './js-ts-safe-project-merge-source-text-candidate.js';
 
 function projectSummary(files, graphConflicts = [], hasProjectGraphDelta = false, outputDiagnosticsGate = undefined, outputDeclarationGate = undefined, outputQualityGate = undefined, moveRenameSummary = undefined, proofEvidence = undefined, symbolRenameSummary = undefined, splitMergeSummary = undefined, projectSymbolGraph = undefined) {
   const byOperation = {};
@@ -11,9 +12,7 @@ function projectSummary(files, graphConflicts = [], hasProjectGraphDelta = false
   const proofLevelStatuses = proofEvidence?.summary?.levelStatuses ?? {};
   return {
     files: files.length,
-    mergedFiles: files.filter((file) => file.status === 'merged').length,
-    blockedFiles: files.filter((file) => file.status === 'blocked').length,
-    outputFiles: files.filter((file) => typeof file.outputSourceText === 'string').length,
+    ...sourceTextMergeSummary(files),
     ...htmlCssProjectSummary(files),
     projectGraphConflicts: graphConflicts.length,
     projectGraphDeltaEvidenceIncluded: hasProjectGraphDelta ? 1 : 0, projectGraphEvidenceIncluded: projectSymbolGraph || hasProjectGraphDelta ? 1 : 0,
@@ -113,6 +112,7 @@ function projectSummaryWithConfidenceEvidence(summary, evidence = [], confidence
 
 function projectEvidence(id, status, summary, context = {}) {
   return uniqueRecords([
+    sourceTextMergeCandidateEvidenceRecord(id, summary),
     projectMergeEvidenceRecord(id, status, summary, context),
     graphEvidenceRecord(id, summary, context),
     ...fileAdmissionEvidenceRecords(context.fileResults),
@@ -168,6 +168,9 @@ function projectConfidence(id, status, summary, evidence = [], reasonCodes = [],
       mergedFiles: summary.mergedFiles,
       blockedFiles: summary.blockedFiles,
       outputFiles: summary.outputFiles,
+      sourceTextMergeCandidateStatus: summary.sourceTextMergeCandidateStatus,
+      sourceTextMergeCandidateFiles: summary.sourceTextMergeCandidateFiles,
+      sourceTextMergeBlockedFiles: summary.sourceTextMergeBlockedFiles,
       projectGraphConflicts: summary.projectGraphConflicts,
       outputDiagnosticConflicts: summary.outputDiagnosticConflicts,
       outputDeclarationConflicts: summary.outputDeclarationConflicts,
@@ -293,6 +296,7 @@ function confidenceLevel(score, status) {
 function compactConfidenceDimensions(status, summary, context, routingCalibration = {}) {
   return compactRecord({
     merge: status === 'merged' ? 'merged' : 'blocked',
+    sourceText: summary.sourceTextMergeCandidateStatus ?? 'absent',
     graph: context.hasProjectGraphEvidence ? (summary.projectGraphConflicts ? 'failed' : 'passed') : 'missing',
     diagnostics: gateConfidenceDimension(context.outputDiagnosticsGate),
     declarations: gateConfidenceDimension(context.outputDeclarationGate),
@@ -303,14 +307,7 @@ function compactConfidenceDimensions(status, summary, context, routingCalibratio
 
 function gateConfidenceDimension(gate) { return !gate ? 'missing' : gate.status === 'passed' ? 'passed' : gate.status === 'skipped' ? 'missing' : 'failed'; }
 
-function uniqueRecords(records) {
-  const seen = new Set();
-  return records.filter((record) => {
-    if (!record?.id || seen.has(record.id)) return false;
-    seen.add(record.id);
-    return true;
-  });
-}
+function uniqueRecords(records) { const seen = new Set(); return records.filter((record) => !record?.id || seen.has(record.id) ? false : (seen.add(record.id), true)); }
 
 function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }

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.164",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",