@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/js-ts-safe-merge-jsx-child-expression-parser.js

@@ -0,0 +1,300 @@
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+
+function parseJsxSource(sourceText) {
+  const elements = [];
+  const allElements = [];
+  const reasonCodes = [];
+  const ordinals = new Map();
+  const stack = [];
+  let index = 0;
+  while (index < sourceText.length) {
+    const start = sourceText.indexOf('<', index);
+    if (start === -1) break;
+    const closing = parseClosingTag(sourceText, start);
+    if (closing) {
+      const open = stack.pop();
+      if (!open || open.tagName !== closing.tagName) {
+        reasonCodes.push('jsx-child-expression-tag-mismatch');
+        index = closing.end;
+        continue;
+      }
+      const element = { ...open, closeStart: closing.start, closeEnd: closing.end, closeText: closing.text, text: sourceText.slice(open.start, closing.end) };
+      elements.push(element);
+      allElements.push(element);
+      index = closing.end;
+      continue;
+    }
+    const opening = parseOpeningTag(sourceText, start);
+    if (!opening) {
+      index = start + 1;
+      continue;
+    }
+    const ordinal = (ordinals.get(opening.tagName) ?? 0) + 1;
+    ordinals.set(opening.tagName, ordinal);
+    const element = {
+      tagName: opening.tagName,
+      key: `${opening.tagName}#${ordinal}`,
+      start,
+      openEnd: opening.end,
+      closeStart: opening.selfClosing ? opening.end : undefined,
+      closeEnd: opening.selfClosing ? opening.end : undefined,
+      openText: opening.text,
+      closeText: opening.selfClosing ? '' : undefined,
+      selfClosing: opening.selfClosing,
+      text: opening.selfClosing ? opening.text : undefined
+    };
+    if (opening.selfClosing) allElements.push(element);
+    else stack.push(element);
+    index = opening.end;
+  }
+  if (stack.length) reasonCodes.push('jsx-child-expression-tag-unclosed');
+  allElements.sort((left, right) => left.start - right.start);
+  return {
+    elements,
+    allElements,
+    byKey: new Map(elements.map((element) => [element.key, element])),
+    byStart: new Map(allElements.map((element) => [element.start, element])),
+    reasonCodes: uniqueStrings(reasonCodes)
+  };
+}
+
+function parseDirectChildren(sourceText, parsed, element) {
+  const tokens = [];
+  const reasonCodes = [];
+  const start = element.openEnd;
+  const end = element.closeStart;
+  if (!Number.isFinite(start) || !Number.isFinite(end) || start > end) {
+    return { tokens, reasonCodes: ['jsx-child-expression-bounds-unsupported'] };
+  }
+  let cursor = start;
+  while (cursor < end) {
+    const childElement = parsed.byStart.get(cursor);
+    if (childElement && childElement.closeEnd <= end) {
+      tokens.push({
+        kind: 'element',
+        tagName: childElement.tagName,
+        fragmentKind: childElement.fragmentKind,
+        start: cursor,
+        end: childElement.closeEnd,
+        text: sourceText.slice(cursor, childElement.closeEnd),
+        ...childElementIdentity(childElement)
+      });
+      cursor = childElement.closeEnd;
+      continue;
+    }
+    if (sourceText[cursor] === '{') {
+      const expressionEnd = bracedValueEnd(sourceText, cursor, end);
+      if (expressionEnd === undefined) return { tokens, reasonCodes: ['jsx-child-expression-unterminated'] };
+      tokens.push({ kind: 'expression', start: cursor, end: expressionEnd, text: sourceText.slice(cursor, expressionEnd) });
+      cursor = expressionEnd;
+      continue;
+    }
+    let next = cursor + 1;
+    while (next < end && !parsed.byStart.has(next) && sourceText[next] !== '{') next += 1;
+    tokens.push({ kind: 'text', start: cursor, end: next, text: sourceText.slice(cursor, next) });
+    cursor = next;
+  }
+  return { tokens, reasonCodes };
+}
+
+function parseOpeningTag(sourceText, start) {
+  const afterOpen = start + 1;
+  if (sourceText[afterOpen] === '>') {
+    return { tagName: 'Fragment', fragmentKind: 'shorthand', start, end: afterOpen + 1, text: '<>', selfClosing: false };
+  }
+  if (/[/!?>]/.test(sourceText[afterOpen] ?? '')) return undefined;
+  const nameMatch = /^[A-Za-z_$][\w$]*(?:[.:][A-Za-z_$][\w$]*|-[\w$]+)*/.exec(sourceText.slice(afterOpen));
+  if (!nameMatch) return undefined;
+  const tagName = nameMatch[0];
+  const end = openingTagEnd(sourceText, afterOpen + tagName.length);
+  if (end === undefined) return undefined;
+  const text = sourceText.slice(start, end);
+  return { tagName, start, end, text, selfClosing: /\/\s*>$/.test(text) };
+}
+
+function parseClosingTag(sourceText, start) {
+  if (sourceText[start] !== '<' || sourceText[start + 1] !== '/') return undefined;
+  const afterSlash = start + 2;
+  if (sourceText[afterSlash] === '>') {
+    return { tagName: 'Fragment', fragmentKind: 'shorthand', start, end: afterSlash + 1, text: '</>' };
+  }
+  const nameMatch = /^[A-Za-z_$][\w$]*(?:[.:][A-Za-z_$][\w$]*|-[\w$]+)*/.exec(sourceText.slice(afterSlash));
+  if (!nameMatch) return undefined;
+  const tagName = nameMatch[0];
+  let cursor = afterSlash + tagName.length;
+  while (cursor < sourceText.length && /\s/.test(sourceText[cursor])) cursor += 1;
+  if (sourceText[cursor] !== '>') return undefined;
+  const end = cursor + 1;
+  return { tagName, start, end, text: sourceText.slice(start, end) };
+}
+
+function openingTagEnd(sourceText, start) {
+  let quote;
+  let escaped = false;
+  let braceDepth = 0;
+  for (let index = start; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === '\'' || char === '`') quote = char;
+    else if (char === '{') braceDepth += 1;
+    else if (char === '}') braceDepth = Math.max(0, braceDepth - 1);
+    else if (char === '>' && braceDepth === 0) return index + 1;
+  }
+  return undefined;
+}
+
+function bracedValueEnd(sourceText, start, end) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let cursor = start; cursor < end; cursor += 1) {
+    const char = sourceText[cursor];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === '\'' || char === '`') quote = char;
+    else if (char === '{') depth += 1;
+    else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return cursor + 1;
+    }
+  }
+  return undefined;
+}
+
+function childElementIdentity(element) {
+  const key = stableJsxKey(element.openText);
+  const hasSpreadProp = /\{\s*\.\.\./.test(String(element.openText ?? ''));
+  return {
+    keyPropValue: key?.value,
+    keyPropText: key?.text,
+    stableKey: key?.stable === true,
+    childIdentityKey: key?.stable === true ? `key:${key.value}` : undefined,
+    hasSpreadProp
+  };
+}
+
+function stableJsxKey(openText) {
+  const text = String(openText ?? '');
+  let cursor = 1;
+  const tagName = jsxAttributeNameAt(text, cursor);
+  if (!tagName) return undefined;
+  cursor += tagName.length;
+  while (cursor < text.length) {
+    while (cursor < text.length && /\s/.test(text[cursor])) cursor += 1;
+    if (text[cursor] === '/' || text[cursor] === '>') return undefined;
+    if (text[cursor] === '{') {
+      const expressionEnd = bracedValueEnd(text, cursor, text.length);
+      if (expressionEnd === undefined) return undefined;
+      cursor = expressionEnd;
+      continue;
+    }
+    const attrStart = cursor;
+    const attrName = jsxAttributeNameAt(text, cursor);
+    if (!attrName) {
+      cursor += 1;
+      continue;
+    }
+    cursor += attrName.length;
+    while (cursor < text.length && /\s/.test(text[cursor])) cursor += 1;
+    if (text[cursor] !== '=') continue;
+    cursor += 1;
+    while (cursor < text.length && /\s/.test(text[cursor])) cursor += 1;
+    const quote = text[cursor];
+    if (quote === '"' || quote === '\'') {
+      const valueStart = cursor + 1;
+      const valueEnd = quotedStringEnd(text, cursor);
+      if (valueEnd === undefined) return undefined;
+      if (attrName === 'key') {
+        return { stable: true, value: text.slice(valueStart, valueEnd - 1), text: text.slice(attrStart, valueEnd).trim() };
+      }
+      cursor = valueEnd;
+      continue;
+    }
+    const valueEnd = skipJsxAttributeValue(text, cursor);
+    if (valueEnd === undefined) return undefined;
+    cursor = valueEnd;
+  }
+  return undefined;
+}
+
+function jsxAttributeNameAt(text, cursor) {
+  const match = /^[A-Za-z_$][\w$]*(?:[-:.][A-Za-z_$][\w$]*)*/.exec(text.slice(cursor));
+  return match?.[0];
+}
+
+function quotedStringEnd(text, start) {
+  const quote = text[start];
+  let escaped = false;
+  for (let cursor = start + 1; cursor < text.length; cursor += 1) {
+    const char = text[cursor];
+    if (escaped) escaped = false;
+    else if (char === '\\') escaped = true;
+    else if (char === quote) return cursor + 1;
+  }
+  return undefined;
+}
+
+function skipJsxAttributeValue(text, cursor) {
+  if (text[cursor] === '{') return bracedValueEnd(text, cursor, text.length);
+  if (text[cursor] === '"' || text[cursor] === '\'' || text[cursor] === '`') return quotedStringEnd(text, cursor);
+  let next = cursor;
+  while (next < text.length && !/[\s/>]/.test(text[next])) next += 1;
+  return next;
+}
+
+function hasConditionalChildExpressionOperator(text) {
+  const value = String(text ?? '');
+  let quote;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    const next = value[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === '\'' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if ((char === '&' && next === '&') || (char === '|' && next === '|') || (char === '?' && next === '?')) return true;
+    if (char === '?' && next !== '.' && next !== '?') return true;
+  }
+  return false;
+}
+
+export { hasConditionalChildExpressionOperator, parseDirectChildren, parseJsxSource };

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

@@ -1,14 +1,34 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { JsTsSafeMergeConflictCodes, identifierRegExp } from './js-ts-safe-merge-constants.js';
 
 export function classifyStatement(text, start, end) {
+  const directiveInfo = parseDirectiveInfo(text);
+  const textHash = hashSemanticValue(text);
+  if (directiveInfo) {
+    const key = directiveLedgerKey(directiveInfo);
+    return {
+      kind: 'directive',
+      key,
+      text,
+      start,
+      end,
+      textHash,
+      ownershipAnchor: topLevelStatementOwnershipAnchor({ kind: 'directive', key, textHash, start, end, directiveInfo }),
+      directiveInfo,
+      names: []
+    };
+  }
   const importInfo = parseImportInfo(text);
   if (importInfo) {
+    const key = importLedgerKey(importInfo);
     return {
       kind: 'import',
-      key: importLedgerKey(importInfo),
+      key,
       text,
       start,
       end,
+      textHash,
+      ownershipAnchor: topLevelStatementOwnershipAnchor({ kind: 'import', key, textHash, start, end }),
       importInfo,
       names: importInfo.specifiers.map((specifier) => specifier.localName).filter(Boolean)
     };
@@ -17,12 +37,15 @@ export function classifyStatement(text, start, end) {
   if (declarationInfo) {
     const unsupported = unsupportedDeclarationPolicy(text, declarationInfo);
     if (unsupported) return { unsupported, text, start, end };
+    const key = declarationLedgerKey(declarationInfo);
     return {
       kind: declarationInfo.kind,
-      key: declarationLedgerKey(declarationInfo),
+      key,
       text,
       start,
       end,
+      textHash,
+      ownershipAnchor: topLevelStatementOwnershipAnchor({ kind: declarationInfo.kind, key, textHash, start, end }),
       declarationInfo,
       names: declarationInfo.names
     };
@@ -30,6 +53,17 @@ export function classifyStatement(text, start, end) {
   return undefined;
 }
 
+function parseDirectiveInfo(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(/^(['"])(use\s+(?:strict|client|server))\1\s*;?$/);
+  if (!match) return undefined;
+  return { kind: 'runtime-directive', value: match[2], quote: match[1] };
+}
+
+function directiveLedgerKey(directiveInfo) {
+  return ['directive', directiveInfo.kind, directiveInfo.value].join(':');
+}
+
 function parseImportInfo(text) {
   const trimmed = text.trim();
   const sideEffect = trimmed.match(/^import\s+(['"])([^'"]+)\1\s*;?$/s);
@@ -271,6 +305,16 @@ function importLedgerKey(importInfo) {
   ].join(':');
 }
 
+function topLevelStatementOwnershipAnchor(input) {
+  const identityAnchor = input.kind === 'directive' && input.directiveInfo?.kind === 'runtime-directive' ? 'runtime-directive-prologue' : input.key;
+  return {
+    schema: 'frontier.lang.jsTsTopLevelStatementOwnershipAnchor.v1', version: 1, mode: 'top-level-ledger-entry',
+    key: ['js-ts-top-level', input.kind, identityAnchor].join('#'), identityAnchor, statementKind: input.kind,
+    start: input.start, end: input.end, textHash: input.textHash, losslessCst: false,
+    parserEvidence: 'frontier-js-ts-narrow-top-level-ledger', reasonCodes: ['top-level-ledger-statement-boundary', 'lossless-cst-unavailable']
+  };
+}
+
 export function importSpecifierCanonical(specifier) {
   return `${specifier.typeOnly ? 'type ' : ''}${specifier.importedName}${specifier.localName === specifier.importedName ? '' : ` as ${specifier.localName}`}`;
 }

package/dist/js-ts-safe-merge-parse-statements.js

@@ -3,6 +3,10 @@ export function skipTopLevelTrivia(sourceText, offset) {
   while (index < sourceText.length) {
     const char = sourceText[index];
     const next = sourceText[index + 1];
+    if (char === '#' && next === '!' && isHashbangAtFileStart(sourceText, index)) {
+      index = consumeLineComment(sourceText, index + 2);
+      continue;
+    }
     if (/\s/.test(char)) {
       index += 1;
       continue;
@@ -22,6 +26,10 @@ export function skipTopLevelTrivia(sourceText, offset) {
   return { offset: index };
 }
 
+function isHashbangAtFileStart(sourceText, offset) {
+  return offset === 0 || (offset === 1 && sourceText.charCodeAt(0) === 0xfeff);
+}
+
 function consumeLineComment(sourceText, offset) {
   const lineEnd = sourceText.indexOf('\n', offset);
   return lineEnd === -1 ? sourceText.length : lineEnd + 1;

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

@@ -1,3 +1,4 @@
+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';
@@ -150,6 +151,9 @@ function createSemanticEditFallbackArtifacts(input, topLevelResult, stagedFallba
         projection,
         currentSourceText: replayCurrentSourceText,
         currentSourcePath: sourcePath,
+        currentSourceHash: typeof replayCurrentSourceText === 'string' ? hashSemanticValue(replayCurrentSourceText) : undefined,
+        expectedOutputSourceText: projection.sourceText,
+        expectedOutputHash: projection.projectedHash,
         language,
         parser: input.parser,
         metadata: stagedFallback?.metadata
@@ -224,11 +228,15 @@ function semanticEditFallbackBlockedResult(input, topLevelResult, artifacts) {
 }
 
 function shouldDeferTopLevelRenamePublicContract(input, admission) {
-  return input.deferTopLevelRenamePublicExportContractToProjectGraph === true
-    && admission.reasonCodes?.length === 1
-    && admission.reasonCodes.includes('top-level-rename-public-export-contract')
-    && admission.summary?.exported !== true
-    && workerPreservesRenamedExportAlias(input.workerSourceText, admission.summary);
+  if (input.deferTopLevelRenamePublicExportContractToProjectGraph !== true
+    || admission.reasonCodes?.length !== 1
+    || !admission.reasonCodes.includes('top-level-rename-public-export-contract')) {
+    return false;
+  }
+  if (admission.summary?.exported === true) {
+    return input.deferDirectExportRenamePublicContractToProjectSymbolRename === true;
+  }
+  return workerPreservesRenamedExportAlias(input.workerSourceText, admission.summary);
 }
 
 function deferredTopLevelRenameAdmission(admission) {

package/dist/js-ts-safe-merge-source-shape-fallbacks.js

@@ -1,11 +1,13 @@
 import { createEnumMemberSemanticFallbackResult } from './js-ts-safe-merge-enum-member-fallback.js';
 import { createJsxAttributeSemanticFallbackResult } from './js-ts-safe-merge-jsx-attribute-fallback.js';
+import { createJsxChildExpressionSemanticFallbackResult } from './js-ts-safe-merge-jsx-child-expression-fallback.js';
 import { createVariableDeclaratorSemanticFallbackResult } from './js-ts-safe-merge-variable-declarator-fallback.js';
 
 function createSourceShapeSemanticFallbackResult(input, topLevelResult, stagedFallback) {
   return createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, stagedFallback)
     ?? createEnumMemberSemanticFallbackResult(input, topLevelResult, stagedFallback)
-    ?? createJsxAttributeSemanticFallbackResult(input, topLevelResult, stagedFallback);
+    ?? createJsxAttributeSemanticFallbackResult(input, topLevelResult, stagedFallback)
+    ?? createJsxChildExpressionSemanticFallbackResult(input, topLevelResult, stagedFallback);
 }
 
 export { createSourceShapeSemanticFallbackResult };

package/dist/js-ts-safe-merge-top-level-rename-fallback.js

@@ -1,6 +1,7 @@
 import { JsTsSafeMergeConflictCodes } from './js-ts-safe-merge-constants.js';
 import { createMergeContext, sameStatementText } from './js-ts-safe-merge-context.js';
 import { scanJsTsTopLevelLedger, validateLedgerUniqueness } from './js-ts-safe-merge-ledger.js';
+import { analyzeTopLevelRenameUseDefEvidence, LexicalUseDefReasonCodes } from './js-ts-semantic-scope-use-def.js';
 import { uniqueStrings } from './native-import-utils.js';
 
 const supportedRenameDeclarationKinds = new Set(['function', 'class', 'type']);
@@ -29,19 +30,42 @@ function analyzeTopLevelRenameAdmission(input, topLevelResult) {
   if (!candidate) return undefined;
 
   const publicContractReasonCodes = publicContractRenameReasonCodes(base, worker, head, candidate);
+  const lexicalUseDefEvidence = analyzeTopLevelRenameUseDefEvidence({
+    sourcePath: input.sourcePath,
+    baseSourceText: input.baseSourceText,
+    workerSourceText: input.workerSourceText,
+    headSourceText: input.headSourceText,
+    ...candidate
+  });
   if (publicContractReasonCodes.length) {
     return {
       status: 'blocked',
       reasonCodes: publicContractReasonCodes,
-      summary: candidateSummary(candidate, publicContractReasonCodes),
+      summary: candidateSummary(candidate, publicContractReasonCodes, lexicalUseDefEvidence),
       ledgers: { base, worker, head }
     };
   }
 
+  const lexicalBlockerReasonCodes = lexicalUseDefEvidence.reasonCodes
+    .filter((code) => code !== LexicalUseDefReasonCodes.noLiveReferences);
+  if (lexicalBlockerReasonCodes.length) {
+    const reasonCodes = uniqueStrings([...publicContractReasonCodes, ...lexicalBlockerReasonCodes]);
+    return {
+      status: 'blocked',
+      reasonCodes,
+      summary: candidateSummary(candidate, reasonCodes, lexicalUseDefEvidence),
+      ledgers: { base, worker, head }
+    };
+  }
+
+  const candidateReasonCodes = [
+    'top-level-rename-source-shape-matches',
+    LexicalUseDefReasonCodes.noLiveReferences
+  ];
   return {
     status: 'candidate',
-    reasonCodes: ['top-level-rename-source-shape-matches'],
-    summary: candidateSummary(candidate, ['top-level-rename-source-shape-matches']),
+    reasonCodes: candidateReasonCodes,
+    summary: candidateSummary(candidate, candidateReasonCodes, lexicalUseDefEvidence),
     ledgers: { base, worker, head }
   };
 }
@@ -79,6 +103,7 @@ function topLevelRenameCandidate(base, worker, head) {
   return {
     fromEntry,
     toEntry,
+    headEntry: entriesByKey(head.entries).get(fromEntry.key),
     fromName,
     toName,
     declarationKind: fromEntry.declarationInfo.declarationKind
@@ -124,13 +149,14 @@ function renameDeclarationText(text, declarationKind, fromName, toName) {
   return undefined;
 }
 
-function candidateSummary(candidate, reasonCodes) {
+function candidateSummary(candidate, reasonCodes, lexicalUseDefEvidence) {
   return {
     fromName: candidate.fromName,
     toName: candidate.toName,
     declarationKind: candidate.declarationKind,
     exported: candidate.fromEntry.declarationInfo?.exported === true || candidate.toEntry.declarationInfo?.exported === true,
-    reasonCodes: uniqueStrings(reasonCodes)
+    reasonCodes: uniqueStrings(reasonCodes),
+    lexicalUseDefEvidence
   };
 }
 

package/dist/js-ts-safe-merge-top-level-rename-result.js

@@ -6,10 +6,15 @@ function topLevelRenameBlockedResult(input, topLevelResult, topLevelRenameAdmiss
     ...(topLevelResult.admission?.reasonCodes ?? []),
     ...(topLevelRenameAdmission.reasonCodes ?? [])
   ]);
+  const primaryReasonCode = topLevelRenameAdmission.reasonCodes?.[0] ?? JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract;
+  const publicContractBlock = topLevelRenameAdmission.reasonCodes
+    ?.includes(JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract);
   const conflict = {
-    code: JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract,
+    code: publicContractBlock ? JsTsSafeMergeConflictCodes.topLevelRenamePublicExportContract : primaryReasonCode,
     gateId: JsTsSafeMergeGateIds.stableExistingDeclarations,
-    message: 'Top-level rename changes a public export contract without project-level evidence.',
+    message: publicContractBlock
+      ? 'Top-level rename changes a public export contract without project-level evidence.'
+      : 'Top-level rename requires lexical use-def evidence before automatic merge.',
     side: 'worker',
     sourcePath: input.sourcePath ?? topLevelResult.sourcePath,
     details: {