@shapeshift-labs/frontier-lang-compiler 0.2.149 → 0.2.151

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

@@ -0,0 +1,320 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+import { effectTargetContextReasonCodes } from '../../semantic-import-runtime-effect-target-evidence.js'; import { mutationTargetContextReasonCodes } from '../../semantic-import-runtime-mutation-evidence.js';
+import { promiseCombinatorContextReasonCodes } from '../../semantic-import-runtime-promise-combinator-evidence.js';
+import { promiseChainContextReasonCodes } from '../../semantic-import-runtime-promise-chain-evidence.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { runtimeOrderEvidenceBinding } from './runtimeOrderEvidenceBinding.js';
+import { sourceTextForSpan } from './sourceTextForSpan.js';
+const runtimeOrderSensitiveRegionKinds = new Set(['call', 'controlFlow', 'effect', 'mutation']);
+
+export function orderSensitiveHeadPeerConflict(input) {
+  if (!isRuntimeOrderSensitiveRegion(input.region, input.baseSymbol)) return undefined;
+  const explicitEvidence = runtimeOrderEvidenceBinding(input);
+  if (explicitEvidence.passed) return undefined;
+  const sameAnchor = sameAnchorRuntimeOrderConflict(input);
+  if (sameAnchor) {
+    return {
+      peer: sameAnchor.region,
+      reasonCodes: uniqueStrings([
+        'head-runtime-order-evidence-changed-since-base',
+        'runtime-order-sensitive-merge-requires-explicit-evidence',
+        ...explicitEvidence.reasonCodes,
+        ...runtimeOrderReasonCodes(input),
+        ...runtimeOrderReasonCodes({ ...input, region: sameAnchor.region })
+      ]),
+      evidenceIds: explicitEvidence.evidenceIds
+    };
+  }
+  const peer = (input.context.headChangeSet?.changedRegions ?? [])
+    .find((region) => orderSensitivePeerChanged(input.region, region, input.context));
+  if (!peer) return undefined;
+  return {
+    peer,
+    reasonCodes: uniqueStrings([
+      'head-order-sensitive-peer-changed-since-base',
+      'runtime-order-sensitive-merge-requires-explicit-evidence',
+      ...explicitEvidence.reasonCodes,
+      ...runtimeOrderReasonCodes(input),
+      ...runtimeOrderReasonCodes({ ...input, region: peer })
+    ]),
+    evidenceIds: explicitEvidence.evidenceIds
+  };
+}
+
+export function runtimeOrderReasonCodes(input) {
+  const regionKind = runtimeRegionKind(input.region, input.baseSymbol);
+  if (regionKind === 'call') return uniqueStrings([...callsiteOrderReasonCodes(input), ...runtimeOrderContextReasonCodes(input)]);
+  if (regionKind === 'controlFlow') return uniqueStrings([...controlFlowOrderReasonCodes(input), ...runtimeOrderContextReasonCodes(input)]);
+  if (regionKind === 'effect') return uniqueStrings([...effectOrderReasonCodes(input), ...runtimeOrderContextReasonCodes(input)]);
+  if (regionKind === 'mutation') return uniqueStrings([...mutationOrderReasonCodes(input), ...runtimeOrderContextReasonCodes(input)]);
+  return [];
+}
+
+export function templateLiteralBlockReasonCodes(input) {
+  const kinds = regionFactKinds(input.region);
+  if (!kinds.includes('tagged-template') && !kinds.includes('template-interpolation')) return [];
+  return uniqueStrings([
+    'template-literal-merge-requires-template-evidence',
+    ...(kinds.includes('tagged-template') ? ['tagged-template-merge-requires-tag-effect-evidence'] : []),
+    ...(kinds.includes('template-interpolation') ? ['template-interpolation-merge-requires-expression-order-evidence'] : []),
+    ...effectOrderReasonCodes(input), ...runtimeOrderContextReasonCodes(input)
+  ]);
+}
+
+function orderSensitivePeerChanged(workerRegion, headRegion, context) {
+  if (!isRuntimeOrderSensitiveRegion(headRegion)) return false;
+  if ((headRegion.conflictKey ?? headRegion.key) === (workerRegion.conflictKey ?? workerRegion.key)) return false;
+  if (!sameRegionSourcePath(workerRegion, headRegion)) return false;
+  if (!headRegionHasCoherentTextChange(headRegion, context)) return false;
+  const workerOwner = runtimeRegionOwner(workerRegion);
+  const headOwner = runtimeRegionOwner(headRegion);
+  return Boolean(workerOwner && headOwner && workerOwner === headOwner);
+}
+
+function sameAnchorRuntimeOrderConflict(input) {
+  const key = input.region?.key ?? stripRegionPrefix(input.region?.conflictKey);
+  if (!key) return undefined;
+  const changedSymbol = (input.context.headChangeSet?.changedSymbols ?? [])
+    .find((symbol) => symbolRuntimeOrderSignatureChangedForKey(symbol, key));
+  if (!changedSymbol) return undefined;
+  const region = (input.context.headChangeSet?.changedRegions ?? [])
+    .find((candidate) => (candidate.key ?? stripRegionPrefix(candidate.conflictKey)) === key)
+    ?? input.region;
+  if (!runtimeOrderContextReasonCodes(input).length && !runtimeOrderContextReasonCodes({ ...input, region }).length) return undefined;
+  return { region, changedSymbol };
+}
+
+function symbolRuntimeOrderSignatureChangedForKey(symbol, key) {
+  if (![symbol?.beforeOwnershipKey, symbol?.afterOwnershipKey, symbol?.ownershipKey].includes(key)) return false;
+  if ((symbol.beforeSignatureHash ?? '') === (symbol.afterSignatureHash ?? '')) return false;
+  if (symbol.beforeSpanHash && symbol.afterSpanHash && symbol.beforeSpanHash !== symbol.afterSpanHash) return false;
+  return true;
+}
+
+function stripRegionPrefix(value) {
+  const text = String(value ?? '');
+  return text.startsWith('region:') ? text.slice('region:'.length) : text || undefined;
+}
+
+function headRegionHasCoherentTextChange(region, context) {
+  const projection = region?.metadata?.changedRegionProjection;
+  const beforeSpan = projection?.before?.sourceSpan;
+  const afterSpan = projection?.after?.sourceSpan;
+  if (!beforeSpan || !afterSpan) return true;
+
+  const beforeHash = projection?.before?.sourceHash ?? context?.base?.nativeSource?.hash;
+  const afterHash = projection?.after?.sourceHash ?? context?.head?.nativeSource?.hash;
+  if (beforeSpan.sourceId && beforeHash && beforeSpan.sourceId !== beforeHash) return false;
+  if (afterSpan.sourceId && afterHash && afterSpan.sourceId !== afterHash) return false;
+
+  const beforeText = sourceTextForSpan(nativeImportSourceText(context?.base), beforeSpan);
+  const afterText = sourceTextForSpan(nativeImportSourceText(context?.head), afterSpan);
+  if (typeof beforeText === 'string' && typeof afterText === 'string') return beforeText !== afterText;
+  return true;
+}
+
+function callsiteOrderReasonCodes(input) {
+  if (!stableCalleeCallsite(input)) return ['callsite-merge-requires-call-order-evidence'];
+  return [
+    'callsite-argument-merge-requires-callee-signature-evidence',
+    'callsite-argument-merge-requires-argument-effect-evidence',
+    'callsite-argument-merge-requires-argument-order-evidence'
+  ];
+}
+
+function controlFlowOrderReasonCodes(input) {
+  return uniqueStrings([
+    'control-flow-merge-requires-control-order-evidence',
+    ...regionFactKinds(input.region).flatMap((kind) => {
+      if (kind === 'branch') return ['control-flow-branch-merge-requires-condition-order-evidence'];
+      if (kind === 'loop') return ['control-flow-loop-merge-requires-iteration-order-evidence'];
+      if (kind === 'exit') return ['control-flow-exit-merge-requires-return-yield-order-evidence'];
+      if (kind === 'transfer') return ['control-flow-transfer-merge-requires-break-continue-order-evidence'];
+      if (kind === 'exception') return ['control-flow-exception-merge-requires-throw-order-evidence'];
+      if (kind === 'async') return ['control-flow-async-merge-requires-await-order-evidence'];
+      return [];
+    })
+  ]);
+}
+
+function effectOrderReasonCodes(input) {
+  return uniqueStrings([
+    'effect-merge-requires-side-effect-evidence',
+    'effect-merge-requires-effect-order-evidence',
+    ...regionFactKinds(input.region).flatMap((kind) => {
+      if (kind === 'async') return ['effect-async-merge-requires-await-order-evidence'];
+      if (kind === 'network') return ['effect-network-merge-requires-io-order-evidence'];
+      if (kind === 'storage') return ['effect-storage-merge-requires-storage-order-evidence'];
+      if (kind === 'scheduler') return ['effect-scheduler-merge-requires-scheduler-order-evidence']; if (kind === 'class-static-block') return ['effect-class-static-block-merge-requires-static-initialization-order-evidence'];
+      if (kind === 'host-context') return ['effect-import-meta-merge-requires-host-context-evidence'];
+      if (kind === 'host') return ['effect-host-merge-requires-host-order-evidence'];
+      if (kind === 'browser') return ['effect-browser-merge-requires-browser-order-evidence'];
+      if (kind === 'getter') return ['effect-getter-merge-requires-getter-order-evidence'];
+      if (kind === 'generator') return ['effect-generator-merge-requires-yield-order-evidence'];
+      if (kind === 'resource-management' || kind === 'using' || kind === 'await-using') return ['effect-resource-management-merge-requires-acquisition-disposal-evidence'];
+      if (kind === 'template-literal') return ['effect-template-literal-merge-requires-template-token-evidence'];
+      if (kind === 'template-interpolation') return ['effect-template-interpolation-merge-requires-expression-order-evidence'];
+      if (kind === 'tagged-template') return ['effect-tagged-template-merge-requires-tag-effect-evidence'];
+      return [];
+    })
+  ]);
+}
+
+function mutationOrderReasonCodes(input) {
+  return uniqueStrings([
+    'mutation-merge-requires-write-order-evidence',
+    ...regionFactKinds(input.region).flatMap((kind) => {
+      if (kind === 'assignment') return ['mutation-assignment-merge-requires-assignment-order-evidence'];
+      if (kind === 'update') return ['mutation-update-merge-requires-update-order-evidence'];
+      if (kind === 'delete') return ['mutation-delete-merge-requires-delete-order-evidence'];
+      if (kind === 'mutating-call') return ['mutation-call-merge-requires-call-order-evidence'];
+      return [];
+    })
+  ]);
+}
+
+function runtimeOrderContextReasonCodes(input) {
+  const evidence = runtimeOrderEvidence(input.region);
+  return uniqueStrings([
+    ...array(evidence?.branchOrder).flatMap(controlFlowContextReasonCodes),
+    ...array(evidence?.loopOrder).flatMap(controlFlowContextReasonCodes),
+    ...array(evidence?.sameLineControlFlow).flatMap(controlFlowContextReasonCodes),
+    ...array(evidence?.loopIterationOrder).flatMap(loopIterationContextReasonCodes),
+    ...array(evidence?.controlTransferOrder).flatMap(controlTransferContextReasonCodes),
+    ...array(evidence?.exitOrder).flatMap(exitContextReasonCodes),
+    ...array(evidence?.reachabilityOrder).flatMap(reachabilityContextReasonCodes),
+    ...(array(evidence?.sameLineShortCircuit).length ? ['runtime-order-short-circuit-merge-requires-expression-order-evidence'] : []),
+    ...(array(evidence?.importMetaHostContext).length ? ['runtime-order-import-meta-merge-requires-host-context-evidence'] : []), ...(array(evidence?.classStaticBlockOrder).length ? ['runtime-order-class-static-block-merge-requires-static-initialization-evidence'] : []),
+    ...(evidence?.sameLineAwait || array(evidence?.sameLineAwaitOrder).length
+      ? ['runtime-order-await-merge-requires-suspension-order-evidence']
+      : []),
+    ...(array(evidence?.sameLineOptionalChain).length
+      ? ['runtime-order-optional-chain-merge-requires-nullish-boundary-evidence']
+      : []),
+    ...(array(evidence?.sameLineConditionalExpression).length
+      ? ['runtime-order-conditional-expression-merge-requires-branch-selection-evidence']
+      : []),
+    ...array(evidence?.sameLinePromiseCombinator).flatMap(promiseCombinatorContextReasonCodes),
+    ...array(evidence?.sameLinePromiseChain).flatMap(promiseChainContextReasonCodes),
+    ...(array(evidence?.sameLineThrowOrder).length || evidence?.sameLineThrow
+      ? ['runtime-order-throw-merge-requires-exception-path-evidence']
+      : []),
+    ...array(evidence?.switchDispatchOrder).flatMap(switchDispatchContextReasonCodes),
+    ...array(evidence?.tryCatchOrder).flatMap(tryCatchContextReasonCodes),
+    ...array(evidence?.mutationTargetOrder).flatMap(mutationTargetContextReasonCodes), ...array(evidence?.effectTargetOrder).flatMap(effectTargetContextReasonCodes),
+    ...array(evidence?.tryFinallyOrder).flatMap(tryFinallyContextReasonCodes),
+    ...array(evidence?.resourceManagementOrder).flatMap(resourceManagementContextReasonCodes)
+  ]);
+}
+
+function runtimeOrderEvidence(region) { return region?.metadata?.runtimeOrderEvidence ?? region?.runtimeOrderEvidence; }
+function exitContextReasonCodes(record) { return uniqueStrings(['runtime-order-exit-merge-requires-completion-value-evidence', record?.delegated ? 'runtime-order-yield-star-merge-requires-iterator-delegation-evidence' : undefined, record?.iteratorProtocolEquivalenceClaim === false ? 'runtime-order-yield-star-iterator-protocol-equivalence-not-proven' : undefined, record?.delegatedCompletionPropagationClaim === false ? 'runtime-order-yield-star-completion-propagation-equivalence-not-proven' : undefined]); }
+function controlFlowContextReasonCodes(record) { if (record?.kind === 'branch') return ['control-flow-branch-merge-requires-condition-order-evidence']; if (record?.kind === 'loop') return ['control-flow-loop-merge-requires-iteration-order-evidence']; if (record?.kind === 'exception') return ['control-flow-exception-merge-requires-throw-order-evidence']; return []; }
+
+function loopIterationContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-loop-iteration-merge-requires-loop-header-evidence',
+    ['for-of', 'for-await-of', 'for-in'].includes(record?.loopKind)
+      ? 'runtime-order-loop-iterator-merge-requires-iteration-source-evidence'
+      : undefined,
+    record?.loopKind === 'for' ? 'runtime-order-for-loop-merge-requires-init-condition-update-evidence' : undefined,
+    record?.loopKind === 'while' || record?.loopKind === 'do'
+      ? 'runtime-order-while-loop-merge-requires-condition-evidence'
+      : undefined
+  ]);
+}
+
+function controlTransferContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-control-transfer-merge-requires-break-continue-evidence',
+    record?.transferKind === 'break' ? 'runtime-order-break-merge-requires-loop-switch-exit-evidence' : undefined,
+    record?.transferKind === 'continue' ? 'runtime-order-continue-merge-requires-next-iteration-evidence' : undefined,
+    record?.labelText ? 'runtime-order-labeled-transfer-merge-requires-label-target-evidence' : undefined,
+    record?.labelText ? (record?.labelTargetKind ? 'runtime-order-labeled-transfer-target-lexical-evidence' : 'runtime-order-labeled-transfer-target-unresolved-review') : undefined
+  ]);
+}
+
+function reachabilityContextReasonCodes(record) {
+  const kind = record?.completionKind;
+  return uniqueStrings(['runtime-order-unreachable-region-merge-requires-reachability-evidence', 'runtime-order-reachability-merge-requires-completion-path-evidence', kind === 'return' ? 'runtime-order-return-reachability-merge-requires-completion-value-evidence' : undefined, kind === 'throw' ? 'runtime-order-throw-reachability-merge-requires-exception-path-evidence' : undefined, kind === 'break' ? 'runtime-order-break-reachability-merge-requires-loop-switch-exit-evidence' : undefined, kind === 'continue' ? 'runtime-order-continue-reachability-merge-requires-next-iteration-evidence' : undefined]);
+}
+
+function switchDispatchContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-switch-dispatch-merge-requires-case-selection-evidence',
+    record?.caseKind === 'case' ? 'runtime-order-switch-case-merge-requires-case-arm-evidence' : undefined,
+    record?.caseKind === 'default' ? 'runtime-order-switch-default-merge-requires-default-arm-evidence' : undefined,
+    record?.caseKind ? undefined : 'runtime-order-switch-merge-requires-discriminant-evidence',
+    record?.fallthroughFromPrevious ? 'runtime-order-switch-fallthrough-merge-requires-prior-case-completion-evidence' : undefined
+  ]);
+}
+
+function tryCatchContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-try-catch-merge-requires-throw-catch-order-evidence',
+    record?.kind === 'catch-handler' ? 'runtime-order-catch-merge-requires-handler-order-evidence' : undefined,
+    record?.kind === 'try-catch' ? 'runtime-order-try-catch-merge-requires-handler-selection-evidence' : undefined
+  ]);
+}
+
+function tryFinallyContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-try-finally-merge-requires-completion-order-evidence',
+    record?.kind === 'finalizer' ? 'runtime-order-finally-merge-requires-finalizer-order-evidence' : undefined,
+    record?.kind === 'try-finally' && record?.enclosingLoop ? 'runtime-order-try-finally-loop-merge-requires-iteration-finalizer-order-evidence' : undefined
+  ]);
+}
+
+function resourceManagementContextReasonCodes(record) { return uniqueStrings(['runtime-order-resource-management-merge-requires-disposal-order-evidence', record?.awaitUsing || record?.declarationKind === 'await-using' ? 'runtime-order-await-using-merge-requires-async-disposal-evidence' : 'runtime-order-using-merge-requires-dispose-evidence', record?.disposalEffectEquivalenceClaim === false ? 'runtime-order-resource-management-disposal-effect-equivalence-not-proven' : undefined]); }
+
+function stableCalleeCallsite(input) {
+  if (runtimeRegionKind(input.region, input.baseSymbol) !== 'call') return false;
+  const baseName = input.baseSymbol?.name ?? input.region?.symbolName;
+  if (!baseName) return false;
+  return [input.workerSymbol?.name, input.headSymbol?.name].every((name) => name === baseName);
+}
+
+function isRuntimeOrderSensitiveRegion(region, symbol) { return runtimeOrderSensitiveRegionKinds.has(runtimeRegionKind(region, symbol)); }
+
+function runtimeRegionKind(region, symbol) { return String(region?.regionKind ?? symbol?.ownershipRegionKind ?? ''); }
+
+function regionFactKinds(region) {
+  const regionKind = runtimeRegionKind(region);
+  const signature = factSignatureFromSymbolName(region?.symbolName, regionKind);
+  return uniqueStrings([
+    ...array(region?.metadata?.factKinds),
+    ...array(region?.metadata?.factKind),
+    ...array(region?.runtimeKinds),
+    ...array(region?.runtimeKind),
+    ...array(signature)
+  ].flatMap((kind) => String(kind ?? '').split('+')).filter(Boolean));
+}
+
+function factSignatureFromSymbolName(symbolName, regionKind) {
+  const marker = `:${regionKind}:`;
+  const text = String(symbolName ?? '');
+  const markerIndex = text.indexOf(marker);
+  if (markerIndex < 0) return undefined;
+  const signature = text.slice(markerIndex + marker.length).replace(/#\d+$/, '');
+  return signature || undefined;
+}
+
+function runtimeRegionOwner(region) {
+  const subjectName = region?.metadata?.subjectName;
+  if (subjectName) return String(subjectName);
+  const symbolName = String(region?.symbolName ?? '');
+  const kind = runtimeRegionKind(region);
+  const marker = `:${kind}:`;
+  const markerIndex = symbolName.indexOf(marker);
+  if (markerIndex >= 0) return symbolName.slice(0, markerIndex);
+  if (kind === 'call' && symbolName.includes('->')) return symbolName.split('->')[0];
+  return '';
+}
+
+function sameRegionSourcePath(left, right) {
+  const leftPath = left?.sourcePath ?? left?.sourceSpan?.path;
+  const rightPath = right?.sourcePath ?? right?.sourceSpan?.path;
+  return Boolean(leftPath && rightPath && leftPath === rightPath);
+}
+
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }

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

@@ -1,5 +1,17 @@
 import { uniqueStrings } from '../../native-import-utils.js';
+import { jsTsFunctionParameterBindingPatternReasonCodes } from '../../js-ts-safe-merge-binding-patterns.js';
+import { attributeMap, parseJsxTags, sameAttrText } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { nativeImportSourceText } from './nativeImportSourceText.js';
+import { runtimeOrderEvidenceBinding } from './runtimeOrderEvidenceBinding.js';
 import { resolveSemanticLineage } from './semanticLineageResolutionRecords.js';
+import {
+  orderSensitiveHeadPeerConflict,
+  runtimeOrderReasonCodes,
+  templateLiteralBlockReasonCodes
+} from './semanticEditRuntimeOrderReasons.js';
+import { typeSyntaxEditClassification, typeSyntaxEditReasonCodes } from './semanticEditTypeSyntaxReasons.js';
+import { sourceTextForSpan } from './sourceTextForSpan.js';
+import { callsiteArgumentAppendMergeClassification } from './semanticEditCallsiteArgumentMerge.js';
 
 export const SemanticEditScriptAdmissionStatuses = Object.freeze([
   'auto-merge-candidate',
@@ -13,21 +25,41 @@ export const SemanticEditScriptAdmissionStatuses = Object.freeze([
 export function classifySemanticEdit(input) {
   if (!input.context.head) return editStatus('candidate', 'needs-review', 0.66, ['head-source-not-provided']);
   if (!input.anchorKey) return editStatus('blocked', 'blocked', 0, ['missing-semantic-anchor']);
+  const templateReasonCodes = templateLiteralBlockReasonCodes(input);
+  if (templateReasonCodes.length) return editStatus('blocked', 'blocked', 0.1, templateReasonCodes);
   if (input.context.workerChangeSet.beforeHash &&
     input.context.headChangeSet?.afterHash === input.context.workerChangeSet.beforeHash &&
     sameSourcePath(input.context.base, input.context.head)) {
-    return editStatus('portable', 'ready', 0.95, ['head-source-matches-base']);
+    const typeSyntax = typeSyntaxEditClassification(input);
+    if (typeSyntax?.status === 'blocked') return editStatus('blocked', 'blocked', 0.12, typeSyntax.reasonCodes, undefined, typeSyntax.evidenceIds);
+    return editStatus('portable', 'ready', typeSyntax ? 0.82 : 0.95,
+      uniqueStrings(['head-source-matches-base', ...(typeSyntax?.reasonCodes ?? [])]), undefined, typeSyntax?.evidenceIds ?? []);
   }
   if (input.region.changeKind === 'added') return classifyAddedRegion(input);
   if (!input.baseSymbol) return classifyMissingBaseAnchor(input);
   if (!input.headSymbol) return classifyMissingHeadAnchor(input);
   if (input.headSymbol.spanHash && input.baseSymbol.spanHash && input.headSymbol.spanHash === input.baseSymbol.spanHash) {
-    return editStatus('portable', 'ready', 0.9, ['head-anchor-matches-base']);
+    const jsxAttributeReasonCodes = jsxAttributeChangeReasonCodes(input);
+    if (jsxAttributeReasonCodes.length) return editStatus('conflict', 'blocked', 0.2, jsxAttributeReasonCodes);
+    const typeSyntax = typeSyntaxEditClassification(input);
+    if (typeSyntax?.status === 'blocked') return editStatus('blocked', 'blocked', 0.12, typeSyntax.reasonCodes, undefined, typeSyntax.evidenceIds);
+    const peerConflict = orderSensitiveHeadPeerConflict(input);
+    if (peerConflict) return editStatus('conflict', 'blocked', 0.2, peerConflict.reasonCodes, undefined, peerConflict.evidenceIds);
+    const runtimeOrderEvidence = runtimeOrderEvidenceBinding(input);
+    return editStatus('portable', 'ready', typeSyntax ? 0.82 : 0.9,
+      uniqueStrings(['head-anchor-matches-base', ...(typeSyntax?.reasonCodes ?? [])]), undefined,
+      uniqueStrings([...(typeSyntax?.evidenceIds ?? []), ...runtimeOrderEvidence.evidenceIds]));
   }
   if (input.headSymbol.spanHash && input.workerSymbol?.spanHash && input.headSymbol.spanHash === input.workerSymbol.spanHash) {
     return editStatus('already-applied', 'ready', 0.92, ['head-anchor-matches-worker']);
   }
-  return editStatus('conflict', 'blocked', 0.2, ['head-anchor-changed-since-base']);
+  const callsiteArgumentAppend = callsiteArgumentAppendMergeClassification(input);
+  if (callsiteArgumentAppend) {
+    return editStatus('portable', 'ready', 0.78, callsiteArgumentAppend.reasonCodes, undefined, callsiteArgumentAppend.evidenceIds, {
+      sourceBackprojection: callsiteArgumentAppend.sourceBackprojection
+    });
+  }
+  return editStatus('conflict', 'blocked', 0.2, headAnchorChangedSinceBaseReasonCodes(input));
 }
 
 export function summarizeSemanticEditOperations(operations) {
@@ -73,6 +105,8 @@ export function semanticEditAdmission(input) {
 }
 
 function classifyAddedRegion(input) {
+  const peerConflict = orderSensitiveHeadPeerConflict(input);
+  if (peerConflict) return editStatus('conflict', 'blocked', 0.2, peerConflict.reasonCodes, undefined, peerConflict.evidenceIds);
   if (!input.headSymbol) return editStatus('portable', 'ready', 0.86, ['added-anchor-absent-from-head']);
   if (input.headSymbol.spanHash && input.workerSymbol?.spanHash && input.headSymbol.spanHash === input.workerSymbol.spanHash) {
     return editStatus('already-applied', 'ready', 0.88, ['added-anchor-already-present-in-head']);
@@ -112,8 +146,59 @@ function classifyMissingHeadAnchor(input) {
   return editStatus('stale', 'needs-review', 0.25, ['head-anchor-missing']);
 }
 
-function editStatus(status, readiness, confidence, reasonCodes, reanchor, evidenceIds = []) {
-  return { status, readiness, confidence, reasonCodes, reanchor, evidenceIds };
+function headAnchorChangedSinceBaseReasonCodes(input) {
+  return uniqueStrings([
+    'head-anchor-changed-since-base',
+    ...typeSyntaxEditReasonCodes(input),
+    ...functionParameterBindingPatternReasonCodes(input),
+    ...runtimeOrderReasonCodes(input)
+  ]);
+}
+
+function jsxAttributeChangeReasonCodes(input) {
+  if (input.region?.regionKind !== 'controlFlow') return [];
+  const baseText = symbolSourceText(input.context.base, input.baseSymbol, input.region);
+  const workerText = symbolSourceText(input.context.worker, input.workerSymbol, input.region);
+  if (!jsxAttributeTextChanged(baseText, workerText)) return [];
+  return uniqueStrings([
+    'runtime-order-sensitive-merge-requires-explicit-evidence',
+    'jsx-attribute-merge-requires-jsx-attribute-evidence',
+    ...runtimeOrderReasonCodes(input)
+  ]);
+}
+
+function jsxAttributeTextChanged(baseText, workerText) {
+  if (typeof baseText !== 'string' || typeof workerText !== 'string') return false;
+  const baseTags = parseJsxTags(baseText);
+  const workerTags = parseJsxTags(workerText);
+  if (baseTags.reasonCodes.length || workerTags.reasonCodes.length) return false;
+  for (const baseTag of baseTags.tags) {
+    const workerTag = workerTags.byKey.get(baseTag.key);
+    if (!workerTag || workerTag.tagName !== baseTag.tagName) continue;
+    const baseAttrs = attributeMap(baseTag);
+    const workerAttrs = attributeMap(workerTag);
+    if (baseAttrs.reasonCodes.length || workerAttrs.reasonCodes.length) continue;
+    for (const baseAttr of baseAttrs.byName.values()) {
+      const workerAttr = workerAttrs.byName.get(baseAttr.name);
+      if (workerAttr && !sameAttrText(baseAttr, workerAttr)) return true;
+    }
+  }
+  return false;
+}
+
+function functionParameterBindingPatternReasonCodes(input) {
+  const baseText = symbolSourceText(input.context.base, input.baseSymbol, input.region);
+  const workerText = symbolSourceText(input.context.worker, input.workerSymbol, input.region);
+  return jsTsFunctionParameterBindingPatternReasonCodes(baseText, workerText);
+}
+
+function symbolSourceText(imported, symbol, region) {
+  const span = symbol?.sourceSpan ?? region?.metadata?.changedRegionProjection?.before?.sourceSpan ?? region?.sourceSpan;
+  return sourceTextForSpan(nativeImportSourceText(imported), span);
+}
+
+function editStatus(status, readiness, confidence, reasonCodes, reanchor, evidenceIds = [], metadata = {}) {
+  return { status, readiness, confidence, reasonCodes, reanchor, evidenceIds, ...metadata };
 }
 
 function reanchorRecord(fromAnchorKey, target, resolved) {

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

@@ -16,6 +16,7 @@ import { semanticEditInsertionAnchor } from './semanticEditInsertionAnchors.js';
 import { markCoveredSemanticEditOperations } from './semanticEditOperationCoverage.js';
 import { sourceTextForSpan } from './sourceTextForSpan.js';
 import { semanticEditIdentityFields, semanticEditOperationContentHash } from './semanticEditIdentityRecords.js';
+import { semanticStructuralDiff, semanticStructuralEdit } from './semanticStructuralDiffRecords.js';
 
 export { SemanticEditScriptAdmissionStatuses };
 
@@ -59,7 +60,8 @@ export function createSemanticEditScript(input = {}, options = {}) {
   );
   const summary = summarizeSemanticEditOperations(operations);
   const admission = semanticEditAdmission({ operations, summary, head, workerChangeSet, headChangeSet, input });
-  const evidence = semanticEditEvidence({ input, language, sourcePath, workerChangeSet, headChangeSet, headLineage, summary, admission });
+  const structuralDiff = semanticStructuralDiff({ input, language, sourcePath, workerChangeSet, headChangeSet, operations });
+  const evidence = semanticEditEvidence({ input, language, sourcePath, workerChangeSet, headChangeSet, headLineage, summary, admission, structuralDiff });
   const core = {
     kind: 'frontier.lang.semanticEditScript',
     version: 1,
@@ -73,12 +75,14 @@ export function createSemanticEditScript(input = {}, options = {}) {
     headChangeSetId: headChangeSet?.id,
     lineageInferenceId: headLineage?.id,
     operations,
-    summary,
+    summary: { ...summary, structural: structuralDiff.summary },
+    structuralDiff,
     admission,
     evidence,
     metadata: compactRecord({
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
+      structuralDiffStatus: structuralDiff.admission.status,
       workerReadiness: workerChangeSet.readiness,
       headReadiness: headChangeSet?.readiness,
       workerReasons: workerChangeSet.reasons,
@@ -134,11 +138,12 @@ function symbolsByAnchor(imported) {
 }
 
 function semanticEditOperation(region, index, context, input) {
+  const operationId = `semantic_edit_op_${idFragment([index, region.key ?? region.conflictKey ?? region.id, input.id ?? 'semantic_edit'].join(':'))}`;
   const anchorKey = region.key ?? region.conflictKey ?? region.id;
   const baseSymbol = context.baseSymbols.get(anchorKey);
   const workerSymbol = context.workerSymbols.get(anchorKey);
   const directHeadSymbol = context.headSymbols.get(anchorKey);
-  const classification = classifySemanticEdit({ region, anchorKey, baseSymbol, workerSymbol, headSymbol: directHeadSymbol, context });
+  const classification = classifySemanticEdit({ region, anchorKey, baseSymbol, workerSymbol, headSymbol: directHeadSymbol, context, scriptInput: input });
   const headSymbol = directHeadSymbol ?? reanchoredHeadSymbol(context, classification);
   const kind = semanticEditOperationKind(region);
   const baseText = spanText(context.base, baseSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.before?.sourceSpan ?? region.sourceSpan);
@@ -172,8 +177,24 @@ function semanticEditOperation(region, index, context, input) {
   });
   const identityRecord = semanticEditIdentityRecord({ kind, region, anchor });
   const identity = semanticEditIdentityFields(identityRecord);
+  const structuralEdit = semanticStructuralEdit({
+    operationId,
+    kind,
+    changeKind: region.changeKind,
+    anchor,
+    spans: {
+      base: baseSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.before?.sourceSpan,
+      worker: workerSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.after?.sourceSpan ?? region.sourceSpan,
+      head: headSymbol?.sourceSpan
+    },
+    hashes,
+    status: classification.status,
+    confidence: classification.confidence,
+    reasonCodes: classification.reasonCodes,
+    reanchor: classification.reanchor
+  });
   return compactRecord({
-    id: `semantic_edit_op_${idFragment([index, anchorKey, input.id ?? 'semantic_edit'].join(':'))}`,
+    id: operationId,
     kind,
     changeKind: region.changeKind,
     anchor,
@@ -187,6 +208,7 @@ function semanticEditOperation(region, index, context, input) {
     hashes,
     status: classification.status,
     operationContentHash: semanticEditOperationContentHash({ ...identityRecord, ...identity, ...hashes, status: classification.status }),
+    structuralEdit,
     reanchor: classification.reanchor,
     readiness: classification.readiness,
     confidence: classification.confidence,
@@ -194,7 +216,8 @@ function semanticEditOperation(region, index, context, input) {
     evidenceIds: classification.evidenceIds,
     metadata: {
       autoMergeClaim: false,
-      semanticEquivalenceClaim: false
+      semanticEquivalenceClaim: false,
+      sourceBackprojection: classification.sourceBackprojection
     }
   });
 }
@@ -253,6 +276,20 @@ function semanticEditEvidence(input) {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
+  }, {
+    id: input.input.structuralEvidenceId ?? `evidence_${idFragment(input.input.id ?? input.sourcePath ?? 'semantic_edit')}_structural_diff`,
+    kind: 'semantic-structural-diff',
+    status: 'needs-review',
+    path: input.sourcePath,
+    summary: `Recorded ${input.structuralDiff.summary.edits} runtime-neutral structural edit(s); replay diagnostics remain required for safety.`,
+    metadata: {
+      structuralDiffId: input.structuralDiff.id,
+      structuralDiffHash: input.structuralDiff.hash,
+      summary: input.structuralDiff.summary,
+      admissionStatus: input.structuralDiff.admission.status,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
   }];
 }