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

package/dist/js-ts-safe-project-merge-ts-options.js

@@ -0,0 +1,205 @@
+const trackedCompilerOptionKeys = [
+  'allowImportingTsExtensions',
+  'allowJs',
+  'baseUrl',
+  'checkJs',
+  'composite',
+  'declaration',
+  'declarationMap',
+  'emitDeclarationOnly',
+  'jsx',
+  'module',
+  'moduleResolution',
+  'noEmit',
+  'noLib',
+  'outDir',
+  'paths',
+  'rootDir',
+  'skipLibCheck',
+  'strict',
+  'strictNullChecks',
+  'target',
+  'verbatimModuleSyntax'
+];
+
+export function createCompilerOptionState(ts, input, options, projectRoot, normalizeDiagnostic) {
+  const defaultCompilerOptions = createDefaultCompilerOptions(ts);
+  const sources = compilerOptionSources(input, options);
+  const compilerOptions = { ...defaultCompilerOptions };
+  const diagnostics = [];
+  for (const source of sources) {
+    const normalized = normalizeCompilerOptionSource(ts, source.options, projectRoot, normalizeDiagnostic);
+    Object.assign(compilerOptions, normalized.options);
+    diagnostics.push(...normalized.diagnostics);
+  }
+  const projectReferences = normalizeProjectReferences(input, options);
+  const metadata = compilerInputMetadata(input, options, compilerOptions, sources, projectReferences);
+  return { compilerOptions, diagnostics, metadata, projectReferences };
+}
+
+export function describeJsTsProjectCompilerInputs(input = {}, options = {}, resolvedCompilerOptions, resolvedSources, resolvedProjectReferences) {
+  const sources = resolvedSources ?? compilerOptionSources(input, options);
+  const projectReferences = resolvedProjectReferences ?? normalizeProjectReferences(input, options);
+  const rawCompilerOptions = resolvedCompilerOptions ?? sources.reduce((merged, source) => Object.assign(merged, source.options), {});
+  return compactRecord({
+    compilerOptions: trackedCompilerOptions(rawCompilerOptions),
+    compilerOptionSources: sources.map((source) => compactRecord({
+      source: source.source,
+      compilerOptions: trackedCompilerOptions(source.options)
+    })),
+    projectReferences: projectReferences.map(projectReferenceMetadata),
+    projectReferenceCount: projectReferences.length || undefined,
+    tsconfigCompilerOptions: trackedCompilerOptions(tsconfigCompilerOptions(input.tsconfig)),
+    tsconfigReferences: normalizeProjectReferences({ projectReferences: input.tsconfig?.references }, {}).map(projectReferenceMetadata),
+    hasTypescriptCompilerApi: false,
+    hasOptionsOverride: isPlainObject(options.compilerOptions) || undefined
+  });
+}
+
+export function normalizeProjectReferences(input = {}, options = {}) {
+  const raw = input.projectReferences
+    ?? input.typescriptProjectReferences
+    ?? input.references
+    ?? input.tsconfigProjectReferences
+    ?? input.tsconfig?.references
+    ?? options.projectReferences;
+  const values = Array.isArray(raw) ? raw : [raw].filter(Boolean);
+  return values.map(normalizeProjectReference).filter((reference) => reference.path);
+}
+
+function createDefaultCompilerOptions(ts) {
+  return {
+    noEmit: true,
+    noLib: true,
+    allowJs: true,
+    checkJs: false,
+    skipLibCheck: true,
+    strict: false,
+    target: ts.ScriptTarget?.ESNext ?? ts.ScriptTarget?.Latest ?? 99,
+    module: ts.ModuleKind?.ESNext ?? 99,
+    moduleResolution: ts.ModuleResolutionKind?.Node10 ?? ts.ModuleResolutionKind?.NodeJs ?? 2,
+    jsx: ts.JsxEmit?.ReactJSX ?? ts.JsxEmit?.Preserve ?? 4
+  };
+}
+
+function compilerOptionSources(input, options = {}) {
+  return [
+    ['tsconfig.compilerOptions', tsconfigCompilerOptions(input.tsconfig)],
+    ['compilerOptions', input.compilerOptions],
+    ['typescriptCompilerOptions', input.typescriptCompilerOptions],
+    ['diagnostic.compilerOptions', options.compilerOptions]
+  ]
+    .filter(([, value]) => isPlainObject(value))
+    .map(([source, value]) => ({ source, options: { ...value } }));
+}
+
+function tsconfigCompilerOptions(tsconfig) {
+  if (!isPlainObject(tsconfig)) return undefined;
+  if (isPlainObject(tsconfig.compilerOptions)) return tsconfig.compilerOptions;
+  const entries = Object.entries(tsconfig).filter(([key]) => trackedCompilerOptionKeys.includes(key));
+  return entries.length ? Object.fromEntries(entries) : undefined;
+}
+
+function normalizeCompilerOptionSource(ts, value, projectRoot, normalizeDiagnostic) {
+  if (!isPlainObject(value)) return { options: {}, diagnostics: [] };
+  if (!ts.convertCompilerOptionsFromJson || !containsStringValue(value)) return { options: { ...value }, diagnostics: [] };
+  const { jsonOptions, passthroughOptions } = splitJsonCompilerOptions(value);
+  if (!Object.keys(jsonOptions).length) return { options: { ...value }, diagnostics: [] };
+  const converted = ts.convertCompilerOptionsFromJson(jsonOptions, projectRoot || '.');
+  return {
+    options: { ...passthroughOptions, ...(converted.options ?? {}) },
+    diagnostics: (converted.errors ?? []).map((diagnostic) => normalizeDiagnostic(ts, diagnostic, 'typescript-compiler-options'))
+  };
+}
+
+function splitJsonCompilerOptions(value) {
+  const jsonOptions = {};
+  const passthroughOptions = {};
+  for (const [key, optionValue] of Object.entries(value)) {
+    if (containsStringValue(optionValue)) jsonOptions[key] = optionValue;
+    else passthroughOptions[key] = optionValue;
+  }
+  return { jsonOptions, passthroughOptions };
+}
+
+function containsStringValue(value) {
+  if (typeof value === 'string') return true;
+  if (Array.isArray(value)) return value.some(containsStringValue);
+  if (isPlainObject(value)) return Object.values(value).some(containsStringValue);
+  return false;
+}
+
+function compilerInputMetadata(input, options, compilerOptions, sources, projectReferences) {
+  return compactRecord({
+    ...describeJsTsProjectCompilerInputs(input, options, compilerOptions, sources, projectReferences),
+    hasTypescriptCompilerApi: true,
+    hasOptionsOverride: isPlainObject(options.compilerOptions) || undefined
+  });
+}
+
+function trackedCompilerOptions(value) {
+  if (!isPlainObject(value)) return undefined;
+  const entries = trackedCompilerOptionKeys
+    .filter((key) => value[key] !== undefined)
+    .map((key) => [key, metadataValue(value[key])])
+    .filter(([, entry]) => entry !== undefined);
+  return entries.length ? Object.fromEntries(entries) : undefined;
+}
+
+function metadataValue(value, depth = 0) {
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  if (Array.isArray(value)) return depth > 3 ? undefined : value.map((entry) => metadataValue(entry, depth + 1)).filter((entry) => entry !== undefined);
+  if (isPlainObject(value)) {
+    if (depth > 3) return undefined;
+    const entries = Object.entries(value)
+      .map(([key, entry]) => [key, metadataValue(entry, depth + 1)])
+      .filter(([, entry]) => entry !== undefined);
+    return entries.length ? Object.fromEntries(entries) : undefined;
+  }
+  return String(value);
+}
+
+function normalizeProjectReference(value) {
+  if (typeof value === 'string') return { path: normalizePath(value) };
+  if (!isPlainObject(value)) return {};
+  return compactRecord({
+    path: normalizePath(value.path ?? value.originalPath ?? value.sourcePath ?? ''),
+    originalPath: value.originalPath === undefined ? undefined : normalizePath(value.originalPath),
+    prepend: value.prepend === true ? true : undefined,
+    circular: value.circular === true ? true : undefined
+  });
+}
+
+function projectReferenceMetadata(reference) {
+  return compactRecord({
+    path: reference.path,
+    originalPath: reference.originalPath,
+    prepend: reference.prepend === true ? true : undefined,
+    circular: reference.circular === true ? true : undefined
+  });
+}
+
+function normalizePath(value) {
+  const raw = String(value ?? '').replace(/\\/g, '/').replace(/\/+/g, '/');
+  const absolute = raw.startsWith('/');
+  const parts = [];
+  for (const part of raw.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') {
+      if (parts.length && parts[parts.length - 1] !== '..') parts.pop();
+      else if (!absolute) parts.push(part);
+      continue;
+    }
+    parts.push(part);
+  }
+  return `${absolute ? '/' : ''}${parts.join('/')}`;
+}
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined));
+}

package/dist/js-ts-safe-project-merge-ts-program.js

@@ -0,0 +1,268 @@
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+import {
+  createCompilerOptionState,
+  describeJsTsProjectCompilerInputs,
+  normalizeProjectReferences
+} from './js-ts-safe-project-merge-ts-options.js';
+
+function createJsTsVirtualTypeScriptProgram(input = {}, outputFiles = [], options = {}) {
+  const ts = input.typescript ?? input.ts ?? input.typescriptModule;
+  if (!ts?.createProgram || !ts?.createSourceFile) return undefined;
+  const sourceFiles = outputFiles.filter((file) => isJsTsSourcePath(file.sourcePath) && typeof file.sourceText === 'string');
+  const projectRoot = normalizePath(input.projectRoot ?? '');
+  const compilerState = createCompilerOptionState(ts, input, options, projectRoot, normalizeTypeScriptDiagnostic);
+  if (!sourceFiles.length) {
+    return {
+      ts,
+      sourceFiles,
+      sourceMap: new Map(),
+      rootNames: [],
+      program: undefined,
+      compilerOptions: compilerState.compilerOptions,
+      compilerOptionDiagnostics: compilerState.diagnostics,
+      compilerMetadata: compilerState.metadata,
+      projectReferences: compilerState.projectReferences
+    };
+  }
+  const sourceMap = new Map(sourceFiles.map((file) => [normalizePath(file.sourcePath), String(file.sourceText)]));
+  const rootNames = [...sourceMap.keys()];
+  const host = createVirtualCompilerHost(ts, compilerState.compilerOptions, sourceMap, projectRoot, options);
+  const program = createVirtualProgram(ts, rootNames, compilerState.compilerOptions, host, compilerState.projectReferences);
+  return {
+    ts,
+    sourceFiles,
+    sourceMap,
+    rootNames,
+    host,
+    program,
+    compilerOptions: compilerState.compilerOptions,
+    compilerOptionDiagnostics: compilerState.diagnostics,
+    compilerMetadata: compilerState.metadata,
+    projectReferences: compilerState.projectReferences
+  };
+}
+
+function createVirtualProgram(ts, rootNames, compilerOptions, host, projectReferences) {
+  if (!projectReferences.length) return ts.createProgram(rootNames, compilerOptions, host);
+  try {
+    return ts.createProgram({ rootNames, options: compilerOptions, host, projectReferences });
+  } catch {
+    return ts.createProgram(rootNames, compilerOptions, host, undefined, undefined, projectReferences);
+  }
+}
+
+function createVirtualCompilerHost(ts, compilerOptions, sourceMap, projectRoot, options = {}) {
+  const defaultHost = ts.createCompilerHost?.(compilerOptions, true);
+  return {
+    ...defaultHost,
+    getCurrentDirectory: () => projectRoot,
+    getCanonicalFileName: (fileName) => normalizePath(defaultHost?.getCanonicalFileName?.(fileName) ?? fileName),
+    useCaseSensitiveFileNames: () => true,
+    getNewLine: () => '\n',
+    fileExists(fileName) {
+      return Boolean(sourceMapMatch(sourceMap, fileName, projectRoot)) || defaultHost?.fileExists?.(fileName) === true;
+    },
+    readFile(fileName) {
+      const match = sourceMapMatch(sourceMap, fileName, projectRoot);
+      return match ? match.sourceText : defaultHost?.readFile?.(fileName);
+    },
+    getSourceFile(fileName, languageVersion) {
+      const match = sourceMapMatch(sourceMap, fileName, projectRoot);
+      if (match) {
+        return ts.createSourceFile(match.sourcePath, match.sourceText, languageVersion, true, scriptKindForPath(ts, match.sourcePath));
+      }
+      return defaultHost?.getSourceFile?.(fileName, languageVersion);
+    },
+    writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
+      if (options.writeFile) return options.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+      return defaultHost?.writeFile?.(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
+    },
+    resolveModuleNames(moduleNames, containingFile) {
+      return moduleNames.map((moduleName) => resolveVirtualModule(ts, sourceMap, moduleName, containingFile, projectRoot));
+    },
+    resolveModuleNameLiterals(moduleLiterals, containingFile) {
+      return moduleLiterals.map((moduleLiteral) => ({
+        resolvedModule: resolveVirtualModule(ts, sourceMap, moduleLiteral?.text ?? moduleLiteral, containingFile, projectRoot)
+      }));
+    }
+  };
+}
+
+function resolveVirtualModule(ts, sourceMap, moduleName, containingFile, projectRoot) {
+  const specifier = String(moduleName ?? '');
+  if (!specifier.startsWith('.') && !specifier.startsWith('/')) return undefined;
+  const baseDir = dirname(normalizePath(containingFile));
+  const target = normalizePath(specifier.startsWith('/') ? specifier.slice(1) : `${baseDir}/${specifier}`);
+  for (const candidate of moduleCandidates(target)) {
+    const match = sourceMapMatch(sourceMap, candidate, projectRoot);
+    if (!match) continue;
+    return {
+      resolvedFileName: match.sourcePath,
+      extension: extensionKind(ts, match.sourcePath),
+      isExternalLibraryImport: false
+    };
+  }
+  return undefined;
+}
+
+function moduleCandidates(target) {
+  const withoutExtension = target.replace(/\.(?:mjs|cjs|jsx?|tsx?)$/, '');
+  return uniqueStrings([
+    target,
+    `${target}.ts`,
+    `${target}.tsx`,
+    `${target}.js`,
+    `${target}.jsx`,
+    `${withoutExtension}.ts`,
+    `${withoutExtension}.tsx`,
+    `${withoutExtension}.js`,
+    `${withoutExtension}.jsx`,
+    `${target}/index.ts`,
+    `${target}/index.tsx`,
+    `${target}/index.js`,
+    `${target}/index.jsx`
+  ].map(normalizePath));
+}
+
+function normalizeSuppliedDiagnostics(value) {
+  const values = Array.isArray(value) ? value : [value].filter(Boolean);
+  return values.map((diagnostic, index) => compactRecord({
+    id: diagnostic.id ?? `diagnostic_${index + 1}`,
+    source: diagnostic.source ?? diagnostic.tool ?? 'supplied',
+    code: String(diagnostic.code ?? diagnostic.diagnosticCode ?? 'diagnostic'),
+    severity: normalizeSeverity(diagnostic.severity ?? diagnostic.category),
+    message: String(diagnostic.message ?? diagnostic.messageText ?? ''),
+    sourcePath: normalizeOptionalPath(diagnostic.sourcePath ?? diagnostic.fileName ?? diagnostic.file?.fileName),
+    start: numberOrUndefined(diagnostic.start),
+    end: numberOrUndefined(diagnostic.end),
+    line: numberOrUndefined(diagnostic.line),
+    column: numberOrUndefined(diagnostic.column)
+  }));
+}
+
+function normalizeTypeScriptDiagnostic(ts, diagnostic, source = 'typescript-compiler-api') {
+  const sourcePath = diagnostic.file?.fileName ? normalizePath(diagnostic.file.fileName) : undefined;
+  const lineInfo = diagnostic.file && Number.isFinite(diagnostic.start)
+    ? diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start)
+    : undefined;
+  return compactRecord({
+    id: `ts_${diagnostic.code}_${sourcePath ?? 'global'}_${diagnostic.start ?? 0}`,
+    source,
+    code: `TS${diagnostic.code}`,
+    severity: diagnostic.category === (ts.DiagnosticCategory?.Error ?? 1) ? 'error' : normalizeSeverity(diagnostic.category),
+    message: flattenDiagnosticMessage(ts, diagnostic.messageText),
+    sourcePath,
+    start: numberOrUndefined(diagnostic.start),
+    end: Number.isFinite(diagnostic.start) && Number.isFinite(diagnostic.length)
+      ? diagnostic.start + diagnostic.length
+      : undefined,
+    line: lineInfo ? lineInfo.line + 1 : undefined,
+    column: lineInfo ? lineInfo.character + 1 : undefined
+  });
+}
+
+function flattenDiagnosticMessage(ts, messageText) {
+  if (ts.flattenDiagnosticMessageText) return ts.flattenDiagnosticMessageText(messageText, '\n');
+  if (typeof messageText === 'string') return messageText;
+  return String(messageText?.messageText ?? messageText ?? '');
+}
+
+function normalizeSeverity(value) {
+  if (typeof value === 'string') {
+    const lowered = value.toLowerCase();
+    if (lowered.includes('error')) return 'error';
+    if (lowered.includes('warn')) return 'warning';
+    if (lowered.includes('suggest')) return 'suggestion';
+    if (lowered.includes('message')) return 'message';
+  }
+  if (value === 1) return 'error';
+  if (value === 0) return 'warning';
+  if (value === 2) return 'suggestion';
+  if (value === 3) return 'message';
+  return 'error';
+}
+
+function scriptKindForPath(ts, sourcePath) {
+  if (sourcePath.endsWith('.tsx')) return ts.ScriptKind?.TSX;
+  if (sourcePath.endsWith('.ts')) return ts.ScriptKind?.TS;
+  if (sourcePath.endsWith('.jsx')) return ts.ScriptKind?.JSX;
+  if (sourcePath.endsWith('.js')) return ts.ScriptKind?.JS;
+  return undefined;
+}
+
+function extensionKind(ts, sourcePath) {
+  if (sourcePath.endsWith('.tsx')) return ts.Extension?.Tsx ?? '.tsx';
+  if (sourcePath.endsWith('.ts')) return ts.Extension?.Ts ?? '.ts';
+  if (sourcePath.endsWith('.jsx')) return ts.Extension?.Jsx ?? '.jsx';
+  return ts.Extension?.Js ?? '.js';
+}
+
+function isJsTsSourcePath(sourcePath) {
+  return /\.(?:mjs|cjs|jsx?|tsx?)$/.test(String(sourcePath ?? ''));
+}
+
+function normalizePath(value) {
+  const raw = String(value ?? '').replace(/\\/g, '/').replace(/\/+/g, '/');
+  const absolute = raw.startsWith('/');
+  const parts = [];
+  for (const part of raw.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') {
+      if (parts.length && parts[parts.length - 1] !== '..') parts.pop();
+      else if (!absolute) parts.push(part);
+      continue;
+    }
+    parts.push(part);
+  }
+  return `${absolute ? '/' : ''}${parts.join('/')}`;
+}
+
+function sourceMapMatch(sourceMap, fileName, projectRoot = '') {
+  for (const candidate of sourcePathCandidates(fileName, projectRoot)) {
+    if (sourceMap.has(candidate)) return { sourcePath: candidate, sourceText: sourceMap.get(candidate) };
+  }
+  return undefined;
+}
+
+function sourcePathCandidates(fileName, projectRoot) {
+  const normalized = normalizePath(fileName);
+  const trimmed = normalized.replace(/^\/+/, '');
+  const candidates = [normalized, trimmed];
+  if (projectRoot) {
+    const root = normalizePath(projectRoot).replace(/\/+$/, '');
+    const trimmedRoot = root.replace(/^\/+/, '');
+    if (normalized.startsWith(`${root}/`)) candidates.push(normalized.slice(root.length + 1));
+    if (trimmed.startsWith(`${trimmedRoot}/`)) candidates.push(trimmed.slice(trimmedRoot.length + 1));
+    candidates.push(`${root}/${trimmed}`);
+  }
+  return uniqueStrings(candidates);
+}
+
+function normalizeOptionalPath(value) {
+  return value === undefined || value === null ? undefined : normalizePath(value);
+}
+
+function dirname(sourcePath) {
+  const normalized = normalizePath(sourcePath);
+  const index = normalized.lastIndexOf('/');
+  return index < 0 ? '' : normalized.slice(0, index);
+}
+
+function numberOrUndefined(value) {
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined));
+}
+
+export {
+  createJsTsVirtualTypeScriptProgram,
+  describeJsTsProjectCompilerInputs,
+  isJsTsSourcePath,
+  normalizePath,
+  normalizeProjectReferences,
+  normalizeSuppliedDiagnostics,
+  normalizeTypeScriptDiagnostic,
+  sourceMapMatch
+};

package/dist/js-ts-safe-project-merge-typed-property-rename-rebase-utils.js

@@ -0,0 +1,69 @@
+import { uniqueStrings } from './js-ts-safe-merge-context.js';
+
+function typedPropertyRenameRebaseEvidence(file, analysis) {
+  return {
+    id: `typed_property_rename_rebase_${safeId(file.sourcePath)}_${safeId(analysis.ownerName)}_${safeId(analysis.fromName)}_${safeId(analysis.toName)}`,
+    kind: 'js-ts-project-typed-property-rename-rebase',
+    status: 'passed',
+    level: 'diagnostics-required-project-rebase',
+    scope: 'source-file',
+    summary: `Rebased worker changes from ${analysis.ownerName}.${analysis.fromName} to ${analysis.ownerName}.${analysis.toName}; project output diagnostics must still pass.`,
+    metadata: {
+      sourcePath: file.sourcePath,
+      ownerName: analysis.ownerName,
+      ownerKind: analysis.ownerKind,
+      fromName: analysis.fromName,
+      toName: analysis.toName,
+      typeText: analysis.typeText,
+      workerAddedMembers: analysis.workerAddedMembers.map((member) => member.name),
+      workerAddedDeclarations: analysis.workerAddedDeclarations.map((entry) => entry.names?.[0]).filter(Boolean),
+      rebasedDeclarations: analysis.rebasedDeclarations,
+      requiresOutputDiagnostics: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+function unsafePropertyAccessReasons(text, fromName) {
+  const property = escapeRegExp(fromName);
+  const reasons = [];
+  if (new RegExp(`\\[\\s*['"]${property}['"]\\s*\\]`).test(text)) reasons.push('typed-property-rename-rebase-bracket-access-unsupported');
+  if (new RegExp(`\\{[^}]*\\b${property}\\b[^}]*\\}`).test(text) && /\b(const|let|var|function)\b/.test(text)) {
+    reasons.push('typed-property-rename-rebase-destructuring-unsupported');
+  }
+  return uniqueStrings(reasons);
+}
+
+function stalePropertyAccessReasons(text, fromName) {
+  const property = escapeRegExp(fromName);
+  return new RegExp(`(\\?\\.|\\.)${property}\\b|\\[\\s*['"]${property}['"]\\s*\\]`).test(text)
+    ? ['typed-property-rename-rebase-stale-property-access']
+    : [];
+}
+
+function renameTypesEqual(left, right) {
+  return Boolean(left && right)
+    && left.optional === right.optional
+    && normalizeTypeText(left.typeText) === normalizeTypeText(right.typeText);
+}
+
+function membersByName(members) { return new Map(members.map((member) => [member.name, member])); }
+function entriesByKey(entries) { return new Map(entries.map((entry) => [entry.key, entry])); }
+function normalizeTypeText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function rejected(reasonCode, reasonCodes = [reasonCode]) { return { ok: false, reasonCodes: uniqueStrings(reasonCodes) }; }
+function safeId(value) { return String(value ?? 'unknown').replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'unknown'; }
+function escapeRegExp(value) { return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+export {
+  entriesByKey,
+  escapeRegExp,
+  membersByName,
+  normalizeTypeText,
+  rejected,
+  renameTypesEqual,
+  safeId,
+  stalePropertyAccessReasons,
+  typedPropertyRenameRebaseEvidence,
+  unsafePropertyAccessReasons
+};