@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.104

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

@@ -0,0 +1,190 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict, detectLineEnding, normalizeLineEndings } from './js-ts-safe-merge-context.js';
+import { importSpecifierCanonical } from './js-ts-safe-merge-ledger.js';
+
+export function createSourceMergePlan(base, worker, head, workerPlan, headPlan, context) {
+  const edits = [];
+  let importSpecifierAdditions = 0;
+  for (const baseEntry of base.entries.filter((entry) => entry.kind === 'import')) {
+    const workerAdditions = workerPlan.importAdditions.get(baseEntry.key) ?? [];
+    const headAdditions = headPlan.importAdditions.get(baseEntry.key) ?? [];
+    if (!workerAdditions.length && !headAdditions.length) continue;
+    importSpecifierAdditions += workerAdditions.length + headAdditions.length;
+    const headEntry = head.entries.find((entry) => entry.key === baseEntry.key);
+    if (!headEntry) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side: 'head',
+        message: 'Head source is missing a base import anchor.',
+        details: { key: baseEntry.key }
+      });
+      continue;
+    }
+    edits.push({
+      kind: 'replace-import',
+      start: headEntry.start,
+      end: headEntry.end,
+      text: renderImportStatement(baseEntry.importInfo, mergedImportSpecifiers(baseEntry.importInfo.specifiers, workerAdditions, headAdditions))
+    });
+  }
+
+  const insertionGroups = variantInsertionGroups(worker, workerPlan.baseKeys, 'worker', context);
+  const headInsertionGroups = variantInsertionGroups(head, headPlan.baseKeys, 'head', context);
+  const headInsertionGroupsByAnchor = new Map(headInsertionGroups.map((group) => [insertionGroupKey(group), group]));
+  const headEntriesByKey = new Map(head.entries.map((entry) => [entry.key, entry]));
+  let topLevelDeclarationAdditions = 0;
+  for (const group of insertionGroups) {
+    const anchor = headEntriesByKey.get(group.anchorKey);
+    if (!anchor) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.insertionAnchorMissing,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side: 'head',
+        message: 'Head source is missing a declaration insertion anchor.',
+        details: { anchorKey: group.anchorKey, mode: group.mode }
+      });
+      continue;
+    }
+    const headGroup = headInsertionGroupsByAnchor.get(insertionGroupKey(group));
+    const insertionSpan = declarationInsertionSpan(head.sourceText, anchor, group.mode, headGroup);
+    const entries = mergedDeclarationEntries(group.entries, headGroup?.entries ?? []);
+    edits.push({
+      kind: 'insert-declarations',
+      start: insertionSpan.start,
+      end: insertionSpan.end,
+      text: declarationInsertionText(entries, detectLineEnding(head.sourceText))
+    });
+    topLevelDeclarationAdditions += group.entries.length;
+  }
+
+  return {
+    edits,
+    importSpecifierAdditions,
+    topLevelDeclarationAdditions
+  };
+}
+
+function variantInsertionGroups(variant, baseKeys, side, context) {
+  const groups = [];
+  let index = 0;
+  while (index < variant.entries.length) {
+    const entry = variant.entries[index];
+    if (baseKeys.has(entry.key)) {
+      index += 1;
+      continue;
+    }
+    const start = index;
+    while (index < variant.entries.length && !baseKeys.has(variant.entries[index].key)) index += 1;
+    const entries = variant.entries.slice(start, index);
+    const previousBase = findPreviousBaseEntry(variant.entries, start, baseKeys);
+    const nextBase = findNextBaseEntry(variant.entries, index, baseKeys);
+    if (!previousBase && !nextBase) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.ambiguousInsertionPoint,
+        gateId: JsTsSafeMergeGateIds.resolvedInsertionAnchors,
+        side,
+        message: `${side} additions have no stable base declaration or import anchor.`,
+        details: { entries: entries.map((item) => item.names?.[0] ?? item.key) }
+      });
+      continue;
+    }
+    groups.push(previousBase
+      ? { mode: 'after', anchorKey: previousBase.key, entries }
+      : { mode: 'before', anchorKey: nextBase.key, entries });
+  }
+  return groups;
+}
+
+function insertionGroupKey(group) {
+  return `${group.mode}:${group.anchorKey}`;
+}
+
+function findPreviousBaseEntry(entries, startIndex, baseKeys) {
+  for (let index = startIndex - 1; index >= 0; index -= 1) {
+    if (baseKeys.has(entries[index].key)) return entries[index];
+  }
+  return undefined;
+}
+
+function findNextBaseEntry(entries, startIndex, baseKeys) {
+  for (let index = startIndex; index < entries.length; index += 1) {
+    if (baseKeys.has(entries[index].key)) return entries[index];
+  }
+  return undefined;
+}
+
+export function applySourceMergePlan(sourceText, mergePlan) {
+  return [...mergePlan.edits]
+    .sort((left, right) => right.start - left.start || right.end - left.end)
+    .reduce((current, edit) => `${current.slice(0, edit.start)}${edit.text}${current.slice(edit.end)}`, sourceText);
+}
+
+function mergedImportSpecifiers(baseSpecifiers, workerAdditions, headAdditions) {
+  const seen = new Set(baseSpecifiers.map((specifier) => specifier.canonical));
+  const additions = [];
+  for (const specifier of [...workerAdditions, ...headAdditions]) {
+    if (seen.has(specifier.canonical)) continue;
+    seen.add(specifier.canonical);
+    additions.push(specifier);
+  }
+  additions.sort((left, right) => left.canonical.localeCompare(right.canonical));
+  return [...baseSpecifiers, ...additions];
+}
+
+function renderImportStatement(importInfo, specifiers) {
+  const clause = [];
+  if (importInfo.defaultLocalName) clause.push(importInfo.defaultLocalName);
+  if (importInfo.namespaceLocalName) clause.push(`* as ${importInfo.namespaceLocalName}`);
+  if (specifiers.length) clause.push(`{ ${specifiers.map(importSpecifierCanonical).join(', ')} }`);
+  const importType = importInfo.typeOnly ? 'type ' : '';
+  return `import ${importType}${clause.join(', ')} from ${importInfo.quote}${importInfo.moduleSpecifier}${importInfo.quote};`;
+}
+
+function declarationInsertionText(entries, lineEnding) {
+  return entries
+    .map((entry) => normalizeLineEndings(entry.text.trimEnd(), lineEnding))
+    .map((text) => text.endsWith(lineEnding) ? text : `${text}${lineEnding}`)
+    .join('');
+}
+
+function mergedDeclarationEntries(workerEntries, headEntries) {
+  const entriesByKey = new Map();
+  for (const entry of [...workerEntries, ...headEntries]) {
+    const key = `${entry.kind}:${entry.key}:${entry.text.trim()}`;
+    if (!entriesByKey.has(key)) entriesByKey.set(key, entry);
+  }
+  return [...entriesByKey.values()].sort((left, right) => {
+    const keyOrder = left.key.localeCompare(right.key);
+    if (keyOrder !== 0) return keyOrder;
+    return left.text.trim().localeCompare(right.text.trim());
+  });
+}
+
+function declarationInsertionSpan(sourceText, anchor, mode, headGroup) {
+  if (!headGroup?.entries.length) {
+    const offset = mode === 'after'
+      ? offsetAfterEntryLine(sourceText, anchor)
+      : offsetBeforeEntryLine(sourceText, anchor);
+    return { start: offset, end: offset };
+  }
+  if (mode === 'after') {
+    return {
+      start: offsetAfterEntryLine(sourceText, anchor),
+      end: offsetAfterEntryLine(sourceText, headGroup.entries[headGroup.entries.length - 1])
+    };
+  }
+  return {
+    start: offsetBeforeEntryLine(sourceText, headGroup.entries[0]),
+    end: offsetBeforeEntryLine(sourceText, anchor)
+  };
+}
+
+function offsetAfterEntryLine(sourceText, entry) {
+  const lineEnd = sourceText.indexOf('\n', entry.end);
+  return lineEnd === -1 ? sourceText.length : lineEnd + 1;
+}
+
+function offsetBeforeEntryLine(sourceText, entry) {
+  return sourceText.lastIndexOf('\n', Math.max(0, entry.start - 1)) + 1;
+}

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

@@ -0,0 +1,175 @@
+import { analyzeVariantLedger, validateIndependentAdditions } from './js-ts-safe-merge-analyze.js';
+import { addConflict, blockedResult, compactRecord, createMergeContext, gatesFor } from './js-ts-safe-merge-context.js';
+import {
+  JsTsSafeMergeConflictCodes,
+  JsTsSafeMergeGateIds,
+  JsTsSafeMergeStatuses,
+  jsTsSafeMergeGateOrder
+} from './js-ts-safe-merge-constants.js';
+import { indexBaseLedger, scanJsTsTopLevelLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger.js';
+import { applySourceMergePlan, createSourceMergePlan } from './js-ts-safe-merge-plan.js';
+
+export { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds, JsTsSafeMergeStatuses };
+
+export function safeMergeJsTsImportsAndDeclarations(input = {}) {
+  const context = createMergeContext(input);
+  const baseSourceText = input.baseSourceText;
+  const workerSourceText = input.workerSourceText;
+  const headSourceText = input.headSourceText;
+
+  if (typeof baseSourceText !== 'string' || typeof workerSourceText !== 'string' || typeof headSourceText !== 'string') {
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.invalidInput,
+      gateId: JsTsSafeMergeGateIds.parseLedger,
+      message: 'baseSourceText, workerSourceText, and headSourceText must be strings.',
+      details: {
+        baseSourceText: typeof baseSourceText,
+        workerSourceText: typeof workerSourceText,
+        headSourceText: typeof headSourceText
+      }
+    });
+    return blockedResult(context);
+  }
+
+  validateStaleSourceHashes(input, context);
+  validateSourceLedgerSpans(input, context);
+  if (context.conflicts.length) return blockedResult(context);
+
+  const base = scanJsTsTopLevelLedger(baseSourceText, 'base', context);
+  const worker = scanJsTsTopLevelLedger(workerSourceText, 'worker', context);
+  const head = scanJsTsTopLevelLedger(headSourceText, 'head', context);
+  if (context.conflicts.length) return blockedResult(context, { base, worker, head });
+
+  validateLedgerUniqueness(base, context);
+  validateLedgerUniqueness(worker, context);
+  validateLedgerUniqueness(head, context);
+  if (context.conflicts.length) return blockedResult(context, { base, worker, head });
+
+  const baseIndex = indexBaseLedger(base, context);
+  if (context.conflicts.length) return blockedResult(context, { base, worker, head });
+
+  const workerPlan = analyzeVariantLedger(base, worker, baseIndex, 'worker', context);
+  const headPlan = analyzeVariantLedger(base, head, baseIndex, 'head', context);
+  validateIndependentAdditions(base, workerPlan, headPlan, context);
+  if (context.conflicts.length) return blockedResult(context, { base, worker, head });
+
+  const mergePlan = createSourceMergePlan(base, worker, head, workerPlan, headPlan, context);
+  if (context.conflicts.length) return blockedResult(context, { base, worker, head });
+
+  const mergedSourceText = applySourceMergePlan(headSourceText, mergePlan);
+  const merged = scanJsTsTopLevelLedger(mergedSourceText, 'merged', context);
+  if (!context.conflicts.length) validateLedgerUniqueness(merged, context);
+  if (context.conflicts.length) return blockedResult(context, { base, worker, head, merged });
+
+  return {
+    kind: 'frontier.lang.jsTsSafeMerge',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMerge.v1',
+    id: context.id,
+    status: JsTsSafeMergeStatuses.merged,
+    sourcePath: context.sourcePath,
+    language: context.language,
+    mergedSourceText,
+    outputSourceText: mergedSourceText,
+    conflicts: [],
+    gates: gatesFor(context),
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    summary: {
+      importSpecifierAdditions: mergePlan.importSpecifierAdditions,
+      topLevelDeclarationAdditions: mergePlan.topLevelDeclarationAdditions,
+      changedExistingDeclarations: 0,
+      conflicts: 0,
+      gatesPassed: jsTsSafeMergeGateOrder.length
+    },
+    metadata: compactRecord({
+      workerChangeSetId: input.workerChangeSetId,
+      headChangeSetId: input.headChangeSetId,
+      baseHash: input.baseHash,
+      workerHash: input.workerHash,
+      headHash: input.headHash,
+      expectedSourceHash: input.expectedSourceHash,
+      currentSourceHash: input.currentSourceHash
+    })
+  };
+}
+
+function validateStaleSourceHashes(input, context) {
+  for (const pair of [
+    ['expectedSourceHash', 'currentSourceHash', 'head'],
+    ['expectedHeadHash', 'headHash', 'head'],
+    ['expectedBaseHash', 'baseHash', 'base'],
+    ['expectedWorkerHash', 'workerHash', 'worker']
+  ]) {
+    const [expectedField, currentField, side] = pair;
+    const expected = input[expectedField];
+    const current = input[currentField];
+    if (typeof expected !== 'string' || typeof current !== 'string' || expected === current) continue;
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.staleSourceHash,
+      gateId: JsTsSafeMergeGateIds.parseLedger,
+      side,
+      message: `${side} source hash is stale for safe merge anchors.`,
+      details: { expectedField, currentField, expected, current }
+    });
+  }
+}
+
+function validateSourceLedgerSpans(input, context) {
+  if (!input.requireSourceLedgerSpans && !input.sourceLedgers && !input.sourceLedger) return;
+  for (const side of ['base', 'worker', 'head']) {
+    const ledger = sourceLedgerForSide(input, side);
+    if (!ledger) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.missingSourceLedgerSpan,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side,
+        message: `${side} source is missing source ledger span evidence.`,
+        details: { side, missing: 'source-ledger' }
+      });
+      continue;
+    }
+    const spans = Array.isArray(ledger.spans) ? ledger.spans : Array.isArray(ledger.entries) ? ledger.entries : [];
+    if (!spans.length) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.missingSourceLedgerSpan,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side,
+        message: `${side} source ledger does not include span entries.`,
+        details: { side, missing: 'spans' }
+      });
+      continue;
+    }
+    const missingIndex = spans.findIndex((entry) => !hasLedgerSpan(entry));
+    if (missingIndex >= 0) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.missingSourceLedgerSpan,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side,
+        message: `${side} source ledger contains an entry without a source span.`,
+        details: { side, index: missingIndex, id: spans[missingIndex]?.id, kind: spans[missingIndex]?.kind }
+      });
+    }
+  }
+}
+
+function sourceLedgerForSide(input, side) {
+  return input.sourceLedgers?.[side]
+    ?? input[`${side}SourceLedger`]
+    ?? (input.sourceLedgerSide === side ? input.sourceLedger : undefined);
+}
+
+function hasLedgerSpan(entry) {
+  const span = entry?.span ?? entry?.sourceSpan;
+  if (!span) return false;
+  const hasOffsets = Number.isFinite(span.start) && Number.isFinite(span.end);
+  const hasLines = Number.isFinite(span.startLine) && Number.isFinite(span.endLine);
+  return hasOffsets || hasLines;
+}

package/dist/js-ts-semantic-conflict-sidecar-constants.js

@@ -0,0 +1,77 @@
+export const JsTsSemanticConflictSidecarClasses = Object.freeze([
+  'same-region',
+  'delete-modify',
+  'duplicate-export',
+  'duplicate-member',
+  'ordered-list-conflict',
+  'parser-ledger-loss',
+  'stale-source-hash',
+  'unsupported-syntax'
+]);
+
+export const classDefaults = Object.freeze({
+  'same-region': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['same-region-concurrent-edit'],
+    suggestedOutcome: 'manual-merge-required'
+  },
+  'delete-modify': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['delete-modify-same-region'],
+    suggestedOutcome: 'choose-delete-or-port-modification'
+  },
+  'duplicate-export': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['duplicate-export-name'],
+    suggestedOutcome: 'rename-or-remove-duplicate-export'
+  },
+  'duplicate-member': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['duplicate-member-name'],
+    suggestedOutcome: 'rename-or-remove-duplicate-member'
+  },
+  'ordered-list-conflict': {
+    severity: 'warning',
+    risk: 'medium',
+    readiness: 'needs-review',
+    reasonCodes: ['ordered-list-concurrent-position'],
+    suggestedOutcome: 'preserve-intended-order-with-human-review'
+  },
+  'parser-ledger-loss': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['parser-or-ledger-loss'],
+    suggestedOutcome: 'rerun-parser-and-ledger-before-merge'
+  },
+  'stale-source-hash': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['stale-source-hash'],
+    suggestedOutcome: 'rerun-semantic-import-before-merge'
+  },
+  'unsupported-syntax': {
+    severity: 'error',
+    risk: 'high',
+    readiness: 'blocked',
+    reasonCodes: ['unsupported-js-ts-syntax'],
+    suggestedOutcome: 'fall-back-to-textual-review'
+  }
+});
+
+export const severityRank = Object.freeze({ info: 1, warning: 2, error: 3 });
+export const riskRank = Object.freeze({ low: 1, medium: 2, high: 3 });
+export const orderedChangeKinds = /^(?:insert|add|move|reorder|replace|modify|update)$/i;
+export const deleteChangeKinds = /^(?:delete|remove|removed|deleted)$/i;
+export const modifyChangeKinds = /^(?:modify|modified|replace|update|edit|move|reorder|insert|add)$/i;
+export const parserLedgerLossPattern = /(?:parser|parse|ledger|source[-_ ]?map|anchor|projection).*(?:loss|lost|missing|failed|error)|(?:loss|lost|missing).*(?:parser|ledger|source[-_ ]?map|anchor|projection)/i;
+export const unsupportedSyntaxPattern = /unsupported|unhandled|unknown syntax|syntax unsupported/i;

package/dist/js-ts-semantic-conflict-sidecar-detectors.js

@@ -0,0 +1,195 @@
+import { idFragment, normalizeSemanticMergeReadiness, uniqueStrings } from './native-import-utils.js';
+import { classDefaults, JsTsSemanticConflictSidecarClasses, orderedChangeKinds, parserLedgerLossPattern, unsupportedSyntaxPattern } from './js-ts-semantic-conflict-sidecar-constants.js';
+import { affectedFromEntries, normalizeAffected, normalizeChange, normalizeDeclaration, sameChangeRegion } from './js-ts-semantic-conflict-sidecar-normalize.js';
+import { array, changePairs, compactRecord, duplicateGroups, firstString, isDeleteChange, isInsertChange, isModifyChange, lossReasonCodes, lossText, normalizeRisk, normalizeSeverity, strings } from './js-ts-semantic-conflict-sidecar-utils.js';
+
+export function explicitSidecars(input, context) {
+  return [
+    ...array(input.conflicts),
+    ...array(input.sidecars),
+    ...array(input.conflictSidecars)
+  ]
+    .filter((record) => JsTsSemanticConflictSidecarClasses.includes(record?.class))
+    .map((record) => conflictSidecar(record.class, record, context));
+}
+
+export function sameRegionSidecars(changes, context) {
+  const records = [];
+  for (const [left, right] of changePairs(changes)) {
+    if (!sameChangeRegion(left, right)) continue;
+    records.push(conflictSidecar('same-region', {
+      id: `js_ts_conflict_${idFragment(left.id)}_${idFragment(right.id)}_same_region`,
+      affected: affectedFromEntries([left, right], context),
+      reasonCodes: ['same-region-concurrent-edit', ...left.reasonCodes, ...right.reasonCodes],
+      metadata: { leftChangeId: left.id, rightChangeId: right.id, leftChangeKind: left.changeKind, rightChangeKind: right.changeKind }
+    }, context));
+  }
+  return records;
+}
+
+export function deleteModifySidecars(changes, context) {
+  const records = [];
+  for (const [left, right] of changePairs(changes)) {
+    if (!sameChangeRegion(left, right)) continue;
+    if (!(isDeleteChange(left) && isModifyChange(right)) && !(isDeleteChange(right) && isModifyChange(left))) continue;
+    const deleted = isDeleteChange(left) ? left : right;
+    const modified = deleted === left ? right : left;
+    records.push(conflictSidecar('delete-modify', {
+      id: `js_ts_conflict_${idFragment(deleted.id)}_${idFragment(modified.id)}_delete_modify`,
+      affected: affectedFromEntries([deleted, modified], context),
+      reasonCodes: ['delete-modify-same-region', ...deleted.reasonCodes, ...modified.reasonCodes],
+      metadata: { deletedChangeId: deleted.id, modifiedChangeId: modified.id, deletedChangeKind: deleted.changeKind, modifiedChangeKind: modified.changeKind }
+    }, context));
+  }
+  return records;
+}
+
+export function duplicateDeclarationSidecars(input, changes, context) {
+  const declarations = [
+    ...array(input.declarations),
+    ...array(input.exports).map((entry) => ({ ...entry, exported: true })),
+    ...array(input.members).map((entry) => ({ ...entry, member: true })),
+    ...array(input.symbols),
+    ...changes.filter((change) => isInsertChange(change) && (change.memberName || change.exportName || change.symbolName))
+  ].map((entry, index) => normalizeDeclaration(entry, index, context)).filter((entry) => entry.name);
+  return [
+    ...duplicateGroups(declarations.filter((entry) => entry.exported), (entry) => [entry.sourcePath, entry.name].join('|'))
+      .map((group) => duplicateRecord('duplicate-export', group, context)),
+    ...duplicateGroups(declarations.filter((entry) => entry.member || entry.containerKey), (entry) => [entry.sourcePath, entry.containerKey, entry.name].join('|'))
+      .map((group) => duplicateRecord('duplicate-member', group, context))
+  ];
+}
+
+export function orderedListSidecars(input, changes, context) {
+  const explicitLists = array(input.orderedLists).flatMap((list, listIndex) =>
+    array(list.changes ?? list.operations ?? list.edits).map((change, changeIndex) => normalizeChange({
+      ...change,
+      listKey: change.listKey ?? list.key ?? list.id,
+      orderedListKey: change.orderedListKey ?? list.key ?? list.id,
+      sourcePath: change.sourcePath ?? list.sourcePath,
+      sourceSpan: change.sourceSpan ?? list.sourceSpan,
+      id: change.id ?? `${list.id ?? list.key ?? 'ordered_list'}_${changeIndex}`,
+      side: change.side ?? change.author ?? `list_${listIndex}`
+    }, context, `ordered_list_${listIndex}_${changeIndex}`))
+  );
+  const orderedChanges = [...changes, ...explicitLists].filter((change) =>
+    change.listKey && orderedChangeKinds.test(change.changeKind)
+  );
+  const groups = duplicateGroups(orderedChanges, (change) => [
+    change.sourcePath,
+    change.listKey,
+    firstString(change.index, change.position, change.orderKey, change.beforeKey, change.afterKey, change.anchorKey)
+  ].join('|'));
+  return groups.map((group) => conflictSidecar('ordered-list-conflict', {
+    id: `js_ts_conflict_${idFragment(group[0].listKey)}_${idFragment(firstString(group[0].index, group[0].position, group[0].orderKey, 'position'))}_ordered_list`,
+    affected: affectedFromEntries(group, context),
+    reasonCodes: ['ordered-list-concurrent-position', ...group.flatMap((entry) => entry.reasonCodes)],
+    metadata: {
+      listKey: group[0].listKey,
+      position: firstString(group[0].index, group[0].position, group[0].orderKey, group[0].beforeKey, group[0].afterKey),
+      changeIds: group.map((entry) => entry.id)
+    }
+  }, context));
+}
+
+export function parserLedgerLossSidecars(input, context) {
+  const losses = [
+    ...array(input.parserLosses),
+    ...array(input.ledgerLosses),
+    ...array(input.losses),
+    ...array(input.diagnostics)
+  ].filter((entry) => parserLedgerLossPattern.test(lossText(entry)) || entry?.kind === 'parser-ledger-loss');
+  if (!losses.length) return [];
+  return [conflictSidecar('parser-ledger-loss', {
+    id: `js_ts_conflict_${idFragment(context.sourcePath ?? context.language ?? 'source')}_parser_ledger_loss`,
+    severity: losses.some((entry) => entry.severity === 'error' || entry.status === 'failed') ? 'error' : undefined,
+    affected: affectedFromEntries(losses, context),
+    reasonCodes: ['parser-or-ledger-loss', ...losses.flatMap(lossReasonCodes)],
+    metadata: { lossIds: uniqueStrings(losses.map((entry) => entry.id)), lossKinds: uniqueStrings(losses.map((entry) => entry.kind ?? entry.code)) }
+  }, context)];
+}
+
+export function staleSourceHashSidecars(input, context) {
+  if (!context.expectedSourceHash || !context.currentSourceHash) return [];
+  if (context.expectedSourceHash === context.currentSourceHash && input.staleSourceHash !== true) return [];
+  return [conflictSidecar('stale-source-hash', {
+    id: `js_ts_conflict_${idFragment(context.sourcePath ?? context.language ?? 'source')}_stale_source_hash`,
+    affected: affectedFromEntries([{ sourcePath: context.sourcePath, sourceHash: context.currentSourceHash, key: context.sourcePath }], context),
+    reasonCodes: ['stale-source-hash', 'expected-source-hash-mismatch'],
+    metadata: { expectedSourceHash: context.expectedSourceHash, currentSourceHash: context.currentSourceHash }
+  }, context)];
+}
+
+export function unsupportedSyntaxSidecars(input, context) {
+  const entries = [
+    ...array(input.unsupportedSyntax),
+    ...array(input.syntaxUnsupported),
+    ...array(input.syntaxLosses),
+    ...array(input.losses).filter((entry) => unsupportedSyntaxPattern.test(lossText(entry)))
+  ];
+  if (!entries.length) return [];
+  return entries.map((entry, index) => conflictSidecar('unsupported-syntax', {
+    id: entry.id ?? `js_ts_conflict_${idFragment(context.sourcePath ?? context.language ?? 'source')}_${index + 1}_unsupported_syntax`,
+    affected: affectedFromEntries([entry], context),
+    reasonCodes: ['unsupported-js-ts-syntax', ...lossReasonCodes(entry)],
+    metadata: compactRecord({
+      syntaxKind: entry.kind ?? entry.syntaxKind,
+      parser: entry.parser,
+      message: entry.message ?? entry.summary
+    })
+  }, context));
+}
+
+export function duplicateRecord(conflictClass, group, context) {
+  return conflictSidecar(conflictClass, {
+    id: `js_ts_conflict_${idFragment(group[0].sourcePath ?? context.sourcePath ?? 'source')}_${idFragment(group[0].containerKey ?? 'export')}_${idFragment(group[0].name)}_${conflictClass.replace(/-/g, '_')}`,
+    affected: affectedFromEntries(group, context),
+    reasonCodes: [conflictClass === 'duplicate-member' ? 'duplicate-member-name' : 'duplicate-export-name'],
+    metadata: {
+      duplicateName: group[0].name,
+      containerKey: group[0].containerKey,
+      declarationIds: group.map((entry) => entry.id)
+    }
+  }, context);
+}
+
+export function conflictSidecar(conflictClass, input, context) {
+  const defaults = classDefaults[conflictClass] ?? classDefaults['same-region'];
+  const affected = normalizeAffected(input.affected ?? input, context);
+  const reasonCodes = uniqueStrings([
+    ...defaults.reasonCodes,
+    ...strings(input.reasonCode),
+    ...strings(input.reasonCodes)
+  ]);
+  const severity = normalizeSeverity(input.severity) ?? defaults.severity;
+  const risk = normalizeRisk(input.risk) ?? defaults.risk;
+  const readiness = normalizeSemanticMergeReadiness(input.readiness) ?? defaults.readiness;
+  const suggestedOutcome = input.suggestedOutcome ?? input.outcome ?? defaults.suggestedOutcome;
+  const id = input.id ?? `js_ts_conflict_${idFragment(conflictClass)}_${idFragment([
+    ...affected.keys,
+    ...affected.sourcePaths,
+    ...reasonCodes
+  ].join('_'))}`;
+  return {
+    kind: 'frontier.lang.jsTsSemanticMergeConflictSidecar',
+    version: 1,
+    schema: 'frontier.lang.jsTsSemanticMergeConflictSidecar.v1',
+    id,
+    class: conflictClass,
+    severity,
+    risk,
+    readiness,
+    affected,
+    reasonCodes,
+    suggestedOutcome,
+    explanation: {
+      class: conflictClass,
+      severity,
+      risk,
+      affected,
+      reasonCodes,
+      suggestedOutcome
+    },
+    metadata: compactRecord(input.metadata)
+  };
+}