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

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

@@ -0,0 +1,141 @@
+import{idFragment,uniqueByEvidenceId}from'../../native-import-utils.js';import{createDocument,createSemanticIndexRecord,createSourceMapRecord,createUniversalAstEnvelope,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{attachNativeImportLossSummary}from'./attachNativeImportLossSummary.js';import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{externalSemanticSourceMapMappings}from'./externalSemanticSourceMapMappings.js';import{inferExternalSemanticIndexFormat}from'./inferExternalSemanticIndexFormat.js';import{normalizeExternalSemanticIndexFormat}from'./normalizeExternalSemanticIndexFormat.js';import{normalizeExternalSemanticIndexPayload}from'./normalizeExternalSemanticIndexPayload.js';import{normalizeExternalSemanticLanguage}from'./normalizeExternalSemanticLanguage.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function importExternalSemanticIndex(input) {
+  const payload = input?.payload ?? input?.semanticIndex ?? input;
+  if (!payload || typeof payload !== 'object') {
+    throw new Error('importExternalSemanticIndex requires a payload object');
+  }
+  const format = normalizeExternalSemanticIndexFormat(input?.format ?? inferExternalSemanticIndexFormat(payload));
+  const idPart = idFragment(input?.id ?? input?.sourcePath ?? input?.projectRoot ?? format);
+  const context = {
+    format,
+    idPart,
+    language: normalizeExternalSemanticLanguage(input?.language ?? payload.language ?? payload.languageId),
+    sourcePath: input?.sourcePath ?? payload.sourcePath ?? payload.uri ?? payload.path,
+    sourceHash: input?.sourceHash ?? payload.sourceHash ?? payload.md5,
+    projectRoot: input?.projectRoot ?? payload.projectRoot ?? payload.project_root ?? payload.metadata?.projectRoot ?? payload.metadata?.project_root,
+    parser: input?.parser ?? `${format}.external-semantic-index`,
+    metadata: input?.metadata ?? {}
+  };
+  const normalized = normalizeExternalSemanticIndexPayload(payload, context);
+  const evidence = attachNativeImportLossSummary(
+    uniqueByEvidenceId([...(normalized.evidence ?? []), ...(input?.evidence ?? [])]),
+    summarizeNativeImportLosses(normalized.losses ?? [], {
+      evidence: [...(normalized.evidence ?? []), ...(input?.evidence ?? [])],
+      parser: context.parser,
+      scanKind: 'external-semantic-index',
+      semanticStatus: normalized.semanticStatus
+    })
+  );
+  const losses = normalizeNativeLossRecords(normalized.losses ?? []);
+  const semanticIndex = createSemanticIndexRecord({
+    id: input?.semanticIndexId ?? normalized.semanticIndexId ?? `index_${idPart}_${idFragment(format)}`,
+    repository: normalized.repository,
+    documents: normalized.documents,
+    symbols: normalized.symbols,
+    occurrences: normalized.occurrences,
+    relations: normalized.relations,
+    facts: normalized.facts,
+    evidence,
+    metadata: {
+      format,
+      parser: context.parser,
+      source: 'external-semantic-index',
+      projectRoot: context.projectRoot,
+      semanticStatus: normalized.semanticStatus,
+      ...normalized.metadata,
+      ...context.metadata
+    }
+  });
+  const sourceMapMappings = externalSemanticSourceMapMappings(semanticIndex, {
+    evidence,
+    losses,
+    sourcePath: context.sourcePath,
+    sourceHash: context.sourceHash
+  });
+  const sourceMaps = sourceMapMappings.length
+    ? [createSourceMapRecord({
+      id: input?.sourceMapId ?? `source_map_${idPart}_${idFragment(format)}`,
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      semanticIndexId: semanticIndex.id,
+      mappings: sourceMapMappings,
+      evidence,
+      metadata: {
+        format,
+        source: 'external-semantic-index',
+        projectRoot: context.projectRoot
+      }
+    })]
+    : [];
+  const document = createDocument({
+    id: input?.documentId ?? `document_${idPart}_${idFragment(format)}`,
+    name: input?.documentName ?? context.sourcePath ?? `${format} semantic index`,
+    nodes: [],
+    rootIds: [],
+    metadata: {
+      sourceLanguage: context.language,
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      semanticStatus: normalized.semanticStatus,
+      externalSemanticIndexFormat: format
+    }
+  });
+  const universalAst = createUniversalAstEnvelope({
+    id: input?.universalAstId ?? `universal_ast_${idPart}_${idFragment(format)}`,
+    document,
+    nativeSources: [],
+    semanticIndex,
+    sourceMaps,
+    losses,
+    evidence,
+    metadata: {
+      sourceLanguage: context.language,
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      projectRoot: context.projectRoot,
+      externalSemanticIndexFormat: format,
+      semanticStatus: normalized.semanticStatus,
+      ...input?.universalAstMetadata
+    }
+  });
+  const readiness = classifyNativeImportReadiness(losses, {
+    evidence,
+    parser: context.parser,
+    scanKind: 'external-semantic-index',
+    semanticStatus: normalized.semanticStatus
+  });
+  return {
+    kind: 'frontier.lang.externalSemanticIndexImport',
+    version: 1,
+    id: input?.id ?? `external_semantic_index_${idPart}_${idFragment(format)}`,
+    format,
+    language: context.language,
+    sourcePath: context.sourcePath,
+    projectRoot: context.projectRoot,
+    semanticIndex,
+    universalAst,
+    sourceMaps,
+    losses,
+    evidence,
+    readiness,
+    summary: {
+      documents: semanticIndex.documents.length,
+      symbols: semanticIndex.symbols.length,
+      occurrences: semanticIndex.occurrences.length,
+      relations: semanticIndex.relations.length,
+      facts: semanticIndex.facts.length,
+      sourceMapMappings: sourceMaps.reduce((sum, sourceMap) => sum + (sourceMap.mappings?.length ?? 0), 0),
+      losses: losses.length,
+      readiness: readiness.readiness
+    },
+    metadata: {
+      format,
+      parser: context.parser,
+      semanticStatus: normalized.semanticStatus,
+      payloadHash: hashSemanticValue(payload),
+      ...normalized.metadata,
+      ...context.metadata
+    }
+  };
+}

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

@@ -0,0 +1,26 @@
+import{createNativeProjectImportResult}from'./createNativeProjectImportResult.js';import{importNativeSource}from'./importNativeSource.js';import{resolveNativeProjectAdapter}from'./resolveNativeProjectAdapter.js';import{runNativeImporterAdapter}from'./runNativeImporterAdapter.js';
+export async function importNativeProject(input = {}) {
+  const sources = input.sources ?? [];
+  const adapters = input.adapters ?? [];
+  const imports = [];
+  for (const [index, source] of sources.entries()) {
+    const adapter = source.adapter && typeof source.adapter === 'object'
+      ? source.adapter
+      : resolveNativeProjectAdapter(source, adapters, input);
+    if (adapter) {
+      imports.push(await runNativeImporterAdapter(adapter, {
+        ...source,
+        adapterOptions: source.adapterOptions ?? input.adapterOptions,
+        adapterMetadata: {
+          projectImportId: input.id,
+          sourceIndex: index,
+          ...input.adapterMetadata,
+          ...source.adapterMetadata
+        }
+      }));
+    } else {
+      imports.push(importNativeSource(source));
+    }
+  }
+  return createNativeProjectImportResult(input, imports);
+}

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

@@ -0,0 +1,317 @@
+import{commonGeneratedTargetPath,idFragment}from'../../native-import-utils.js';import{inferSourceMapMappings,normalizeSourceMapMappings,normalizeSourceMaps}from'../../native-source-maps.js';import{createKernelSourcePreservationRecords,summarizeKernelSourcePreservationRecords}from'../../semantic-import-source-preservation.js';import{createDocument,createImportResult,createNativeAstRecord,createPatch,createSourceMapRecord,createUniversalAstEnvelope,hashSemanticValue,nativeSourceNode}from'@shapeshift-labs/frontier-lang-kernel';
+import{attachInputUniversalDialectRegistry}from'../../universal-dialect-registry.js';
+import{attachNativeImportLossSummary}from'./attachNativeImportLossSummary.js';import{createLightweightNativeImport}from'./createLightweightNativeImport.js';import{createNativeSourcePreservation}from'./createNativeSourcePreservation.js';import{hasNativeExactAstEvidence}from'./hasNativeExactAstEvidence.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{unverifiedNativeAstLosses}from'./unverifiedNativeAstLosses.js';import{withNativeImportReadiness}from'./withNativeImportReadiness.js';
+export function importNativeSource(input) {
+  const language = input.language ?? input.nativeAst?.language;
+  if (!language) throw new Error('importNativeSource requires a language or nativeAst.language');
+  const sourcePath = input.sourcePath ?? input.nativeAst?.sourcePath;
+  const declaredSourceHash = input.sourceHash ?? input.nativeAst?.sourceHash;
+  const sourceHash = typeof input.sourceText === 'string'
+    ? hashSemanticValue(input.sourceText)
+    : declaredSourceHash ?? hashSemanticValue(input.nativeAst?.nodes ?? input.nativeAst ?? {});
+  const targetPath = input.targetPath ?? input.target?.emitPath;
+  const targetHash = input.targetHash;
+  const importIdPart = idFragment(input.id ?? input.nativeSourceId ?? sourcePath ?? language);
+  const sourcePreservation = input.sourcePreservation ?? (typeof input.sourceText === 'string'
+    ? createNativeSourcePreservation({
+      language,
+      sourcePath,
+      sourceHash: declaredSourceHash,
+      sourceText: input.sourceText,
+      metadata: { importIdPart }
+    })
+    : undefined);
+  const lightweight = !input.nativeAst && !input.nodes && input.sourceText
+    ? createLightweightNativeImport({
+      language,
+      sourceText: input.sourceText,
+      sourcePath,
+      sourceHash,
+      parser: input.parser,
+      sourcePreservation
+    })
+    : undefined;
+  const nativeAst = input.nativeAst ?? createNativeAstRecord({
+    id: input.nativeAstId ?? `native_ast_${importIdPart}`,
+    language,
+    parser: input.parser ?? lightweight?.parser,
+    parserVersion: input.parserVersion,
+    sourcePath,
+    sourceHash,
+    rootId: input.rootId ?? lightweight?.rootId ?? 'native_root',
+    nodes: input.nodes ?? lightweight?.nodes ?? {
+      native_root: {
+        id: 'native_root',
+        kind: 'Unknown',
+        languageKind: `${language}.unknown`,
+        value: null,
+        metadata: { reason: 'no-native-ast-nodes-provided' }
+      }
+    },
+    losses: input.losses ?? lightweight?.losses,
+    metadata: {
+      ...(input.sourceText ? { sourceBytes: input.sourceText.length } : {}),
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservationSummary: sourcePreservation.summary,
+        sourcePreservation
+      } : {}),
+      ...(declaredSourceHash && declaredSourceHash !== sourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: false
+      } : {}),
+      ...lightweight?.metadata,
+      ...input.nativeAstMetadata
+    }
+  });
+  const frontierNodeIds = input.frontierNodeIds ?? input.semanticNodes?.map((node) => node.id) ?? [];
+  const semanticNodes = input.semanticNodes ?? [];
+  const semanticStatus = input.semanticStatus ?? (semanticNodes.length ? 'mapped' : 'native-only');
+  const nativeAstExact = hasNativeExactAstEvidence(input, nativeAst, lightweight);
+  const baseLosses = normalizeNativeLossRecords(input.losses ?? nativeAst.losses ?? lightweight?.losses ?? []);
+  const losses = normalizeNativeLossRecords([
+    ...baseLosses,
+    ...unverifiedNativeAstLosses(input, nativeAst, {
+      importIdPart,
+      exactAst: nativeAstExact,
+      hasLosses: baseLosses.length > 0,
+      lightweight
+    })
+  ]);
+  const nativeSource = nativeSourceNode({
+    id: input.nativeSourceId ?? `native_source_${importIdPart}`,
+    name: input.name ?? sourcePath?.split(/[\\/]/).filter(Boolean).at(-1) ?? `${language}NativeSource`,
+    language,
+    parser: input.parser ?? nativeAst.parser,
+    parserVersion: input.parserVersion ?? nativeAst.parserVersion,
+    sourcePath,
+    sourceHash,
+    symbol: input.symbol,
+    ast: nativeAst,
+    frontierNodeIds,
+    losses,
+    target: input.target,
+    metadata: {
+      semanticStatus,
+      mappings: input.mappings ?? [],
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservation
+      } : {}),
+      ...(declaredSourceHash && declaredSourceHash !== sourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: false
+      } : {}),
+      ...input.nativeSourceMetadata
+    }
+  });
+  const document = createDocument({
+    id: input.documentId ?? `document_${importIdPart}`,
+    name: input.documentName ?? nativeSource.name,
+    nodes: [...semanticNodes, nativeSource],
+    rootIds: input.rootIds,
+    metadata: {
+      sourceLanguage: language,
+      semanticStatus,
+      ...input.documentMetadata
+    }
+  });
+  const baseEvidence = input.evidence ?? [{
+    id: input.evidenceId ?? `evidence_${importIdPart}_import`,
+    kind: 'import',
+    status: losses.some((loss) => loss.severity === 'error') ? 'failed' : 'passed',
+    path: sourcePath,
+    summary: `Imported ${language} native source with ${Object.keys(nativeAst.nodes).length} native AST node(s), ${semanticNodes.length} semantic node(s), and ${losses.length} loss record(s).`,
+    metadata: {
+      parser: nativeAst.parser,
+      sourcePath,
+      semanticStatus,
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservationSummary: sourcePreservation.summary
+      } : {}),
+      ...(declaredSourceHash && declaredSourceHash !== sourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: false
+      } : {})
+    }
+  }];
+  const lossSummary = summarizeNativeImportLosses(losses, {
+    exactAst: nativeAstExact,
+    evidence: baseEvidence,
+    parser: nativeAst.parser,
+    scanKind: lightweight?.metadata?.scanKind,
+    semanticStatus
+  });
+  const evidence = attachNativeImportLossSummary(baseEvidence, lossSummary);
+  const semanticIndex = input.semanticIndex ?? lightweight?.semanticIndex;
+  const sourceMapMappings = normalizeSourceMapMappings(
+    input.mappings ?? lightweight?.mappings ?? inferSourceMapMappings({
+      semanticIndex,
+      nativeAst,
+      nativeSource,
+      evidence
+    }),
+    {
+      semanticIndex,
+      nativeAst,
+      nativeSource,
+      evidence,
+      losses,
+      sourcePreservation,
+      target: input.target,
+      targetPath,
+      targetHash
+    }
+  );
+  const inferredTargetPath = targetPath ?? commonGeneratedTargetPath(sourceMapMappings);
+  const inferredSourceMaps = sourceMapMappings.length
+    ? [createSourceMapRecord({
+      id: input.sourceMapId ?? `source_map_${importIdPart}`,
+      sourcePath,
+      sourceHash,
+      target: input.target,
+      targetPath: inferredTargetPath,
+      targetHash,
+      semanticIndexId: semanticIndex?.id,
+      nativeAstId: nativeAst.id,
+      nativeSourceId: nativeSource.id,
+      mappings: sourceMapMappings,
+      evidence,
+      metadata: {
+        sourceLanguage: language,
+        parser: nativeAst.parser,
+        semanticStatus
+      }
+    })]
+    : [];
+  const sourceMaps = normalizeSourceMaps(input.sourceMaps ?? inferredSourceMaps, {
+    document,
+    nativeSources: [nativeSource],
+    nativeAst,
+    nativeSource,
+    semanticIndex,
+    evidence,
+    losses,
+    sourcePreservation,
+    target: input.target,
+    targetPath: inferredTargetPath,
+    targetHash,
+    sourcePath,
+    sourceHash,
+    defaultSourceMapId: `source_map_${importIdPart}`
+  });
+  const sourcePreservationRecords = createKernelSourcePreservationRecords({
+    idPart: importIdPart,
+    language,
+    sourcePath,
+    sourceHash,
+    sourcePreservation,
+    sourceMaps,
+    losses,
+    evidence,
+    nativeSource,
+    nativeAst,
+    semanticIndex
+  });
+  const kernelSourcePreservationSummary = summarizeKernelSourcePreservationRecords(sourcePreservationRecords);
+  const resultSourceMapMappings = sourceMaps.flatMap((sourceMap) => sourceMap.mappings ?? []);
+  let universalAst = createUniversalAstEnvelope({
+    id: input.universalAstId ?? `universal_ast_${importIdPart}`,
+    document,
+    nativeSources: [nativeSource],
+    semanticIndex,
+    sourceMaps,
+    losses,
+    evidence,
+    metadata: {
+      sourceLanguage: language,
+      sourcePath,
+      semanticStatus,
+      nativeImportLossSummary: lossSummary,
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservation
+      } : {}),
+      ...(sourcePreservationRecords.length ? {
+        sourcePreservationRecords,
+        kernelSourcePreservationRecords: sourcePreservationRecords,
+        kernelSourcePreservationSummary
+      } : {}),
+      ...(declaredSourceHash && declaredSourceHash !== sourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: false
+      } : {}),
+      ...input.universalAstMetadata
+    }
+  });
+  universalAst = attachInputUniversalDialectRegistry(universalAst, input, { language, sourcePath });
+  const patch = input.patch ?? createPatch({
+    id: input.patchId ?? `patch_${importIdPart}_import`,
+    author: input.author ?? '@shapeshift-labs/frontier-lang-compiler/importNativeSource',
+    risk: losses.some((loss) => loss.severity === 'error') ? 'high' : losses.length ? 'medium' : 'low',
+    operations: [...semanticNodes, nativeSource].map((node) => ({
+      op: 'upsertNode',
+      node,
+      touches: [{ id: node.id, access: node.kind === 'nativeSource' ? 'evidence' : 'schema' }]
+    })),
+    evidence,
+    metadata: {
+      sourceLanguage: language,
+      sourcePath,
+      semanticIndexId: semanticIndex?.id,
+      universalAstId: universalAst.id,
+      sourceMapIds: sourceMaps.map((sourceMap) => sourceMap.id),
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservationSummary: sourcePreservation.summary
+      } : {}),
+      ...(sourcePreservationRecords.length ? {
+        kernelSourcePreservationRecordIds: sourcePreservationRecords.map((record) => record.id),
+        kernelSourcePreservationSummary
+      } : {}),
+      ...(declaredSourceHash && declaredSourceHash !== sourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: false
+      } : {}),
+      nativeImportLossSummary: lossSummary
+    }
+  });
+  const importResult = createImportResult({
+    id: input.id ?? `import_${importIdPart}`,
+    language,
+    sourcePath,
+    document,
+    patch,
+    nativeAst,
+    semanticIndex,
+    universalAst,
+    sourceMaps,
+    losses,
+    evidence,
+    metadata: {
+      nativeSourceId: nativeSource.id,
+      semanticIndexId: semanticIndex?.id,
+      universalAstId: universalAst.id,
+      sourceMapIds: sourceMaps.map((sourceMap) => sourceMap.id),
+      semanticStatus,
+      mappings: resultSourceMapMappings,
+      ...(sourcePreservation ? {
+        sourcePreservationId: sourcePreservation.id,
+        sourcePreservation
+      } : {}),
+      ...(sourcePreservationRecords.length ? {
+        sourcePreservationRecords,
+        kernelSourcePreservationRecords: sourcePreservationRecords,
+        kernelSourcePreservationSummary
+      } : {}),
+      ...(declaredSourceHash && declaredSourceHash !== sourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: false
+      } : {}),
+      nativeImportLossSummary: lossSummary,
+      ...input.metadata
+    }
+  });
+  return { ...withNativeImportReadiness(importResult, lossSummary), nativeSource };
+}

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

@@ -0,0 +1,46 @@
+export function inferExternalSemanticIndexFormat(payload) {
+  if (payload.kind === 'frontier.lang.semanticIndex') return 'frontier-semantic-index';
+  if (Array.isArray(payload) && payload.some((entry) => entry?.type === 'vertex' || entry?.type === 'edge')) return 'lsif';
+  if (Array.isArray(payload) && payload.some(isGleanFactEntry)) return 'glean';
+  if (Array.isArray(payload.vertices) || Array.isArray(payload.edges)) return 'lsif';
+  if (Array.isArray(payload.documents) && payload.documents.some((document) => document?.relative_path ?? document?.relativePath)) return 'scip';
+  if (payload.metadata?.project_root || payload.metadata?.projectRoot || payload.external_symbols || payload.externalSymbols) return 'scip';
+  if (Array.isArray(payload.documents) && payload.documents.some((document) => document?.symbols && document?.occurrences && (document?.uri || document?.md5 || document?.schema))) return 'semanticdb';
+  if (Array.isArray(payload.textDocuments) && payload.textDocuments.some(isSemanticDbDocument)) return 'semanticdb';
+  if (payload.glean || payload.schemaId || payload.repo_hash || payload.repoHash || payload.factsByPredicate) return 'glean';
+  if (Array.isArray(payload.facts) && payload.facts.some((fact) => fact?.predicate || fact?.predicateName)) return 'glean';
+  if (payload.predicates && typeof payload.predicates === 'object') return 'glean';
+  if (Array.isArray(payload.documents) && payload.documents.some(isLspDocument)) return 'lsp';
+  if (Array.isArray(payload.documentSymbols) || Array.isArray(payload.symbols) || payload.semanticTokens || payload.textDocument || payload.diagnostics || payload.location || payload.range) return 'lsp';
+  return 'frontier-semantic-index';
+}
+
+function isSemanticDbDocument(document) {
+  if (!document || typeof document !== 'object') return false;
+  return Boolean(
+    (document.symbols || document.occurrences) &&
+    (document.uri || document.path || document.md5 || document.schema)
+  );
+}
+
+function isLspDocument(document) {
+  if (!document || typeof document !== 'object') return false;
+  return Boolean(
+    document.textDocument ||
+    document.documentSymbols ||
+    document.semanticTokens ||
+    document.diagnostics ||
+    (document.symbols && !document.occurrences)
+  );
+}
+
+function isGleanFactEntry(entry) {
+  if (!entry || typeof entry !== 'object') return false;
+  const predicate = entry.predicate ?? entry.predicateName ?? entry.name;
+  return typeof predicate === 'string' && (
+    Array.isArray(entry.facts) ||
+    Array.isArray(entry.results) ||
+    entry.key ||
+    entry.value
+  );
+}

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

@@ -0,0 +1,8 @@
+export function inferredAdapterCoverageNotes(context, coverage) {
+  const notes = [];
+  if (!coverage.exactAst) notes.push('Adapter did not declare exact parser AST/CST coverage; import readiness depends on losses and evidence.');
+  if (!coverage.generatedRanges) notes.push('Adapter does not declare generated-range coverage unless parse output includes generated spans.');
+  if (!coverage.diagnostics) notes.push('Adapter did not declare parser diagnostics support.');
+  if (context.language && context.parser) notes.push(`Coverage summary applies to ${context.language} via ${context.parser}.`);
+  return notes;
+}

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

@@ -0,0 +1,5 @@
+export function inferredAdapterExactness(exactAst, capabilities) {
+  if (exactAst) return 'exact-parser-ast';
+  if (capabilities.has('nativeast')) return 'adapter-reported-native-ast';
+  return 'loss-aware-native-ast';
+}

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

@@ -0,0 +1,5 @@
+export function inferredSemanticCoverageLevel(input) {
+  if (input.references || input.types || input.controlFlow) return 'semantic-index';
+  if (input.declarations || input.symbols) return 'declaration-index';
+  return 'native-ast';
+}

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

@@ -0,0 +1,4 @@
+import{csharpRoslynKind}from'./csharpRoslynKind.js';
+export function isCSharpRoslynNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof csharpRoslynKind(value) === 'string');
+}

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

@@ -0,0 +1,4 @@
+import{clangAstKind}from'./clangAstKind.js';
+export function isClangAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof clangAstKind(value) === 'string');
+}

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

@@ -0,0 +1,4 @@
+import{goAstKind}from'./goAstKind.js';
+export function isGoAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof goAstKind(value) === 'string');
+}

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

@@ -0,0 +1,4 @@
+import{javaAstKind}from'./javaAstKind.js';
+export function isJavaAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof javaAstKind(value) === 'string');
+}

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

@@ -0,0 +1,4 @@
+import{kotlinPsiKind}from'./kotlinPsiKind.js';
+export function isKotlinPsiNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof kotlinPsiKind(value) === 'string');
+}

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

@@ -0,0 +1,3 @@
+export function isNativeSourceImportResult(input) {
+  return Boolean(input && typeof input === 'object' && input.kind === 'frontier.lang.importResult' && input.nativeSource && input.universalAst);
+}

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

@@ -0,0 +1,4 @@
+import{pythonAstKind}from'./pythonAstKind.js';
+export function isPythonAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof pythonAstKind(value) === 'string');
+}

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

@@ -0,0 +1,4 @@
+import{rustSynKind}from'./rustSynKind.js';
+export function isRustSynAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof rustSynKind(value) === 'string');
+}

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

@@ -0,0 +1,4 @@
+import{swiftSyntaxKind}from'./swiftSyntaxKind.js';
+export function isSwiftSyntaxNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof swiftSyntaxKind(value) === 'string');
+}

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

@@ -0,0 +1,3 @@
+export function isSyntaxAstNode(value) {
+  return Boolean(value && typeof value === 'object' && typeof (value.type ?? value.kind) === 'string');
+}

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

@@ -0,0 +1,13 @@
+export function javaAnnotationProcessingSummary(value) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) return { processorCount: value.length };
+  if (typeof value === 'object') {
+    const summary = {};
+    if (typeof value.hash === 'string') summary.hash = value.hash;
+    if (typeof value.enabled === 'boolean') summary.enabled = value.enabled;
+    if (Array.isArray(value.processors)) summary.processorCount = value.processors.length;
+    if (Array.isArray(value.generatedSources)) summary.generatedSourceCount = value.generatedSources.length;
+    return Object.keys(summary).length ? summary : { present: true };
+  }
+  return { present: Boolean(value) };
+}

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

@@ -0,0 +1,18 @@
+import{ignoredJavaAstField}from'./ignoredJavaAstField.js';import{isJavaAstNode}from'./isJavaAstNode.js';import{javaAstChildWithParent}from'./javaAstChildWithParent.js';import{javaAstKind}from'./javaAstKind.js';
+export function javaAstChildEntries(node, kind = javaAstKind(node)) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredJavaAstField(key));
+  const entries = [];
+  for (const field of fieldNames) {
+    const value = node[field];
+    if (Array.isArray(value)) {
+      entries.push([field, value.map((entry) => javaAstChildWithParent(entry, kind, field))]);
+      continue;
+    }
+    if (value && typeof value === 'object') {
+      entries.push([field, javaAstChildWithParent(value, kind, field)]);
+    }
+  }
+  return entries.filter(([, value]) => Array.isArray(value)
+    ? value.some(isJavaAstNode)
+    : isJavaAstNode(value));
+}

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

@@ -0,0 +1,6 @@
+import{isJavaAstNode}from'./isJavaAstNode.js';
+export function javaAstChildWithParent(entry, parentKind, parentField) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return entry;
+  if (!isJavaAstNode(entry)) return entry;
+  return { parentKind, parentField, ...entry };
+}

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

@@ -0,0 +1,11 @@
+import{javaAstName}from'./javaAstName.js';
+export function javaAstDeclarationName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['name', 'identifier', 'simpleName', 'qualifiedName', 'id']) {
+    const value = node[key];
+    const name = javaAstName(value);
+    if (name) return name;
+  }
+  if (node.declaration && typeof node.declaration === 'object') return javaAstDeclarationName(node.declaration);
+  return undefined;
+}