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

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

@@ -0,0 +1,202 @@
+import {
+  applyMemberAdditions,
+  canonicalizeSourceBodies,
+  findContainer,
+  normalizeKind,
+  normalizeMemberText,
+  parseMembers,
+  uniqueStrings
+} from './js-ts-semantic-merge-parse.js';
+import { mergeResult } from './js-ts-safe-member-merge-result.js';
+
+const NonSemanticRegionKinds = new Set(['property', 'type', 'config', 'content']);
+const OrderSensitiveRegionKinds = new Set(['body', 'call', 'controlFlow', 'effect', 'import', 'mutation', 'route']);
+
+function safeMergeJsTsMembers(input = {}) {
+  return mergeJsTsSafeMemberAdditions(input);
+}
+
+function mergeJsTsSafeMemberAdditions(input = {}) {
+  const baseSourceText = input.baseSourceText;
+  const workerSourceText = input.workerSourceText;
+  const headSourceText = input.headSourceText;
+  const reasonCodes = [];
+  if (typeof baseSourceText !== 'string') reasonCodes.push('missing-base-source-text');
+  if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
+  if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
+  const policyRegions = normalizePolicyRegions(input.policy ?? input.mergePolicy ?? input);
+  if (!policyRegions.length) reasonCodes.push('missing-unordered-region-policy');
+  const preparedRegions = [];
+  for (const region of policyRegions) {
+    const policyReasons = validatePolicyRegion(region);
+    reasonCodes.push(...policyReasons);
+    if (policyReasons.length) continue;
+    if (typeof baseSourceText !== 'string' || typeof workerSourceText !== 'string' || typeof headSourceText !== 'string') continue;
+    const prepared = prepareRegion({ region, baseSourceText, workerSourceText, headSourceText });
+    reasonCodes.push(...prepared.reasonCodes);
+    if (prepared.ok) preparedRegions.push(prepared.value);
+  }
+  if (typeof baseSourceText === 'string' && typeof workerSourceText === 'string' && preparedRegions.length) {
+    const canonicalWorker = canonicalizeSourceBodies(workerSourceText, preparedRegions, 'worker');
+    if (canonicalWorker !== baseSourceText) reasonCodes.push('non-policy-source-change:worker');
+  }
+  if (typeof baseSourceText === 'string' && typeof headSourceText === 'string' && preparedRegions.length) {
+    const canonicalHead = canonicalizeSourceBodies(headSourceText, preparedRegions, 'head');
+    if (canonicalHead !== baseSourceText) reasonCodes.push('non-policy-source-change:head');
+  }
+  const uniqueReasons = uniqueStrings(reasonCodes);
+  const explicitPolicy = policyRegions.length > 0;
+  if (uniqueReasons.length) return mergeResult('rejected', undefined, uniqueReasons, preparedRegions, input, explicitPolicy);
+  const sourceText = applyMemberAdditions(headSourceText, preparedRegions);
+  return mergeResult('merged', sourceText, [], preparedRegions, input, explicitPolicy);
+}
+
+function normalizePolicyRegions(policy) {
+  const direct = Array.isArray(policy) ? policy : undefined;
+  const regions = direct
+    ?? policy?.unorderedRegions
+    ?? policy?.unorderedMemberRegions
+    ?? policy?.safeList
+    ?? policy?.safeMembers
+    ?? [];
+  return Array.isArray(regions) ? regions : [];
+}
+
+function validatePolicyRegion(region) {
+  const reasonCodes = [];
+  const kind = normalizeKind(region?.kind);
+  if (!kind || !['interface', 'type', 'class', 'object'].includes(kind)) reasonCodes.push('unsupported-region-kind');
+  if (!region?.name || typeof region.name !== 'string') reasonCodes.push('missing-region-name');
+  if (!regionDeclaresNonSemanticOrder(region)) reasonCodes.push('region-not-declared-non-semantic');
+  const regionKind = region?.regionKind;
+  if (regionKind && OrderSensitiveRegionKinds.has(regionKind)) reasonCodes.push(`order-sensitive-region-kind:${regionKind}`);
+  if (kind === 'object' && (!regionKind || !NonSemanticRegionKinds.has(regionKind))) reasonCodes.push('object-region-kind-not-safe-listed');
+  return reasonCodes;
+}
+
+function regionDeclaresNonSemanticOrder(region) {
+  return region?.order === 'non-semantic'
+    || region?.ordering === 'non-semantic'
+    || region?.nonSemanticOrder === true
+    || region?.orderSensitive === false;
+}
+
+function prepareRegion(input) {
+  const kind = normalizeKind(input.region.kind);
+  const base = findContainer(input.baseSourceText, input.region);
+  const worker = findContainer(input.workerSourceText, input.region);
+  const head = findContainer(input.headSourceText, input.region);
+  const reasonCodes = [];
+  for (const [side, match] of [['base', base], ['worker', worker], ['head', head]]) {
+    if (match.reasonCodes.length) reasonCodes.push(...match.reasonCodes.map((reason) => `${reason}:${side}:${kind}:${input.region.name}`));
+  }
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  const baseMembers = parseMembers(base.value.body, kind);
+  const workerMembers = parseMembers(worker.value.body, kind);
+  const headMembers = parseMembers(head.value.body, kind);
+  reasonCodes.push(...regionParseReasons(input.region, 'base', baseMembers));
+  reasonCodes.push(...regionParseReasons(input.region, 'worker', workerMembers));
+  reasonCodes.push(...regionParseReasons(input.region, 'head', headMembers));
+  reasonCodes.push(...duplicateReasons(input.region, 'base', baseMembers.members));
+  reasonCodes.push(...duplicateReasons(input.region, 'worker', workerMembers.members));
+  reasonCodes.push(...duplicateReasons(input.region, 'head', headMembers.members));
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  const baseByKey = membersByKey(baseMembers.members);
+  const workerByKey = membersByKey(workerMembers.members);
+  const headByKey = membersByKey(headMembers.members);
+  reasonCodes.push(...existingMemberReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerByKey));
+  reasonCodes.push(...existingMemberReasons(input.region, 'head', baseMembers.members, headMembers.members, headByKey));
+  const workerAddedKeys = workerMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
+  const headAddedKeys = headMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
+  reasonCodes.push(...duplicateAddedReasons(input.region, workerAddedKeys, workerByKey, headByKey));
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  return {
+    ok: true,
+    reasonCodes: [],
+    value: {
+      policy: input.region,
+      kind,
+      name: input.region.name,
+      base: base.value,
+      worker: worker.value,
+      head: head.value,
+      baseMembers: baseMembers.members,
+      workerMembers: workerMembers.members,
+      headMembers: headMembers.members,
+      workerAddedKeys,
+      headAddedKeys,
+      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key))
+    }
+  };
+}
+
+function regionParseReasons(region, side, parsed) {
+  return parsed.reasonCodes.map((reason) => regionReason(region, `${reason}:${side}`));
+}
+
+function duplicateReasons(region, side, members) {
+  const seen = new Map();
+  const duplicateGroups = new Map();
+  for (const member of members) {
+    const group = seen.get(member.key);
+    if (group) {
+      group.push(member);
+      duplicateGroups.set(member.key, group);
+    } else {
+      seen.set(member.key, [member]);
+    }
+  }
+  return [...duplicateGroups].map(([key, group]) => {
+    const reason = group.some(isOverloadLikeMember) ? `overload-collision:${side}:${key}` : `duplicate-key:${side}:${key}`;
+    return regionReason(region, reason);
+  });
+}
+
+function existingMemberReasons(region, side, baseMembers, sideMembers, sideByKey) {
+  const reasonCodes = [];
+  const sideBaseOrder = sideMembers.map((member) => member.key).filter((key) => baseMembers.some((baseMember) => baseMember.key === key));
+  const baseOrder = baseMembers.map((member) => member.key);
+  if (sideBaseOrder.join('\u0000') !== baseOrder.join('\u0000')) {
+    reasonCodes.push(regionReason(region, `existing-member-order-changed:${side}`));
+  }
+  for (const baseMember of baseMembers) {
+    const sideMember = sideByKey.get(baseMember.key);
+    if (!sideMember) {
+      reasonCodes.push(regionReason(region, `existing-member-removed:${side}:${baseMember.key}`));
+      continue;
+    }
+    if (normalizeMemberText(sideMember.text) !== normalizeMemberText(baseMember.text)) {
+      reasonCodes.push(regionReason(region, `existing-member-changed:${side}:${baseMember.key}`));
+    }
+  }
+  return reasonCodes;
+}
+
+function duplicateAddedReasons(region, workerAddedKeys, workerByKey, headByKey) {
+  const duplicateAddedKeys = workerAddedKeys.filter((key) => headByKey.has(key));
+  return duplicateAddedKeys.map((key) => {
+    const workerMember = workerByKey.get(key);
+    const headMember = headByKey.get(key);
+    const reason = isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)
+      ? `overload-collision:worker-head:${key}`
+      : `duplicate-added-key:${key}`;
+    return regionReason(region, reason);
+  });
+}
+
+function isOverloadLikeMember(member) {
+  return member?.memberKind === 'method' || member?.memberKind === 'constructor';
+}
+
+function membersByKey(members) {
+  return new Map(members.map((member) => [member.key, member]));
+}
+
+function regionReason(region, reason) {
+  return `${reason}:${normalizeKind(region.kind)}:${region.name}`;
+}
+
+export {
+  mergeJsTsSafeMemberAdditions,
+  safeMergeJsTsMembers
+};

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

@@ -0,0 +1,279 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict, arraysEqual, sameStatementText } from './js-ts-safe-merge-context.js';
+
+export function analyzeVariantLedger(base, variant, baseIndex, side, context) {
+  const projectedBaseKeys = [];
+  const addedEntries = [];
+  const importAdditions = new Map();
+  const baseKeys = new Set(baseIndex.orderedKeys);
+
+  for (const entry of variant.entries) {
+    const baseEntry = baseIndex.entriesByKey.get(entry.key);
+    if (!baseEntry) {
+      if (entry.kind === 'import') {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.newImportDeclaration,
+          gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+          side,
+          message: `${side} source adds a new import declaration; only specifier additions to existing imports are accepted.`,
+          details: { key: entry.key, statement: entry.text.trim() }
+        });
+      } else {
+        addedEntries.push(entry);
+      }
+      continue;
+    }
+    projectedBaseKeys.push(entry.key);
+    if (entry.kind !== baseEntry.kind) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side,
+        message: `${side} source changes a base ledger entry kind.`,
+        details: { key: entry.key, baseKind: baseEntry.kind, sideKind: entry.kind }
+      });
+      continue;
+    }
+    if (entry.kind === 'import') {
+      const additions = analyzeImportStatementChange(baseEntry, entry, side, context);
+      if (additions.length) importAdditions.set(entry.key, additions);
+    } else if (!sameStatementText(baseEntry.text, entry.text)) {
+      const typeAliasConflict = baseEntry.declarationInfo?.declarationKind === 'type'
+        || entry.declarationInfo?.declarationKind === 'type';
+      addConflict(context, {
+        code: typeAliasConflict ? JsTsSafeMergeConflictCodes.typeAliasConflict : JsTsSafeMergeConflictCodes.changedExistingDeclaration,
+        gateId: JsTsSafeMergeGateIds.stableExistingDeclarations,
+        side,
+        message: typeAliasConflict
+          ? `${side} source changes an existing type alias body.`
+          : `${side} source changes an existing top-level declaration or export body.`,
+        details: { key: entry.key, name: entry.names?.[0], declarationKind: entry.declarationInfo?.declarationKind }
+      });
+    }
+  }
+
+  if (!arraysEqual(projectedBaseKeys, baseIndex.orderedKeys)) {
+    const code = base.entries.some((entry) => entry.kind === 'import' && entry.importInfo.sideEffectOnly)
+      ? JsTsSafeMergeConflictCodes.sideEffectImportReorder
+      : JsTsSafeMergeConflictCodes.topLevelOrderChanged;
+    addConflict(context, {
+      code,
+      gateId: JsTsSafeMergeGateIds.preserveBaseOrder,
+      side,
+      message: `${side} source changes the order or presence of base top-level entries.`,
+      details: {
+        expected: baseIndex.orderedKeys,
+        actual: projectedBaseKeys
+      }
+    });
+  }
+
+  return {
+    side,
+    addedEntries,
+    importAdditions,
+    baseKeys
+  };
+}
+
+function analyzeImportStatementChange(baseEntry, variantEntry, side, context) {
+  const baseImport = baseEntry.importInfo;
+  const variantImport = variantEntry.importInfo;
+  if (!sameImportShape(baseImport, variantImport)) {
+    addConflict(context, {
+      code: baseImport.sideEffectOnly ? JsTsSafeMergeConflictCodes.sideEffectImportReorder : JsTsSafeMergeConflictCodes.importShapeChanged,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      side,
+      message: `${side} source changes an existing import shape instead of adding named specifiers.`,
+      details: { key: baseEntry.key }
+    });
+    return [];
+  }
+  if (baseImport.sideEffectOnly) {
+    if (!sameStatementText(baseEntry.text, variantEntry.text)) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.sideEffectImportReorder,
+        gateId: JsTsSafeMergeGateIds.preserveBaseOrder,
+        side,
+        message: `${side} source changes a side-effect import.`,
+        details: { key: baseEntry.key }
+      });
+    }
+    return [];
+  }
+
+  const baseSpecifiers = baseImport.specifiers;
+  const variantSpecifiers = variantImport.specifiers;
+  if (variantSpecifiers.length < baseSpecifiers.length) {
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.importSpecifierRemoved,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      side,
+      message: `${side} source removes import specifiers.`,
+      details: { key: baseEntry.key }
+    });
+    return [];
+  }
+  for (let index = 0; index < baseSpecifiers.length; index += 1) {
+    if (variantSpecifiers[index]?.canonical !== baseSpecifiers[index].canonical) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.importSpecifierReordered,
+        gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+        side,
+        message: `${side} source reorders or changes existing import specifiers.`,
+        details: {
+          key: baseEntry.key,
+          expected: baseSpecifiers.map((specifier) => specifier.canonical),
+          actual: variantSpecifiers.map((specifier) => specifier.canonical)
+        }
+      });
+      return [];
+    }
+  }
+  const additions = variantSpecifiers.slice(baseSpecifiers.length);
+  if (additions.length === 0 && !sameStatementText(baseEntry.text, variantEntry.text)) {
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.importFormattingChanged,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      side,
+      message: `${side} source changes import formatting without a specifier addition.`,
+      details: { key: baseEntry.key }
+    });
+  }
+  return additions;
+}
+
+function sameImportShape(left, right) {
+  return left.moduleSpecifier === right.moduleSpecifier
+    && left.typeOnly === right.typeOnly
+    && left.sideEffectOnly === right.sideEffectOnly
+    && left.defaultLocalName === right.defaultLocalName
+    && left.namespaceLocalName === right.namespaceLocalName;
+}
+
+export function validateIndependentAdditions(base, workerPlan, headPlan, context) {
+  const declarationNames = new Set();
+  for (const entry of base.entries.filter((item) => item.kind !== 'import')) {
+    for (const name of entry.names ?? []) declarationNames.add(`${entry.kind}:${name}`);
+  }
+  validateAddedEntryNames(workerPlan, declarationNames, context);
+  validateAddedEntryNames(headPlan, declarationNames, context);
+  validateCrossSideAddedNames(workerPlan, headPlan, context);
+  validateCrossSideImportAdditions(workerPlan, headPlan, context);
+  validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, context);
+}
+
+function validateAddedEntryNames(plan, baseNames, context) {
+  for (const entry of plan.addedEntries) {
+    if (entry.kind !== 'declaration' && entry.kind !== 'export') {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.independentTopLevelDeclarations,
+        side: plan.side,
+        message: `${plan.side} source adds an unsupported top-level entry.`,
+        details: { kind: entry.kind, statement: entry.text.trim() }
+      });
+      continue;
+    }
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      if (baseNames.has(nameKey)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: plan.side,
+          message: `${plan.side} source adds a duplicate top-level name.`,
+          details: { name, kind: entry.kind }
+        });
+      }
+    }
+  }
+}
+
+function validateCrossSideAddedNames(workerPlan, headPlan, context) {
+  const headEntriesByName = new Map();
+  for (const entry of headPlan.addedEntries) {
+    for (const name of entry.names ?? []) headEntriesByName.set(`${entry.kind}:${name}`, entry);
+  }
+  for (const entry of workerPlan.addedEntries) {
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      const headEntry = headEntriesByName.get(nameKey);
+      if (headEntry) {
+        const typeAliasConflict = entry.declarationInfo?.declarationKind === 'type'
+          || headEntry.declarationInfo?.declarationKind === 'type';
+        addConflict(context, {
+          code: typeAliasConflict ? JsTsSafeMergeConflictCodes.typeAliasConflict : JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: 'worker',
+          message: typeAliasConflict
+            ? 'Worker and head add conflicting type aliases.'
+            : 'Worker and head add the same top-level name.',
+          details: { name, kind: entry.kind, workerDeclarationKind: entry.declarationInfo?.declarationKind, headDeclarationKind: headEntry.declarationInfo?.declarationKind }
+        });
+      }
+    }
+  }
+}
+
+function validateCrossSideImportAdditions(workerPlan, headPlan, context) {
+  for (const [key, workerAdditions] of workerPlan.importAdditions) {
+    const headAdditions = headPlan.importAdditions.get(key) ?? [];
+    const headLocalNames = new Set(headAdditions.map((specifier) => specifier.localName));
+    const headImportedNames = new Set(headAdditions.map((specifier) => `${specifier.typeOnly ? 'type:' : 'value:'}${specifier.importedName}`));
+    for (const specifier of workerAdditions) {
+      if (headLocalNames.has(specifier.localName) || headImportedNames.has(`${specifier.typeOnly ? 'type:' : 'value:'}${specifier.importedName}`)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: 'worker',
+          message: 'Worker and head add duplicate import specifiers.',
+          details: { key, specifier: specifier.canonical }
+        });
+      }
+    }
+  }
+}
+
+function validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, context) {
+  const topLevelBindingNames = new Set();
+  for (const entry of base.entries.filter((item) => item.kind !== 'import')) {
+    for (const name of entry.names ?? []) topLevelBindingNames.add(name);
+  }
+  for (const plan of [workerPlan, headPlan]) {
+    for (const entry of plan.addedEntries.filter((item) => item.kind !== 'import')) {
+      for (const name of entry.names ?? []) topLevelBindingNames.add(name);
+    }
+  }
+  const importLocalNames = new Set();
+  for (const entry of base.entries.filter((item) => item.kind === 'import')) {
+    const additions = [
+      ...(workerPlan.importAdditions.get(entry.key) ?? []),
+      ...(headPlan.importAdditions.get(entry.key) ?? [])
+    ];
+    for (const specifier of [
+      ...(entry.importInfo.defaultLocalName ? [{ localName: entry.importInfo.defaultLocalName, canonical: `default:${entry.importInfo.defaultLocalName}` }] : []),
+      ...(entry.importInfo.namespaceLocalName ? [{ localName: entry.importInfo.namespaceLocalName, canonical: `namespace:${entry.importInfo.namespaceLocalName}` }] : []),
+      ...entry.importInfo.specifiers,
+      ...additions
+    ]) {
+      if (importLocalNames.has(specifier.localName)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          message: 'Merged imports would contain duplicate local names.',
+          details: { localName: specifier.localName, specifier: specifier.canonical }
+        });
+      }
+      if (topLevelBindingNames.has(specifier.localName)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          message: 'Merged imports would duplicate a top-level declaration name.',
+          details: { localName: specifier.localName, specifier: specifier.canonical }
+        });
+      }
+      importLocalNames.add(specifier.localName);
+    }
+  }
+}

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

@@ -0,0 +1,50 @@
+export const JsTsSafeMergeStatuses = Object.freeze({
+  merged: 'merged',
+  blocked: 'blocked'
+});
+
+export const JsTsSafeMergeGateIds = Object.freeze({
+  parseLedger: 'parse-ledger',
+  preserveBaseOrder: 'preserve-base-order',
+  stableExistingDeclarations: 'stable-existing-declarations',
+  independentImportSpecifiers: 'independent-import-specifiers',
+  independentTopLevelDeclarations: 'independent-top-level-declarations',
+  uniqueNames: 'unique-names',
+  resolvedInsertionAnchors: 'resolved-insertion-anchors'
+});
+
+export const JsTsSafeMergeConflictCodes = Object.freeze({
+  invalidInput: 'invalid-input',
+  parserLedgerLoss: 'parser-ledger-loss',
+  malformedSyntax: 'malformed-syntax',
+  sideEffectImportReorder: 'side-effect-import-reorder',
+  topLevelOrderChanged: 'top-level-order-changed',
+  changedExistingDeclaration: 'changed-existing-declaration',
+  typeAliasConflict: 'type-alias-conflict',
+  importShapeChanged: 'import-shape-changed',
+  importSpecifierRemoved: 'import-specifier-removed',
+  importSpecifierReordered: 'import-specifier-reordered',
+  importFormattingChanged: 'import-formatting-changed',
+  newImportDeclaration: 'new-import-declaration',
+  duplicateName: 'duplicate-name',
+  computedKey: 'computed-key',
+  unsupportedDecorator: 'unsupported-decorator-merge-anchor',
+  unsupportedOverload: 'unsupported-overload-merge-anchor',
+  staleSourceHash: 'stale-source-hash',
+  missingSourceLedgerSpan: 'missing-source-ledger-span',
+  ambiguousInsertionPoint: 'ambiguous-insertion-point',
+  insertionAnchorMissing: 'insertion-anchor-missing'
+});
+
+export const jsTsSafeMergeGateOrder = Object.freeze([
+  JsTsSafeMergeGateIds.parseLedger,
+  JsTsSafeMergeGateIds.preserveBaseOrder,
+  JsTsSafeMergeGateIds.stableExistingDeclarations,
+  JsTsSafeMergeGateIds.independentImportSpecifiers,
+  JsTsSafeMergeGateIds.independentTopLevelDeclarations,
+  JsTsSafeMergeGateIds.uniqueNames,
+  JsTsSafeMergeGateIds.resolvedInsertionAnchors
+]);
+
+const identifierPattern = '[A-Za-z_$][\\w$]*';
+export const identifierRegExp = new RegExp(`^${identifierPattern}$`);

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

@@ -0,0 +1,118 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds, JsTsSafeMergeStatuses, jsTsSafeMergeGateOrder } from './js-ts-safe-merge-constants.js';
+
+export function createMergeContext(input) {
+  return {
+    id: String(input.id ?? 'js_ts_safe_merge'),
+    sourcePath: input.sourcePath,
+    language: input.language ?? 'typescript',
+    conflicts: [],
+    blockedGateIds: new Set(),
+    gateReasonCodes: new Map()
+  };
+}
+
+export function blockedResult(context, ledgers = {}) {
+  const reasonCodes = uniqueStrings(context.conflicts.map((conflict) => conflict.code));
+  return {
+    kind: 'frontier.lang.jsTsSafeMerge',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMerge.v1',
+    id: context.id,
+    status: JsTsSafeMergeStatuses.blocked,
+    sourcePath: context.sourcePath,
+    language: context.language,
+    conflicts: context.conflicts,
+    gates: gatesFor(context),
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      importSpecifierAdditions: 0,
+      topLevelDeclarationAdditions: 0,
+      changedExistingDeclarations: context.conflicts.filter((conflict) => conflict.code === JsTsSafeMergeConflictCodes.changedExistingDeclaration).length,
+      conflicts: context.conflicts.length,
+      gatesPassed: gatesFor(context).filter((gate) => gate.status === 'passed').length
+    },
+    metadata: {
+      ledgers: compactRecord({
+        base: ledgerSummary(ledgers.base),
+        worker: ledgerSummary(ledgers.worker),
+        head: ledgerSummary(ledgers.head),
+        merged: ledgerSummary(ledgers.merged)
+      })
+    }
+  };
+}
+
+export function addConflict(context, conflict) {
+  const gateId = conflict.gateId ?? JsTsSafeMergeGateIds.parseLedger;
+  const record = {
+    code: conflict.code,
+    gateId,
+    message: conflict.message,
+    side: conflict.side,
+    sourcePath: context.sourcePath,
+    details: compactRecord(conflict.details)
+  };
+  context.conflicts.push(record);
+  context.blockedGateIds.add(gateId);
+  const gateReasonCodes = context.gateReasonCodes.get(gateId) ?? [];
+  gateReasonCodes.push(conflict.code);
+  context.gateReasonCodes.set(gateId, uniqueStrings(gateReasonCodes));
+}
+
+export function gatesFor(context) {
+  let blockedSeen = false;
+  return jsTsSafeMergeGateOrder.map((id) => {
+    const blocked = context.blockedGateIds.has(id);
+    const status = blocked ? 'blocked' : blockedSeen ? 'skipped' : 'passed';
+    if (blocked) blockedSeen = true;
+    return {
+      id,
+      status,
+      reasonCodes: context.gateReasonCodes.get(id) ?? []
+    };
+  });
+}
+
+export function sameStatementText(left, right) {
+  return normalizeLineEndings(String(left ?? '').trim(), '\n') === normalizeLineEndings(String(right ?? '').trim(), '\n');
+}
+
+export function normalizeLineEndings(text, lineEnding) {
+  return String(text ?? '').replace(/\r\n?/g, '\n').replace(/\n/g, lineEnding);
+}
+
+export function detectLineEnding(text) {
+  return String(text ?? '').includes('\r\n') ? '\r\n' : '\n';
+}
+
+export function arraysEqual(left, right) {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => value === right[index]);
+}
+
+export function uniqueStrings(values) {
+  return [...new Set((values ?? []).filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record ?? {}).filter(([, value]) => value !== undefined));
+}
+
+export function ledgerSummary(ledger) {
+  if (!ledger) return undefined;
+  return {
+    label: ledger.label,
+    entries: ledger.entries.length,
+    imports: ledger.entries.filter((entry) => entry.kind === 'import').length,
+    declarations: ledger.entries.filter((entry) => entry.kind === 'declaration').length,
+    exports: ledger.entries.filter((entry) => entry.kind === 'export').length
+  };
+}