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

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

@@ -0,0 +1,314 @@
+const EnvironmentPackageConditions = Object.freeze([
+  'browser',
+  'node',
+  'development',
+  'production',
+  'worker',
+  'workerd',
+  'deno',
+  'bun',
+  'react-native'
+]);
+
+function exportTargetsForValue(value, conditions, condition) {
+  if (!value) return [];
+  if (typeof value === 'string') return [{ path: value, condition }];
+  if (Array.isArray(value)) return value.flatMap((entry) => exportTargetsForValue(entry, conditions, condition));
+  if (!isRecord(value)) return [];
+  return conditions.flatMap((key) => exportTargetsForValue(value[key], conditions, key));
+}
+
+function exportMapMatch(exportsValue, subpath) {
+  if (!isRecord(exportsValue) || !Object.keys(exportsValue).some((key) => key.startsWith('.'))) return subpath === '.' ? { key: '.', value: exportsValue } : undefined;
+  if (Object.prototype.hasOwnProperty.call(exportsValue, subpath)) return { key: subpath, value: exportsValue[subpath] };
+  for (const [pattern, target] of Object.entries(exportsValue)) {
+    const capture = patternCapture(subpath, pattern);
+    if (capture !== undefined) return { key: pattern, value: replaceTargetCapture(target, capture) };
+  }
+  return undefined;
+}
+
+function packageConditions(moduleResolution = {}, sourcePath, packageContext, edgeMetadata) {
+  return prioritizeConditions(
+    moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'],
+    packageConditionPreferences(sourcePath, moduleResolution, packageContext, edgeMetadata)
+  );
+}
+
+function packageRuntimeConditionAmbiguity(value, moduleResolution, sourcePath, packageContext, edgeMetadata) {
+  if (packageRuntimeConditionEvidence(moduleResolution, sourcePath, packageContext, edgeMetadata).packageRuntimeCondition) return undefined;
+  const conditions = new Set(packageConditions(moduleResolution, sourcePath, packageContext, edgeMetadata));
+  if (!conditions.has('import') || !conditions.has('require')) return undefined;
+  const runtimeTargets = packageRuntimeTargetsForValue(value, conditions);
+  if (!runtimeTargets.import.size || !runtimeTargets.require.size) return undefined;
+  return sameSet(runtimeTargets.import, runtimeTargets.require) ? undefined : 'import|require';
+}
+
+function packageEnvironmentConditionAmbiguity(value, moduleResolution, sourcePath, packageContext, edgeMetadata) {
+  if (packageEnvironmentConditionEvidence(moduleResolution, edgeMetadata).packageEnvironmentCondition) return undefined;
+  const conditions = new Set(packageConditions(moduleResolution, sourcePath, packageContext, edgeMetadata));
+  const environmentTargets = packageEnvironmentTargetsForValue(value, conditions);
+  const present = Object.entries(environmentTargets).filter(([, targets]) => targets.size);
+  if (present.length < 2) return undefined;
+  const first = present[0][1];
+  return present.every(([, targets]) => sameSet(first, targets))
+    ? undefined
+    : present.map(([condition]) => condition).join('|');
+}
+
+function packageRuntimeConditionEvidence(moduleResolution = {}, sourcePath, packageContext, edgeMetadata) {
+  const edgeCondition = packageRuntimeConditionFromEdge(edgeMetadata);
+  const extensionCondition = packageRuntimeConditionFromExtension(sourcePath);
+  const packageType = packageTypeForSource(moduleResolution, sourcePath, packageContext);
+  const packageTypeCondition = packageType === 'module' ? 'import' : packageType === 'commonjs' ? 'require' : undefined;
+  if (edgeCondition) {
+    const conflict = edgeCondition.conflictsWithSource && (
+      extensionCondition && extensionCondition !== edgeCondition.packageRuntimeCondition ||
+      packageTypeCondition && packageTypeCondition !== edgeCondition.packageRuntimeCondition
+    );
+    if (conflict) return compactRecord({
+      packageRuntimeConditionEvidenceSource: 'conflict',
+      packageRuntimeConditionEdgeKind: edgeCondition.packageRuntimeConditionEdgeKind,
+      packageRuntimeConditionCandidates: uniqueStrings([edgeCondition.packageRuntimeCondition, extensionCondition, packageTypeCondition]),
+      packageRuntimeConditionReasonCode: 'package-runtime-condition-conflict-missing',
+      packageRuntimeConditionConflict: true,
+      packageType
+    });
+    if (edgeCondition.preferred || !extensionCondition && !packageTypeCondition) return compactRecord({ ...edgeCondition, packageType });
+  }
+  const hostAmbiguity = edgeCondition ? undefined : packageRuntimeHostConditionAmbiguity(edgeMetadata, packageType);
+  if (hostAmbiguity) return hostAmbiguity;
+  if (extensionCondition) return { packageRuntimeCondition: extensionCondition, packageRuntimeConditionEvidenceSource: 'source-extension', packageType };
+  if (packageTypeCondition) return { packageRuntimeCondition: packageTypeCondition, packageRuntimeConditionEvidenceSource: 'package-type', packageType };
+  return {};
+}
+
+function packageEnvironmentConditionEvidence(moduleResolution = {}, edgeMetadata = {}) {
+  const condition = stringValue(
+    edgeMetadata.packageEnvironmentCondition ??
+    moduleResolution.packageEnvironmentCondition ??
+    moduleResolution.environmentCondition
+  );
+  return condition ? {
+    packageEnvironmentCondition: condition,
+    packageEnvironmentConditionEvidenceSource: edgeMetadata.packageEnvironmentCondition ? 'edge-metadata' : 'module-resolution'
+  } : {};
+}
+
+function packageRuntimeTargetsForValue(value, conditions) {
+  const result = { import: new Set(), require: new Set() };
+  collectPackageRuntimeTargets(value, conditions, result);
+  return result;
+}
+
+function packageEnvironmentTargetsForValue(value, conditions) {
+  const result = Object.fromEntries(EnvironmentPackageConditions.map((condition) => [condition, new Set()]));
+  collectPackageEnvironmentTargets(value, conditions, result);
+  return result;
+}
+
+function collectPackageRuntimeTargets(value, conditions, result) {
+  if (Array.isArray(value)) {
+    for (const entry of value) collectPackageRuntimeTargets(entry, conditions, result);
+    return;
+  }
+  if (!isRecord(value)) return;
+  for (const [condition, target] of Object.entries(value)) {
+    if (!conditions.has(condition)) continue;
+    if (condition === 'import' || condition === 'require') {
+      for (const entry of exportTargetsForValue(target, [...conditions], condition)) result[condition].add(entry.path);
+    } else {
+      collectPackageRuntimeTargets(target, conditions, result);
+    }
+  }
+}
+
+function collectPackageEnvironmentTargets(value, conditions, result) {
+  if (Array.isArray(value)) {
+    for (const entry of value) collectPackageEnvironmentTargets(entry, conditions, result);
+    return;
+  }
+  if (!isRecord(value)) return;
+  for (const [condition, target] of Object.entries(value)) {
+    if (!conditions.has(condition)) continue;
+    if (result[condition]) {
+      for (const entry of exportTargetsForValue(target, [...conditions], condition)) result[condition].add(entry.path);
+    } else {
+      collectPackageEnvironmentTargets(target, conditions, result);
+    }
+  }
+}
+
+function packageConditionPreferences(sourcePath, moduleResolution, packageContext, edgeMetadata) {
+  const environmentCondition = packageEnvironmentConditionEvidence(moduleResolution, edgeMetadata).packageEnvironmentCondition;
+  const runtimeCondition = packageRuntimeConditionEvidence(
+    moduleResolution,
+    sourcePath,
+    packageContext,
+    edgeMetadata
+  ).packageRuntimeCondition;
+  const runtimePreferences = runtimeCondition === 'require'
+    ? ['require', 'node', 'default']
+    : runtimeCondition === 'import'
+      ? ['import', 'module', 'default']
+      : [];
+  return uniqueStrings([environmentCondition, ...runtimePreferences]);
+}
+
+function packageRuntimeConditionFromEdge(edgeMetadata = {}) {
+  const hostKind = edgeMetadata.hostDependencyKind;
+  if (edgeMetadata.importKind === 'import-meta-resolve' || !edgeMetadata.importKind && hostKind === 'import-meta-resolve') return edgeCondition('import', 'host-import-resolve', 'package-runtime-condition-edge-host-resolve-evidence', true, false);
+  if (edgeMetadata.importKind === 'require-resolve' || !edgeMetadata.importKind && hostKind === 'require-resolve') return edgeCondition('require', 'host-require-resolve', 'package-runtime-condition-edge-host-resolve-evidence', true, true);
+  if (edgeMetadata.importKind === 'commonjs-require' || !edgeMetadata.importKind && edgeMetadata.commonJs) return edgeCondition('require', 'commonjs-require', 'package-runtime-condition-edge-require-evidence', true, true);
+  if (edgeMetadata.commonJs && commonJsHelperImportKind(edgeMetadata.importKind)) return edgeCondition('require', commonJsHelperEdgeKind(edgeMetadata), 'package-runtime-condition-edge-require-evidence', true, true);
+  if (edgeMetadata.importKind === 'dynamic-import' || !edgeMetadata.importKind && edgeMetadata.dynamicImport) return edgeCondition('import', 'dynamic-import', 'package-runtime-condition-edge-dynamic-import-evidence', true, false);
+  if (staticImportKind(edgeMetadata.importKind)) return edgeCondition('import', `static-${edgeMetadata.importKind}`, 'package-runtime-condition-edge-import-evidence', false, false);
+  return undefined;
+}
+
+function packageRuntimeHostConditionAmbiguity(edgeMetadata = {}, packageType) {
+  const hostKind = edgeMetadata.hostDependencyKind;
+  if (!hostKind) return undefined;
+  return compactRecord({
+    packageRuntimeConditionEvidenceSource: 'host-runtime-ambiguous',
+    packageRuntimeConditionEdgeKind: `host-${hostKind}`,
+    packageRuntimeConditionReasonCode: 'package-runtime-condition-host-ambiguous-missing',
+    packageType
+  });
+}
+
+function edgeCondition(packageRuntimeCondition, packageRuntimeConditionEdgeKind, packageRuntimeConditionReasonCode, preferred, conflictsWithSource) {
+  return {
+    packageRuntimeCondition,
+    packageRuntimeConditionEvidenceSource: 'edge-kind',
+    packageRuntimeConditionEdgeKind,
+    packageRuntimeConditionReasonCode,
+    preferred,
+    conflictsWithSource
+  };
+}
+
+function staticImportKind(importKind) {
+  return importKind === 'module' ||
+    importKind === 'side-effect' ||
+    importKind === 'reexport' ||
+    importKind === 'namespace-reexport' ||
+    importKind === 'default' ||
+    importKind === 'namespace' ||
+    importKind === 'named' ||
+    importKind === 'type-named' ||
+    importKind === 'type-default' ||
+    importKind === 'type-reexport';
+}
+
+function commonJsHelperImportKind(importKind) {
+  return importKind === 'default' ||
+    importKind === 'namespace' ||
+    importKind === 'reexport' ||
+    importKind === 'namespace-reexport';
+}
+
+function commonJsHelperEdgeKind(edgeMetadata) {
+  const helper = typeof edgeMetadata.interopHelper === 'string'
+    ? edgeMetadata.interopHelper.replace(/^__/, '')
+    : edgeMetadata.importKind;
+  return `commonjs-helper-${helper}`;
+}
+
+function packageRuntimeConditionFromExtension(sourcePath) {
+  const path = String(sourcePath ?? '');
+  if (/\.(?:cjs|cts)$/.test(path)) return 'require';
+  if (/\.(?:mjs|mts)$/.test(path)) return 'import';
+  return undefined;
+}
+
+function packageTypeForSource(moduleResolution = {}, sourcePath, packageContext) {
+  return normalizePackageType(
+    packageContext?.packageType ?? packageContext?.type ??
+    packageTypeByRoot(moduleResolution.packageTypeByRoot, sourcePath) ??
+    packageTypeByRoot(moduleResolution.packageTypes, sourcePath) ??
+    moduleResolution.packageType ?? moduleResolution.type
+  );
+}
+
+function packageTypeByRoot(typeMap, sourcePath) {
+  if (!isRecord(typeMap)) return undefined;
+  const normalizedSource = normalizeProjectPath(sourcePath);
+  return Object.entries(typeMap)
+    .map(([root, value]) => ({ root: normalizeProjectPath(root), value }))
+    .filter((entry) => pathInsideRoot(normalizedSource, entry.root))
+    .sort((left, right) => right.root.length - left.root.length)[0]?.value;
+}
+
+function normalizePackageType(value) {
+  const type = typeof value === 'string' ? value : value?.type ?? value?.packageType;
+  return type === 'module' || type === 'commonjs' ? type : undefined;
+}
+
+function sameSet(left, right) {
+  if (left.size !== right.size) return false;
+  for (const value of left) if (!right.has(value)) return false;
+  return true;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value))];
+}
+
+function stringValue(value) {
+  return typeof value === 'string' && value.length ? value : undefined;
+}
+
+function prioritizeConditions(conditions, preferred) {
+  const entries = Array.isArray(conditions) ? conditions : [conditions];
+  const normalized = entries.map((entry) => String(entry)).filter(Boolean);
+  if (!preferred.length) return normalized;
+  const preferredSet = new Set(preferred);
+  return [
+    ...preferred.filter((condition) => normalized.includes(condition)),
+    ...normalized.filter((condition) => !preferredSet.has(condition))
+  ];
+}
+
+function isRecord(value) { return value && typeof value === 'object' && !Array.isArray(value); }
+
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+function replaceTargetCapture(target, capture) {
+  if (typeof target === 'string') return target.replace('*', capture);
+  if (Array.isArray(target)) return target.map((entry) => replaceTargetCapture(entry, capture));
+  if (!isRecord(target)) return target;
+  return Object.fromEntries(Object.entries(target).map(([key, value]) => [key, replaceTargetCapture(value, capture)]));
+}
+
+function normalizeProjectPath(path) {
+  const parts = [];
+  for (const part of String(path ?? '').split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') parts.pop(); else parts.push(part);
+  }
+  return parts.join('/');
+}
+
+function patternCapture(value, pattern) {
+  if (pattern === value) return '';
+  if (!String(pattern).includes('*')) return undefined;
+  const [prefix, suffix = ''] = String(pattern).split('*');
+  if (!String(value).startsWith(prefix) || !String(value).endsWith(suffix)) return undefined;
+  return String(value).slice(prefix.length, String(value).length - suffix.length);
+}
+
+function pathInsideRoot(sourcePath, root) {
+  if (!root) return true;
+  return sourcePath === root || sourcePath.startsWith(`${root}/`);
+}
+
+export {
+  exportMapMatch,
+  exportTargetsForValue,
+  packageConditions,
+  packageEnvironmentConditionAmbiguity,
+  packageEnvironmentConditionEvidence,
+  packageRuntimeConditionAmbiguity,
+  packageRuntimeConditionEvidence
+};

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

@@ -0,0 +1,43 @@
+function resolveReExportIdentityImportTargets(importEdges = [], reExportIdentities = []) {
+  const identityMatches = reExportIdentityTargetIndex(reExportIdentities);
+  const edgeById = new Map(importEdges.map((edge) => [edge.id, edge]));
+  return importEdges.map((edge) => {
+    if (edge?.resolvedTargetSymbolId || !edge?.targetDocumentId || !projectImportTargetName(edge)) return edge;
+    const matches = identityMatches.get(`${edge.targetDocumentId}\0${projectImportTargetName(edge)}`) ?? [];
+    if (matches.length !== 1 || !matches[0].originSymbolId) return edge;
+    return resolvedReExportImportEdge(edge, matches[0], edgeById.get(matches[0].relationId));
+  });
+}
+
+function reExportIdentityTargetIndex(reExportIdentities = []) {
+  const result = new Map();
+  for (const identity of reExportIdentities) {
+    if (!identity?.sourceDocumentId || !identity.exportedName) continue;
+    const key = `${identity.sourceDocumentId}\0${identity.exportedName}`;
+    result.set(key, [...(result.get(key) ?? []), identity]);
+  }
+  return result;
+}
+
+function resolvedReExportImportEdge(edge, identity, relationEdge) {
+  return {
+    ...edge,
+    resolvedTargetSymbolId: identity.originSymbolId,
+    reExportResolved: true,
+    reExportResolutionKind: identity.isExportStar ? 'export-star' : 're-export-identity',
+    reExportIdentityId: identity.id,
+    reExportRelationId: identity.relationId,
+    reExportSourcePath: identity.sourcePath,
+    reExportModuleSpecifier: identity.moduleSpecifier,
+    reExportTargetSourcePath: relationEdge?.resolvedModulePath,
+    reExportTargetDocumentId: relationEdge?.targetDocumentId
+  };
+}
+
+function projectImportTargetName(edge) {
+  if (edge?.importKind === 'side-effect' || edge?.importKind === 'namespace' || edge?.importKind === 'module') return undefined;
+  const name = edge?.importedName ?? edge?.localName ?? edge?.exportedName;
+  return name && name !== '*' ? String(name) : undefined;
+}
+
+export { resolveReExportIdentityImportTargets };

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

@@ -15,7 +15,9 @@ export function reExportIdentityRecord(identity, edge, resolveDocumentExportSymb
 }
 
 export function isReExportImportEdge(edge) {
-  return edge.importKind === 'reexport' || edge.importKind === 'namespace-reexport' || edge.exportStar === true;
+  if (edge.exportStar === true) return true;
+  if (edge.importKind !== 'reexport' && edge.importKind !== 'namespace-reexport') return false;
+  return Boolean(edge.importedName || edge.exportedName || edge.namespace || edge.localName);
 }
 
 export function reExportIdentityInputFromEdge(edge, id) {
@@ -25,6 +27,11 @@ export function reExportIdentityInputFromEdge(edge, id) {
     sourcePath: edge.sourcePath,
     sourceHash: edge.sourceHash,
     moduleSpecifier: edge.moduleSpecifier,
+    hasImportAttributes: edge.hasImportAttributes,
+    importAttributeCount: edge.importAttributeCount,
+    importAttributeKeys: edge.importAttributeKeys,
+    importAttributeHash: edge.importAttributeHash,
+    importAttributes: edge.importAttributes,
     symbolId: edge.targetSymbolId,
     relationId: edge.id,
     publicContract: edge.publicContract
@@ -41,6 +48,11 @@ export function exportStarReExportIdentityRecords(edge, targetExports) {
       sourcePath: edge.sourcePath,
       sourceHash: edge.sourceHash,
       moduleSpecifier: edge.moduleSpecifier,
+      hasImportAttributes: edge.hasImportAttributes,
+      importAttributeCount: edge.importAttributeCount,
+      importAttributeKeys: edge.importAttributeKeys,
+      importAttributeHash: edge.importAttributeHash,
+      importAttributes: edge.importAttributes,
       symbolId: edge.targetSymbolId,
       relationId: edge.id,
       importedName: symbol.name,
@@ -53,6 +65,48 @@ export function exportStarReExportIdentityRecords(edge, targetExports) {
     }));
 }
 
+export function commonJsAliasReExportIdentityRecords(importEdges, exportEdges, resolveDocumentExportSymbolId) {
+  const requireAliases = new Map();
+  for (const edge of importEdges ?? []) {
+    if (edge.importKind !== 'commonjs-require' || !edge.localName || !edge.targetDocumentId || !edge.moduleSpecifier) continue;
+    requireAliases.set(commonJsAliasKey(edge.sourceDocumentId, edge.localName), edge);
+  }
+  return (exportEdges ?? []).flatMap((edge) => {
+    if (!edge.exportedName || edge.moduleSpecifier) return [];
+    const member = commonJsAliasMember(edge.localName);
+    const importEdge = member ? requireAliases.get(commonJsAliasKey(edge.sourceDocumentId, member.alias)) : undefined;
+    if (!importEdge) return [];
+    return [compactRecord({
+      id: `reexport_commonjs_alias_${idFragment(edge.id)}_${idFragment(importEdge.id)}_${idFragment(member.importedName)}`,
+      sourceDocumentId: edge.sourceDocumentId,
+      sourcePath: edge.sourcePath,
+      sourceHash: edge.sourceHash,
+      moduleSpecifier: importEdge.moduleSpecifier,
+      symbolId: edge.targetSymbolId,
+      relationId: edge.id,
+      importRelationId: importEdge.id,
+      importedName: member.importedName,
+      exportedName: edge.exportedName,
+      localName: edge.localName,
+      originSymbolId: resolveDocumentExportSymbolId(importEdge.targetDocumentId, member.importedName),
+      exportedSymbolId: resolveDocumentExportSymbolId(edge.sourceDocumentId, edge.exportedName) ?? edge.targetSymbolId,
+      localSymbolId: edge.targetSymbolId,
+      commonJs: true,
+      reExport: true,
+      publicContract: edge.publicContract
+    })];
+  });
+}
+
+function commonJsAliasMember(localName) {
+  const match = String(localName ?? '').match(/^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/);
+  return match ? { alias: match[1], importedName: match[2] } : undefined;
+}
+
+function commonJsAliasKey(sourceDocumentId, alias) {
+  return `${sourceDocumentId ?? ''}\u0000${alias}`;
+}
+
 function idFragment(value) {
   return String(value ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 80) || 'id';
 }

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

@@ -0,0 +1,108 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { semanticEffectRegionRecordsForImport } from '../../semantic-import-effect-regions.js';
+import { importMetaHostContextEvidence } from '../../semantic-import-runtime-import-meta-evidence.js';
+import { resourceManagementRuntimeRegionRecordsForImport } from '../../semantic-import-runtime-resource-management-evidence.js';
+import { classStaticBlockRuntimeRecordsForImport } from './projectSymbolGraphClassStaticBlocks.js';
+
+function createProjectRuntimeRegionRecords(semanticIndex, imports, publicContractRegions) {
+  const publicKeys = publicRuntimeSymbolKeys(publicContractRegions);
+  return uniqueRecords(imports.flatMap((imported) => runtimeRegionsForImport(imported, publicKeys)));
+}
+
+function runtimeRegionsForImport(imported, publicKeys) {
+  const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+  const symbolsById = new Map((semanticIndex?.symbols ?? []).map((symbol) => [symbol.id, symbol]));
+  const publicNames = new Set((semanticIndex?.symbols ?? []).filter((symbol) => symbol?.kind === 'export').map((symbol) => symbol.name));
+  const sourceText = nativeImportSourceText(imported);
+  const semanticRuntimeRecords = semanticEffectRegionRecordsForImport(imported, semanticIndex).ownershipRegions.map((region) => {
+    const subject = symbolsById.get(region.metadata?.subjectId);
+    const expressionText = sourceTextForSpan(sourceText, region.sourceSpan);
+    const runtimeOrderEvidence = importMetaHostContextEvidence(expressionText, region.metadata?.runtimeOrderEvidence);
+    const signatureHash = hashSemanticValue({
+      kind: 'frontier.lang.projectRuntimeRegionSignature',
+      regionKind: region.regionKind,
+      factKinds: region.metadata?.factKinds,
+      spanKind: region.metadata?.spanKind,
+      runtimeOrderEvidence,
+      expressionText
+    });
+    const runtimeRecordId = `runtime_region_${idFragment(region.id)}_${idFragment(hashSemanticValue({
+      kind: 'frontier.lang.projectRuntimeRegionRecordId',
+      key: region.key,
+      regionKind: region.regionKind,
+      runtimeKinds: region.metadata?.factKinds,
+      line: region.metadata?.factLine,
+      ordinal: region.metadata?.occurrenceOrdinal
+    }))}`;
+    return compactRecord({
+      id: runtimeRecordId,
+      key: region.key,
+      regionKind: region.regionKind,
+      runtimeKind: region.metadata?.factKinds?.[0] ?? region.regionKind,
+      runtimeKinds: region.metadata?.factKinds,
+      sourcePath: region.sourcePath,
+      sourceHash: region.sourceHash,
+      sourceSpan: region.sourceSpan,
+      precision: region.precision,
+      spanKind: region.metadata?.spanKind,
+      symbolId: region.metadata?.subjectId,
+      symbolName: subject?.name ?? region.metadata?.subjectName,
+      symbolKind: subject?.kind,
+      line: region.metadata?.factLine,
+      ordinal: region.metadata?.occurrenceOrdinal,
+      runtimeOrderEvidence,
+      signatureHash,
+      publicContract: publicKeys.has(runtimePublicKey(region.sourcePath, subject?.name ?? region.metadata?.subjectName))
+        || publicNames.has(subject?.name) || undefined,
+      factIds: region.metadata?.factIds,
+      evidenceIds: uniqueStrings((region.metadata?.factIds ?? []).map((id) => `fact:${id}`))
+    });
+  });
+  return [
+    ...semanticRuntimeRecords,
+    ...resourceManagementRuntimeRegionRecordsForImport(imported, semanticIndex, publicKeys),
+    ...classStaticBlockRuntimeRecordsForImport(imported, semanticIndex, publicKeys)
+  ];
+}
+
+function publicRuntimeSymbolKeys(regions = []) {
+  return new Set(regions.flatMap((region) => [
+    runtimePublicKey(region.sourcePath, region.symbolName),
+    runtimePublicKey(region.sourcePath, region.exportedName)
+  ]).filter(Boolean));
+}
+
+function runtimePublicKey(sourcePath, symbolName) {
+  return sourcePath && symbolName ? `${sourcePath}\0${symbolName}` : undefined;
+}
+
+function nativeImportSourceText(imported) {
+  return imported?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.sourceText;
+}
+
+function sourceTextForSpan(sourceText, span) {
+  if (!sourceText || !span?.startLine || !span?.endLine) return undefined;
+  const lines = String(sourceText).split(/\r\n|\n|\r/).slice(span.startLine - 1, span.endLine);
+  if (!lines.length) return undefined;
+  lines[0] = lines[0].slice(Math.max(0, (span.startColumn ?? 1) - 1));
+  lines[lines.length - 1] = lines[lines.length - 1].slice(0, Math.max(0, (span.endColumn ?? 1) - 1));
+  return lines.join('\n');
+}
+
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export { createProjectRuntimeRegionRecords };