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

package/dist/declarations/source-preservation.d.ts

@@ -60,6 +60,8 @@ export type NativeSourceTokenKind =
   | 'operator'
   | 'punctuation'
   | 'comment'
+  | 'jsdoc-comment'
+  | 'block-comment'
   | 'source-map-comment'
   | 'whitespace'
   | 'newline'
@@ -145,6 +147,22 @@ export interface NativeSourceLedger {
   readonly summary: NativeSourceLedgerSummary;
 }
 
+export type ParserTriviaExactnessStatus = 'exact' | 'approximate' | 'blocked' | (string & {});
+export type ParserTriviaOwnershipStatus = 'exact' | 'blocked' | (string & {});
+export type ParserTriviaOwnershipRelation =
+  | 'directive-prologue'
+  | 'source-directive'
+  | 'leading-comment'
+  | 'trailing-comment'
+  | 'jsdoc-comment'
+  | 'block-comment'
+  | 'file-comment'
+  | 'generated-source-boundary'
+  | 'file-entrypoint-directive'
+  | (string & {});
+export interface ParserTriviaEvidenceInput { readonly [key: string]: unknown; readonly status?: ParserTriviaExactnessStatus; readonly exactParserTrivia?: boolean; readonly exact?: boolean; readonly losslessCst?: boolean; readonly sourceHash?: string; readonly sourceId?: string; readonly roundtripHash?: string; readonly evidenceSourceHash?: string; readonly parserEvidence?: string; readonly adapterId?: string; readonly parserAdapterId?: string; readonly parserId?: string; readonly adapter?: string; readonly evidenceId?: string; readonly id?: string; readonly blocked?: boolean; readonly reasonCodes?: readonly string[]; readonly blockReasonCodes?: readonly string[]; readonly metadata?: Record<string, unknown>; }
+export interface ParserTriviaExactnessRecord { readonly schema: 'frontier.lang.parserTriviaExactness.v1'; readonly version: 1; readonly status: ParserTriviaExactnessStatus; readonly exactParserTrivia: boolean; readonly losslessCst?: boolean; readonly sourcePath?: string; readonly sourceHash?: string; readonly evidenceSourceHash?: string; readonly sourceHashVerified?: boolean; readonly parserEvidence?: string; readonly adapterId?: string; readonly evidenceId?: string; readonly reasonCodes: readonly string[]; readonly blockReasonCodes: readonly string[]; readonly reviewRequired: boolean; readonly autoMergeClaim: false; readonly semanticEquivalenceClaim: false; }
+
 export interface NativeSourcePreservation {
   readonly kind: 'frontier.lang.nativeSourcePreservation';
   readonly version: 1;
@@ -174,8 +192,19 @@ export interface NativeSourcePreservation {
     readonly braces?: number;
     readonly exactSourceAvailable: boolean;
     readonly truncated: boolean;
+    readonly parserTriviaExactnessStatus?: string;
+    readonly exactParserTrivia?: boolean;
+    readonly parserTriviaExactnessReasonCodes?: readonly string[];
+    readonly parserTriviaExactnessBlockReasonCodes?: readonly string[];
   };
-  readonly metadata?: Record<string, unknown>;
+  readonly metadata?: Record<string, unknown> & { readonly parserTriviaExactness?: ParserTriviaExactnessRecord };
+}
+
+export interface NativeSourceTokenTriviaScan {
+  readonly tokens: readonly NativeSourcePreservedToken[];
+  readonly trivia: readonly NativeSourcePreservedToken[];
+  readonly truncated?: boolean;
+  readonly parserEvidence?: string;
 }
 
 export interface CreateNativeSourcePreservationOptions {
@@ -192,7 +221,9 @@ export interface CreateNativeSourcePreservationOptions {
   readonly includeSourceLedger?: boolean;
   readonly maxTokens?: number;
   readonly maxTrivia?: number;
+  readonly tokensAndTrivia?: NativeSourceTokenTriviaScan;
   readonly maxDirectives?: number;
   readonly maxLedgerSpans?: number;
+  readonly parserTriviaEvidence?: ParserTriviaEvidenceInput;
   readonly metadata?: Record<string, unknown>;
 }

package/dist/declarations/target-adapters.d.ts

@@ -81,11 +81,31 @@ export interface NativeTargetProjectionAdapterInput {
   readonly metadata: Record<string, unknown>;
 }
 
+export interface Ecma426SourceMapSection {
+  readonly offset: { readonly line: number; readonly column: number };
+  readonly map: Ecma426SourceMapPayload;
+}
+
+export interface Ecma426SourceMapPayload {
+  readonly version: 3;
+  readonly file?: string;
+  readonly sourceRoot?: string;
+  readonly sources?: readonly (string | null)[];
+  readonly sourcesContent?: readonly (string | null)[];
+  readonly names?: readonly string[];
+  readonly mappings?: string;
+  readonly ignoreList?: readonly number[];
+  readonly sections?: readonly Ecma426SourceMapSection[];
+  readonly [key: string]: unknown;
+}
+
+export type NativeSourceMapInput = SourceMapRecord | Ecma426SourceMapPayload | string;
+
 export interface NativeTargetProjectionAdapterResult {
   readonly id?: string;
   readonly output?: string;
   readonly outputHash?: string;
-  readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly sourceMaps?: readonly NativeSourceMapInput[];
   readonly losses?: readonly NativeAstLossRecord[];
   readonly evidence?: readonly EvidenceRecord[];
   readonly diagnostics?: readonly NativeImporterAdapterDiagnostic[];
@@ -128,7 +148,7 @@ export interface NativeTargetProjectionResult {
   readonly output: string;
   readonly outputHash: string;
   readonly outputMode: 'target-adapter';
-  readonly sourceMaps: readonly SourceMapRecord[];
+  readonly sourceMaps: readonly NativeSourceMapInput[];
   readonly losses: readonly NativeAstLossRecord[];
   readonly lossSummary: NativeImportLossSummary;
   readonly readiness: NativeImportReadinessClassification;

package/dist/index.d.ts

@@ -18,19 +18,28 @@ export * from './declarations/semantic-sidecar-admission.js';
 export * from './declarations/semantic-merge-candidates.js';
 export * from './declarations/semantic-merge-conflicts.js';
 export * from './declarations/semantic-edit-script.js';
+export * from './declarations/semantic-structural-diff.js';
 export * from './declarations/semantic-lineage.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-edit-bundle.js';
 export * from './declarations/semantic-patch-bundle-index.js';
 export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-patch-bundle-overlaps.js';
+export * from './declarations/semantic-patch-bundle-composition.js';
 export * from './declarations/semantic-transform-identity.js';
 export * from './declarations/bidirectional-target-change.js';
 export * from './declarations/bidirectional-target-change-source-edit.js';
 export * from './declarations/semantic-impact.js';
+export * from './declarations/semantic-graph-layers.js';
 export * from './declarations/semantic-sidecar.js';
 export * from './declarations/semantic-sidecar-example.js';
 export * from './declarations/js-ts-semantic-merge.js';
+export * from './declarations/js-ts-project-merge-declaration-emit-parity.js';
+export * from './declarations/js-ts-project-merge-declarations.js';
+export * from './declarations/js-ts-project-merge-diagnostics.js';
+export * from './declarations/js-ts-project-merge-tsconfig.js';
+export * from './declarations/js-ts-project-merge-jsx-render-branch.js';
+export * from './declarations/js-ts-project-merge-semantic-equivalence-proof.js';
 export * from './declarations/native-diff.js';
 export * from './declarations/semantic-slice.js';
 export * from './declarations/semantic-slice-admission.js';
@@ -41,6 +50,29 @@ export * from './declarations/import-adapter-options-platform.js';
 export * from './declarations/target-adapters.js';
 export * from './declarations/native-project-admission.js';
 export * from './declarations/native-project-module-resolution.js';
+export * from './declarations/native-project-source-evidence.js';
+export * from './declarations/native-project-jsx-graph.js';
+export * from './declarations/native-project-css-modules.js';
+export * from './declarations/native-project-compiler-callable-signatures.js';
+export * from './declarations/native-project-compiler-composite-types.js';
+export * from './declarations/native-project-compiler-index-signature.js';
+export * from './declarations/native-project-compiler-assignability-oracle.js';
+export * from './declarations/native-project-compiler-public-api-source-binding.js';
+export * from './declarations/native-project-compiler-type-reference-targets.js';
+export * from './declarations/native-project-compiler-enum-proof.js';
+export * from './declarations/native-project-compiler-class-member-runtime-proof.js';
+export * from './declarations/native-project-compiler-scope.js';
+export * from './declarations/native-project-scope-template-reference.js';
+export * from './declarations/native-project-decorator-metadata.js';
+export * from './declarations/native-project-runtime-effect-target.js';
+export * from './declarations/native-project-runtime-mutation-target.js';
+export * from './declarations/native-project-runtime-resource-management.js';
+export * from './declarations/native-project-runtime-reachability.js';
+export * from './declarations/native-project-runtime-promise-combinator.js';
+export * from './declarations/native-project-runtime-promise-chain.js';
+export * from './declarations/native-project-runtime-yield-delegation.js';
+export * from './declarations/native-project-runtime-executable-effect-evidence.js';
+export * from './declarations/native-project-module-declarations.js';
 export * from './declarations/native-project.js';
 export * from './declarations/roundtrip.js';
 export * from './declarations/runtime.js';

package/dist/index.js

@@ -15,6 +15,7 @@ export { createNativeImportCoverageMatrix } from './internal/index-impl/createNa
 export { createNativeImportResultContract } from './internal/index-impl/createNativeImportResultContract.js';
 export { createNativeParserAstFormatMatrix } from './internal/index-impl/createNativeParserAstFormatMatrix.js';
 export { createNativeParserFeatureMatrix } from './internal/index-impl/createNativeParserFeatureMatrix.js';
+export { createNativeProjectModuleResolutionFromPackageManifests } from './internal/index-impl/createNativeProjectModuleResolutionFromPackageManifests.js';
 export { createNativeRoundtripEvidence } from './internal/index-impl/createNativeRoundtripEvidence.js';
 export { createProjectImportAdmissionRecord } from './internal/index-impl/createProjectImportAdmissionRecord.js';
 export { createNativeSourcePreservation } from './internal/index-impl/createNativeSourcePreservation.js';
@@ -23,8 +24,12 @@ export { createProjectionTargetLossMatrix } from './internal/index-impl/createPr
 export { createPythonAstNativeImporterAdapter } from './internal/index-impl/createPythonAstNativeImporterAdapter.js';
 export { createRustSynNativeImporterAdapter } from './internal/index-impl/createRustSynNativeImporterAdapter.js';
 export { createSemanticImportSidecar } from './internal/index-impl/createSemanticImportSidecar.js';
+export { createSemanticGraphLayerSummary, SemanticGraphLayerKinds } from './semantic-import-graph-layers.js';
 export { compactSemanticSidecarExample } from './semantic-sidecar-example.js';
 export * from './js-ts-semantic-merge.js';
+export { createJsTsProjectMergeDeclarationEmitParityProof } from './js-ts-safe-project-merge-declaration-emit-parity.js';
+export { createJsTsProjectMergeDeclarationGate } from './js-ts-safe-project-merge-declarations.js';
+export { createJsTsProjectMergeDiagnosticsGate } from './js-ts-safe-project-merge-diagnostics.js';
 export { createSemanticSlice } from './internal/index-impl/createSemanticSlice.js';
 export { createSemanticSliceAdmissionRecord } from './internal/index-impl/createSemanticSliceAdmissionRecord.js';
 export { createSwiftSyntaxNativeImporterAdapter } from './internal/index-impl/createSwiftSyntaxNativeImporterAdapter.js';
@@ -72,6 +77,7 @@ export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProje
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
 export { createSemanticEditBundleAdmission, SemanticEditBundleAdmissionStatuses } from './internal/index-impl/semanticEditBundleAdmission.js';
 export { compareSemanticPatchBundleRecords, querySemanticPatchBundleOverlaps, SemanticPatchBundleOverlapKinds, SemanticPatchBundleOverlapStatuses } from './internal/index-impl/semanticPatchBundleOverlaps.js';
+export { composeSemanticPatchBundleProjections } from './internal/index-impl/semanticPatchBundleComposition.js';
 export { createSemanticTransformIdentityRecord, deriveSemanticTransformIdentityRecords, semanticTransformIdentityFields } from './internal/index-impl/semanticTransformIdentityRecords.js';
 export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandidateForAdmission, querySemanticMergeCandidateAdmissionOverlaps, SemanticMergeCandidateProjectionRisks, semanticMergeCandidateReadinessSortKey, sortSemanticMergeCandidateAdmissionRecords } from './internal/index-impl/semanticMergeCandidateRecords.js';
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';

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

@@ -1,5 +1,6 @@
-import{nativeLanguageCompileTarget}from'../../coverage-matrix-profiles.js';import{idFragment,uniqueByEvidenceId,uniqueByLossId}from'../../native-import-utils.js';
+import{nativeLanguageCompileTarget}from'../../coverage-matrix-profiles.js';import{idFragment,uniqueByEvidenceId,uniqueByLossId}from'../../native-import-utils.js';import{normalizeSourceMaps}from'../../native-source-maps.js';
 import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{createProjectionTargetLossMatrix}from'./createProjectionTargetLossMatrix.js';import{importNativeSource}from'./importNativeSource.js';import{isNativeSourceImportResult}from'./isNativeSourceImportResult.js';import{nativeCompileSourceLanguage}from'./nativeCompileSourceLanguage.js';import{nativeCompileTarget}from'./nativeCompileTarget.js';import{nativeProjectionReview}from'./nativeProjectionReview.js';import{nativeSourceCompileEvidence}from'./nativeSourceCompileEvidence.js';import{nativeSourceCompileSourceMaps}from'./nativeSourceCompileSourceMaps.js';import{nativeSourceCompileTargetCoverage}from'./nativeSourceCompileTargetCoverage.js';import{nativeSourceCompileTargetLosses}from'./nativeSourceCompileTargetLosses.js';import{projectNativeImportToSource}from'./projectNativeImportToSource.js';import{resolveNativeTargetProjectionAdapter}from'./resolveNativeTargetProjectionAdapter.js';import{runNativeTargetProjectionAdapter}from'./runNativeTargetProjectionAdapter.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+import{classifySourceMapGeneratedBoundary}from'./sourceMapGeneratedBoundaryGate.js';
 export function compileNativeSource(input, options = {}) {
   const importResult = isNativeSourceImportResult(input) ? input : importNativeSource(input);
   const sourceLanguage = nativeCompileSourceLanguage(importResult, input);
@@ -105,7 +106,7 @@ export function compileNativeSource(input, options = {}) {
     scanKind: 'native-source-compile',
     semanticStatus: importResult.metadata?.semanticStatus ?? options.semanticStatus
   });
-  const sourceMaps = options.emitSourceMap === false
+  const emittedSourceMaps = options.emitSourceMap === false
     ? []
     : nativeSourceCompileSourceMaps({
       id: options.sourceMapId ?? `source_map_${idFragment(id)}_${idFragment(target)}`,
@@ -123,8 +124,32 @@ export function compileNativeSource(input, options = {}) {
       losses,
       compileResultId: id
     });
+  const sourceMaps = normalizeSourceMaps(emittedSourceMaps, {
+    document: importResult.document,
+    nativeSources: [importResult.nativeSource].filter(Boolean),
+    nativeAst: importResult.nativeAst ?? importResult.nativeSource?.ast,
+    nativeSource: importResult.nativeSource,
+    semanticIndex: importResult.semanticIndex ?? importResult.universalAst?.semanticIndex,
+    evidence,
+    losses,
+    sourcePreservation: importResult.metadata?.sourcePreservation ?? importResult.nativeSource?.metadata?.sourcePreservation,
+    target,
+    targetPath: options.targetPath ?? targetProjection?.targetPath,
+    targetHash: options.targetHash ?? outputHash,
+    sourcePath: importResult.sourcePath ?? importResult.nativeSource?.sourcePath,
+    sourceHash: importResult.nativeSource?.sourceHash ?? importResult.nativeAst?.sourceHash ?? importResult.sourceHash,
+    defaultSourceMapId: options.sourceMapId ?? `source_map_${idFragment(id)}_${idFragment(target)}`
+  });
+  if (targetProjection?.sourceMaps?.length) targetProjection.sourceMaps = sourceMaps;
   const sourceMap = sourceMaps[0];
-  const projectionReview = nativeProjectionReview({
+  const sourceMapGeneratedBoundaryGate = classifySourceMapGeneratedBoundary(sourceMaps, {
+    sourceLanguage,
+    target,
+    outputMode,
+    projectionMode: projection.mode
+  });
+  const projectionReview = {
+    ...nativeProjectionReview({
     mode: projection.mode, outputMode, language: projection.language, sourceLanguage, target,
     sourcePath: importResult.sourcePath ?? importResult.nativeSource?.sourcePath,
     exactSourceAvailable: projection.metadata?.exactSourceAvailable === true,
@@ -132,9 +157,12 @@ export function compileNativeSource(input, options = {}) {
     sourceHashVerified: projection.metadata?.sourceHashVerified === true,
     declarationCount: projection.declarations.length, sourceMapCount: sourceMaps.length,
     losses, targetLosses, readiness: readiness.readiness, targetCoverage, targetProjection
-  });
+    }),
+    sourceMapGeneratedBoundaryGate
+  };
   compileEvidence.metadata.projectionReview = projectionReview;
-  for (const record of sourceMaps) record.metadata = { ...(record.metadata ?? {}), projectionReview };
+  compileEvidence.metadata.sourceMapGeneratedBoundaryGate = sourceMapGeneratedBoundaryGate;
+  for (const record of sourceMaps) record.metadata = { ...(record.metadata ?? {}), projectionReview, sourceMapGeneratedBoundaryGate };
   const roundtripEvidence = createNativeRoundtripEvidence(importResult, {
     id: `evidence_${idPart}_${idFragment(target)}_native_roundtrip`,
     projection,
@@ -146,6 +174,25 @@ export function compileNativeSource(input, options = {}) {
     target,
     outputMode
   });
+  const roundtripBoundaryGate = {
+    schema: sourceMapGeneratedBoundaryGate.schema,
+    version: sourceMapGeneratedBoundaryGate.version,
+    status: sourceMapGeneratedBoundaryGate.status,
+    readiness: sourceMapGeneratedBoundaryGate.readiness,
+    action: sourceMapGeneratedBoundaryGate.action,
+    reviewRequired: sourceMapGeneratedBoundaryGate.reviewRequired,
+    exactBoundary: sourceMapGeneratedBoundaryGate.exactBoundary,
+    sourceMapIds: sourceMapGeneratedBoundaryGate.sourceMapIds,
+    sourceMapMappingIds: sourceMapGeneratedBoundaryGate.sourceMapMappingIds,
+    reasonCodes: sourceMapGeneratedBoundaryGate.reasonCodes,
+    summary: sourceMapGeneratedBoundaryGate.summary
+  };
+  roundtripEvidence.metadata.sourceMapGeneratedBoundaryGate = roundtripBoundaryGate;
+  roundtripEvidence.metadata.roundtripEvidence.sourceMapGeneratedBoundaryGate = roundtripBoundaryGate;
+  roundtripEvidence.metadata.roundtripEvidence.audit = {
+    ...roundtripEvidence.metadata.roundtripEvidence.audit,
+    sourceMapGeneratedBoundaryGate: roundtripBoundaryGate
+  };
   const resultEvidence = uniqueByEvidenceId([...evidence, roundtripEvidence]);
   return {
     kind: 'frontier.lang.nativeSourceCompileResult',
@@ -191,6 +238,7 @@ export function compileNativeSource(input, options = {}) {
       targetReadiness: targetCoverage.readiness,
       targetSupported: targetCoverage.supported,
       projectionReview,
+      sourceMapGeneratedBoundaryGate,
       ...options.metadata,
       roundtripEvidence: roundtripEvidence.metadata.roundtripEvidence
     }

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

@@ -1,4 +1,4 @@
-import{idFragment,uniqueRecordsById}from'../../native-import-utils.js';import{lightweightDependencyRelations}from'../../lightweight-dependency-relations.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration,semanticPatchHintForRegion}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{idFragment,uniqueRecordsById}from'../../native-import-utils.js';import{lightweightDependencyRelations}from'../../lightweight-dependency-relations.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration,semanticPatchHintForRegion}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';import{dynamicImportExpressionEdgeFields}from'./dynamicImportExpressionMetadata.js';
 export function createLightweightNativeImport(input) {
   const parser = input.parser ?? `${input.language}.lightweight-declaration-scan`;
   const rootId = 'native_root';
@@ -43,6 +43,8 @@ export function createLightweightNativeImport(input) {
     };
     if (declaration.symbolId) {
       const occurrenceId = `occ_${idFragment(declaration.nodeId)}_def`;
+      const relationId = `rel_${idFragment(documentId)}_${idFragment(declaration.nodeId)}`;
+      const moduleEdge = lightweightModuleEdge(declaration, input, documentId, relationId, ownershipRegion);
       symbols.push({
         id: declaration.symbolId,
         scheme: 'frontier',
@@ -68,10 +70,11 @@ export function createLightweightNativeImport(input) {
         nativeAstNodeId: declaration.nodeId
       });
       relations.push({
-        id: `rel_${idFragment(documentId)}_${idFragment(declaration.nodeId)}`,
+        id: relationId,
         sourceId: documentId,
-        predicate: declaration.role === 'import' ? 'imports' : 'defines',
-        targetId: declaration.symbolId
+        predicate: lightweightRelationPredicate(declaration),
+        targetId: declaration.symbolId,
+        ...(moduleEdge ? { metadata: { moduleEdge } } : {})
       });
       facts.push({
         id: `fact_${idFragment(declaration.nodeId)}_kind`,
@@ -93,6 +96,14 @@ export function createLightweightNativeImport(input) {
           key: ownershipRegion.key
         }
       });
+      if (moduleEdge) facts.push({
+        id: `fact_${idFragment(relationId)}_${idFragment(declaration.symbolId)}_module_edge`,
+        predicate: 'moduleEdge',
+        subjectId: declaration.symbolId,
+        objectId: declaration.symbolId,
+        value: moduleEdge,
+        evidenceIds: [evidenceId]
+      });
       mappings.push({
         id: `map_${idFragment(declaration.nodeId)}`,
         nativeAstNodeId: declaration.nodeId,
@@ -190,3 +201,46 @@ export function createLightweightNativeImport(input) {
     }
   };
 }
+
+function lightweightRelationPredicate(declaration) {
+  if (declaration.role === 'import') return 'imports';
+  if (declaration.role === 'export') return 'exports';
+  return 'defines';
+}
+
+function lightweightModuleEdge(declaration, input, documentId, relationId, ownershipRegion) {
+  if (declaration.role !== 'import' && declaration.role !== 'export') return undefined;
+  const fields = declaration.fields ?? {};
+  const metadata = declaration.metadata ?? {};
+  const moduleSpecifier = fields.importPath ?? fields.moduleSpecifier ?? fields.exportPath ?? fields.source
+    ?? metadata.importPath ?? metadata.moduleSpecifier ?? metadata.exportPath ?? metadata.source;
+  return compactRecord({
+    kind: 'frontier.lang.moduleEdge',
+    version: 1,
+    id: relationId,
+    edgeKind: declaration.role === 'import' ? 'import' : moduleSpecifier || metadata.reexport ? 're-export' : 'export',
+    role: declaration.role,
+    sourceDocumentId: documentId,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    moduleSpecifier,
+    symbolId: declaration.symbolId,
+    relationId,
+    ownershipRegionId: ownershipRegion.id,
+    ownershipRegionKey: ownershipRegion.key,
+    importKind: fields.importKind ?? metadata.importKind,
+    exportKind: fields.exportKind ?? metadata.exportKind,
+    importedName: fields.importedName ?? metadata.importedName,
+    exportedName: fields.exportedName ?? metadata.exportedName,
+    localName: fields.localName ?? metadata.localName,
+    namespace: fields.namespace ?? metadata.namespace,
+    exportStar: fields.exportStar ?? metadata.exportStar,
+    isTypeOnly: fields.typeOnly ?? fields.isTypeOnly ?? metadata.typeOnly ?? metadata.isTypeOnly,
+    ...dynamicImportExpressionEdgeFields(metadata),
+    publicContract: declaration.role === 'export' || metadata.publicContract
+  });
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -1,4 +1,13 @@
-import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{normalizeSyntaxAstRoot}from'./normalizeSyntaxAstRoot.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitSyntaxAstNode}from'./visitSyntaxAstNode.js';
+import { adapterDiagnosticToLoss } from './adapterDiagnosticToLoss.js';
+import { createAstNormalizationContext } from './createAstNormalizationContext.js';
+import { mergeNativeLosses } from './mergeNativeLosses.js';
+import { missingInjectedParserResult } from './missingInjectedParserResult.js';
+import { normalizeSyntaxAstRoot } from './normalizeSyntaxAstRoot.js';
+import { semanticIndexFromNativeDeclarations } from './semanticIndexFromNativeDeclarations.js';
+import { createSyntaxAstSourcePreservation } from './syntaxAstSourcePreservation.js';
+import { truncatedAstLoss } from './truncatedAstLoss.js';
+import { visitSyntaxAstNode } from './visitSyntaxAstNode.js';
+
 export function createNativeImportFromSyntaxAst(ast, input, options) {
   const root = normalizeSyntaxAstRoot(ast, options.astFormat);
   if (!root) {
@@ -14,6 +23,7 @@ export function createNativeImportFromSyntaxAst(ast, input, options) {
     context.losses.push(truncatedAstLoss(input, context, options));
   }
   const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  const sourcePreservation = createSyntaxAstSourcePreservation(ast, input, options);
   return {
     rootId: context.rootId,
     nodes: context.nodes,
@@ -25,11 +35,17 @@ export function createNativeImportFromSyntaxAst(ast, input, options) {
     }, input)) ?? []),
     evidence: semantic.evidence,
     diagnostics: options.diagnostics,
+    ...(sourcePreservation ? { sourcePreservation } : {}),
     metadata: {
       astFormat: options.astFormat,
       parser: options.parser,
       normalizedNodeCount: Object.keys(context.nodes).length,
       declarationCount: context.declarations.length,
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservationSummary: sourcePreservation.summary,
+        parserTriviaExactness: sourcePreservation.metadata?.parserTriviaExactness
+      } : {}),
       truncated: context.truncated
     }
   };

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

@@ -1,4 +1,13 @@
-import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitTypeScriptAstNode}from'./visitTypeScriptAstNode.js';
+import { createAstNormalizationContext } from './createAstNormalizationContext.js';
+import { semanticIndexFromNativeDeclarations } from './semanticIndexFromNativeDeclarations.js';
+import {
+  attachTypeScriptCompilerReferenceGraph,
+  createTypeScriptCompilerReferenceGraph
+} from './typeScriptCompilerReferenceGraph.js';
+import { createTypeScriptSourceFilePreservation } from './typeScriptSourceFilePreservation.js';
+import { truncatedAstLoss } from './truncatedAstLoss.js';
+import { visitTypeScriptAstNode } from './visitTypeScriptAstNode.js';
+
 export function createNativeImportFromTypeScriptAst(sourceFile, input, options) {
   const context = createAstNormalizationContext(input, options);
   visitTypeScriptAstNode(sourceFile, sourceFile, context, 'root', options.ts);
@@ -6,18 +15,33 @@ export function createNativeImportFromTypeScriptAst(sourceFile, input, options)
     context.losses.push(truncatedAstLoss(input, context, options));
   }
   const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  const referenceGraph = createTypeScriptCompilerReferenceGraph(
+    sourceFile,
+    input,
+    options,
+    context,
+    semantic.semanticIndex
+  );
+  const sourcePreservation = createTypeScriptSourceFilePreservation(sourceFile, input, options);
   return {
     rootId: context.rootId,
     nodes: context.nodes,
-    semanticIndex: semantic.semanticIndex,
-    mappings: semantic.mappings,
+    semanticIndex: attachTypeScriptCompilerReferenceGraph(semantic.semanticIndex, referenceGraph),
+    mappings: [...semantic.mappings, ...referenceGraph.mappings],
     losses: context.losses,
-    evidence: semantic.evidence,
+    evidence: [...semantic.evidence, ...referenceGraph.evidence],
+    ...(sourcePreservation ? { sourcePreservation } : {}),
     metadata: {
       astFormat: options.astFormat,
       parser: options.parser,
       normalizedNodeCount: Object.keys(context.nodes).length,
       declarationCount: context.declarations.length,
+      compilerReferenceGraph: referenceGraph.summary,
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservationSummary: sourcePreservation.summary,
+        parserTriviaExactness: sourcePreservation.metadata?.parserTriviaExactness
+      } : {}),
       truncated: context.truncated
     }
   };

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

@@ -1,8 +1,9 @@
 import{idFragment,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{createDocument,createPatch,createUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
 import{createNativeImportResultContract}from'./createNativeImportResultContract.js';import{createProjectImportAdmissionRecord}from'./createProjectImportAdmissionRecord.js';import{mergeSemanticIndexes}from'./mergeSemanticIndexes.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{summarizeProjectSourcePreservation}from'./summarizeProjectSourcePreservation.js';
 import{createProjectDocumentExportSymbolResolver,createProjectDocumentExportSymbolsResolver,createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{createProjectCompilerGraphRecords}from'./projectSymbolGraphCompilerFacts.js';import{createProjectJsxGraphRecords}from'./projectSymbolGraphJsxRecords.js';import{createProjectRuntimeRegionRecords}from'./projectSymbolGraphRuntimeRegions.js';import{createProjectScopeUseDefRecords}from'./projectSymbolGraphScopeUseDefRecords.js';import{createProjectSourceEvidenceRecords}from'./projectSymbolGraphSourceRecords.js';import{createProjectCssModuleGraphRecords}from'./projectSymbolGraphCssModules.js';
 import{publicContractRegionRecord}from'./projectSymbolGraphPublicContracts.js';
-import{exportStarReExportIdentityRecords,isReExportImportEdge,reExportIdentityInputFromEdge,reExportIdentityRecord}from'./projectSymbolGraphReExports.js';
+import{commonJsAliasReExportIdentityRecords,exportStarReExportIdentityRecords,isReExportImportEdge,reExportIdentityInputFromEdge,reExportIdentityRecord}from'./projectSymbolGraphReExports.js';import{createProjectModuleDeclarationShapeRecords}from'./projectSymbolGraphModuleDeclarationShapes.js';import{resolveReExportIdentityImportTargets}from'./projectSymbolGraphReExportImportTargets.js';
 export function createNativeProjectImportResult(input, imports) {
   const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
   const nodes = {};
@@ -141,9 +142,7 @@ export function createNativeProjectImportResult(input, imports) {
     }
   };
 }
-
 const PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS = Object.freeze([]);
-
 function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const documents = semanticIndex?.documents ?? [];
   const symbolsById = new Map((semanticIndex?.symbols ?? []).map((symbol) => [symbol.id, symbol]));
@@ -155,7 +154,7 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const resolveDocumentExportSymbols = createProjectDocumentExportSymbolsResolver(semanticIndex?.symbols ?? [], documents);
   const facts = semanticIndex?.facts ?? [];
   const moduleEdgeFacts = facts.filter((fact) => fact.predicate === 'moduleEdge');
-  const moduleEdgeByRelation = new Map(moduleEdgeFacts.map((fact) => [fact.subjectId, fact]));
+  const moduleEdgeByRelation = new Map(moduleEdgeFacts.map((fact) => [objectValue(fact.value).relationId ?? fact.subjectId, fact]));
   const relations = semanticIndex?.relations ?? [];
   const importEdges = relations
     .filter((relation) => relation.predicate === 'imports')
@@ -167,19 +166,19 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const reExportIdentities = uniqueRecords([
     ...facts
       .filter((fact) => fact.predicate === 'reExportIdentity' && fact.value)
+      .filter((fact) => hasConcreteReExportIdentity(objectValue(fact.value)))
       .map((fact) => reExportIdentityRecord(objectValue(fact.value), moduleEdgeById.get(objectValue(fact.value).relationId ?? fact.objectId), resolveDocumentExportSymbolId, { factId: fact.id })),
-    ...exportEdges
-      .filter((edge) => edge.isReExport)
-      .map((edge) => reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId)),
     ...importEdges
       .filter((edge) => isReExportImportEdge(edge))
       .flatMap((edge) => edge.exportStar
         ? exportStarReExportIdentityRecords(edge, resolveDocumentExportSymbols(edge.targetDocumentId))
-        : [reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId)])
+        : [reExportIdentityRecord(reExportIdentityInputFromEdge(edge, `reexport_${idFragment(edge.id)}`), edge, resolveDocumentExportSymbolId)]),...commonJsAliasReExportIdentityRecords(importEdges, exportEdges, resolveDocumentExportSymbolId)
   ]);
+  const resolvedImportEdges = resolveReExportIdentityImportTargets(importEdges, reExportIdentities);
   const publicContractRegions = uniqueRecords(facts
     .filter((fact) => fact.predicate === 'publicContractRegion' && fact.value)
     .map((fact) => publicContractRegionRecord(objectValue(fact.value), fact, symbolsById.get(fact.subjectId))));
+  const compilerGraphRecords = createProjectCompilerGraphRecords(semanticIndex, symbolsById, documentsById, publicContractRegions); const runtimeRegionRecords = createProjectRuntimeRegionRecords(semanticIndex, imports, publicContractRegions); const scopeUseDefRecords = createProjectScopeUseDefRecords(semanticIndex, imports, publicContractRegions); const jsxGraphRecords = createProjectJsxGraphRecords(semanticIndex, imports, publicContractRegions, resolvedImportEdges, exportEdges); const cssModuleGraphRecords = createProjectCssModuleGraphRecords(semanticIndex, imports, resolvedImportEdges, scopeUseDefRecords.scopeReferenceRecords, jsxGraphRecords.jsxPropRecords); const sourceEvidenceRecords = createProjectSourceEvidenceRecords(imports); const moduleDeclarationShapeRecords = createProjectModuleDeclarationShapeRecords(semanticIndex, exportEdges);
   const fileHashes = uniqueRecords([
     ...documents.map((document) => fileHashRecord(document)),
     ...facts
@@ -197,10 +196,20 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
     relationCount: relations.length,
     factCount: facts.length,
     fileHashes,
-    importEdges,
+    importEdges: resolvedImportEdges,
     exportEdges,
-    reExportIdentities,
+    reExportIdentities, moduleDeclarationRecords: moduleDeclarationShapeRecords.moduleDeclarationRecords, exportAssignmentRecords: moduleDeclarationShapeRecords.exportAssignmentRecords,
     publicContractRegions,
+    sourceFileRecords: sourceEvidenceRecords.sourceFileRecords, sourceSpanRecords: sourceEvidenceRecords.sourceSpanRecords,
+    compilerSymbolRecords: compilerGraphRecords.compilerSymbolRecords,
+    compilerTypeRecords: compilerGraphRecords.compilerTypeRecords,
+    runtimeRegionRecords,
+    scopeBindingRecords: scopeUseDefRecords.scopeBindingRecords,
+    scopeReferenceRecords: scopeUseDefRecords.scopeReferenceRecords,
+    jsxElementRecords: jsxGraphRecords.jsxElementRecords,
+    jsxPropRecords: jsxGraphRecords.jsxPropRecords,
+    cssModuleImportBindings: cssModuleGraphRecords.cssModuleImportBindings, cssModuleUseSites: cssModuleGraphRecords.cssModuleUseSites,
+    cssModuleUseSiteBlockers: cssModuleGraphRecords.cssModuleUseSiteBlockers, cssModuleUseSiteGraphs: cssModuleGraphRecords.cssModuleUseSiteGraphs,
     remainingFields: PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS
   };
 }
@@ -223,7 +232,8 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     symbolMetadata.source,
     symbol?.kind === 'module' ? symbol.name : undefined
   );
-  const resolution = resolveProjectModule(document?.path, moduleSpecifier, documentsByPath, moduleResolution);
+  const runtimeEdgeMetadata = compactRecord({ importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind), exportKind: firstString(moduleEdge.exportKind, value.exportKind, symbolMetadata.exportKind), dynamicImport: firstBoolean(moduleEdge.dynamicImport, value.dynamicImport, metadata.dynamicImport, symbolMetadata.dynamicImport), hostDependencyKind: firstString(moduleEdge.hostDependencyKind, value.hostDependencyKind, metadata.hostDependencyKind, symbolMetadata.hostDependencyKind), commonJs: firstBoolean(moduleEdge.commonJs, value.commonJs, metadata.commonJs, symbolMetadata.commonJs), interopHelper: firstString(moduleEdge.interopHelper, value.interopHelper, metadata.interopHelper, symbolMetadata.interopHelper), packageEnvironmentCondition: firstString(moduleEdge.packageEnvironmentCondition, value.packageEnvironmentCondition, metadata.packageEnvironmentCondition, symbolMetadata.packageEnvironmentCondition) });
+  const resolution = resolveProjectModule(document?.path, moduleSpecifier, documentsByPath, moduleResolution, runtimeEdgeMetadata);
   const record = {
     id: relation.id,
     sourceDocumentId: relation.sourceId,
@@ -239,11 +249,15 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     resolutionPathVariant: resolution?.resolutionPathVariant,
     packageName: resolution?.packageName,
     packageSubpath: resolution?.packageSubpath,
+    packageExportKey: resolution?.packageExportKey,
     packageExportCondition: resolution?.packageExportCondition,
+    packageExportTarget: resolution?.packageExportTarget,
+    packageRuntimeCondition: resolution?.packageRuntimeCondition, packageRuntimeConditionEvidenceSource: resolution?.packageRuntimeConditionEvidenceSource, packageRuntimeConditionEdgeKind: resolution?.packageRuntimeConditionEdgeKind, packageRuntimeConditionCandidates: resolution?.packageRuntimeConditionCandidates, packageRuntimeConditionReasonCode: resolution?.packageRuntimeConditionReasonCode, packageEnvironmentCondition: resolution?.packageEnvironmentCondition, packageEnvironmentConditionEvidenceSource: resolution?.packageEnvironmentConditionEvidenceSource, packageEnvironmentConditionCandidates: resolution?.packageEnvironmentConditionCandidates, packageEnvironmentConditionReasonCode: resolution?.packageEnvironmentConditionReasonCode, packageWorkspaceRootAmbiguous: resolution?.packageWorkspaceRootAmbiguous, packageWorkspaceRoots: resolution?.packageWorkspaceRoots, packageResolutionReasonCode: resolution?.packageResolutionReasonCode,
+    packageType: resolution?.packageType,
     packageImportKey: resolution?.packageImportKey,
     packageImportCondition: resolution?.packageImportCondition,
     packageImportTarget: resolution?.packageImportTarget,
-    importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind),
+    importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind), commonJs: firstBoolean(moduleEdge.commonJs, value.commonJs, metadata.commonJs, symbolMetadata.commonJs), interopHelper: firstString(moduleEdge.interopHelper, value.interopHelper, metadata.interopHelper, symbolMetadata.interopHelper), dynamicImport: firstBoolean(moduleEdge.dynamicImport, value.dynamicImport, metadata.dynamicImport, symbolMetadata.dynamicImport), dynamicImportSpecifierKind: firstString(moduleEdge.dynamicImportSpecifierKind, value.dynamicImportSpecifierKind, metadata.dynamicImportSpecifierKind, symbolMetadata.dynamicImportSpecifierKind), dynamicImportExpressionText: firstString(moduleEdge.dynamicImportExpressionText, value.dynamicImportExpressionText, metadata.dynamicImportExpressionText, symbolMetadata.dynamicImportExpressionText), dynamicImportExpressionHash: firstString(moduleEdge.dynamicImportExpressionHash, value.dynamicImportExpressionHash, metadata.dynamicImportExpressionHash, symbolMetadata.dynamicImportExpressionHash), dynamicImportStaticSpecifierEvidence: firstBoolean(moduleEdge.dynamicImportStaticSpecifierEvidence, value.dynamicImportStaticSpecifierEvidence, metadata.dynamicImportStaticSpecifierEvidence, symbolMetadata.dynamicImportStaticSpecifierEvidence), dynamicImportRuntimeResolutionClaim: firstBoolean(moduleEdge.dynamicImportRuntimeResolutionClaim, value.dynamicImportRuntimeResolutionClaim, metadata.dynamicImportRuntimeResolutionClaim, symbolMetadata.dynamicImportRuntimeResolutionClaim), dynamicImportResolutionProofRequired: firstBoolean(moduleEdge.dynamicImportResolutionProofRequired, value.dynamicImportResolutionProofRequired, metadata.dynamicImportResolutionProofRequired, symbolMetadata.dynamicImportResolutionProofRequired), hostDependency: firstBoolean(moduleEdge.hostDependency, value.hostDependency, metadata.hostDependency, symbolMetadata.hostDependency), hostDependencyKind: firstString(moduleEdge.hostDependencyKind, value.hostDependencyKind, metadata.hostDependencyKind, symbolMetadata.hostDependencyKind), hostDependencyBase: firstString(moduleEdge.hostDependencyBase, value.hostDependencyBase, metadata.hostDependencyBase, symbolMetadata.hostDependencyBase), hostDependencyExpressionText: firstString(moduleEdge.hostDependencyExpressionText, value.hostDependencyExpressionText, metadata.hostDependencyExpressionText, symbolMetadata.hostDependencyExpressionText), hostDependencyExpressionHash: firstString(moduleEdge.hostDependencyExpressionHash, value.hostDependencyExpressionHash, metadata.hostDependencyExpressionHash, symbolMetadata.hostDependencyExpressionHash), hostDependencyStaticSpecifierEvidence: firstBoolean(moduleEdge.hostDependencyStaticSpecifierEvidence, value.hostDependencyStaticSpecifierEvidence, metadata.hostDependencyStaticSpecifierEvidence, symbolMetadata.hostDependencyStaticSpecifierEvidence), hostDependencyRuntimeResolutionClaim: firstBoolean(moduleEdge.hostDependencyRuntimeResolutionClaim, value.hostDependencyRuntimeResolutionClaim, metadata.hostDependencyRuntimeResolutionClaim, symbolMetadata.hostDependencyRuntimeResolutionClaim), hostDependencyResolutionProofRequired: firstBoolean(moduleEdge.hostDependencyResolutionProofRequired, value.hostDependencyResolutionProofRequired, metadata.hostDependencyResolutionProofRequired, symbolMetadata.hostDependencyResolutionProofRequired), hasImportAttributes: firstBoolean(moduleEdge.hasImportAttributes, value.hasImportAttributes, metadata.hasImportAttributes, symbolMetadata.hasImportAttributes), importAttributeCount: moduleEdge.importAttributeCount ?? value.importAttributeCount ?? metadata.importAttributeCount ?? symbolMetadata.importAttributeCount, importAttributeKeys: moduleEdge.importAttributeKeys ?? value.importAttributeKeys ?? metadata.importAttributeKeys ?? symbolMetadata.importAttributeKeys, importAttributeHash: firstString(moduleEdge.importAttributeHash, value.importAttributeHash, metadata.importAttributeHash, symbolMetadata.importAttributeHash), importAttributes: moduleEdge.importAttributes ?? value.importAttributes ?? metadata.importAttributes ?? symbolMetadata.importAttributes,
     exportKind: firstString(moduleEdge.exportKind, value.exportKind, symbolMetadata.exportKind),
     importedName: firstString(moduleEdge.importedName, value.importedName, symbolMetadata.importedName),
     exportedName: firstString(moduleEdge.exportedName, value.exportedName, symbolMetadata.exportedName),
@@ -252,7 +266,7 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     exportStar: firstBoolean(moduleEdge.exportStar, value.exportStar, symbolMetadata.exportStar),
     isTypeOnly: firstBoolean(moduleEdge.isTypeOnly, value.isTypeOnly, symbolMetadata.isTypeOnly, symbolMetadata.typeOnly),
     isReExport: firstBoolean(moduleEdge.isReExport, value.isReExport, symbolMetadata.reexport) ?? (relation.predicate === 'exports' && Boolean(moduleSpecifier)),
-    publicContract: firstBoolean(moduleEdge.publicContract, value.publicContract, metadata.publicContract),
+    publicContract: firstBoolean(moduleEdge.publicContract, value.publicContract, metadata.publicContract, symbolMetadata.publicContract),
     evidenceIds: uniqueStrings([...(relation.evidenceIds ?? []), ...(fact?.evidenceIds ?? [])])
   };
   return compactRecord({ ...record, resolvedTargetSymbolId: resolveTargetSymbolId(record) });
@@ -277,6 +291,8 @@ function objectValue(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
 
+function hasConcreteReExportIdentity(identity) { return Boolean(identity.exportedName || identity.importedName || identity.localName || identity.namespace); }
+
 function compactRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }
@@ -292,17 +308,5 @@ function uniqueRecords(records) {
   }
   return result;
 }
-
-function firstString(...values) {
-  for (const value of values) {
-    if (value !== undefined && value !== null && String(value)) return String(value);
-  }
-  return undefined;
-}
-
-function firstBoolean(...values) {
-  for (const value of values) {
-    if (typeof value === 'boolean') return value;
-  }
-  return undefined;
-}
+function firstString(...values) { for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value); return undefined; }
+function firstBoolean(...values) { for (const value of values) if (typeof value === 'boolean') return value; return undefined; }