@shapeshift-labs/frontier-lang-compiler 0.2.117 → 0.2.119

package/README.md

@@ -238,6 +238,12 @@ console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@p
 console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
 ```
 
+NodeNext-style JS extension specifiers can resolve to supplied TS source files.
+For example, `import './runtime.js'` can resolve to `src/runtime.ts` when that is
+the available project document. Graph edges record `resolutionPathVariant` as
+`"extension-substitution"` so coordinators can distinguish exact source matches
+from source-extension substitutions during stale checks and merge admission.
+
 Package `imports` maps are also modeled for `#internal` specifiers. Top-level
 `moduleResolution.imports` applies from `packageRoot`/`root`, while
 `packages[name].imports` applies to the nearest configured package root. Graph
@@ -271,6 +277,13 @@ For `export * from './module.js'`, project graphs fan out re-export identities
 for each named export in the resolved target document and omit `default`, which
 matches JavaScript module semantics.
 
+When using `createTypeScriptCompilerNativeImporterAdapter`, compiler AST imports
+emit the same binding-level module facts instead of only statement-level module
+edges. Default, namespace, named, type-only, side-effect, re-export, export-star,
+local export, `export default`, and `export =` declarations carry `importKind`,
+`exportKind`, `localName`, `importedName`, `exportedName`, `isTypeOnly`, and
+public-contract metadata into the semantic index and project symbol graph.
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js

package/dist/declarations/native-project.d.ts

@@ -108,6 +108,7 @@ export interface NativeProjectSymbolGraphModuleEdgeRecord {
   readonly targetDocumentId?: string;
   readonly resolvedTargetSymbolId?: string;
   readonly resolutionKind?: 'relative-source' | 'relative-missing' | 'alias-source' | 'alias-missing' | 'path-alias-source' | 'path-alias-missing' | 'base-url-source' | 'base-url-missing' | 'package-source' | 'package-missing' | 'package-external' | 'package-import-source' | 'package-import-missing' | 'package-import-external' | string;
+  readonly resolutionPathVariant?: 'exact' | 'extension-substitution' | 'extensionless' | 'index' | string;
   readonly packageName?: string; readonly packageSubpath?: string; readonly packageExportCondition?: string;
   readonly packageImportKey?: string; readonly packageImportCondition?: string; readonly packageImportTarget?: string;
   readonly importKind?: string;

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

@@ -240,6 +240,7 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     resolvedModulePath: resolution?.path,
     targetDocumentId: resolution?.documentId,
     resolutionKind: resolution?.kind,
+    resolutionPathVariant: resolution?.resolutionPathVariant,
     packageName: resolution?.packageName,
     packageSubpath: resolution?.packageSubpath,
     packageExportCondition: resolution?.packageExportCondition,
@@ -253,7 +254,7 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     localName: firstString(moduleEdge.localName, value.localName, symbolMetadata.localName),
     namespace: firstString(moduleEdge.namespace, value.namespace, symbolMetadata.namespace),
     exportStar: firstBoolean(moduleEdge.exportStar, value.exportStar, symbolMetadata.exportStar),
-    isTypeOnly: firstBoolean(moduleEdge.isTypeOnly, value.isTypeOnly),
+    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),
     evidenceIds: uniqueStrings([...(relation.evidenceIds ?? []), ...(fact?.evidenceIds ?? [])])

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

@@ -0,0 +1,52 @@
+export function modulePathCandidates(path) {
+  const normalized = String(path ?? '');
+  return uniqueCandidates([
+    candidate(normalized, 'exact'),
+    ...extensionSubstitutionCandidates(normalized),
+    ...extensionlessCandidates(normalized),
+    ...indexCandidates(normalized)
+  ]);
+}
+
+function extensionSubstitutionCandidates(path) {
+  const entries = [
+    ['.js', ['.ts', '.tsx', '.d.ts', '.jsx']],
+    ['.jsx', ['.tsx', '.ts', '.d.ts']],
+    ['.mjs', ['.mts', '.ts', '.d.mts']],
+    ['.cjs', ['.cts', '.ts', '.d.cts']]
+  ];
+  for (const [from, targets] of entries) {
+    if (!path.endsWith(from)) continue;
+    const base = path.slice(0, -from.length);
+    return targets.map((target) => candidate(`${base}${target}`, 'extension-substitution'));
+  }
+  return [];
+}
+
+function extensionlessCandidates(path) {
+  if (hasKnownExtension(path)) return [];
+  return ['.js', '.ts', '.tsx', '.jsx', '.mjs', '.mts', '.cjs', '.cts', '.d.ts']
+    .map((extension) => candidate(`${path}${extension}`, 'extensionless'));
+}
+
+function indexCandidates(path) {
+  return ['.js', '.ts', '.tsx', '.jsx', '.mjs', '.mts', '.cjs', '.cts', '.d.ts']
+    .map((extension) => candidate(`${path}/index${extension}`, 'index'));
+}
+
+function hasKnownExtension(path) {
+  return /\.(?:[cm]?[jt]sx?|d\.[cm]?ts)$/.test(path);
+}
+
+function candidate(path, variant) {
+  return { path, variant };
+}
+
+function uniqueCandidates(candidates) {
+  const seen = new Set();
+  return candidates.filter((entry) => {
+    if (!entry.path || seen.has(entry.path)) return false;
+    seen.add(entry.path);
+    return true;
+  });
+}

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

@@ -1,3 +1,5 @@
+import { modulePathCandidates } from './projectSymbolGraphModulePathCandidates.js';
+
 export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath) {
   if (!sourcePath || !moduleSpecifier || !moduleSpecifier.startsWith('.')) return undefined;
   const base = sourcePath.includes('/') ? sourcePath.slice(0, sourcePath.lastIndexOf('/')) : '';
@@ -6,6 +8,7 @@ export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, docume
   return {
     path: target?.path ?? unresolvedPath,
     documentId: target?.id,
+    resolutionPathVariant: target?.resolutionPathVariant,
     kind: target ? 'relative-source' : 'relative-missing'
   };
 }
@@ -69,7 +72,7 @@ function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, module
   for (const candidate of candidates) {
     const target = moduleTargetDocument(candidate.path, documentsByPath);
     const packageFields = packageResolutionFields(candidate, packageInfo);
-    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source`, ...packageFields };
+    if (target) return { path: target.path, documentId: target.id, resolutionPathVariant: target.resolutionPathVariant, kind: `${candidate.kind}-source`, ...packageFields };
     firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing`, ...packageFields };
   }
   return firstMissing ?? (packageInfo ? { kind: 'package-external', ...packageInfo } : undefined);
@@ -95,7 +98,7 @@ function resolvePackageImportProjectModule(sourcePath, moduleSpecifier, document
       packageImportTarget,
       packageName: packageContext.packageName
     };
-    if (resolved) return { path: resolved.path, documentId: resolved.id, kind: 'package-import-source', ...record };
+    if (resolved) return { path: resolved.path, documentId: resolved.id, resolutionPathVariant: resolved.resolutionPathVariant, kind: 'package-import-source', ...record };
     firstMissing ??= { path: candidatePath, kind: 'package-import-missing', ...record };
   }
   return firstMissing ?? { kind: 'package-import-external', packageImportKey: match.key };
@@ -224,16 +227,12 @@ function packageFallbackTargets(options, subpath) {
 
 function moduleTargetDocument(path, documentsByPath) {
   for (const candidate of modulePathCandidates(path)) {
-    const document = documentsByPath.get(candidate);
-    if (document) return document;
+    const document = documentsByPath.get(candidate.path);
+    if (document) return { ...document, resolutionPathVariant: candidate.variant };
   }
   return undefined;
 }
 
-function modulePathCandidates(path) {
-  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}.d.ts`, `${path}/index.js`, `${path}/index.ts`, `${path}/index.d.ts`];
-}
-
 function targetExportName(edge) {
   const name = edge.importedName ?? edge.localName ?? edge.exportedName;
   if (!name || name === '*') return undefined;

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

@@ -15,7 +15,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       symbolId,
       regionKind: declarationRegionKind(declaration)
     };
-    const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
+    const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}_${declaration.role ?? 'definition'}`;
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
       ...normalizedDeclaration,
       nodeId: declaration.nativeNode.id,
@@ -24,7 +24,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       span: declaration.nativeNode.span,
       symbolId
     }, documentId);
-    const relationId = `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`;
+    const relationId = `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}`;
     const moduleEdge = moduleEdgeForDeclaration(normalizedDeclaration, input, documentId, relationId, ownershipRegion);
     const publicContractRegion = publicContractRegionForDeclaration(normalizedDeclaration, ownershipRegion, moduleEdge);
     const reExportIdentity = reExportIdentityForDeclaration(normalizedDeclaration, input, documentId, relationId, ownershipRegion, moduleEdge);
@@ -76,17 +76,17 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       ...(Object.keys(graphMetadata).length ? { metadata: graphMetadata } : {})
     });
     facts.push({
-      id: `fact_${idFragment(declaration.nativeNode.id)}_kind`,
+      id: `fact_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}_kind`,
       predicate: 'nativeKind',
       subjectId: symbolId,
       value: declaration.nativeNode.languageKind
     }, {
-      id: `fact_${idFragment(declaration.nativeNode.id)}_ownership_region`,
+      id: `fact_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}_ownership_region`,
       predicate: 'semanticOwnershipRegion',
       subjectId: symbolId,
       value: ownershipRegion
     }, {
-      id: `fact_${idFragment(declaration.nativeNode.id)}_ownership_region_taxonomy`,
+      id: `fact_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}_ownership_region_taxonomy`,
       predicate: 'semanticOwnershipRegionTaxonomy',
       subjectId: symbolId,
       value: {
@@ -96,7 +96,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       }
     }, ...projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }));
     mappings.push({
-      id: `map_${idFragment(declaration.nativeNode.id)}`,
+      id: `map_${idFragment(declaration.nativeNode.id)}_${idFragment(symbolId)}`,
       nativeAstNodeId: declaration.nativeNode.id,
       semanticSymbolId: symbolId,
       semanticOccurrenceId: occurrenceId,
@@ -197,7 +197,8 @@ function moduleEdgeForDeclaration(declaration, input, documentId, relationId, ow
     exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
     localName: declaration.localName ?? declaration.metadata?.localName,
     namespace: declaration.namespace ?? declaration.metadata?.namespace,
-    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly ?? declaration.metadata?.typeOnly,
+    exportStar: declaration.exportStar ?? declaration.metadata?.exportStar,
     isReExport: edgeKind === 're-export',
     publicContract: publicContractForDeclaration(declaration, edgeKind)
   });
@@ -255,7 +256,8 @@ function reExportIdentityForDeclaration(declaration, input, documentId, relation
     importedName: declaration.importedName ?? declaration.metadata?.importedName,
     localName: declaration.localName ?? declaration.metadata?.localName,
     namespace: declaration.namespace ?? declaration.metadata?.namespace,
-    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly ?? declaration.metadata?.typeOnly,
+    exportStar: declaration.exportStar ?? declaration.metadata?.exportStar,
     symbolId: declaration.symbolId,
     relationId,
     ownershipRegionId: ownershipRegion.id,
@@ -267,7 +269,7 @@ function reExportIdentityForDeclaration(declaration, input, documentId, relation
 function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }) {
   return [
     moduleEdge ? {
-      id: `fact_${idFragment(relationId)}_module_edge`,
+      id: graphFactId(relationId, symbolId, 'module_edge'),
       predicate: 'moduleEdge',
       subjectId: relationId,
       objectId: symbolId,
@@ -275,7 +277,7 @@ function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIde
       evidenceIds: [evidenceId]
     } : undefined,
     reExportIdentity ? {
-      id: `fact_${idFragment(relationId)}_re_export_identity`,
+      id: graphFactId(relationId, symbolId, 're_export_identity'),
       predicate: 'reExportIdentity',
       subjectId: symbolId,
       objectId: relationId,
@@ -283,7 +285,7 @@ function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIde
       evidenceIds: [evidenceId]
     } : undefined,
     publicContractRegion ? {
-      id: `fact_${idFragment(symbolId)}_public_contract_region`,
+      id: graphFactId(relationId, symbolId, 'public_contract_region'),
       predicate: 'publicContractRegion',
       subjectId: symbolId,
       objectId: publicContractRegion.id,
@@ -302,6 +304,10 @@ function hashParts(sourceHash) {
   };
 }
 
+function graphFactId(relationId, symbolId, suffix) {
+  return `fact_${idFragment(hashSemanticValue([relationId, symbolId, suffix]))}_${suffix}`;
+}
+
 function compactRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }

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

@@ -1,20 +1,30 @@
 import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';import{idFragment}from'../../native-import-utils.js';
-import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';import{namedDeclaration}from'./namedDeclaration.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+import{declarationRecord}from'./declarationRecord.js';import{namedDeclaration}from'./namedDeclaration.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';import{typeScriptExportedDeclarationEntries}from'./typeScriptExportedDeclarationEntries.js';import{typeScriptModuleDeclarationEntries}from'./typeScriptModuleDeclarationEntries.js';
 export function typeScriptDeclaration(node, kind, nativeNodeId, input, options = {}) {
   const enrich = (declaration, symbolNode = node.name ?? node) => enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options);
+  const moduleEntries = typeScriptModuleDeclarationEntries(node, kind, nativeNodeId, input);
+  if (moduleEntries?.length) return moduleEntries.map((entry) => enrich(entry.declaration, entry.symbolNode ?? node));
+  const exportedEntries = typeScriptExportedDeclarationEntries(node, kind, nativeNodeId, input, options);
+  if (exportedEntries.length && Array.isArray(node.declarationList?.declarations)) return exportedEntries.map((entry) => enrich(entry.declaration, entry.symbolNode ?? node));
   if (kind === 'ImportDeclaration' || kind === 'ImportEqualsDeclaration') {
     const name = stringFromTsExpression(node.moduleSpecifier) ?? stringFromTsExpression(node.externalModuleReference?.expression);
     if (name) return enrich(declarationRecord(input, nativeNodeId, name, 'module', 'import'), node.moduleSpecifier ?? node.externalModuleReference?.expression ?? node);
   }
-  if (kind === 'FunctionDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'function'));
-  if (kind === 'ClassDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'class'));
-  if (kind === 'InterfaceDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'interface'));
-  if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'type'));
+  if (kind === 'FunctionDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'function')), exportedEntries, enrich, node);
+  if (kind === 'ClassDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'class')), exportedEntries, enrich, node);
+  if (kind === 'InterfaceDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'interface')), exportedEntries, enrich, node);
+  if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return declarationWithExports(enrich(namedDeclaration(input, nativeNodeId, node.name, 'type')), exportedEntries, enrich, node);
   if (kind === 'VariableDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'variable'));
   if (kind === 'MethodDeclaration' || kind === 'MethodSignature') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'method'));
   return undefined;
 }
 
+function declarationWithExports(declaration, exportedEntries, enrich, node) {
+  const exports = exportedEntries.map((entry) => enrich(entry.declaration, entry.symbolNode ?? node));
+  if (!declaration) return exports.length ? exports : undefined;
+  return exports.length ? [declaration, ...exports] : declaration;
+}
+
 function enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options) {
   if (!declaration) return declaration;
   const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();

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

@@ -0,0 +1,104 @@
+import{idFragment}from'../../native-import-utils.js';
+import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';
+export function typeScriptExportedDeclarationEntries(node, kind, nativeNodeId, input, options = {}) {
+  const modifiers = declarationModifiers(node, options.ts);
+  if (!modifiers.exported) return [];
+  if (isVariableStatement(node, kind)) return variableStatementExportEntries(node, nativeNodeId, input, modifiers);
+  const localName = identifierName(node.name);
+  const symbolKind = exportedSymbolKind(kind);
+  if (!symbolKind && !modifiers.defaulted) return [];
+  return [exportEntry(input, nativeNodeId, {
+    localName,
+    exportedName: modifiers.defaulted ? 'default' : localName,
+    exportKind: modifiers.defaulted ? 'default' : exportKindForDeclaration(kind),
+    isTypeOnly: typeOnlyDeclarationKind(kind),
+    symbolNode: node.name ?? node
+  })];
+}
+
+function variableStatementExportEntries(node, nativeNodeId, input, modifiers) {
+  const declarations = node.declarationList?.declarations ?? [];
+  return declarations
+    .map((declaration) => {
+      const localName = identifierName(declaration.name);
+      if (!localName) return undefined;
+      return exportEntry(input, nativeNodeId, {
+        localName,
+        exportedName: modifiers.defaulted ? 'default' : localName,
+        exportKind: modifiers.defaulted ? 'default' : 'named',
+        isTypeOnly: false,
+        symbolNode: declaration.name
+      });
+    })
+    .filter(Boolean);
+}
+
+function exportEntry(input, nativeNodeId, binding) {
+  return {
+    declaration: {
+      ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
+      symbolId: `symbol:${input.language}:export:${idFragment(binding.exportedName)}`,
+      localName: binding.localName,
+      exportedName: binding.exportedName,
+      exportKind: binding.exportKind,
+      isTypeOnly: binding.isTypeOnly,
+      publicContract: true,
+      metadata: {
+        scan: 'typescript-exported-declaration',
+        localName: binding.localName,
+        exportedName: binding.exportedName,
+        exportKind: binding.exportKind,
+        isTypeOnly: binding.isTypeOnly,
+        typeOnly: binding.isTypeOnly,
+        publicContract: true
+      }
+    },
+    symbolNode: binding.symbolNode
+  };
+}
+
+function declarationModifiers(node, ts) {
+  const helperModifiers = safeModifiers(node, ts);
+  const names = new Set([...(node.modifiers ?? []), ...helperModifiers].map((modifier) => modifierName(modifier, ts)));
+  return {
+    exported: names.has('ExportKeyword') || names.has('export'),
+    defaulted: names.has('DefaultKeyword') || names.has('default')
+  };
+}
+
+function safeModifiers(node, ts) {
+  try {
+    if (typeof ts?.canHaveModifiers === 'function' && !ts.canHaveModifiers(node)) return [];
+    return typeof ts?.getModifiers === 'function' ? [...(ts.getModifiers(node) ?? [])] : [];
+  } catch {
+    return [];
+  }
+}
+
+function isVariableStatement(node, kind) {
+  return kind === 'VariableStatement' || Array.isArray(node.declarationList?.declarations);
+}
+
+function modifierName(modifier, ts) {
+  if (typeof modifier.kindName === 'string') return modifier.kindName;
+  if (ts?.SyntaxKind && modifier.kind !== undefined) return ts.SyntaxKind[modifier.kind] ?? String(modifier.kind);
+  if (typeof modifier.text === 'string') return modifier.text;
+  if (typeof modifier.name === 'string') return modifier.name;
+  return String(modifier.kind ?? '');
+}
+
+function exportedSymbolKind(kind) {
+  if (kind === 'FunctionDeclaration') return 'function';
+  if (kind === 'ClassDeclaration') return 'class';
+  if (kind === 'InterfaceDeclaration') return 'interface';
+  if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return 'type';
+  return undefined;
+}
+
+function exportKindForDeclaration(kind) {
+  return typeOnlyDeclarationKind(kind) ? 'type-named' : 'named';
+}
+
+function typeOnlyDeclarationKind(kind) {
+  return kind === 'InterfaceDeclaration' || kind === 'TypeAliasDeclaration';
+}

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

@@ -0,0 +1,279 @@
+import{idFragment}from'../../native-import-utils.js';
+import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+export function typeScriptModuleDeclarationEntries(node, kind, nativeNodeId, input) {
+  if (kind === 'ImportDeclaration') return importDeclarationEntries(node, nativeNodeId, input);
+  if (kind === 'ImportEqualsDeclaration') return importEqualsDeclarationEntries(node, nativeNodeId, input);
+  if (kind === 'ExportDeclaration') return exportDeclarationEntries(node, nativeNodeId, input);
+  if (kind === 'ExportAssignment') return exportAssignmentEntries(node, nativeNodeId, input);
+  return undefined;
+}
+
+function importDeclarationEntries(node, nativeNodeId, input) {
+  const moduleSpecifier = stringFromTsExpression(node.moduleSpecifier);
+  if (!moduleSpecifier) return [];
+  const typeOnly = Boolean(node.importClause?.isTypeOnly);
+  const bindings = importClauseBindings(node.importClause, typeOnly);
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, 'ImportDeclaration', bindings, {
+    typeOnly,
+    sideEffectOnly: bindings.length === 0,
+    importKind: bindings.length === 0 ? 'side-effect' : 'module'
+  });
+}
+
+function importEqualsDeclarationEntries(node, nativeNodeId, input) {
+  const moduleSpecifier = stringFromTsExpression(node.moduleReference?.expression ?? node.externalModuleReference?.expression);
+  const localName = identifierName(node.name);
+  if (!moduleSpecifier || !localName) return [];
+  const typeOnly = Boolean(node.isTypeOnly);
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, 'ImportEqualsDeclaration', [{
+    localName,
+    importedName: 'default',
+    importKind: 'commonjs-require',
+    isTypeOnly: typeOnly,
+    symbolNode: node.name
+  }], { typeOnly, importKind: 'commonjs-require' });
+}
+
+function exportDeclarationEntries(node, nativeNodeId, input) {
+  const moduleSpecifier = stringFromTsExpression(node.moduleSpecifier);
+  const typeOnly = Boolean(node.isTypeOnly);
+  const exportStar = moduleSpecifier && !node.exportClause;
+  const bindings = exportClauseBindings(node.exportClause, { typeOnly, reExport: Boolean(moduleSpecifier) });
+  return [
+    ...(moduleSpecifier ? importModuleEntries(input, nativeNodeId, moduleSpecifier, 'ExportFromDeclaration', reExportImportBindings(bindings, exportStar), {
+      typeOnly,
+      reexport: true,
+      exportStar,
+      importKind: exportStar ? 'reexport' : 'reexport'
+    }) : []),
+    ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
+      typeOnly,
+      exportStar,
+      reExport: Boolean(moduleSpecifier),
+      exportKind: exportStar ? 'export-star' : 'named'
+    })
+  ];
+}
+
+function exportAssignmentEntries(node, nativeNodeId, input) {
+  const exportedName = node.isExportEquals ? 'module.exports' : 'default';
+  const localName = stringFromTsExpression(node.expression);
+  return [{
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, exportedName, 'export', 'export'),
+      exportedName,
+      localName,
+      exportKind: node.isExportEquals ? 'assignment' : 'default',
+      publicContract: true,
+      metadata: compactRecord({
+        exportKind: node.isExportEquals ? 'assignment' : 'default',
+        exportedName,
+        localName,
+        publicContract: true
+      })
+    }),
+    symbolNode: node.expression ?? node
+  }];
+}
+
+function importClauseBindings(importClause, typeOnly) {
+  if (!importClause) return [];
+  const bindings = [];
+  const defaultName = identifierName(importClause.name);
+  if (defaultName) bindings.push({
+    localName: defaultName,
+    importedName: 'default',
+    importKind: typeOnly ? 'type-default' : 'default',
+    isTypeOnly: typeOnly,
+    symbolNode: importClause.name
+  });
+  const named = importClause.namedBindings;
+  if (!named) return bindings;
+  if (Array.isArray(named.elements)) {
+    bindings.push(...named.elements.map((element) => importSpecifierBinding(element, typeOnly)).filter(Boolean));
+  } else {
+    const namespace = identifierName(named.name);
+    if (namespace) bindings.push({ localName: namespace, importedName: '*', namespace, importKind: 'namespace', isTypeOnly: typeOnly, symbolNode: named.name });
+  }
+  return bindings;
+}
+
+function importSpecifierBinding(element, parentTypeOnly) {
+  const localName = identifierName(element.name);
+  if (!localName) return undefined;
+  const typeOnly = Boolean(parentTypeOnly || element.isTypeOnly);
+  const importedName = identifierName(element.propertyName) ?? localName;
+  return {
+    localName,
+    importedName,
+    importKind: typeOnly ? 'type-named' : 'named',
+    isTypeOnly: typeOnly,
+    symbolNode: element.name
+  };
+}
+
+function exportClauseBindings(exportClause, options) {
+  if (!exportClause) return [];
+  if (Array.isArray(exportClause.elements)) {
+    return exportClause.elements.map((element) => exportSpecifierBinding(element, options)).filter(Boolean);
+  }
+  const exportedName = identifierName(exportClause.name);
+  if (!exportedName) return [];
+  return [{
+    localName: exportedName,
+    importedName: '*',
+    exportedName,
+    namespace: exportedName,
+    importKind: 'namespace-reexport',
+    exportKind: 'namespace-reexport',
+    isTypeOnly: Boolean(options.typeOnly),
+    reExport: Boolean(options.reExport),
+    symbolNode: exportClause.name
+  }];
+}
+
+function exportSpecifierBinding(element, options) {
+  const exportedName = identifierName(element.name);
+  if (!exportedName) return undefined;
+  const typeOnly = Boolean(options.typeOnly || element.isTypeOnly);
+  const localName = identifierName(element.propertyName) ?? exportedName;
+  return {
+    localName,
+    importedName: options.reExport ? localName : undefined,
+    exportedName,
+    importKind: options.reExport ? typeOnly ? 'type-reexport' : 'reexport' : undefined,
+    exportKind: typeOnly ? 'type-named' : 'named',
+    isTypeOnly: typeOnly,
+    reExport: Boolean(options.reExport),
+    symbolNode: element.name
+  };
+}
+
+function reExportImportBindings(bindings, exportStar) {
+  if (exportStar) return [];
+  return bindings.map((binding) => ({
+    localName: binding.exportedName ?? binding.localName,
+    importedName: binding.importedName ?? binding.localName,
+    exportedName: binding.exportedName,
+    namespace: binding.namespace,
+    importKind: binding.importKind ?? 'reexport',
+    isTypeOnly: binding.isTypeOnly,
+    symbolNode: binding.symbolNode
+  }));
+}
+
+function importModuleEntries(input, nativeNodeId, moduleSpecifier, _languageKind, bindings, metadata) {
+  const moduleEntry = {
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, moduleSpecifier, 'module', 'import'),
+      importPath: moduleSpecifier,
+      moduleSpecifier,
+      importKind: metadata.importKind,
+      isTypeOnly: metadata.typeOnly,
+      exportStar: metadata.exportStar,
+      metadata: moduleMetadata('typescript-import', bindings, metadata)
+    })
+  };
+  return [moduleEntry, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
+}
+
+function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
+  const declaration = compactRecord({
+    ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
+    symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
+    importPath: moduleSpecifier,
+    moduleSpecifier,
+    localName: binding.localName,
+    importedName: binding.importedName,
+    exportedName: binding.exportedName,
+    namespace: binding.namespace,
+    importKind: binding.importKind,
+    isTypeOnly: binding.isTypeOnly,
+    metadata: compactRecord({
+      scan: 'typescript-import-binding',
+      moduleSpecifier,
+      importPath: moduleSpecifier,
+      localName: binding.localName,
+      importedName: binding.importedName,
+      exportedName: binding.exportedName,
+      namespace: binding.namespace,
+      importKind: binding.importKind,
+      isTypeOnly: binding.isTypeOnly,
+      typeOnly: binding.isTypeOnly
+    })
+  });
+  return { declaration, symbolNode: binding.symbolNode };
+}
+
+function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
+  const statementName = metadata.exportStar
+    ? `* from ${moduleSpecifier}`
+    : moduleSpecifier ? `{${bindings.map((binding) => binding.exportedName).join(',')}} from ${moduleSpecifier}` : `{${bindings.map((binding) => binding.exportedName).join(',')}}`;
+  const statement = {
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, statementName, 'module', 'export'),
+      exportPath: moduleSpecifier,
+      moduleSpecifier,
+      exportKind: metadata.exportKind,
+      exportStar: metadata.exportStar,
+      isTypeOnly: metadata.typeOnly,
+      reExport: metadata.reExport,
+      publicContract: true,
+      metadata: moduleMetadata('typescript-export', bindings, metadata)
+    })
+  };
+  return [statement, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
+}
+
+function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
+  const declaration = compactRecord({
+    ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
+    symbolId: `symbol:${input.language}:export:${idFragment(`${moduleSpecifier ?? 'local'}:${binding.exportedName}:${binding.localName}`)}`,
+    exportPath: moduleSpecifier,
+    moduleSpecifier,
+    localName: binding.localName,
+    importedName: binding.importedName,
+    exportedName: binding.exportedName,
+    namespace: binding.namespace,
+    exportKind: binding.exportKind,
+    isTypeOnly: binding.isTypeOnly,
+    reExport: binding.reExport,
+    publicContract: true,
+    metadata: compactRecord({
+      scan: 'typescript-export-binding',
+      moduleSpecifier,
+      exportPath: moduleSpecifier,
+      localName: binding.localName,
+      importedName: binding.importedName,
+      exportedName: binding.exportedName,
+      namespace: binding.namespace,
+      exportKind: binding.exportKind,
+      isTypeOnly: binding.isTypeOnly,
+      typeOnly: binding.isTypeOnly,
+      reExport: binding.reExport,
+      publicContract: true
+    })
+  });
+  return { declaration, symbolNode: binding.symbolNode };
+}
+
+function moduleMetadata(scan, bindings, metadata) {
+  return compactRecord({
+    scan,
+    moduleOnly: true,
+    bindingCount: bindings.length,
+    importKind: metadata.importKind,
+    exportKind: metadata.exportKind,
+    isTypeOnly: metadata.typeOnly,
+    typeOnly: metadata.typeOnly,
+    sideEffectOnly: metadata.sideEffectOnly,
+    reexport: metadata.reexport,
+    reExport: metadata.reExport,
+    exportStar: metadata.exportStar,
+    publicContract: metadata.reExport || metadata.exportKind
+  });
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -23,17 +23,20 @@ export function visitTypeScriptAstNode(node, sourceFile, context, propertyPath,
   } else if (Array.isArray(node.children)) {
     node.children.forEach(visitChild);
   }
-  const declaration = typeScriptDeclaration(node, kind, id, context.input, context.options);
+  const declarationResult = typeScriptDeclaration(node, kind, id, context.input, context.options);
+  const declarations = Array.isArray(declarationResult) ? declarationResult.filter(Boolean) : declarationResult ? [declarationResult] : [];
+  const primaryDeclaration = declarations[0];
   const nativeNode = {
     id,
     kind,
     languageKind: `${context.input.language}.${kind}`,
     span,
-    value: declaration?.name ?? typeScriptNodeValue(node),
+    value: primaryDeclaration?.name ?? typeScriptNodeValue(node),
     fields: primitiveTypeScriptFields(node, kind),
     children,
     metadata: {
-      ...declaration?.metadata,
+      ...primaryDeclaration?.metadata,
+      ...(declarations.length > 1 ? { declarationCount: declarations.length } : {}),
       astFormat: context.options.astFormat,
       propertyPath,
       pos: numberOrUndefined(node.pos),
@@ -41,6 +44,6 @@ export function visitTypeScriptAstNode(node, sourceFile, context, propertyPath,
     }
   };
   context.nodes[id] = nativeNode;
-  if (declaration) context.declarations.push({ ...declaration, nativeNode });
+  for (const declaration of declarations) context.declarations.push({ ...declaration, nativeNode });
   return id;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.117",
+  "version": "0.2.119",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",