@shapeshift-labs/frontier-lang-compiler 0.2.141 → 0.2.143

package/README.md

@@ -200,11 +200,12 @@ interface, type, class, or object member additions. Existing class/object method
 or property body edits inside the declared member region are preserved for
 semantic replay while added members are neutralized; object member additions are
 re-emitted with safe commas when both sides add final properties.
-If staged whole-declaration replay cannot verify because head changed a sibling
-member inside the same declaration, `safeMergeJsTsSource` retries the direct
-semantic edit projection and admits the merge only when replay still verifies
-cleanly. That direct retry can project onto the staged top-level merge output,
-so safe import/declaration additions are preserved alongside the sibling edit.
+When head changed an existing sibling declaration or sibling member,
+`safeMergeJsTsSource` prefers the direct semantic edit projection over a
+neutralized staged projection, and admits the merge only when replay still
+verifies cleanly. That direct path projects onto a staged top-level output with
+head declaration changes replayed first, so safe import/declaration additions
+are preserved without dropping the head-side sibling edit.
 
 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

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

@@ -15,30 +15,26 @@ import {
   createStagedDeclarationReplayRecord
 } from './js-ts-safe-merge-staged-declaration-replay.js';
 import { createStagedTopLevelSemanticFallback } from './js-ts-safe-merge-staged-top-level-fallback.js';
+import { createVariableDeclaratorSemanticFallbackResult } from './js-ts-safe-merge-variable-declarator-fallback.js';
 import { idFragment, uniqueStrings } from './native-import-utils.js';
 
 function semanticEditFallbackResult(input, topLevelResult) {
   if (!shouldTrySemanticEditFallback(topLevelResult)) return topLevelResult;
   const stagedFallback = createStagedTopLevelSemanticFallback(input, topLevelResult);
-  let selectedFallback = stagedFallback;
-  let artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback);
-  if (stagedFallback && artifacts.status !== 'verified') {
-    const directFallback = stagedFallback.directProjectionHeadSourceText && stagedFallback.safeTopLevelChanges > 0
-      ? { ...stagedFallback, projectionMode: 'direct' }
-      : undefined;
-    const directArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, directFallback);
-    if (directArtifacts.status === 'verified') {
-      artifacts = directArtifacts;
-      selectedFallback = directFallback;
-    } else if (directFallback) {
-      const plainDirectArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, undefined);
-      if (plainDirectArtifacts.status === 'verified') {
-        artifacts = plainDirectArtifacts;
-        selectedFallback = undefined;
-      }
-    }
+  const candidates = semanticFallbackCandidates(stagedFallback);
+  let selectedFallback = candidates[0];
+  let artifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, selectedFallback);
+  for (const candidate of candidates.slice(1)) {
+    if (artifacts.status === 'verified') break;
+    const nextArtifacts = createSemanticEditFallbackArtifacts(input, topLevelResult, candidate);
+    if (nextArtifacts.status === 'verified') selectedFallback = candidate;
+    artifacts = nextArtifacts.status === 'verified' ? nextArtifacts : artifacts;
+  }
+  if (artifacts.status !== 'verified') {
+    const variableDeclaratorResult = createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback);
+    if (variableDeclaratorResult) return variableDeclaratorResult;
+    return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
   }
-  if (artifacts.status !== 'verified') return semanticEditFallbackBlockedResult(input, topLevelResult, artifacts);
   const resultBase = selectedFallback?.stagedTopLevelResult ?? topLevelResult;
   const mergedSourceText = artifacts.projection.sourceText;
   const gates = semanticEditGates(artifacts);
@@ -83,6 +79,16 @@ function semanticEditFallbackResult(input, topLevelResult) {
   };
 }
 
+function semanticFallbackCandidates(stagedFallback) {
+  if (!stagedFallback) return [undefined];
+  const headChanged = (stagedFallback.neutralization?.summary?.headChangedExistingDeclarations ?? 0) > 0;
+  const directFallback = stagedFallback.directProjectionHeadSourceText && (headChanged || stagedFallback.safeTopLevelChanges > 0)
+    ? { ...stagedFallback, projectionMode: 'direct' }
+    : undefined;
+  if (headChanged) return directFallback ? [directFallback, undefined] : [undefined];
+  return directFallback ? [stagedFallback, directFallback, undefined] : [stagedFallback];
+}
+
 function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallback) {
   try {
     const id = String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge');

package/dist/js-ts-safe-merge-variable-declarator-fallback.js

@@ -0,0 +1,188 @@
+import { JsTsSafeMergeStatuses } from './js-ts-safe-merge-constants.js';
+import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+import { semanticFallbackChangedExistingDeclarations } from './js-ts-safe-merge-semantic-edit-fallback-utils.js';
+import {
+  sameVariableDeclaratorText,
+  sameVariableStatementShell,
+  variableStatementsByKey
+} from './js-ts-safe-merge-variable-declarator-parser.js';
+
+function createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback) {
+  const currentSourceText = fallbackCurrentSourceText(input, stagedFallback);
+  const merge = mergeVariableDeclaratorSources({
+    baseSourceText: input.baseSourceText,
+    workerSourceText: input.workerSourceText,
+    headSourceText: input.headSourceText,
+    currentSourceText
+  });
+  if (!merge.ok || merge.sourceText === currentSourceText) return undefined;
+  const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
+  const language = input.language ?? topLevelResult.language ?? 'typescript';
+  const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+  const phase = stagedFallback
+    ? 'staged-top-level-variable-declarator-semantic-fallback'
+    : 'variable-declarator-semantic-fallback';
+  const artifacts = createJsTsSafeMergeSemanticArtifacts({
+    ...input,
+    id: `${String(input.id ?? topLevelResult.id ?? 'js_ts_safe_merge')}_variable_declarator`,
+    language,
+    sourcePath,
+    headSourceText: currentSourceText,
+    headHash: undefined,
+    currentSourceHash: undefined
+  }, {
+    ...resultBase,
+    id: `${String(input.id ?? resultBase.id ?? 'js_ts_safe_merge')}_variable_declarator`,
+    language,
+    sourcePath,
+    mergedSourceText: merge.sourceText,
+    outputSourceText: merge.sourceText
+  });
+  if (artifacts.status !== 'verified') return undefined;
+  const gates = semanticArtifactGates(artifacts);
+  return {
+    ...resultBase,
+    id: String(input.id ?? resultBase.id ?? topLevelResult.id),
+    status: JsTsSafeMergeStatuses.merged,
+    mergedSourceText: merge.sourceText,
+    outputSourceText: merge.sourceText,
+    conflicts: [],
+    gates,
+    admission: {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: []
+    },
+    summary: {
+      ...resultBase.summary,
+      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback),
+      conflicts: 0,
+      gatesPassed: gates.filter((gate) => gate.status === 'passed').length,
+      semanticEditOperations: artifacts.script.summary.operations,
+      semanticEditAppliedOperations: artifacts.replay.summary.applied,
+      semanticEditReplayStatus: artifacts.replay.status,
+      variableDeclaratorStatements: merge.summary.statements,
+      variableDeclaratorEdits: merge.summary.edits,
+      composedPhases: 2
+    },
+    metadata: {
+      ...resultBase.metadata,
+      composed: {
+        phase,
+        phases: stagedFallback
+          ? ['top-level-neutralization', 'top-level-ledger', 'variable-declarator']
+          : ['top-level-ledger', 'variable-declarator'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        stagedTopLevelSummary: stagedFallback?.stagedTopLevelResult?.summary,
+        neutralization: stagedFallback?.neutralization?.summary,
+        variableDeclaratorFallback: merge.summary
+      }
+    },
+    semanticArtifacts: artifacts
+  };
+}
+
+function fallbackCurrentSourceText(input, stagedFallback) {
+  return stagedFallback?.directReplayCurrentSourceText
+    ?? stagedFallback?.replayCurrentSourceText
+    ?? input.headSourceText;
+}
+
+function mergeVariableDeclaratorSources(input) {
+  if (![input.baseSourceText, input.workerSourceText, input.headSourceText, input.currentSourceText].every((text) => typeof text === 'string')) {
+    return blocked('missing-source-text');
+  }
+  const base = variableStatementsByKey(input.baseSourceText);
+  const worker = variableStatementsByKey(input.workerSourceText);
+  const head = variableStatementsByKey(input.headSourceText);
+  const current = variableStatementsByKey(input.currentSourceText);
+  if ([base, worker, head, current].some((source) => source.reasonCodes.length)) {
+    return blocked('variable-declarator-parse-blocked');
+  }
+  const edits = [];
+  let changedStatements = 0;
+  for (const statement of base.statements) {
+    const key = statement.names.join('\0');
+    const workerStatement = worker.byKey.get(key);
+    const headStatement = head.byKey.get(key);
+    const currentStatement = current.byKey.get(key);
+    if (!workerStatement || !headStatement || !currentStatement) continue;
+    const merged = mergeVariableStatement(statement, workerStatement, headStatement, currentStatement);
+    if (merged.status === 'blocked') return blocked(...merged.reasonCodes);
+    if (!merged.replacement || sameVariableDeclaratorText(merged.replacement, currentStatement.text)) continue;
+    edits.push({ start: currentStatement.start, end: currentStatement.end, replacement: merged.replacement });
+    changedStatements += 1;
+  }
+  if (!edits.length) return blocked('no-variable-declarator-merge-candidate');
+  const sourceText = edits.sort((left, right) => right.start - left.start)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), input.currentSourceText);
+  return {
+    ok: true,
+    sourceText,
+    summary: {
+      statements: changedStatements,
+      edits: edits.length
+    }
+  };
+}
+
+function mergeVariableStatement(base, worker, head, current) {
+  if (!sameVariableStatementShell(base, worker) || !sameVariableStatementShell(base, head) || !sameVariableStatementShell(base, current)) {
+    return blockedStatement('variable-declarator-shell-changed');
+  }
+  const declarators = [];
+  let changed = false;
+  for (let index = 0; index < base.declarators.length; index += 1) {
+    const baseDeclarator = base.declarators[index];
+    const workerDeclarator = worker.declarators[index];
+    const headDeclarator = head.declarators[index];
+    const currentDeclarator = current.declarators[index];
+    if (![workerDeclarator, headDeclarator, currentDeclarator].every((entry) => entry?.name === baseDeclarator.name)) {
+      return blockedStatement('variable-declarator-name-order-changed');
+    }
+    const workerChanged = !sameVariableDeclaratorText(baseDeclarator.text, workerDeclarator.text);
+    const headChanged = !sameVariableDeclaratorText(baseDeclarator.text, headDeclarator.text);
+    if (workerChanged && headChanged && !sameVariableDeclaratorText(workerDeclarator.text, headDeclarator.text)) {
+      return blockedStatement('variable-declarator-conflict');
+    }
+    if (!sameVariableDeclaratorText(currentDeclarator.text, headDeclarator.text)
+      && !sameVariableDeclaratorText(currentDeclarator.text, workerDeclarator.text)) {
+      return blockedStatement('variable-declarator-current-diverged');
+    }
+    const replacement = workerChanged ? workerDeclarator.text : currentDeclarator.text;
+    if (!sameVariableDeclaratorText(replacement, currentDeclarator.text)) changed = true;
+    declarators.push(replacement);
+  }
+  return {
+    status: 'merged',
+    replacement: changed ? `${current.prefix}${declarators.join(', ')}${current.suffix}` : undefined
+  };
+}
+
+function semanticArtifactGates(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) };
+}
+
+function blocked(...reasonCodes) {
+  return { ok: false, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function blockedStatement(...reasonCodes) {
+  return { status: 'blocked', reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+export { createVariableDeclaratorSemanticFallbackResult };

package/dist/js-ts-safe-merge-variable-declarator-parser.js

@@ -0,0 +1,179 @@
+import { normalizeLineEndings, uniqueStrings } from './js-ts-safe-merge-context.js';
+
+function variableStatementsByKey(sourceText) {
+  const reasonCodes = [];
+  const statements = topLevelStatements(sourceText)
+    .map((statement) => parseVariableStatement(statement))
+    .filter(Boolean);
+  const byKey = new Map();
+  for (const statement of statements) {
+    const key = statement.names.join('\0');
+    if (byKey.has(key)) reasonCodes.push('duplicate-variable-declarator-statement-key');
+    byKey.set(key, statement);
+  }
+  return { statements, byKey, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function parseVariableStatement(statement) {
+  const text = statement.text;
+  if (/[`]/.test(text)) return undefined;
+  const leading = text.match(/^\s*/)?.[0].length ?? 0;
+  const meaningful = text.slice(leading);
+  const match = /^(?:export\s+)?(?:declare\s+)?(?:const|let|var)\s+/u.exec(meaningful);
+  if (!match) return undefined;
+  const prefixEnd = leading + match[0].length;
+  const suffixStart = statementSuffixStart(text);
+  if (suffixStart <= prefixEnd) return undefined;
+  const declaratorText = text.slice(prefixEnd, suffixStart);
+  if (/[\r\n]/.test(declaratorText)) return undefined;
+  const declarators = splitDeclarators(declaratorText, prefixEnd);
+  if (declarators.length < 2 || declarators.some((entry) => !entry.name)) return undefined;
+  return {
+    start: statement.start,
+    end: statement.end,
+    text,
+    prefix: text.slice(0, prefixEnd),
+    suffix: text.slice(suffixStart),
+    names: declarators.map((entry) => entry.name),
+    declarators
+  };
+}
+
+function statementSuffixStart(text) {
+  let index = text.length;
+  while (index > 0 && /\s/u.test(text[index - 1])) index -= 1;
+  if (text[index - 1] === ';') index -= 1;
+  while (index > 0 && /\s/u.test(text[index - 1])) index -= 1;
+  return index;
+}
+
+function splitDeclarators(text, offset) {
+  const parts = [];
+  let start = 0;
+  let state = 'code';
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (state === 'line-comment') {
+      if (char === '\n') state = 'code';
+      continue;
+    }
+    if (state === 'block-comment') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        state = 'code';
+      }
+      continue;
+    }
+    if (state !== 'code') {
+      if (char === '\\') index += 1;
+      else if (char === state) state = 'code';
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      state = 'line-comment';
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      state = 'block-comment';
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      state = char;
+      continue;
+    }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth -= 1;
+    else if (char === ',' && depth === 0) {
+      parts.push(declaratorPart(text, start, index, offset));
+      start = index + 1;
+    }
+    if (depth < 0) return [];
+  }
+  if (state !== 'code' || depth !== 0) return [];
+  parts.push(declaratorPart(text, start, text.length, offset));
+  return parts;
+}
+
+function declaratorPart(text, start, end, offset) {
+  let localStart = start;
+  let localEnd = end;
+  while (localStart < localEnd && /\s/u.test(text[localStart])) localStart += 1;
+  while (localEnd > localStart && /\s/u.test(text[localEnd - 1])) localEnd -= 1;
+  const value = text.slice(localStart, localEnd);
+  const name = /^[A-Za-z_$][\w$]*/u.exec(value)?.[0];
+  return {
+    name: name && value[name.length] !== '?' ? name : undefined,
+    text: value,
+    start: offset + localStart,
+    end: offset + localEnd
+  };
+}
+
+function topLevelStatements(sourceText) {
+  const statements = [];
+  let start = 0;
+  let state = 'code';
+  let depth = 0;
+  for (let index = 0; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (state === 'line-comment') {
+      if (char === '\n') state = 'code';
+      continue;
+    }
+    if (state === 'block-comment') {
+      if (char === '*' && next === '/') {
+        index += 1;
+        state = 'code';
+      }
+      continue;
+    }
+    if (state !== 'code') {
+      if (char === '\\') index += 1;
+      else if (char === state) state = 'code';
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      state = 'line-comment';
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      state = 'block-comment';
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+      state = char;
+      continue;
+    }
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth -= 1;
+    else if (char === ';' && depth === 0) {
+      statements.push({ start, end: index + 1, text: sourceText.slice(start, index + 1) });
+      start = index + 1;
+    }
+  }
+  if (sourceText.slice(start).trim()) statements.push({ start, end: sourceText.length, text: sourceText.slice(start) });
+  return statements;
+}
+
+function sameVariableStatementShell(left, right) {
+  return sameVariableDeclaratorText(left.prefix, right.prefix)
+    && sameVariableDeclaratorText(left.suffix, right.suffix)
+    && left.names.join('\0') === right.names.join('\0');
+}
+
+function sameVariableDeclaratorText(left, right) {
+  return normalizeLineEndings(String(left ?? '').trim(), '\n') === normalizeLineEndings(String(right ?? '').trim(), '\n');
+}
+
+export {
+  sameVariableDeclaratorText,
+  sameVariableStatementShell,
+  variableStatementsByKey
+};

package/package.json

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