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

package/dist/internal/index-impl/typeScriptSourceFilePreservation.js

@@ -0,0 +1,296 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import {
+  createParserSpanCoverageProof,
+  createPreservedSourceOwnershipAnchor,
+  preservedOwnershipAnchorKind,
+  preservedSourceSegmentRole
+} from '../../native-source-preservation-ownership.js';
+import { createNativeSourcePreservation } from './createNativeSourcePreservation.js';
+
+const PARSER_EVIDENCE = 'typescript-compiler-api-source-file-scanner';
+
+export function createTypeScriptSourceFilePreservation(sourceFile, input, options = {}) {
+  const ts = options.ts;
+  const sourceText = sourceFileText(sourceFile, input);
+  if (!sourceText || !ts || typeof ts.createScanner !== 'function') return undefined;
+  const sourceHash = hashSemanticValue(sourceText);
+  const tokensAndTrivia = scanTypeScriptSourceFileTokens(sourceFile, input, { ...options, sourceHash, sourceText });
+  if (!tokensAndTrivia) return undefined;
+  return createNativeSourcePreservation({
+    language: input.language ?? options.language ?? 'typescript',
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    sourceText,
+    tokensAndTrivia,
+    includeTokens: options.includeTokens !== false,
+    includeTrivia: options.includeTrivia !== false,
+    parserSpanCoverageProof: tokensAndTrivia.parserSpanCoverageProof,
+    parserTriviaEvidence: tokensAndTrivia.parserTriviaEvidence,
+    metadata: {
+      parserTokenTriviaEvidence: PARSER_EVIDENCE,
+      parserTokenTriviaSource: 'typescript-source-file',
+      parserSpanCoverageProof: tokensAndTrivia.parserSpanCoverageProof,
+      ...(options.sourcePreservationMetadata ?? {})
+    }
+  });
+}
+
+function scanTypeScriptSourceFileTokens(sourceFile, input, options) {
+  const ts = options.ts;
+  const sourceText = options.sourceText;
+  const scanner = ts.createScanner(
+    options.scriptTarget ?? ts.ScriptTarget?.Latest ?? ts.ScriptTarget?.ESNext ?? 99,
+    false,
+    languageVariant(ts, input, options),
+    sourceText,
+    undefined,
+    0,
+    sourceText.length
+  );
+  const lineStarts = sourceLineStarts(sourceFile, sourceText);
+  const tokens = [];
+  const trivia = [];
+  const maxTokens = Number.isFinite(options.maxTokens) ? Math.max(0, options.maxTokens) : 20000;
+  const maxTrivia = Number.isFinite(options.maxTrivia) ? Math.max(0, options.maxTrivia) : 20000;
+  let truncated = false;
+  for (let kind = scanner.scan(); !isEndOfFile(ts, kind); kind = scanner.scan()) {
+    const start = scanner.getTokenPos();
+    const end = scanner.getTextPos();
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) continue;
+    const text = sourceText.slice(start, end);
+    const mappedKind = sourceSegmentKind(ts, kind, text, input, options);
+    const target = preservedSourceSegmentRole(mappedKind) === 'trivia' ? trivia : tokens;
+    const max = target === tokens ? maxTokens : maxTrivia;
+    if (target.length >= max) {
+      truncated = true;
+      continue;
+    }
+    target.push(preservedParserSegment({
+      index: target.length,
+      kind: mappedKind,
+      text,
+      start,
+      end,
+      lineStarts,
+      sourceHash: options.sourceHash,
+      sourcePath: input.sourcePath,
+      syntaxKind: syntaxKindName(ts, kind)
+    }));
+  }
+  const parserSpanCoverageProof = createParserSpanCoverageProof({
+    sourceText,
+    sourcePath: input.sourcePath,
+    sourceHash: options.sourceHash,
+    segments: [...tokens, ...trivia],
+    tokenCount: tokens.length,
+    triviaCount: trivia.length,
+    commentCount: trivia.filter((entry) => isCommentKind(entry.kind)).length,
+    parserEvidence: PARSER_EVIDENCE,
+    adapterId: input.adapterId ?? options.adapterId ?? 'frontier.typescript-compiler-native-importer',
+    evidenceId: `${input.adapterId ?? options.adapterId ?? 'frontier.typescript-compiler-native-importer'}:parser-span-coverage:${idFragment(input.sourcePath ?? options.sourceHash)}`,
+    languageMode: sourceLanguageMode(ts, input, options),
+    boundedLanguages: ['javascript', 'typescript', 'jsx', 'tsx'],
+    truncated
+  });
+  const parserTriviaEvidence = parserTriviaEvidenceForSpanCoverage(parserSpanCoverageProof, {
+    sourceHash: options.sourceHash,
+    sourcePath: input.sourcePath,
+    adapterId: input.adapterId ?? options.adapterId ?? 'frontier.typescript-compiler-native-importer',
+    truncated
+  });
+  return {
+    tokens: tokens.map((entry) => withParserTriviaEvidence(entry, parserTriviaEvidence)),
+    trivia: trivia.map((entry) => withParserTriviaEvidence(entry, parserTriviaEvidence)),
+    truncated,
+    parserEvidence: PARSER_EVIDENCE,
+    parserSpanCoverageProof,
+    parserTriviaEvidence
+  };
+}
+
+function preservedParserSegment(input) {
+  const role = preservedSourceSegmentRole(input.kind);
+  const textHash = hashSemanticValue(input.text);
+  const span = {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    ...sourceSpanPositions(input.start, input.end, input.lineStarts)
+  };
+  return {
+    id: `${input.kind}_${input.index + 1}_${idFragment(input.start)}`,
+    kind: input.kind,
+    text: input.text,
+    textHash,
+    span,
+    ownershipAnchor: createPreservedSourceOwnershipAnchor({
+      kind: input.kind,
+      role,
+      text: input.text,
+      textHash,
+      sourcePath: input.sourcePath,
+      sourceHash: input.sourceHash,
+      span,
+      anchorKind: preservedOwnershipAnchorKind(input.kind, role),
+      parserEvidence: PARSER_EVIDENCE,
+      parserTriviaEvidence: {
+        status: 'exact',
+        exactParserTrivia: true,
+        losslessCst: true,
+        sourceHash: input.sourceHash,
+        parserEvidence: PARSER_EVIDENCE,
+        adapterId: 'typescript-compiler-api'
+      }
+    }),
+    metadata: { syntaxKind: input.syntaxKind, parserEvidence: PARSER_EVIDENCE }
+  };
+}
+
+function withParserTriviaEvidence(record, parserTriviaEvidence) {
+  const role = preservedSourceSegmentRole(record.kind);
+  return {
+    ...record,
+    ownershipAnchor: createPreservedSourceOwnershipAnchor({
+      kind: record.kind,
+      role,
+      text: record.text,
+      textHash: record.textHash,
+      sourcePath: record.span.path,
+      sourceHash: record.span.sourceId,
+      span: record.span,
+      anchorKind: preservedOwnershipAnchorKind(record.kind, role),
+      parserEvidence: PARSER_EVIDENCE,
+      parserTriviaEvidence
+    }),
+    metadata: {
+      ...record.metadata,
+      parserSpanCoverageStatus: parserTriviaEvidence.parserSpanCoverageProof?.status
+    }
+  };
+}
+
+function sourceSpanPositions(start, end, lineStarts) {
+  const startLine = lineForOffset(lineStarts, start);
+  const endLine = lineForOffset(lineStarts, end);
+  return {
+    start,
+    end,
+    startLine: startLine + 1,
+    startColumn: start - lineStarts[startLine] + 1,
+    endLine: endLine + 1,
+    endColumn: end - lineStarts[endLine] + 1
+  };
+}
+
+function sourceLineStarts(sourceFile, sourceText) {
+  const starts = typeof sourceFile.getLineStarts === 'function' ? [...sourceFile.getLineStarts()] : [0];
+  if (starts.length > 1 || sourceText.length === 0) return starts;
+  for (let index = 0; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    if (char === '\r' || char === '\n') {
+      if (char === '\r' && sourceText[index + 1] === '\n') index += 1;
+      starts.push(index + 1);
+    }
+  }
+  return starts;
+}
+
+function lineForOffset(lineStarts, offset) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    if (lineStarts[mid] <= offset && (mid === lineStarts.length - 1 || lineStarts[mid + 1] > offset)) return mid;
+    if (lineStarts[mid] > offset) high = mid - 1;
+    else low = mid + 1;
+  }
+  return 0;
+}
+
+function sourceSegmentKind(ts, kind, text, input, options) {
+  const name = syntaxKindName(ts, kind);
+  if (text === '\r' || text === '\n' || text === '\r\n') return 'newline';
+  if (/^[ \t\v\f]+$/.test(text)) return 'whitespace';
+  if (String(text).startsWith('//') || String(text).startsWith('/*')) return preservedCommentKind(text);
+  if (/^[0-9]/.test(text)) return 'number';
+  if (String(text).startsWith('`')) return 'template';
+  if (String(text).startsWith('"') || String(text).startsWith("'")) return 'string';
+  if (isJsxSource(ts, input, options) && (text === '<' || text === '</' || text === '/>')) return 'jsx';
+  if (name === 'WhitespaceTrivia') return 'whitespace';
+  if (name === 'NewLineTrivia') return 'newline';
+  if (name === 'ShebangTrivia') return 'shebang';
+  if (name === 'SingleLineCommentTrivia' || name === 'MultiLineCommentTrivia') return preservedCommentKind(text);
+  if (name === 'Identifier' || name === 'PrivateIdentifier') return 'identifier';
+  if (name.endsWith('Keyword')) return 'keyword';
+  if (name.includes('StringLiteral')) return 'string';
+  if (name.includes('Template')) return 'template';
+  if (name === 'NumericLiteral' || name === 'BigIntLiteral') return 'number';
+  if (name === 'RegularExpressionLiteral') return 'regex-like';
+  if (name.includes('Jsx')) return 'jsx';
+  if (/^[()[\]{};,]$/.test(text)) return 'punctuation';
+  if (/^[=+\-*/%&|^!<>?:.]+$/.test(text)) return 'operator';
+  return 'unknown';
+}
+
+function sourceFileText(sourceFile, input) {
+  return typeof sourceFile?.getFullText === 'function'
+    ? sourceFile.getFullText()
+    : typeof sourceFile?.text === 'string' ? sourceFile.text : input.sourceText;
+}
+
+function languageVariant(ts, input, options) {
+  return isJsxSource(ts, input, options) ? ts.LanguageVariant?.JSX ?? 1 : ts.LanguageVariant?.Standard ?? 0;
+}
+
+function parserTriviaEvidenceForSpanCoverage(parserSpanCoverageProof, input) {
+  const exact = parserSpanCoverageProof?.status === 'exact';
+  const blockReasonCodes = exact ? [] : [
+    'exact-parser-trivia-span-coverage-blocked',
+    ...(parserSpanCoverageProof?.blockReasonCodes ?? []),
+    input.truncated ? 'source-preservation-truncated' : undefined
+  ].filter(Boolean);
+  return {
+    status: exact ? 'exact' : 'blocked',
+    exactParserTrivia: exact,
+    losslessCst: exact,
+    sourceHash: input.sourceHash,
+    adapterId: input.adapterId,
+    evidenceId: `${input.adapterId}:parser-trivia:${idFragment(input.sourcePath ?? input.sourceHash)}`,
+    parserEvidence: PARSER_EVIDENCE,
+    parserSpanCoverageProof,
+    ...(exact ? {} : { blockReasonCodes })
+  };
+}
+
+function sourceLanguageMode(ts, input, options) {
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  if (sourcePath.endsWith('.tsx') || options.scriptKind === ts.ScriptKind?.TSX) return 'tsx';
+  if (sourcePath.endsWith('.jsx') || options.scriptKind === ts.ScriptKind?.JSX) return 'jsx';
+  if (sourcePath.endsWith('.js') || sourcePath.endsWith('.mjs') || sourcePath.endsWith('.cjs') || options.scriptKind === ts.ScriptKind?.JS) return 'javascript';
+  return 'typescript';
+}
+
+function isJsxSource(ts, input, options) {
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  return sourcePath.endsWith('.tsx') || sourcePath.endsWith('.jsx') || options.scriptKind === ts.ScriptKind?.TSX || options.scriptKind === ts.ScriptKind?.JSX;
+}
+
+function isEndOfFile(ts, kind) {
+  return kind === ts.SyntaxKind?.EndOfFileToken || syntaxKindName(ts, kind) === 'EndOfFileToken';
+}
+
+function syntaxKindName(ts, kind) {
+  return ts?.SyntaxKind?.[kind] ?? String(kind);
+}
+
+function preservedCommentKind(text) {
+  const value = String(text ?? '');
+  if (/[#@]\s*sourceMappingURL=|[#@]\s*sourceURL=/.test(value)) return 'source-map-comment';
+  if (value.startsWith('/**') && value[3] !== '/') return 'jsdoc-comment';
+  if (value.startsWith('/*')) return 'block-comment';
+  return 'comment';
+}
+
+function isCommentKind(kind) {
+  return kind === 'comment' || kind === 'jsdoc-comment' || kind === 'block-comment' || kind === 'source-map-comment';
+}

package/dist/js-ts-safe-member-class-invariants.js

@@ -0,0 +1,247 @@
+import { normalizeKind, uniqueStrings } from './js-ts-semantic-merge-parse.js';
+
+export function classBodyInvariantReasons(region, side, body) {
+  const reasonCodes = [];
+  for (const segment of splitClassElementSegments(body)) {
+    const text = segment.text.trim();
+    if (!text) continue;
+    if (hasClassDecorator(text)) reasonCodes.push(regionReason(region, `decorator-member:${side}`));
+    if (hasStaticBlock(text)) reasonCodes.push(regionReason(region, `static-block-ordering:${side}`));
+  }
+  return uniqueStrings(reasonCodes);
+}
+
+export function classPrivateScopeReasons(region, side, baseMembers, sideMembers, sideAddedKeys) {
+  const reasonCodes = [];
+  const basePrivateNames = privateDeclarationNames(baseMembers);
+  const sidePrivateNames = privateDeclarationNames(sideMembers);
+  for (const name of duplicatePrivateDeclarationNames(sideMembers)) {
+    reasonCodes.push(regionReason(region, `private-name-scope:${side}:${name}`));
+  }
+  for (const key of sideAddedKeys) {
+    const member = sideMembers.find((candidate) => candidate.key === key);
+    if (!member) continue;
+    const declaredName = privateNameFromKey(member.key);
+    if (declaredName && basePrivateNames.has(declaredName)) {
+      reasonCodes.push(regionReason(region, `private-name-scope:${side}:${declaredName}`));
+    }
+    for (const name of privateReferences(member)) {
+      if (!basePrivateNames.has(name) && !sidePrivateNames.has(name)) {
+        reasonCodes.push(regionReason(region, `private-name-scope:${side}:${name}`));
+      }
+    }
+  }
+  return uniqueStrings(reasonCodes);
+}
+
+export function classPrivateAddedCollisionReasons(region, workerAddedKeys, headAddedKeys, workerByKey, headByKey) {
+  const workerNames = privateNamesForKeys(workerAddedKeys, workerByKey);
+  const headNames = privateNamesForKeys(headAddedKeys, headByKey);
+  return [...workerNames].filter((name) => headNames.has(name))
+    .map((name) => regionReason(region, `private-name-scope:worker-head:${name}`));
+}
+
+export function isAccessorMember(member) {
+  return member?.memberKind === 'accessor';
+}
+
+export function isPrivateMemberKey(key) {
+  return Boolean(privateNameFromKey(key));
+}
+
+export function privateNameFromKey(key) {
+  const normalized = String(key ?? '').replace(/^static\./, '');
+  return normalized.startsWith('#') ? normalized : undefined;
+}
+
+function regionReason(region, reason) {
+  return `${reason}:${normalizeKind(region.kind)}:${region.name}`;
+}
+
+function privateNamesForKeys(keys, byKey) {
+  const names = new Set();
+  for (const key of keys) {
+    const name = privateNameFromKey(byKey.get(key)?.key);
+    if (name) names.add(name);
+  }
+  return names;
+}
+
+function privateDeclarationNames(members) {
+  const names = new Set();
+  for (const member of members) {
+    const name = privateNameFromKey(member.key);
+    if (name) names.add(name);
+  }
+  return names;
+}
+
+function duplicatePrivateDeclarationNames(members) {
+  const namesByPrivateName = new Map();
+  for (const member of members) {
+    const name = privateNameFromKey(member.key);
+    if (!name) continue;
+    const keys = namesByPrivateName.get(name) ?? new Set();
+    keys.add(member.key);
+    namesByPrivateName.set(name, keys);
+  }
+  return [...namesByPrivateName]
+    .filter(([, keys]) => keys.size > 1)
+    .map(([name]) => name);
+}
+
+function privateReferences(member) {
+  const declarations = new Set();
+  const declaredName = privateNameFromKey(member?.key);
+  if (declaredName) declarations.add(declaredName);
+  return privateNameTokens(member?.text).filter((name) => !declarations.has(name));
+}
+
+function privateNameTokens(text) {
+  const names = [];
+  const source = String(text ?? '');
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[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 === '#' && /[A-Za-z_$]/.test(next ?? '')) {
+      let end = index + 2;
+      while (/[\w$]/.test(source[end] ?? '')) end += 1;
+      names.push(source.slice(index, end));
+      index = end - 1;
+    }
+  }
+  return uniqueStrings(names);
+}
+
+function hasClassDecorator(text) {
+  return String(text ?? '').trimStart().startsWith('@');
+}
+
+function hasStaticBlock(text) {
+  return /^static\s*\{/.test(String(text ?? '').trimStart());
+}
+
+function splitClassElementSegments(body) {
+  const entries = [];
+  const text = String(body ?? '');
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[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 === '{' || char === '[' || char === '(') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}' || char === ']' || char === ')') {
+      depth -= 1;
+      if (depth === 0 && char === '}') {
+        const nextIndex = nextSignificantIndex(text, index + 1);
+        if (text[nextIndex] !== ';') {
+          entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+          start = index + 1;
+        }
+      }
+      continue;
+    }
+    if (char === ';' && depth === 0) {
+      entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+      start = index + 1;
+    }
+  }
+  entries.push({ text: text.slice(start), start, end: text.length });
+  return entries.filter((entry) => entry.text.trim());
+}
+
+function nextSignificantIndex(text, offset) {
+  let index = offset;
+  while (index < text.length) {
+    if (/\s/.test(text[index])) {
+      index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '/') {
+      index += 2;
+      while (index < text.length && text[index] !== '\n' && text[index] !== '\r') index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '*') {
+      index += 2;
+      while (index < text.length && !(text[index] === '*' && text[index + 1] === '/')) index += 1;
+      index += 2;
+      continue;
+    }
+    break;
+  }
+  return index;
+}

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

@@ -91,6 +91,10 @@ function memberConflictForReason(reason, input, index) {
 
 function blockedReasonCode(reason) {
   if (reason.includes('computed-key')) return 'computed-key';
+  if (reason.includes('decorator-member')) return 'decorator-member';
+  if (reason.includes('static-block-ordering')) return 'static-block-ordering';
+  if (reason.includes('accessor-pairing')) return 'accessor-pairing';
+  if (reason.includes('private-name-scope')) return 'private-name-scope';
   if (reason.includes('spread-like-member') || reason.includes('spread-member')) return 'spread-like-member';
   if (reason.includes('overload-collision')) return 'overload-collision';
   if (reason.includes('type-alias-conflict')) return 'type-alias-conflict';
@@ -109,6 +113,9 @@ function blockedReasonCode(reason) {
 
 function conflictCodeForReason(reasonCode) {
   if (reasonCode === 'computed-key') return JsTsSafeMergeConflictCodes.computedKey;
+  if (reasonCode === 'decorator-member') return JsTsSafeMergeConflictCodes.unsupportedDecorator;
+  if (reasonCode === 'static-block-ordering') return JsTsSafeMergeConflictCodes.topLevelOrderChanged;
+  if (reasonCode === 'accessor-pairing' || reasonCode === 'private-name-scope') return JsTsSafeMergeConflictCodes.duplicateName;
   if (reasonCode === 'overload-collision') return JsTsSafeMergeConflictCodes.unsupportedOverload;
   if (reasonCode === 'type-alias-conflict') return JsTsSafeMergeConflictCodes.typeAliasConflict;
   if (reasonCode === 'duplicate-member-name') return JsTsSafeMergeConflictCodes.duplicateName;
@@ -122,11 +129,15 @@ function conflictCodeForReason(reasonCode) {
 }
 
 function gateIdForReason(reasonCode) {
-  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision') return JsTsSafeMergeGateIds.uniqueNames;
+  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision' || reasonCode === 'accessor-pairing' || reasonCode === 'private-name-scope') {
+    return JsTsSafeMergeGateIds.uniqueNames;
+  }
   if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member' || reasonCode === 'non-policy-source-change') {
     return JsTsSafeMergeGateIds.stableExistingDeclarations;
   }
-  if (reasonCode === 'existing-member-order-changed' || reasonCode === 'order-sensitive-region-kind') return JsTsSafeMergeGateIds.preserveBaseOrder;
+  if (reasonCode === 'existing-member-order-changed' || reasonCode === 'order-sensitive-region-kind' || reasonCode === 'static-block-ordering') {
+    return JsTsSafeMergeGateIds.preserveBaseOrder;
+  }
   return JsTsSafeMergeGateIds.parseLedger;
 }
 
@@ -137,13 +148,22 @@ function reasonDetails(reason, reasonCode) {
   if (['base', 'worker', 'head'].includes(parts[2])) details.side = parts[2];
   const kind = parts.find((part) => ['interface', 'type', 'class', 'object'].includes(part));
   if (kind) details.regionKind = kind;
-  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision') details.memberName = parts.at(-3) ?? parts.at(-1);
+  if (reasonCode === 'duplicate-member-name'
+    || reasonCode === 'overload-collision'
+    || reasonCode === 'accessor-pairing'
+    || reasonCode === 'private-name-scope') {
+    details.memberName = parts.at(-3) ?? parts.at(-1);
+  }
   if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member') details.memberName = parts.at(-3);
   return details;
 }
 
 function memberConflictMessage(reasonCode, details) {
   if (reasonCode === 'computed-key') return 'Computed member keys are not safe for automatic member merge.';
+  if (reasonCode === 'decorator-member') return 'Decorated class members are not safe for automatic unordered member merge.';
+  if (reasonCode === 'static-block-ordering') return 'Class static blocks make member order observable and block unordered member merge.';
+  if (reasonCode === 'accessor-pairing') return 'Getter/setter member pairs are not safe for automatic unordered member merge.';
+  if (reasonCode === 'private-name-scope') return 'Private class names must remain scoped to one class element declaration set.';
   if (reasonCode === 'spread-like-member') return 'Spread-like member syntax makes object member merge ambiguous.';
   if (reasonCode === 'overload-collision') return 'Member overloads or duplicate method signatures collide in an unordered member region.';
   if (reasonCode === 'changed-existing-member') return 'An existing member changed inside a safe member-addition region.';

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

@@ -9,6 +9,14 @@ import {
   removePreparedMemberAdditions,
   uniqueStrings
 } from './js-ts-semantic-merge-parse.js';
+import {
+  classBodyInvariantReasons,
+  classPrivateAddedCollisionReasons,
+  classPrivateScopeReasons,
+  isAccessorMember,
+  isPrivateMemberKey,
+  privateNameFromKey
+} from './js-ts-safe-member-class-invariants.js';
 import { mergeResult } from './js-ts-safe-member-merge-result.js';
 
 const NonSemanticRegionKinds = new Set(['property', 'type', 'config', 'content']);
@@ -155,6 +163,11 @@ function prepareRegion(input) {
   const baseMembers = parseMembers(base.value.body, kind);
   const workerMembers = parseMembers(worker.value.body, kind);
   const headMembers = parseMembers(head.value.body, kind);
+  if (kind === 'class') {
+    reasonCodes.push(...classBodyInvariantReasons(input.region, 'base', base.value.body));
+    reasonCodes.push(...classBodyInvariantReasons(input.region, 'worker', worker.value.body));
+    reasonCodes.push(...classBodyInvariantReasons(input.region, 'head', head.value.body));
+  }
   reasonCodes.push(...regionParseReasons(input.region, 'base', baseMembers));
   reasonCodes.push(...regionParseReasons(input.region, 'worker', workerMembers));
   reasonCodes.push(...regionParseReasons(input.region, 'head', headMembers));
@@ -170,6 +183,11 @@ function prepareRegion(input) {
   const workerAddedKeys = workerMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
   const headAddedKeys = headMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
   reasonCodes.push(...duplicateAddedReasons(input.region, workerAddedKeys, workerByKey, headByKey));
+  if (kind === 'class') {
+    reasonCodes.push(...classPrivateScopeReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerAddedKeys));
+    reasonCodes.push(...classPrivateScopeReasons(input.region, 'head', baseMembers.members, headMembers.members, headAddedKeys));
+    reasonCodes.push(...classPrivateAddedCollisionReasons(input.region, workerAddedKeys, headAddedKeys, workerByKey, headByKey));
+  }
   if (reasonCodes.length) return { ok: false, reasonCodes };
   return {
     ok: true,
@@ -209,7 +227,11 @@ function duplicateReasons(region, side, members) {
     }
   }
   return [...duplicateGroups].map(([key, group]) => {
-    const reason = group.some(isOverloadLikeMember) ? `overload-collision:${side}:${key}` : `duplicate-key:${side}:${key}`;
+    let reason;
+    if (group.some(isOverloadLikeMember)) reason = `overload-collision:${side}:${key}`;
+    else if (group.every(isAccessorMember)) reason = `accessor-pairing:${side}:${key}`;
+    else if (isPrivateMemberKey(key)) reason = `private-name-scope:${side}:${privateNameFromKey(key)}`;
+    else reason = `duplicate-key:${side}:${key}`;
     return regionReason(region, reason);
   });
 }
@@ -239,9 +261,11 @@ function duplicateAddedReasons(region, workerAddedKeys, workerByKey, headByKey)
   return duplicateAddedKeys.map((key) => {
     const workerMember = workerByKey.get(key);
     const headMember = headByKey.get(key);
-    const reason = isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)
-      ? `overload-collision:worker-head:${key}`
-      : `duplicate-added-key:${key}`;
+    let reason;
+    if (isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)) reason = `overload-collision:worker-head:${key}`;
+    else if (isAccessorMember(workerMember) || isAccessorMember(headMember)) reason = `accessor-pairing:worker-head:${key}`;
+    else if (isPrivateMemberKey(key)) reason = `private-name-scope:worker-head:${privateNameFromKey(key)}`;
+    else reason = `duplicate-added-key:${key}`;
     return regionReason(region, reason);
   });
 }