@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.43

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

@@ -0,0 +1,66 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromJavaAst}from'./createNativeImportFromJavaAst.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{javaAstRoot}from'./javaAstRoot.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseJavaAstSource}from'./parseJavaAstSource.js';
+export function createJavaAstNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.java-ast-native-importer',
+    language: options.language ?? 'java',
+    parser: options.parser ?? 'javac',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: false,
+      trivia: false,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned javac/JDT/JavaParser-shaped Java ASTs into native AST nodes and declaration-level semantic index records.',
+        'Java AST imports do not resolve overloads, bindings, annotation processors, generated Lombok code, classpaths, modules, bytecode, comments/trivia, or control flow by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.java'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.compilationUnit
+        ?? input.options?.unit
+        ?? input.options?.sourceFile
+        ?? options.ast
+        ?? options.compilationUnit
+        ?? options.unit
+        ?? options.sourceFile
+        ?? parseJavaAstSource(input, options);
+      const root = javaAstRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'javac',
+          adapterId: options.id ?? 'frontier.java-ast-native-importer',
+          message: 'createJavaAstNativeImporterAdapter requires an injected Java AST object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.problems, input, {
+        parser: options.parser ?? 'javac'
+      });
+      return createNativeImportFromJavaAst(root, input, {
+        parser: options.parser ?? 'javac',
+        astFormat: 'java-ast',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        javaVersion: options.javaVersion ?? input.options?.javaVersion ?? parsed?.javaVersion,
+        sourceLevel: options.sourceLevel ?? input.options?.sourceLevel ?? parsed?.sourceLevel,
+        classPath: input.options?.classPath ?? options.classPath ?? parsed?.classPath,
+        modulePath: input.options?.modulePath ?? options.modulePath ?? parsed?.modulePath,
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated,
+        annotationProcessing: input.options?.annotationProcessing ?? options.annotationProcessing ?? parsed?.annotationProcessing,
+        bindingEvidence: input.options?.bindingEvidence ?? options.bindingEvidence ?? parsed?.bindingEvidence,
+        positionResolver: input.options?.positionResolver ?? options.positionResolver,
+        lineMap: input.options?.lineMap ?? options.lineMap ?? parsed?.lineMap,
+        includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations
+      });
+    }
+  };
+}

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

@@ -0,0 +1,73 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromKotlinPsi}from'./createNativeImportFromKotlinPsi.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{kotlinGeneratedSourcePath}from'./kotlinGeneratedSourcePath.js';import{kotlinPsiRoot}from'./kotlinPsiRoot.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';import{parseKotlinPsiSource}from'./parseKotlinPsiSource.js';
+export function createKotlinPsiNativeImporterAdapter(options = {}) {
+  return {
+    id: options.id ?? 'frontier.kotlin-psi-native-importer',
+    language: options.language ?? 'kotlin',
+    parser: options.parser ?? 'kotlin-psi',
+    version: options.version,
+    capabilities: uniqueStrings(['nativeAst', 'semanticIndex', 'sourceMaps', 'diagnostics', ...(options.capabilities ?? [])]),
+    coverage: nativeImporterAdapterCoverage({
+      exactness: 'exact-parser-ast',
+      exactAst: true,
+      tokens: true,
+      trivia: true,
+      diagnostics: true,
+      sourceRanges: true,
+      generatedRanges: false,
+      semanticCoverage: declarationSemanticCoverage(),
+      notes: [
+        'Normalizes caller-owned Kotlin PSI/KtFile-shaped syntax trees into native AST nodes and declaration-level semantic index records.',
+        'Kotlin PSI imports do not resolve Analysis API symbols, FIR/K2 types, overloads, nullability flow, expect/actual matching, compiler-plugin generated declarations, KSP/KAPT output, scripts, build variants, or control flow by themselves; attach host evidence for those claims.'
+      ]
+    }, options.coverage),
+    supportedExtensions: options.supportedExtensions ?? ['.kt', '.kts'],
+    diagnostics: options.diagnostics,
+    parse(input) {
+      const parsed = input.options?.ast
+        ?? input.options?.nativeAst
+        ?? input.options?.ktFile
+        ?? input.options?.file
+        ?? input.options?.sourceFile
+        ?? input.options?.root
+        ?? options.ast
+        ?? options.ktFile
+        ?? options.file
+        ?? options.sourceFile
+        ?? options.root
+        ?? parseKotlinPsiSource(input, options);
+      const root = kotlinPsiRoot(parsed);
+      if (!root) {
+        return missingInjectedParserResult(input, {
+          parser: options.parser ?? 'kotlin-psi',
+          adapterId: options.id ?? 'frontier.kotlin-psi-native-importer',
+          message: 'createKotlinPsiNativeImporterAdapter requires an injected Kotlin PSI KtFile-shaped object, parserModule.parse function, parse function, or adapterOptions.ast.'
+        });
+      }
+      const parseDiagnostics = normalizeParserErrors(parsed?.errors ?? parsed?.diagnostics ?? parsed?.parseDiagnostics, input, {
+        parser: options.parser ?? 'kotlin-psi'
+      });
+      return createNativeImportFromKotlinPsi(root, input, {
+        parser: options.parser ?? 'kotlin-psi',
+        astFormat: 'kotlin-psi',
+        maxNodes: options.maxNodes,
+        diagnostics: parseDiagnostics,
+        kotlinVersion: options.kotlinVersion ?? input.options?.kotlinVersion ?? parsed?.kotlinVersion,
+        languageVersion: options.languageVersion ?? input.options?.languageVersion ?? parsed?.languageVersion,
+        apiVersion: options.apiVersion ?? input.options?.apiVersion ?? parsed?.apiVersion,
+        script: input.options?.script ?? options.script ?? parsed?.script ?? /\.kts$/i.test(input.sourcePath ?? ''),
+        generated: input.options?.generated ?? options.generated ?? parsed?.generated ?? kotlinGeneratedSourcePath(input.sourcePath),
+        analysisApiEvidence: input.options?.analysisApiEvidence ?? options.analysisApiEvidence ?? parsed?.analysisApiEvidence,
+        firEvidence: input.options?.firEvidence ?? options.firEvidence ?? parsed?.firEvidence,
+        compilerPluginEvidence: input.options?.compilerPluginEvidence ?? options.compilerPluginEvidence ?? parsed?.compilerPluginEvidence,
+        kspEvidence: input.options?.kspEvidence ?? options.kspEvidence ?? parsed?.kspEvidence,
+        kaptEvidence: input.options?.kaptEvidence ?? options.kaptEvidence ?? parsed?.kaptEvidence,
+        multiplatformEvidence: input.options?.multiplatformEvidence ?? options.multiplatformEvidence ?? parsed?.multiplatformEvidence,
+        buildVariantEvidence: input.options?.buildVariantEvidence ?? options.buildVariantEvidence ?? parsed?.buildVariantEvidence,
+        positionResolver: input.options?.positionResolver ?? options.positionResolver,
+        lineMap: input.options?.lineMap ?? options.lineMap ?? parsed?.lineMap,
+        includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations
+      });
+    }
+  };
+}

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

@@ -0,0 +1,154 @@
+import{idFragment}from'../../native-import-utils.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+export function createLightweightNativeImport(input) {
+  const parser = input.parser ?? `${input.language}.lightweight-declaration-scan`;
+  const rootId = 'native_root';
+  const nodes = {
+    [rootId]: {
+      id: rootId,
+      kind: 'Program',
+      languageKind: `${input.language}.program`,
+      children: [],
+      metadata: { parser, sourceHash: input.sourceHash }
+    }
+  };
+  const declarations = scanNativeDeclarations(input);
+  const losses = [];
+  const documentId = `doc_${idFragment(input.sourcePath ?? input.language)}`;
+  const symbols = [];
+  const occurrences = [];
+  const relations = [];
+  const facts = [];
+  const mappings = [];
+  const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_lightweight_scan`;
+
+  for (const declaration of declarations) {
+    const ownershipRegion = semanticOwnershipRegionForDeclaration(input, declaration, documentId);
+    nodes[rootId].children.push(declaration.nodeId);
+    nodes[declaration.nodeId] = {
+      id: declaration.nodeId,
+      kind: declaration.kind,
+      languageKind: declaration.languageKind,
+      span: declaration.span,
+      value: declaration.name ?? declaration.importPath ?? null,
+      fields: declaration.fields,
+      metadata: {
+        ...declaration.metadata,
+        ownershipRegionId: ownershipRegion.id,
+        ownershipRegionKey: ownershipRegion.key,
+        ownershipRegionKind: ownershipRegion.regionKind
+      }
+    };
+    if (declaration.symbolId) {
+      const occurrenceId = `occ_${idFragment(declaration.nodeId)}_def`;
+      symbols.push({
+        id: declaration.symbolId,
+        scheme: 'frontier',
+        name: declaration.name,
+        kind: declaration.symbolKind,
+        language: input.language,
+        nativeAstNodeId: declaration.nodeId,
+        signatureHash: hashSemanticValue([input.language, declaration.kind, declaration.name, declaration.fields ?? {}]),
+        definitionSpan: declaration.span,
+        metadata: {
+          ownershipRegionId: ownershipRegion.id,
+          ownershipRegionKey: ownershipRegion.key,
+          ownershipRegionKind: ownershipRegion.regionKind
+        }
+      });
+      occurrences.push({
+        id: occurrenceId,
+        documentId,
+        symbolId: declaration.symbolId,
+        role: declaration.role ?? 'definition',
+        span: declaration.span,
+        nativeAstNodeId: declaration.nodeId
+      });
+      relations.push({
+        id: `rel_${idFragment(documentId)}_${idFragment(declaration.nodeId)}`,
+        sourceId: documentId,
+        predicate: declaration.role === 'import' ? 'imports' : 'defines',
+        targetId: declaration.symbolId
+      });
+      facts.push({
+        id: `fact_${idFragment(declaration.nodeId)}_kind`,
+        predicate: 'nativeKind',
+        subjectId: declaration.symbolId,
+        value: declaration.languageKind
+      }, {
+        id: `fact_${idFragment(declaration.nodeId)}_ownership_region`,
+        predicate: 'semanticOwnershipRegion',
+        subjectId: declaration.symbolId,
+        value: ownershipRegion
+      }, {
+        id: `fact_${idFragment(declaration.nodeId)}_ownership_region_taxonomy`,
+        predicate: 'semanticOwnershipRegionTaxonomy',
+        subjectId: declaration.symbolId,
+        value: {
+          regionKind: ownershipRegion.regionKind,
+          granularity: ownershipRegion.granularity,
+          key: ownershipRegion.key
+        }
+      });
+      mappings.push({
+        id: `map_${idFragment(declaration.nodeId)}`,
+        nativeAstNodeId: declaration.nodeId,
+        semanticSymbolId: declaration.symbolId,
+        semanticOccurrenceId: occurrenceId,
+        sourceSpan: declaration.span,
+        evidenceIds: [evidenceId],
+        lossIds: declaration.loss ? [declaration.loss.id] : [],
+        ownershipRegionId: ownershipRegion.id,
+        ownershipRegionKey: ownershipRegion.key,
+        ownershipRegionKind: ownershipRegion.regionKind,
+        precision: 'declaration'
+      });
+    }
+    if (declaration.loss) losses.push(declaration.loss);
+  }
+  losses.push(...lightweightCoverageLosses(input, declarations, input.sourcePreservation));
+
+  const semanticIndex = createSemanticIndexRecord({
+    id: `index_${idFragment(input.sourcePath ?? input.language)}`,
+    documents: [{
+      id: documentId,
+      path: input.sourcePath ?? `${input.language}:memory`,
+      language: input.language,
+      sourceHash: input.sourceHash
+    }],
+    symbols,
+    occurrences,
+    relations,
+    facts,
+    evidence: [{
+      id: evidenceId,
+      kind: 'import',
+      status: 'passed',
+      path: input.sourcePath,
+      summary: `Lightweight declaration scan found ${symbols.length} symbol(s).`,
+      metadata: { parser }
+    }],
+    metadata: {
+      parser,
+      coverage: 'declarations-only',
+      unsupported: ['full expression AST', 'type checking', 'control flow', 'comments and formatting preservation']
+    }
+  });
+
+  return {
+    parser,
+    rootId,
+    nodes,
+    losses,
+    semanticIndex,
+    mappings,
+    metadata: {
+      parser,
+      scanKind: 'lightweight-declaration-scan',
+      declarationCount: declarations.length,
+      ...(input.sourcePreservation ? {
+        sourcePreservationId: input.sourcePreservation.id,
+        sourcePreservationSummary: input.sourcePreservation.summary
+      } : {})
+    }
+  };
+}

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

@@ -0,0 +1,5 @@
+import{createNativeImportCoverageMatrix as createNativeImportCoverageMatrixImpl}from'../../native-import-coverage-matrix.js';
+import{coverageMatrixContext}from'./coverageMatrixContext.js';
+export function createNativeImportCoverageMatrix(input = {}) {
+  return createNativeImportCoverageMatrixImpl(input, coverageMatrixContext());
+}

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

@@ -0,0 +1,39 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{csharpEvidenceSummary}from'./csharpEvidenceSummary.js';import{csharpGeneratedCodeLoss}from'./csharpGeneratedCodeLoss.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitCSharpRoslynNode}from'./visitCSharpRoslynNode.js';
+export function createNativeImportFromCSharpRoslyn(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitCSharpRoslynNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(csharpGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      csharpVersion: options.csharpVersion,
+      languageVersion: options.languageVersion,
+      nullableContext: options.nullableContext,
+      generated: options.generated,
+      projectReferences: csharpEvidenceSummary(options.projectReferences),
+      analyzerDiagnostics: csharpEvidenceSummary(options.analyzerDiagnostics),
+      semanticModelEvidence: csharpEvidenceSummary(options.semanticModelEvidence),
+      sourceGeneratorEvidence: csharpEvidenceSummary(options.sourceGeneratorEvidence),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,36 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{clangPreprocessorRecords}from'./clangPreprocessorRecords.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{serializableIncludeGraphSummary}from'./serializableIncludeGraphSummary.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitClangAstNode}from'./visitClangAstNode.js';
+export function createNativeImportFromClangAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitClangAstNode(root, context, 'root');
+  for (const [index, record] of clangPreprocessorRecords(options.preprocessorRecords).entries()) {
+    visitClangAstNode(record, context, `preprocessorRecords[${index}]`);
+  }
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      cStandard: options.cStandard,
+      compileFlags: Array.isArray(options.compileFlags) ? options.compileFlags.slice() : options.compileFlags,
+      includeSystemHeaders: Boolean(options.includeSystemHeaders),
+      preprocessorRecordCount: clangPreprocessorRecords(options.preprocessorRecords).length,
+      includeGraph: serializableIncludeGraphSummary(options.includeGraph),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,35 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{goTypeEvidenceSummary}from'./goTypeEvidenceSummary.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitGoAstNode}from'./visitGoAstNode.js';
+export function createNativeImportFromGoAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitGoAstNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      goVersion: options.goVersion,
+      packageName: options.packageName,
+      includeComments: Boolean(options.includeComments),
+      buildTags: Array.isArray(options.buildTags) ? options.buildTags.slice() : options.buildTags,
+      generated: options.generated,
+      fileSetEvidence: Boolean(options.fileSet),
+      typeEvidence: goTypeEvidenceSummary(options.typeEvidence),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,39 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{javaAnnotationProcessingSummary}from'./javaAnnotationProcessingSummary.js';import{javaBindingEvidenceSummary}from'./javaBindingEvidenceSummary.js';import{javaGeneratedCodeLoss}from'./javaGeneratedCodeLoss.js';import{javaPathEvidenceSummary}from'./javaPathEvidenceSummary.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitJavaAstNode}from'./visitJavaAstNode.js';
+export function createNativeImportFromJavaAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitJavaAstNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(javaGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      javaVersion: options.javaVersion,
+      sourceLevel: options.sourceLevel,
+      classPathEvidence: javaPathEvidenceSummary(options.classPath),
+      modulePathEvidence: javaPathEvidenceSummary(options.modulePath),
+      annotationProcessing: javaAnnotationProcessingSummary(options.annotationProcessing),
+      bindingEvidence: javaBindingEvidenceSummary(options.bindingEvidence),
+      generated: options.generated,
+      includeAnnotations: Boolean(options.includeAnnotations),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,47 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{kotlinEvidenceSummary}from'./kotlinEvidenceSummary.js';import{kotlinGeneratedCodeLoss}from'./kotlinGeneratedCodeLoss.js';import{kotlinScriptLoss}from'./kotlinScriptLoss.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitKotlinPsiNode}from'./visitKotlinPsiNode.js';
+export function createNativeImportFromKotlinPsi(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitKotlinPsiNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(kotlinGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  if (options.script && !context.losses.some((loss) => loss.metadata?.script === true)) {
+    context.losses.push(kotlinScriptLoss(input, context.rootId, undefined, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      kotlinVersion: options.kotlinVersion,
+      languageVersion: options.languageVersion,
+      apiVersion: options.apiVersion,
+      script: Boolean(options.script),
+      generated: options.generated,
+      analysisApiEvidence: kotlinEvidenceSummary(options.analysisApiEvidence),
+      firEvidence: kotlinEvidenceSummary(options.firEvidence),
+      compilerPluginEvidence: kotlinEvidenceSummary(options.compilerPluginEvidence),
+      kspEvidence: kotlinEvidenceSummary(options.kspEvidence),
+      kaptEvidence: kotlinEvidenceSummary(options.kaptEvidence),
+      multiplatformEvidence: kotlinEvidenceSummary(options.multiplatformEvidence),
+      buildVariantEvidence: kotlinEvidenceSummary(options.buildVariantEvidence),
+      includeAnnotations: Boolean(options.includeAnnotations),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,30 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitPythonAstNode}from'./visitPythonAstNode.js';
+export function createNativeImportFromPythonAst(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitPythonAstNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      pythonVersion: options.pythonVersion,
+      includeAttributes: Boolean(options.includeAttributes),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,30 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitRustSynNode}from'./visitRustSynNode.js';
+export function createNativeImportFromRustSyn(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitRustSynNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      rustEdition: options.rustEdition,
+      includeAttributes: Boolean(options.includeAttributes),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,37 @@
+import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{swiftEvidenceSummary}from'./swiftEvidenceSummary.js';import{swiftGeneratedCodeLoss}from'./swiftGeneratedCodeLoss.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitSwiftSyntaxNode}from'./visitSwiftSyntaxNode.js';
+export function createNativeImportFromSwiftSyntax(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitSwiftSyntaxNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  if (options.generated && !context.losses.some((loss) => loss.kind === 'generatedCode')) {
+    context.losses.push(swiftGeneratedCodeLoss(input, context.rootId, undefined, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      swiftVersion: options.swiftVersion,
+      languageMode: options.languageMode,
+      generated: options.generated,
+      sourceKitEvidence: swiftEvidenceSummary(options.sourceKitEvidence),
+      macroExpansionEvidence: swiftEvidenceSummary(options.macroExpansionEvidence),
+      packageResolutionEvidence: swiftEvidenceSummary(options.packageResolutionEvidence),
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,36 @@
+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';
+export function createNativeImportFromSyntaxAst(ast, input, options) {
+  const root = normalizeSyntaxAstRoot(ast, options.astFormat);
+  if (!root) {
+    return missingInjectedParserResult(input, {
+      parser: options.parser,
+      adapterId: input.adapterId,
+      message: 'Injected AST did not contain an object root node.'
+    });
+  }
+  const context = createAstNormalizationContext(input, options);
+  visitSyntaxAstNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: mergeNativeLosses(context.losses, options.diagnostics?.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, {
+      id: input.adapterId,
+      version: input.adapterVersion
+    }, input)) ?? []),
+    evidence: semantic.evidence,
+    diagnostics: options.diagnostics,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}