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

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

@@ -0,0 +1,170 @@
+import {
+  JsTsSafeMergeConflictCodes,
+  JsTsSafeMergeGateIds,
+  JsTsSafeMergeStatuses,
+  jsTsSafeMergeGateOrder
+} from './js-ts-safe-merge-constants.js';
+import { safeMergeJsTsImportsAndDeclarations } from './js-ts-safe-merge.js';
+import {
+  applyJsTsPreparedMemberAdditions,
+  neutralizeJsTsSafeMemberMergeSources
+} from './js-ts-safe-member-merge.js';
+
+function safeMergeJsTsSource(input = {}) {
+  if (!hasMemberMergePolicy(input)) return safeMergeJsTsImportsAndDeclarations(input);
+
+  const memberNeutralization = neutralizeJsTsSafeMemberMergeSources(input);
+  if (!memberNeutralization.ok) {
+    return composedBlockedResult(input, 'member-analysis', memberNeutralization.result, memberNeutralization.analysis);
+  }
+
+  const topLevelResult = safeMergeJsTsImportsAndDeclarations({
+    ...input,
+    baseSourceText: memberNeutralization.baseSourceText,
+    workerSourceText: memberNeutralization.workerSourceText,
+    headSourceText: memberNeutralization.headSourceText
+  });
+  if (topLevelResult.status !== JsTsSafeMergeStatuses.merged) {
+    return composedBlockedResult(input, 'top-level', topLevelResult, memberNeutralization.analysis);
+  }
+
+  const memberApplication = applyJsTsPreparedMemberAdditions(
+    topLevelResult.mergedSourceText,
+    memberNeutralization.analysis.preparedRegions,
+    ['head', 'worker']
+  );
+  if (memberApplication.reasonCodes.length) {
+    return composedMemberApplicationBlockedResult(input, topLevelResult, memberNeutralization.analysis, memberApplication.reasonCodes);
+  }
+
+  const memberAdditions = memberNeutralization.analysis.preparedRegions.reduce((total, region) => (
+    total + region.workerAddedKeys.length + region.headAddedKeys.length
+  ), 0);
+  return {
+    ...topLevelResult,
+    id: String(input.id ?? topLevelResult.id),
+    mergedSourceText: memberApplication.sourceText,
+    outputSourceText: memberApplication.sourceText,
+    summary: {
+      ...topLevelResult.summary,
+      memberRegions: memberNeutralization.analysis.preparedRegions.length,
+      memberAdditions,
+      composedPhases: 2
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      composed: {
+        phases: ['top-level', 'member'],
+        memberRegions: memberNeutralization.analysis.preparedRegions.map((region) => ({
+          kind: region.kind,
+          name: region.name,
+          regionKind: region.policy.regionKind,
+          workerAddedKeys: region.workerAddedKeys,
+          headAddedKeys: region.headAddedKeys
+        }))
+      }
+    }
+  };
+}
+
+function hasMemberMergePolicy(input) {
+  const policy = input.policy ?? input.mergePolicy ?? input;
+  const regions = Array.isArray(policy)
+    ? policy
+    : policy?.unorderedRegions
+      ?? policy?.unorderedMemberRegions
+      ?? policy?.safeList
+      ?? policy?.safeMembers
+      ?? [];
+  return Array.isArray(regions) && regions.length > 0;
+}
+
+function composedBlockedResult(input, phase, result, memberAnalysis) {
+  return {
+    kind: 'frontier.lang.jsTsSafeMerge',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMerge.v1',
+    id: String(input.id ?? result.id ?? 'js_ts_safe_merge'),
+    status: JsTsSafeMergeStatuses.blocked,
+    sourcePath: input.sourcePath,
+    language: input.language ?? 'typescript',
+    conflicts: result.conflicts ?? [],
+    gates: result.gates ?? [],
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: result.admission?.reasonCodes ?? result.reasonCodes ?? []
+    },
+    summary: {
+      importSpecifierAdditions: 0,
+      topLevelDeclarationAdditions: 0,
+      changedExistingDeclarations: result.summary?.changedExistingDeclarations ?? 0,
+      conflicts: result.conflicts?.length ?? result.summary?.conflicts ?? 0,
+      gatesPassed: result.gates?.filter((gate) => gate.status === 'passed').length ?? 0,
+      memberRegions: memberAnalysis?.preparedRegions?.length ?? 0,
+      memberAdditions: 0,
+      composedPhases: phase === 'top-level' ? 2 : 1
+    },
+    metadata: {
+      composed: {
+        phase,
+        sourceKind: result.kind
+      }
+    }
+  };
+}
+
+function composedMemberApplicationBlockedResult(input, topLevelResult, memberAnalysis, reasonCodes) {
+  const conflicts = reasonCodes.map((reason) => ({
+    code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+    gateId: JsTsSafeMergeGateIds.parseLedger,
+    message: 'Composed member application could not find a stable target container.',
+    side: 'merged',
+    sourcePath: input.sourcePath,
+    details: { reason }
+  }));
+  return {
+    ...topLevelResult,
+    status: JsTsSafeMergeStatuses.blocked,
+    mergedSourceText: undefined,
+    outputSourceText: undefined,
+    conflicts,
+    gates: jsTsSafeMergeGateOrder.map((id, index) => ({
+      id,
+      status: index === 0 ? 'blocked' : 'skipped',
+      reasonCodes: index === 0 ? [JsTsSafeMergeConflictCodes.parserLedgerLoss] : []
+    })),
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: [JsTsSafeMergeConflictCodes.parserLedgerLoss]
+    },
+    summary: {
+      ...topLevelResult.summary,
+      conflicts: conflicts.length,
+      gatesPassed: 0,
+      memberRegions: memberAnalysis.preparedRegions.length,
+      memberAdditions: 0,
+      composedPhases: 2
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      composed: {
+        phase: 'member-application',
+        reasonCodes
+      }
+    }
+  };
+}
+
+export {
+  safeMergeJsTsSource
+};

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
+  };
+}

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

@@ -0,0 +1,92 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict } from './js-ts-safe-merge-context.js';
+
+export function validateLedgerUniqueness(ledger, context) {
+  const keyOwners = new Map();
+  for (const entry of ledger.entries) {
+    const existing = keyOwners.get(entry.key);
+    if (existing) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.duplicateName,
+        gateId: JsTsSafeMergeGateIds.uniqueNames,
+        side: ledger.label,
+        message: `${ledger.label} source has duplicate top-level ledger keys.`,
+        details: { key: entry.key, firstOffset: existing.start, secondOffset: entry.start }
+      });
+    } else {
+      keyOwners.set(entry.key, entry);
+    }
+  }
+
+  const nameOwners = new Map();
+  for (const entry of ledger.entries) {
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      const existing = nameOwners.get(nameKey);
+      if (existing) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: ledger.label,
+          message: `${ledger.label} source has duplicate top-level names.`,
+          details: { name, firstOffset: existing.start, secondOffset: entry.start }
+        });
+      } else {
+        nameOwners.set(nameKey, entry);
+      }
+    }
+  }
+
+  for (const entry of ledger.entries.filter((item) => item.kind === 'import')) {
+    validateUniqueImportSpecifiers(entry, ledger.label, context);
+  }
+}
+
+function validateUniqueImportSpecifiers(entry, side, context) {
+  const localNames = new Map();
+  const specifiers = [
+    ...(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
+  ];
+  for (const specifier of specifiers) {
+    const existing = localNames.get(specifier.localName);
+    if (existing) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.duplicateName,
+        gateId: JsTsSafeMergeGateIds.uniqueNames,
+        side,
+        message: `${side} source has duplicate import binding names.`,
+        details: { importKey: entry.key, localName: specifier.localName, first: existing.canonical, second: specifier.canonical }
+      });
+    } else {
+      localNames.set(specifier.localName, specifier);
+    }
+  }
+}
+
+export function indexBaseLedger(base, context) {
+  const entriesByKey = new Map();
+  for (const entry of base.entries) entriesByKey.set(entry.key, entry);
+  const names = new Set();
+  for (const entry of base.entries) {
+    for (const name of entry.names ?? []) {
+      const nameKey = `${entry.kind}:${name}`;
+      if (names.has(nameKey)) {
+        addConflict(context, {
+          code: JsTsSafeMergeConflictCodes.duplicateName,
+          gateId: JsTsSafeMergeGateIds.uniqueNames,
+          side: 'base',
+          message: 'Base source has duplicate declaration or export names.',
+          details: { name }
+        });
+      }
+      names.add(nameKey);
+    }
+  }
+  return {
+    entriesByKey,
+    orderedKeys: base.entries.map((entry) => entry.key),
+    names
+  };
+}

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

@@ -0,0 +1,85 @@
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds } from './js-ts-safe-merge-constants.js';
+import { addConflict } from './js-ts-safe-merge-context.js';
+import { classifyStatement, importSpecifierCanonical } from './js-ts-safe-merge-parse-declarations.js';
+import { findStatementEnd, skipTopLevelTrivia } from './js-ts-safe-merge-parse-statements.js';
+
+export function scanJsTsTopLevelLedger(sourceText, label, context) {
+  const entries = [];
+  let offset = 0;
+  while (offset < sourceText.length) {
+    const skipped = skipTopLevelTrivia(sourceText, offset);
+    if (skipped.error) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains unterminated top-level trivia.`,
+        details: { offset, error: skipped.error }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+    offset = skipped.offset;
+    if (offset >= sourceText.length) break;
+
+    if (sourceText[offset] === '@') {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.unsupportedDecorator,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains decorator syntax that is not safe for ledger merge anchors.`,
+        details: { offset, reasonCode: 'unsupported-js-ts-syntax', preview: sourceText.slice(offset, Math.min(sourceText.length, offset + 80)) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+
+    const end = findStatementEnd(sourceText, offset);
+    if (end.error) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.malformedSyntax,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains a top-level statement the narrow ledger cannot bound.`,
+        details: { offset, error: end.error, preview: sourceText.slice(offset, Math.min(sourceText.length, offset + 80)) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+
+    const statementText = sourceText.slice(offset, end.offset);
+    const entry = classifyStatement(statementText, offset, end.offset);
+    if (entry?.unsupported) {
+      addConflict(context, {
+        code: entry.unsupported.code,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains syntax that is not safe for automatic JS/TS ledger merge.`,
+        details: { offset, ...entry.unsupported.details, statement: statementText.trim().slice(0, 120) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+    if (!entry) {
+      addConflict(context, {
+        code: JsTsSafeMergeConflictCodes.parserLedgerLoss,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: label,
+        message: `${label} source contains an unsupported top-level statement.`,
+        details: { offset, statement: statementText.trim().slice(0, 120) }
+      });
+      return createLedger(label, sourceText, entries);
+    }
+    entries.push(entry);
+    offset = end.offset;
+  }
+  return createLedger(label, sourceText, entries);
+}
+
+function createLedger(label, sourceText, entries) {
+  return {
+    label,
+    sourceText,
+    entries,
+    baseEntries: entries.filter((entry) => entry.kind === 'import' || entry.kind === 'declaration' || entry.kind === 'export')
+  };
+}
+
+export { importSpecifierCanonical } from './js-ts-safe-merge-parse-declarations.js';
+export { indexBaseLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger-validation.js';