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

package/README.md

@@ -168,7 +168,8 @@ The JS/TS semantic merge smoke corpus lives at
 `test/smoke/js-ts-semantic-merge-oracles.mjs`. The fixtures are deliberately
 small and dependency-free. They cover accepted projection/replay cases, exact
 source preservation, generated/source-map boundaries, safe import/declaration
-merges, safe unordered member merges, and rejected unsafe cases such as stale
+merges, safe unordered member merges, composed top-level/member safe merges,
+and rejected unsafe cases such as stale
 ledger spans, import specifier reordering, computed keys, duplicate exported
 names, duplicate object members, decorators, overload anchors, and same-anchor
 edit conflicts. Fixture failures include the fixture id and the actual

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

@@ -1,4 +1,4 @@
-export type JsTsSafeMemberMergeRegionKind = 'interface' | 'type' | 'object';
+export type JsTsSafeMemberMergeRegionKind = 'interface' | 'type' | 'class' | 'object';
 export type JsTsSafeMemberMergeOrder = 'non-semantic' | string;
 export type JsTsSafeMemberMergeStatus = 'merged' | 'rejected';
 
@@ -26,6 +26,30 @@ export interface JsTsSafeMemberMergeInput {
   readonly policy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
   readonly mergePolicy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
   readonly unorderedRegions?: readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly allowNonPolicySourceChanges?: boolean;
+}
+
+export interface JsTsSafeMemberMergeConflict {
+  readonly code: string;
+  readonly gateId: string;
+  readonly message: string;
+  readonly side?: 'base' | 'worker' | 'head' | string;
+  readonly sourcePath?: string;
+  readonly details?: Record<string, unknown>;
+}
+
+export interface JsTsSafeMemberMergeGate {
+  readonly id: string;
+  readonly status: 'passed' | 'blocked' | 'skipped' | string;
+  readonly reasonCodes: readonly string[];
+}
+
+export interface JsTsSafeMemberMergeAdmission {
+  readonly status: 'auto-merge-candidate' | 'blocked' | string;
+  readonly action: 'apply' | 'human-review' | string;
+  readonly reviewRequired: boolean;
+  readonly autoApplyCandidate: boolean;
+  readonly reasonCodes: readonly string[];
 }
 
 export interface JsTsSafeMemberMergedRegion {
@@ -42,12 +66,16 @@ export interface JsTsSafeMemberMergeResult {
   readonly status: JsTsSafeMemberMergeStatus;
   readonly sourceText?: string;
   readonly reasonCodes: readonly string[];
+  readonly conflicts: readonly JsTsSafeMemberMergeConflict[];
+  readonly gates: readonly JsTsSafeMemberMergeGate[];
+  readonly admission: JsTsSafeMemberMergeAdmission;
   readonly mergedRegions: readonly JsTsSafeMemberMergedRegion[];
   readonly summary: {
     readonly regions: number;
     readonly workerAdditions: number;
     readonly headAdditions: number;
     readonly appliedAdditions: number;
+    readonly conflicts: number;
   };
   readonly metadata: {
     readonly explicitPolicy: boolean;

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

@@ -1,4 +1,8 @@
 import type { FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+import type {
+  JsTsSafeMemberMergePolicy,
+  JsTsSafeMemberMergePolicyRegion
+} from './js-ts-safe-member-merge.js';
 
 export type JsTsSafeMergeStatus = 'merged' | 'blocked';
 export type JsTsSafeMergeGateStatus = 'passed' | 'blocked' | 'skipped';
@@ -65,6 +69,9 @@ export interface JsTsSafeMergeInput {
   readonly baseSourceLedger?: unknown;
   readonly workerSourceLedger?: unknown;
   readonly headSourceLedger?: unknown;
+  readonly policy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly mergePolicy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly unorderedRegions?: readonly JsTsSafeMemberMergePolicyRegion[];
 }
 
 export interface JsTsSafeMergeConflict {
@@ -98,6 +105,9 @@ export interface JsTsSafeMergeSummary {
   readonly changedExistingDeclarations: number;
   readonly conflicts: number;
   readonly gatesPassed: number;
+  readonly memberRegions?: number;
+  readonly memberAdditions?: number;
+  readonly composedPhases?: number;
 }
 
 export interface JsTsSafeMergeResult {
@@ -118,3 +128,4 @@ export interface JsTsSafeMergeResult {
 }
 
 export declare function safeMergeJsTsImportsAndDeclarations(input: JsTsSafeMergeInput): JsTsSafeMergeResult;
+export declare function safeMergeJsTsSource(input: JsTsSafeMergeInput): JsTsSafeMergeResult;

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

@@ -1,5 +1,6 @@
 import {
   applyMemberAdditions,
+  applyPreparedMemberAdditions,
   canonicalizeSourceBodies,
   findContainer,
   normalizeKind,
@@ -17,6 +18,54 @@ function safeMergeJsTsMembers(input = {}) {
 }
 
 function mergeJsTsSafeMemberAdditions(input = {}) {
+  const analysis = analyzeJsTsSafeMemberAdditions(input);
+  const uniqueReasons = uniqueStrings(analysis.reasonCodes);
+  if (uniqueReasons.length) {
+    return mergeResult('rejected', undefined, uniqueReasons, analysis.preparedRegions, input, analysis.explicitPolicy);
+  }
+  const sourceText = applyMemberAdditions(analysis.headSourceText, analysis.preparedRegions);
+  return mergeResult('merged', sourceText, [], analysis.preparedRegions, input, analysis.explicitPolicy);
+}
+
+function analyzeJsTsSafeMemberAdditions(input = {}) {
+  const analysis = prepareJsTsSafeMemberAdditions(input);
+  const reasonCodes = [...analysis.reasonCodes];
+  if (!input.allowNonPolicySourceChanges) {
+    reasonCodes.push(...nonPolicySourceChangeReasons(analysis));
+  }
+  return {
+    ...analysis,
+    reasonCodes: uniqueStrings(reasonCodes),
+    ok: reasonCodes.length === 0
+  };
+}
+
+function neutralizeJsTsSafeMemberMergeSources(input = {}) {
+  const analysis = analyzeJsTsSafeMemberAdditions({
+    ...input,
+    allowNonPolicySourceChanges: true
+  });
+  if (analysis.reasonCodes.length) {
+    return {
+      ok: false,
+      analysis,
+      result: mergeResult('rejected', undefined, analysis.reasonCodes, analysis.preparedRegions, input, analysis.explicitPolicy)
+    };
+  }
+  return {
+    ok: true,
+    analysis,
+    baseSourceText: analysis.baseSourceText,
+    workerSourceText: canonicalizeSourceBodies(analysis.workerSourceText, analysis.preparedRegions, 'worker'),
+    headSourceText: canonicalizeSourceBodies(analysis.headSourceText, analysis.preparedRegions, 'head')
+  };
+}
+
+function applyJsTsPreparedMemberAdditions(sourceText, preparedRegions, sides) {
+  return applyPreparedMemberAdditions(sourceText, preparedRegions, sides);
+}
+
+function prepareJsTsSafeMemberAdditions(input = {}) {
   const baseSourceText = input.baseSourceText;
   const workerSourceText = input.workerSourceText;
   const headSourceText = input.headSourceText;
@@ -36,6 +85,20 @@ function mergeJsTsSafeMemberAdditions(input = {}) {
     reasonCodes.push(...prepared.reasonCodes);
     if (prepared.ok) preparedRegions.push(prepared.value);
   }
+  const explicitPolicy = policyRegions.length > 0;
+  return {
+    baseSourceText,
+    workerSourceText,
+    headSourceText,
+    reasonCodes: uniqueStrings(reasonCodes),
+    preparedRegions,
+    explicitPolicy
+  };
+}
+
+function nonPolicySourceChangeReasons(analysis) {
+  const reasonCodes = [];
+  const { baseSourceText, workerSourceText, headSourceText, preparedRegions } = analysis;
   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');
@@ -44,11 +107,7 @@ function mergeJsTsSafeMemberAdditions(input = {}) {
     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);
+  return reasonCodes;
 }
 
 function normalizePolicyRegions(policy) {
@@ -125,7 +184,8 @@ function prepareRegion(input) {
       headMembers: headMembers.members,
       workerAddedKeys,
       headAddedKeys,
-      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key))
+      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key)),
+      headAddedMembers: headMembers.members.filter((member) => headAddedKeys.includes(member.key))
     }
   };
 }
@@ -197,6 +257,9 @@ function regionReason(region, reason) {
 }
 
 export {
+  analyzeJsTsSafeMemberAdditions,
+  applyJsTsPreparedMemberAdditions,
   mergeJsTsSafeMemberAdditions,
+  neutralizeJsTsSafeMemberMergeSources,
   safeMergeJsTsMembers
 };

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-semantic-merge-member-source.js

@@ -1,3 +1,6 @@
+import { findContainer } from './js-ts-semantic-merge-member-containers.js';
+import { uniqueStrings } from './js-ts-semantic-merge-member-utils.js';
+
 function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
   let output = sourceText;
   const replacements = preparedRegions
@@ -10,15 +13,29 @@ function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
 }
 
 function applyMemberAdditions(headSourceText, preparedRegions) {
-  let output = headSourceText;
+  return applyPreparedMemberAdditions(headSourceText, preparedRegions, ['worker']).sourceText;
+}
+
+function applyPreparedMemberAdditions(sourceText, preparedRegions, sides = ['worker']) {
+  let output = sourceText;
+  const reasonCodes = [];
   const replacements = preparedRegions
-    .filter((region) => region.workerAddedMembers.length)
-    .map((region) => ({ range: region.head, replacement: appendMembersToBody(region.head.body, region.workerAddedMembers) }))
+    .map((region) => {
+      const match = findContainer(sourceText, region.policy);
+      if (match.reasonCodes.length) {
+        reasonCodes.push(...match.reasonCodes.map((reason) => `target-${reason}:${region.kind}:${region.name}`));
+        return undefined;
+      }
+      const members = sides.flatMap((side) => region[`${side}AddedMembers`] ?? []);
+      if (!members.length) return undefined;
+      return { range: match.value, replacement: appendMembersToBody(match.value.body, members) };
+    })
+    .filter(Boolean)
     .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
   for (const { range, replacement } of replacements) {
     output = `${output.slice(0, range.bodyStart)}${replacement}${output.slice(range.bodyEnd)}`;
   }
-  return output;
+  return { sourceText: output, reasonCodes: uniqueStrings(reasonCodes) };
 }
 
 function appendMembersToBody(body, members) {
@@ -60,5 +77,6 @@ function leadingWhitespace(line) {
 
 export {
   applyMemberAdditions,
+  applyPreparedMemberAdditions,
   canonicalizeSourceBodies
 };

package/dist/js-ts-semantic-merge-parse.js

@@ -7,6 +7,7 @@ export {
 } from './js-ts-semantic-merge-member-segments.js';
 export {
   applyMemberAdditions,
+  applyPreparedMemberAdditions,
   canonicalizeSourceBodies
 } from './js-ts-semantic-merge-member-source.js';
 export {

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

@@ -4,6 +4,9 @@ export {
   JsTsSafeMergeStatuses,
   safeMergeJsTsImportsAndDeclarations
 } from './js-ts-safe-merge.js';
+export {
+  safeMergeJsTsSource
+} from './js-ts-safe-merge-composed.js';
 export {
   mergeJsTsSafeMemberAdditions,
   safeMergeJsTsMembers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.104",
+  "version": "0.2.105",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",