@shapeshift-labs/frontier-lang-compiler 0.2.131 → 0.2.133

package/README.md

@@ -188,6 +188,14 @@ artifacts keep `autoMergeClaim: false` and `semanticEquivalenceClaim: false`,
 but give coordinators machine-readable proof that the projected source matches
 the merge output and that applying the same projection again is a no-op.
 
+When the top-level JS/TS ledger blocks only because an existing declaration
+body or semantic fact changed, `safeMergeJsTsSource` can fall back to the
+generic semantic edit script path. The fallback admits the merge only after the
+script is an auto-merge candidate, the source projection succeeds, replay on
+current head is `accepted-clean`, and replay on the projected source is
+`already-applied`. Same-anchor head edits, stale anchors, and non-body conflicts
+remain blocked for review.
+
 Project-level JS/TS safe merges compose the same file-level gates across a
 base/worker/head file set. They preserve head-only files, admit worker-only
 file additions when file additions are enabled, block conflicting same-path

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

@@ -109,6 +109,9 @@ export interface JsTsSafeMergeSummary {
   readonly gatesPassed: number;
   readonly memberRegions?: number;
   readonly memberAdditions?: number;
+  readonly semanticEditOperations?: number;
+  readonly semanticEditAppliedOperations?: number;
+  readonly semanticEditReplayStatus?: string;
   readonly composedPhases?: number;
 }
 

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

@@ -148,6 +148,7 @@ export function validateIndependentAdditions(base, workerPlan, headPlan, context
   validateCrossSideAddedNames(workerPlan, headPlan, context);
   validateCrossSideExportStarAdditions(workerPlan, headPlan, context);
   validateCrossSideImportAdditions(workerPlan, headPlan, context);
+  validateMergedImportShapes(base, workerPlan, headPlan, context);
   validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, context);
 }
 
@@ -234,6 +235,32 @@ function validateCrossSideImportAdditions(workerPlan, headPlan, context) {
   }
 }
 
+function validateMergedImportShapes(base, workerPlan, headPlan, context) {
+  for (const entry of base.entries.filter((item) => item.kind === 'import')) {
+    const additions = [
+      ...(workerPlan.importAdditions.get(entry.key) ?? []),
+      ...(headPlan.importAdditions.get(entry.key) ?? [])
+    ];
+    const namespaceAddition = additions.find((specifier) => specifier.additionKind === 'namespace');
+    if (!namespaceAddition) continue;
+    const namedAdditions = additions.filter((specifier) => !specifier.additionKind);
+    if (!entry.importInfo.specifiers.length && !namedAdditions.length) continue;
+    addConflict(context, {
+      code: JsTsSafeMergeConflictCodes.importShapeChanged,
+      gateId: JsTsSafeMergeGateIds.independentImportSpecifiers,
+      message: 'Merged imports would combine namespace and named import specifiers.',
+      details: {
+        key: entry.key,
+        namespace: namespaceAddition.localName,
+        namedSpecifiers: [
+          ...entry.importInfo.specifiers.map((specifier) => specifier.canonical),
+          ...namedAdditions.map((specifier) => specifier.canonical)
+        ]
+      }
+    });
+  }
+}
+
 function validateMergedImportAndDeclarationNames(base, workerPlan, headPlan, context) {
   const topLevelBindingNames = new Set();
   for (const entry of base.entries.filter((item) => item.kind !== 'import')) {

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

@@ -5,6 +5,7 @@ import {
   jsTsSafeMergeGateOrder
 } from './js-ts-safe-merge-constants.js';
 import { safeMergeJsTsImportsAndDeclarations } from './js-ts-safe-merge.js';
+import { semanticEditFallbackResult } from './js-ts-safe-merge-semantic-edit-fallback.js';
 import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
 import {
   applyJsTsPreparedMemberAdditions,
@@ -12,7 +13,12 @@ import {
 } from './js-ts-safe-member-merge.js';
 
 function safeMergeJsTsSource(input = {}) {
-  if (!hasMemberMergePolicy(input)) return safeMergeJsTsImportsAndDeclarations(input);
+  if (!hasMemberMergePolicy(input)) {
+    const topLevelResult = safeMergeJsTsImportsAndDeclarations(input);
+    return topLevelResult.status === JsTsSafeMergeStatuses.merged
+      ? topLevelResult
+      : semanticEditFallbackResult(input, topLevelResult);
+  }
 
   const memberNeutralization = neutralizeJsTsSafeMemberMergeSources(input);
   if (!memberNeutralization.ok) {

package/dist/js-ts-safe-merge-semantic-edit-fallback.js

@@ -0,0 +1,263 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { createSemanticEditScript } from './internal/index-impl/semanticEditScripts.js';
+import { projectSemanticEditScriptToSource } from './internal/index-impl/projectSemanticEditScriptToSource.js';
+import { replaySemanticEditProjection } from './internal/index-impl/replaySemanticEditProjection.js';
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { idFragment, uniqueStrings } from './native-import-utils.js';
+
+function semanticEditFallbackResult(input, topLevelResult) {
+  if (!shouldTrySemanticEditFallback(topLevelResult)) return topLevelResult;
+  const artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult);
+  if (artifacts.status !== 'verified') return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
+  const mergedSourceText = artifacts.projection.sourceText;
+  const gates = semanticEditGates(artifacts);
+  return {
+    ...topLevelResult,
+    status: JsTsSafeMergeStatuses.merged,
+    mergedSourceText,
+    outputSourceText: mergedSourceText,
+    conflicts: [],
+    gates,
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    summary: {
+      ...topLevelResult.summary,
+      conflicts: 0,
+      gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
+      semanticEditOperations: artifacts.script.summary.operations,
+      semanticEditAppliedOperations: artifacts.replay.summary.applied,
+      semanticEditReplayStatus: artifacts.replay.status,
+      composedPhases: 2
+    },
+    metadata: {
+      ...topLevelResult.metadata,
+      composed: {
+        phase: 'semantic-edit-fallback',
+        phases: ['top-level-ledger', 'semantic-edit'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
+      }
+    },
+    semanticArtifacts: artifacts
+  };
+}
+
+function shouldTrySemanticEditFallback(result) {
+  const conflicts = result.conflicts ?? [];
+  return conflicts.length > 0 && conflicts.every((conflict) => conflict.code === JsTsSafeMergeConflictCodes.changedExistingDeclaration);
+}
+
+function createSemanticEditFallbackArtifacts(input, topLevelResult) {
+  try {
+    const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
+    const language = input.language ?? topLevelResult.language ?? 'typescript';
+    const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+    const script = createSemanticEditScript({
+      ...input,
+      id: `${id}_semantic_edit`,
+      language,
+      sourcePath
+    });
+    const projection = projectSemanticEditScriptToSource({
+      id: `${id}_semantic_edit_projection`,
+      script,
+      workerSourceText: input.workerSourceText,
+      headSourceText: input.headSourceText,
+      headSourcePath: sourcePath,
+      parser: input.parser
+    });
+    const replay = replaySemanticEditProjection({
+      id: `${id}_semantic_edit_replay`,
+      projection,
+      currentSourceText: input.headSourceText,
+      currentSourcePath: sourcePath,
+      language,
+      parser: input.parser
+    });
+    const alreadyAppliedReplay = replaySemanticEditProjection({
+      id: `${id}_semantic_edit_already_applied`,
+      projection,
+      currentSourceText: projection.sourceText,
+      currentSourcePath: sourcePath,
+      currentSourceHash: projection.projectedHash,
+      language,
+      parser: input.parser
+    });
+    return semanticEditArtifacts({
+      id,
+      language,
+      sourcePath,
+      script,
+      projection,
+      replay,
+      alreadyAppliedReplay,
+      topLevelResult
+    });
+  } catch (error) {
+    return blockedSemanticEditArtifacts(input, topLevelResult, ['semantic-edit-fallback-error'], error);
+  }
+}
+
+function semanticEditArtifacts(input) {
+  const reasonCodes = semanticEditArtifactReasonCodes(input);
+  const status = reasonCodes.length ? 'blocked' : 'verified';
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_edit_artifacts_${idFragment(input.id)}`,
+    sourcePath: input.sourcePath,
+    language: input.language,
+    status,
+    script: input.script,
+    projection: input.projection,
+    replay: input.replay,
+    alreadyAppliedReplay: input.alreadyAppliedReplay,
+    admission: {
+      status: status === 'verified' ? 'auto-merge-candidate' : 'blocked',
+      action: status === 'verified' ? 'apply' : 'human-review',
+      reviewRequired: status !== 'verified',
+      autoApplyCandidate: status === 'verified',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      operations: input.script.summary.operations,
+      edits: input.projection.edits.length,
+      replayStatus: input.replay.status,
+      alreadyAppliedReplayStatus: input.alreadyAppliedReplay.status,
+      projectedSourceMatchesMerged: input.projection.sourceText === input.replay.outputSourceText,
+      replayOutputMatchesMerged: input.replay.outputSourceText === input.projection.sourceText
+    },
+    evidence: [{
+      id: `evidence_${idFragment(input.id)}_js_ts_semantic_edit_replay`,
+      kind: 'js-ts-semantic-edit-replay',
+      status: status === 'verified' ? 'passed' : 'needs-review',
+      path: input.sourcePath,
+      summary: status === 'verified'
+        ? `JS/TS semantic edit replay verified ${input.script.summary.operations} operation(s).`
+        : `JS/TS semantic edit replay requires review: ${reasonCodes.join(', ')}.`
+    }],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      source: 'js-ts-semantic-edit-fallback',
+      originalReasonCodes: input.topLevelResult.admission?.reasonCodes ?? []
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function semanticEditArtifactReasonCodes(input) {
+  const scriptReady = input.script.admission.status === 'auto-merge-candidate';
+  const projectionReady = input.projection.status === 'projected';
+  const replayReady = input.replay.status === 'accepted-clean';
+  const alreadyAppliedReady = input.alreadyAppliedReplay.status === 'already-applied';
+  return uniqueStrings([
+    scriptReady ? undefined : `semantic-edit-script-${input.script.admission.status}`,
+    projectionReady ? undefined : `semantic-edit-projection-${input.projection.status}`,
+    replayReady ? undefined : `semantic-edit-replay-${input.replay.status}`,
+    input.replay.outputSourceText !== input.projection.sourceText ? 'semantic-edit-replay-output-mismatch' : undefined,
+    alreadyAppliedReady ? undefined : `semantic-edit-already-applied-${input.alreadyAppliedReplay.status}`,
+    ...(scriptReady ? [] : input.script.admission.reasonCodes),
+    ...(projectionReady ? [] : input.projection.admission.reasonCodes),
+    ...(replayReady ? [] : input.replay.admission.reasonCodes),
+    ...(alreadyAppliedReady ? [] : input.alreadyAppliedReplay.admission.reasonCodes)
+  ]);
+}
+
+function blockedSemanticEditArtifacts(input, topLevelResult, reasonCodes, error) {
+  const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');
+  const core = {
+    kind: 'frontier.lang.jsTsSafeMergeSemanticArtifacts',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMergeSemanticArtifacts.v1',
+    id: `js_ts_safe_merge_semantic_edit_artifacts_${idFragment(id)}`,
+    sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
+    language: input.language ?? topLevelResult.language ?? 'typescript',
+    status: 'blocked',
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      operations: 0,
+      edits: 0,
+      replayStatus: 'blocked',
+      alreadyAppliedReplayStatus: 'blocked',
+      projectedSourceMatchesMerged: false,
+      replayOutputMatchesMerged: false
+    },
+    metadata: {
+      source: 'js-ts-semantic-edit-fallback',
+      error: error?.message
+    }
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function semanticEditFallbackBlockedResult(input, topLevelResult, artifacts) {
+  const reasonCodes = artifacts.admission.reasonCodes.length
+    ? artifacts.admission.reasonCodes
+    : topLevelResult.admission?.reasonCodes ?? [];
+  const gates = semanticEditGates(artifacts);
+  const conflict = {
+    code: JsTsSafeMergeConflictCodes.changedExistingDeclaration,
+    gateId: 'semantic-edit-replay',
+    message: 'JS/TS semantic edit fallback did not verify a clean replay.',
+    side: 'worker',
+    sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
+    details: { reasonCodes }
+  };
+  return {
+    ...topLevelResult,
+    conflicts: [conflict],
+    gates,
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      ...topLevelResult.summary,
+      conflicts: 1,
+      gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
+      semanticEditOperations: artifacts.summary.operations,
+      semanticEditReplayStatus: artifacts.summary.replayStatus
+    },
+    semanticArtifacts: artifacts
+  };
+}
+
+function semanticEditGates(artifacts) {
+  return [
+    gate('semantic-edit-script', artifacts.script?.admission?.status === 'auto-merge-candidate', artifacts.script?.admission?.reasonCodes),
+    gate('semantic-edit-projection', artifacts.projection?.status === 'projected', artifacts.projection?.admission?.reasonCodes),
+    gate('semantic-edit-replay', artifacts.replay?.status === 'accepted-clean', artifacts.replay?.admission?.reasonCodes),
+    gate('semantic-edit-already-applied', artifacts.alreadyAppliedReplay?.status === 'already-applied', artifacts.alreadyAppliedReplay?.admission?.reasonCodes)
+  ];
+}
+
+function gate(id, passed, reasonCodes = []) {
+  return { id, status: passed ? 'passed' : 'blocked', reasonCodes: passed ? [] : uniqueStrings(reasonCodes) };
+}
+
+export {
+  semanticEditFallbackResult
+};

package/package.json

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