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

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

@@ -0,0 +1,6 @@
+import{normalizeNativeLossRecord}from'./normalizeNativeLossRecord.js';
+export function normalizeNativeLossRecords(losses) {
+  return (Array.isArray(losses) ? losses : [losses])
+    .filter((loss) => loss !== undefined && loss !== null)
+    .map((loss, index) => normalizeNativeLossRecord(loss, `loss_${index + 1}`));
+}

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

@@ -0,0 +1,37 @@
+import{normalizeProjectionMatrixTargets}from'../../coverage-matrix-profiles.js';import{normalizeNativeLanguageId,normalizeStringList}from'../../native-import-utils.js';
+import{normalizeAdapterDiagnostics}from'./normalizeAdapterDiagnostics.js';import{normalizeNativeTargetProjectionAdapterCoverage}from'./normalizeNativeTargetProjectionAdapterCoverage.js';
+export function normalizeNativeTargetProjectionAdapter(adapter) {
+  if (!adapter || typeof adapter !== 'object') {
+    throw new Error('Native target projection adapter must be an object');
+  }
+  if (!adapter.id) throw new Error('Native target projection adapter requires an id');
+  const sourceLanguage = normalizeNativeLanguageId(adapter.sourceLanguage ?? adapter.language);
+  if (!sourceLanguage) throw new Error(`Native target projection adapter ${adapter.id} requires a sourceLanguage`);
+  const target = normalizeProjectionMatrixTargets([adapter.target ?? adapter.targetLanguage])[0];
+  if (!target) throw new Error(`Native target projection adapter ${adapter.id} requires a target`);
+  if (typeof adapter.project !== 'function') throw new Error(`Native target projection adapter ${adapter.id} requires a project function`);
+  const capabilities = normalizeStringList(adapter.capabilities);
+  const summaryInput = {
+    id: String(adapter.id),
+    sourceLanguage,
+    language: sourceLanguage,
+    target,
+    parser: `target:${target}`,
+    version: adapter.version === undefined ? undefined : String(adapter.version)
+  };
+  return Object.freeze({
+    id: summaryInput.id,
+    sourceLanguage,
+    target,
+    version: summaryInput.version,
+    capabilities,
+    supportedParsers: normalizeStringList(adapter.supportedParsers),
+    supportedExtensions: normalizeStringList(adapter.supportedExtensions).map((extension) => extension.startsWith('.') ? extension.toLowerCase() : `.${extension.toLowerCase()}`),
+    coverage: normalizeNativeTargetProjectionAdapterCoverage(adapter.coverage, { capabilities }),
+    diagnostics: normalizeAdapterDiagnostics(adapter.diagnostics, summaryInput, {
+      language: sourceLanguage,
+      parser: summaryInput.parser,
+      parserVersion: summaryInput.version
+    }, 'target-adapter')
+  });
+}

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

@@ -0,0 +1,20 @@
+import{normalizeSemanticMergeReadiness,normalizeStringList,uniqueStrings}from'../../native-import-utils.js';
+export function normalizeNativeTargetProjectionAdapterCoverage(value = {}, context = {}) {
+  const capabilities = new Set(normalizeStringList(context.capabilities).map((capability) => capability.toLowerCase()));
+  const lossKinds = uniqueStrings(value.lossKinds ?? []);
+  const handledLossKinds = uniqueStrings([
+    ...(value.handledLossKinds ?? []),
+    ...(capabilities.has('macros') || capabilities.has('macroexpansion') ? ['macroExpansion', 'macroHygiene'] : []),
+    ...(capabilities.has('preprocessor') ? ['preprocessor', 'conditionalCompilation'] : []),
+    ...(capabilities.has('dynamicruntime') ? ['dynamicRuntime', 'dynamicDispatch'] : []),
+    ...(capabilities.has('typeinference') ? ['typeInference', 'overloadResolution'] : [])
+  ]);
+  return Object.freeze({
+    readiness: normalizeSemanticMergeReadiness(value.readiness) ?? 'needs-review',
+    lossKinds,
+    handledLossKinds,
+    sourceMapPrecision: value.sourceMapPrecision,
+    semanticCoverage: value.semanticCoverage ?? {},
+    notes: uniqueStrings(value.notes ?? ['Target projection adapter output is host-owned evidence and should be reviewed unless declared ready.'])
+  });
+}

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

@@ -0,0 +1,18 @@
+import{idFragment}from'../../native-import-utils.js';
+import{spanFromLoc}from'./spanFromLoc.js';
+export function normalizeParserErrors(errors, input, options) {
+  return (errors ?? []).map((error, index) => ({
+    id: `diagnostic_${idFragment(options.parser)}_parser_error_${index + 1}`,
+    severity: 'error',
+    code: error.code ?? error.reasonCode,
+    phase: 'parse',
+    kind: 'unsupportedSyntax',
+    message: String(error.message ?? 'Parser reported a syntax error.'),
+    path: input.sourcePath,
+    span: spanFromLoc(error.loc ? { start: error.loc, end: error.loc } : undefined, input),
+    metadata: {
+      parser: options.parser,
+      reasonCode: error.reasonCode
+    }
+  }));
+}

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

@@ -0,0 +1,32 @@
+export function normalizeRustSynKind(kind) {
+  const text = String(kind);
+  const compact = text.replace(/^(?:syn::)?/, '').replace(/^Item::/, 'Item').replace(/^ImplItem::/, 'ImplItem').replace(/^TraitItem::/, 'TraitItem');
+  if (/^fn$/i.test(compact)) return 'ItemFn';
+  if (/^struct$/i.test(compact)) return 'ItemStruct';
+  if (/^enum$/i.test(compact)) return 'ItemEnum';
+  if (/^trait$/i.test(compact)) return 'ItemTrait';
+  if (/^impl$/i.test(compact)) return 'ItemImpl';
+  if (/^use$/i.test(compact)) return 'ItemUse';
+  if (/^mod$/i.test(compact)) return 'ItemMod';
+  if (/^type$/i.test(compact)) return 'ItemType';
+  if (/^const$/i.test(compact)) return 'ItemConst';
+  if (/^static$/i.test(compact)) return 'ItemStatic';
+  if (/^union$/i.test(compact)) return 'ItemUnion';
+  if (/^item_fn$/i.test(compact)) return 'ItemFn';
+  if (/^item_struct$/i.test(compact)) return 'ItemStruct';
+  if (/^item_enum$/i.test(compact)) return 'ItemEnum';
+  if (/^item_trait$/i.test(compact)) return 'ItemTrait';
+  if (/^item_impl$/i.test(compact)) return 'ItemImpl';
+  if (/^item_use$/i.test(compact)) return 'ItemUse';
+  if (/^item_mod$/i.test(compact)) return 'ItemMod';
+  if (/^item_type$/i.test(compact)) return 'ItemType';
+  if (/^item_const$/i.test(compact)) return 'ItemConst';
+  if (/^item_static$/i.test(compact)) return 'ItemStatic';
+  if (/^item_union$/i.test(compact)) return 'ItemUnion';
+  if (/^item_macro$/i.test(compact)) return 'ItemMacro';
+  if (/^macro$/i.test(compact)) return 'Macro';
+  if (/^impl_item_fn$/i.test(compact)) return 'ImplItemFn';
+  if (/^trait_item_fn$/i.test(compact)) return 'TraitItemFn';
+  if (/^foreign_item_fn$/i.test(compact)) return 'ForeignItemFn';
+  return compact;
+}

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

@@ -0,0 +1,98 @@
+import{idFragment}from'../../native-import-utils.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{externalDiagnosticFact}from'./externalDiagnosticFact.js';import{externalDiagnosticLoss}from'./externalDiagnosticLoss.js';import{externalSemanticBase}from'./externalSemanticBase.js';import{nameFromExternalSymbol}from'./nameFromExternalSymbol.js';import{normalizeArray}from'./normalizeArray.js';import{normalizeExternalSemanticLanguage}from'./normalizeExternalSemanticLanguage.js';import{normalizeExternalSymbolKind}from'./normalizeExternalSymbolKind.js';import{scipOccurrenceRole}from'./scipOccurrenceRole.js';import{scipOccurrenceRoleSet}from'./scipOccurrenceRoleSet.js';import{scipRelationshipRelations}from'./scipRelationshipRelations.js';import{scipSymbolFacts}from'./scipSymbolFacts.js';import{scipSymbolId}from'./scipSymbolId.js';import{scipSyntaxKind}from'./scipSyntaxKind.js';import{spanFromScipOccurrence}from'./spanFromScipOccurrence.js';import{withExternalEmptyLoss}from'./withExternalEmptyLoss.js';
+export function normalizeScipPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: 'scip' });
+  const metadata = payload.metadata ?? {};
+  const projectRoot = context.projectRoot ?? metadata.project_root ?? metadata.projectRoot;
+  result.repository = projectRoot ? { root: projectRoot } : undefined;
+  const documents = normalizeArray(payload.documents);
+  for (const [documentIndex, document] of documents.entries()) {
+    const path = document.relative_path ?? document.relativePath ?? document.path ?? context.sourcePath ?? `scip-document-${documentIndex + 1}`;
+    const language = normalizeExternalSemanticLanguage(document.language ?? context.language);
+    const documentId = document.id ?? `doc_${idFragment(path)}`;
+    result.documents.push({
+      id: documentId,
+      path,
+      language,
+      sourceHash: document.sourceHash ?? document.md5 ?? context.sourceHash,
+      metadata: {
+        format: 'scip',
+        projectRoot,
+        textDocumentEncoding: metadata.text_document_encoding ?? metadata.textDocumentEncoding,
+        documentIndex
+      }
+    });
+    const documentSymbols = new Map();
+    for (const symbolInfo of [...normalizeArray(document.symbols), ...normalizeArray(payload.external_symbols ?? payload.externalSymbols)]) {
+      const symbolId = scipSymbolId(symbolInfo.symbol, context, normalizeArray(document.symbols).includes(symbolInfo) ? documentId : undefined);
+      if (!symbolId || documentSymbols.has(symbolId)) continue;
+      documentSymbols.set(symbolId, true);
+      result.symbols.push({
+        id: symbolId,
+        scheme: 'scip',
+        name: symbolInfo.display_name ?? symbolInfo.displayName ?? nameFromExternalSymbol(symbolInfo.symbol),
+        kind: normalizeExternalSymbolKind(symbolInfo.kind),
+        language,
+        signatureHash: hashSemanticValue([symbolInfo.symbol, symbolInfo.signature_documentation ?? symbolInfo.signatureDocumentation]),
+        metadata: {
+          format: 'scip',
+          rawSymbol: symbolInfo.symbol,
+          documentation: symbolInfo.documentation,
+          enclosingSymbol: symbolInfo.enclosing_symbol ?? symbolInfo.enclosingSymbol,
+          external: !normalizeArray(document.symbols).includes(symbolInfo)
+        }
+      });
+      result.facts.push(...scipSymbolFacts(symbolInfo, symbolId));
+      result.relations.push(...scipRelationshipRelations(symbolInfo, symbolId, context));
+    }
+    for (const [occurrenceIndex, occurrence] of normalizeArray(document.occurrences).entries()) {
+      const symbolId = scipSymbolId(occurrence.symbol, context, documentId);
+      if (!symbolId) continue;
+      const role = scipOccurrenceRole(occurrence.symbol_roles ?? occurrence.symbolRoles);
+      if (!documentSymbols.has(symbolId)) {
+        documentSymbols.set(symbolId, true);
+        result.symbols.push({
+          id: symbolId,
+          scheme: 'scip',
+          name: nameFromExternalSymbol(occurrence.symbol),
+          kind: scipSyntaxKind(occurrence.syntax_kind ?? occurrence.syntaxKind),
+          language,
+          metadata: { format: 'scip', rawSymbol: occurrence.symbol, inferredFromOccurrence: true }
+        });
+      }
+      result.occurrences.push({
+        id: occurrence.id ?? `occ_${idFragment(documentId)}_${occurrenceIndex + 1}`,
+        documentId,
+        symbolId,
+        role,
+        span: spanFromScipOccurrence(occurrence, path, context.sourceHash),
+        metadata: {
+          format: 'scip',
+          symbolRoles: occurrence.symbol_roles ?? occurrence.symbolRoles,
+          roleSet: scipOccurrenceRoleSet(occurrence.symbol_roles ?? occurrence.symbolRoles),
+          syntaxKind: occurrence.syntax_kind ?? occurrence.syntaxKind,
+          overrideDocumentation: occurrence.override_documentation ?? occurrence.overrideDocumentation
+        }
+      });
+      for (const diagnostic of normalizeArray(occurrence.diagnostics)) {
+        const scopedDiagnostic = { ...diagnostic, range: diagnostic.range ?? occurrence.range };
+        result.facts.push(externalDiagnosticFact(scopedDiagnostic, context, documentId, path, result.facts.length));
+        result.losses.push(externalDiagnosticLoss(scopedDiagnostic, context, path));
+      }
+      if (scipOccurrenceRoleSet(occurrence.symbol_roles ?? occurrence.symbolRoles).includes('generated')) {
+        result.losses.push({
+          id: `loss_${idFragment(documentId)}_${occurrenceIndex + 1}_generated_scip_occurrence`,
+          severity: 'warning',
+          phase: 'index',
+          sourceFormat: 'scip',
+          kind: 'generatedCode',
+          message: 'SCIP occurrence is marked generated; merge admission should review generated/source ownership before applying patches.',
+          span: spanFromScipOccurrence(occurrence, path, context.sourceHash),
+          semanticSymbolId: symbolId,
+          metadata: { format: 'scip', symbolRoles: occurrence.symbol_roles ?? occurrence.symbolRoles }
+        });
+      }
+    }
+  }
+  return withExternalEmptyLoss(result, context);
+}

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

@@ -0,0 +1,57 @@
+import{idFragment}from'../../native-import-utils.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{externalDiagnosticFact}from'./externalDiagnosticFact.js';import{externalDiagnosticLoss}from'./externalDiagnosticLoss.js';import{externalSemanticBase}from'./externalSemanticBase.js';import{nameFromExternalSymbol}from'./nameFromExternalSymbol.js';import{normalizeArray}from'./normalizeArray.js';import{normalizeExternalSemanticLanguage}from'./normalizeExternalSemanticLanguage.js';import{normalizeExternalSymbolKind}from'./normalizeExternalSymbolKind.js';import{semanticDbOccurrenceRole}from'./semanticDbOccurrenceRole.js';import{semanticDbSymbolFacts}from'./semanticDbSymbolFacts.js';import{semanticDbSymbolId}from'./semanticDbSymbolId.js';import{spanFromSemanticDbRange}from'./spanFromSemanticDbRange.js';import{uriToPath}from'./uriToPath.js';import{withExternalEmptyLoss}from'./withExternalEmptyLoss.js';
+export function normalizeSemanticDbPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: 'semanticdb' });
+  const documents = normalizeArray(payload.documents ?? payload.textDocuments ?? payload);
+  for (const [documentIndex, document] of documents.entries()) {
+    const sourcePath = uriToPath(document.uri) ?? document.uri ?? document.path ?? context.sourcePath ?? `semanticdb-document-${documentIndex + 1}`;
+    const language = normalizeExternalSemanticLanguage(document.language ?? context.language ?? 'scala');
+    const documentId = document.id ?? `doc_${idFragment(sourcePath)}`;
+    result.documents.push({
+      id: documentId,
+      path: sourcePath,
+      language,
+      sourceHash: document.md5 ?? document.sourceHash ?? context.sourceHash,
+      metadata: { format: 'semanticdb', schema: document.schema, documentIndex }
+    });
+    for (const [symbolIndex, symbolInfo] of normalizeArray(document.symbols).entries()) {
+      const symbolId = semanticDbSymbolId(symbolInfo.symbol, context, documentId);
+      result.symbols.push({
+        id: symbolId,
+        scheme: 'semanticdb',
+        name: symbolInfo.display_name ?? symbolInfo.displayName ?? nameFromExternalSymbol(symbolInfo.symbol),
+        kind: normalizeExternalSymbolKind(symbolInfo.kind),
+        language,
+        signatureHash: hashSemanticValue(symbolInfo.signature ?? symbolInfo.signature_documentation ?? symbolInfo.signatureDocumentation ?? symbolInfo),
+        metadata: { format: 'semanticdb', symbolIndex, rawSymbol: symbolInfo.symbol, properties: symbolInfo.properties }
+      });
+      result.facts.push(...semanticDbSymbolFacts(symbolInfo, symbolId));
+    }
+    for (const [occurrenceIndex, occurrence] of normalizeArray(document.occurrences).entries()) {
+      const symbolId = semanticDbSymbolId(occurrence.symbol, context, documentId);
+      if (!result.symbols.some((symbol) => symbol.id === symbolId)) {
+        result.symbols.push({
+          id: symbolId,
+          scheme: 'semanticdb',
+          name: nameFromExternalSymbol(occurrence.symbol),
+          kind: 'symbol',
+          language,
+          metadata: { format: 'semanticdb', inferredFromOccurrence: true, rawSymbol: occurrence.symbol }
+        });
+      }
+      result.occurrences.push({
+        id: occurrence.id ?? `occ_${idFragment(documentId)}_${occurrenceIndex + 1}`,
+        documentId,
+        symbolId,
+        role: semanticDbOccurrenceRole(occurrence.role),
+        span: spanFromSemanticDbRange(occurrence.range, sourcePath, document.md5 ?? context.sourceHash),
+        metadata: { format: 'semanticdb', role: occurrence.role }
+      });
+    }
+    for (const diagnostic of normalizeArray(document.diagnostics)) {
+      result.facts.push(externalDiagnosticFact(diagnostic, context, documentId, sourcePath, result.facts.length));
+      result.losses.push(externalDiagnosticLoss(diagnostic, context, sourcePath));
+    }
+  }
+  return withExternalEmptyLoss(result, context);
+}

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

@@ -0,0 +1,4 @@
+export function normalizeSemanticSliceRef(ref, prefix) {
+  const text = String(ref ?? '');
+  return text.startsWith(`${prefix}:`) ? text.slice(prefix.length + 1) : text;
+}

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

@@ -0,0 +1,45 @@
+import{upperFirst}from'../../native-import-utils.js';
+export function normalizeSwiftSyntaxKind(kind) {
+  const text = String(kind)
+    .replace(/^SwiftSyntax\./, '')
+    .replace(/Syntax$/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
+  const known = {
+    sourcefile: 'SourceFile',
+    importdecl: 'ImportDecl',
+    classdecl: 'ClassDecl',
+    structdecl: 'StructDecl',
+    enumdecl: 'EnumDecl',
+    protocoldecl: 'ProtocolDecl',
+    actordecl: 'ActorDecl',
+    extensiondecl: 'ExtensionDecl',
+    typealiasdecl: 'TypeAliasDecl',
+    associatedtypedecl: 'AssociatedTypeDecl',
+    functiondecl: 'FunctionDecl',
+    initializerdecl: 'InitializerDecl',
+    initdecl: 'InitializerDecl',
+    deinitializerdecl: 'DeinitializerDecl',
+    deinitdecl: 'DeinitializerDecl',
+    subscriptdecl: 'SubscriptDecl',
+    operatordecl: 'OperatorDecl',
+    precedencegroupdecl: 'PrecedenceGroupDecl',
+    variabledecl: 'VariableDecl',
+    patternbinding: 'PatternBinding',
+    enumcasedecl: 'EnumCaseDecl',
+    enumcaseelement: 'EnumCaseElement',
+    macrodecl: 'MacroDecl',
+    macroexpansiondecl: 'MacroExpansionDecl',
+    freestandingmacroexpansion: 'FreestandingMacroExpansion',
+    freestandingmacroexpansionsyntax: 'FreestandingMacroExpansion',
+    attributemacroexpansion: 'AttributeMacroExpansion',
+    ifconfigdecl: 'IfConfigDecl',
+    ifconfigexpr: 'IfConfigExpr',
+    unexpectednodes: 'UnexpectedNodes',
+    missingtoken: 'MissingToken',
+    skippedtoken: 'SkippedToken',
+    error: 'Error'
+  };
+  if (known[compact]) return known[compact];
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}

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

@@ -0,0 +1,5 @@
+export function normalizeSyntaxAstRoot(ast, astFormat) {
+  if (!ast || typeof ast !== 'object') return undefined;
+  if (astFormat === 'babel' && ast.program && typeof ast.program === 'object') return ast.program;
+  return ast;
+}

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

@@ -0,0 +1,3 @@
+export function numberOrUndefined(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

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

@@ -0,0 +1,24 @@
+import{adapterCoverageSnapshotFromSummary}from'./adapterCoverageSnapshotFromSummary.js';import{effectiveNativeImporterAdapterCoverage}from'./effectiveNativeImporterAdapterCoverage.js';import{nativeImporterAdapterCapabilityEvidence}from'./nativeImporterAdapterCapabilityEvidence.js';import{observeNativeImporterAdapterCoverageDetails}from'./observeNativeImporterAdapterCoverageDetails.js';
+export function observeNativeImporterAdapterCoverage(coverage, parseResult = {}, context = {}) {
+  const nodes = parseResult.nativeAst?.nodes ?? parseResult.nodes ?? {};
+  const nodeList = Object.values(nodes);
+  const sourceMapMappings = parseResult.sourceMaps?.flatMap((sourceMap) => sourceMap.mappings ?? []) ?? parseResult.mappings ?? [];
+  const semanticIndex = parseResult.semanticIndex;
+  const semanticSymbols = semanticIndex?.symbols?.length ?? 0;
+  const declared = coverage.declared ?? adapterCoverageSnapshotFromSummary(coverage);
+  const observed = observeNativeImporterAdapterCoverageDetails(parseResult, context, {
+    declared,
+    nodeList,
+    sourceMapMappings,
+    semanticIndex,
+    semanticSymbols
+  });
+  const effective = effectiveNativeImporterAdapterCoverage(declared, observed);
+  return Object.freeze({
+    ...coverage,
+    ...effective,
+    declared,
+    observed,
+    capabilityEvidence: nativeImporterAdapterCapabilityEvidence(declared, observed, effective)
+  });
+}

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

@@ -0,0 +1,66 @@
+import{adapterCoverageSourcePreservation}from'./adapterCoverageSourcePreservation.js';import{maxSemanticCoverageLevel}from'./maxSemanticCoverageLevel.js';import{nativeAstNodes}from'./nativeAstNodes.js';import{normalizeNativeImporterAdapterObservedCoverage}from'./normalizeNativeImporterAdapterObservedCoverage.js';import{normalizeNativeImporterSemanticCoverage}from'./normalizeNativeImporterSemanticCoverage.js';import{observedAdapterExactness}from'./observedAdapterExactness.js';import{observeNativeImporterSemanticEvidence}from'./observeNativeImporterSemanticEvidence.js';
+export function observeNativeImporterAdapterCoverageDetails(parseResult = {}, context = {}, observedContext = {}) {
+  const declared = observedContext.declared ?? {};
+  const nodeList = observedContext.nodeList ?? Object.values(parseResult.nativeAst?.nodes ?? parseResult.nodes ?? {});
+  const sourceMapMappings = observedContext.sourceMapMappings
+    ?? parseResult.sourceMaps?.flatMap((sourceMap) => sourceMap.mappings ?? [])
+    ?? parseResult.mappings
+    ?? [];
+  const semanticIndex = observedContext.semanticIndex ?? parseResult.semanticIndex;
+  const semanticSymbols = observedContext.semanticSymbols ?? semanticIndex?.symbols?.length ?? 0;
+  const diagnostics = context.diagnostics ?? [];
+  const diagnosticErrors = diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+  const diagnosticWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length;
+  const diagnosticInfos = diagnostics.filter((diagnostic) => diagnostic.severity === 'info').length;
+  const sourceRangeNodes = nodeList.filter((node) => Boolean(node?.span)).length;
+  const sourceRangeMappings = sourceMapMappings.filter((mapping) => Boolean(mapping?.sourceSpan)).length;
+  const generatedRangeMappings = sourceMapMappings.filter((mapping) => Boolean(mapping?.generatedSpan)).length;
+  const preservation = adapterCoverageSourcePreservation(parseResult);
+  const tokenCount = preservation?.summary?.tokens ?? preservation?.tokens?.length ?? 0;
+  const triviaCount = preservation?.summary?.trivia ?? preservation?.trivia?.length ?? 0;
+  const semanticEvidence = observeNativeImporterSemanticEvidence(semanticIndex);
+  const semanticCoverage = normalizeNativeImporterSemanticCoverage({
+    level: maxSemanticCoverageLevel(
+      semanticSymbols || semanticEvidence.declarations
+        ? 'declaration-index'
+        : 'native-ast',
+      semanticEvidence.references || semanticEvidence.types || semanticEvidence.controlFlow
+        ? 'semantic-index'
+        : semanticSymbols ? 'declaration-index' : 'native-ast'
+    ),
+    declarations: semanticSymbols > 0 || semanticEvidence.declarations > 0,
+    symbols: semanticSymbols > 0,
+    references: semanticEvidence.references > 0,
+    types: semanticEvidence.types > 0,
+    controlFlow: semanticEvidence.controlFlow > 0
+  }, {});
+  return normalizeNativeImporterAdapterObservedCoverage({
+    exactness: observedAdapterExactness(declared, nodeList.length),
+    exactAst: Boolean(declared.exactAst && nodeList.length > 0),
+    tokens: tokenCount > 0,
+    tokenCount,
+    trivia: triviaCount > 0,
+    triviaCount,
+    diagnostics: diagnostics.length,
+    parserDiagnostics: diagnostics.length,
+    diagnosticErrors,
+    diagnosticWarnings,
+    diagnosticInfos,
+    losses: context.losses?.length ?? 0,
+    nativeAstNodes: nodeList.length,
+    semanticSymbols,
+    semanticReferences: semanticEvidence.references,
+    semanticTypes: semanticEvidence.types,
+    semanticControlFlow: semanticEvidence.controlFlow,
+    references: semanticEvidence.references > 0,
+    types: semanticEvidence.types > 0,
+    controlFlow: semanticEvidence.controlFlow > 0,
+    sourceMapMappings: sourceMapMappings.length,
+    sourceRanges: sourceRangeNodes > 0 || sourceRangeMappings > 0,
+    sourceRangeNodes,
+    sourceRangeMappings,
+    generatedRanges: generatedRangeMappings > 0,
+    generatedRangeMappings,
+    semanticCoverage
+  }, declared);
+}

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

@@ -0,0 +1,23 @@
+import{semanticPredicateMatches}from'./semanticPredicateMatches.js';
+export function observeNativeImporterSemanticEvidence(semanticIndex = {}) {
+  const occurrences = semanticIndex?.occurrences ?? [];
+  const relations = semanticIndex?.relations ?? [];
+  const facts = semanticIndex?.facts ?? [];
+  const symbols = semanticIndex?.symbols ?? [];
+  const referenceRelations = relations.filter((relation) => semanticPredicateMatches(relation?.predicate, ['reference', 'call', 'read', 'write', 'use']));
+  const typeFacts = facts.filter((fact) => semanticPredicateMatches(fact?.predicate, ['type', 'declaredtype', 'inferredtype', 'typeof']));
+  const typedSymbols = symbols.filter((symbol) => Boolean(symbol?.declaredType ?? symbol?.inferredType ?? symbol?.typeId ?? symbol?.valueType));
+  const controlFlowRecords = [
+    ...relations.filter((relation) => semanticPredicateMatches(relation?.predicate, ['controlflow', 'cfg', 'flow'])),
+    ...facts.filter((fact) => semanticPredicateMatches(fact?.predicate, ['controlflow', 'cfg', 'flow']))
+  ];
+  return {
+    declarations: occurrences.filter((occurrence) => occurrence?.role === 'definition' || occurrence?.role === 'declaration').length,
+    references: occurrences.filter((occurrence) => {
+      const role = String(occurrence?.role ?? '').toLowerCase();
+      return role && role !== 'definition' && role !== 'declaration';
+    }).length + referenceRelations.length,
+    types: typeFacts.length + typedSymbols.length,
+    controlFlow: controlFlowRecords.length
+  };
+}

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

@@ -0,0 +1,6 @@
+import{nativeAstNodes}from'./nativeAstNodes.js';
+export function observedAdapterExactness(declared = {}, nativeAstNodes = 0) {
+  if (!nativeAstNodes) return 'unknown';
+  if (declared.exactAst) return declared.exactness ?? 'exact-parser-ast';
+  return 'adapter-reported-native-ast';
+}

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

@@ -0,0 +1,3 @@
+export function oneLine(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}

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

@@ -0,0 +1,15 @@
+export function parseCSharpRoslynSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.roslyn?.parse ?? options.csharpRoslyn?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    languageVersion: options.languageVersion ?? input.options?.languageVersion,
+    csharpVersion: options.csharpVersion ?? input.options?.csharpVersion,
+    nullableContext: options.nullableContext ?? input.options?.nullableContext,
+    kind: options.sourceCodeKind ?? input.options?.sourceCodeKind,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,16 @@
+export function parseClangAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.clang?.parse ?? options.libclang?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    language: options.language ?? input.language,
+    standard: options.cStandard ?? input.options?.cStandard,
+    compileFlags: options.compileFlags ?? input.options?.compileFlags,
+    includeSystemHeaders: options.includeSystemHeaders ?? input.options?.includeSystemHeaders,
+    astDumpFormat: 'json',
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,15 @@
+export function parseGoAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.goAst?.parse ?? options.goParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    mode: options.mode ?? input.options?.mode ?? 'ParseComments',
+    goVersion: options.goVersion ?? input.options?.goVersion,
+    packageName: options.packageName ?? input.options?.packageName,
+    includeComments: options.includeComments ?? input.options?.includeComments,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,16 @@
+export function parseJavaAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.javac?.parse ?? options.jdt?.parse ?? options.javaParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    javaVersion: options.javaVersion ?? input.options?.javaVersion,
+    sourceLevel: options.sourceLevel ?? input.options?.sourceLevel,
+    classPath: options.classPath ?? input.options?.classPath,
+    modulePath: options.modulePath ?? input.options?.modulePath,
+    includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,16 @@
+export function parseKotlinPsiSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.kotlinPsi?.parse ?? options.kotlinCompiler?.parse ?? options.intellijPsi?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    kotlinVersion: options.kotlinVersion ?? input.options?.kotlinVersion,
+    languageVersion: options.languageVersion ?? input.options?.languageVersion,
+    apiVersion: options.apiVersion ?? input.options?.apiVersion,
+    script: options.script ?? input.options?.script ?? /\.kts$/i.test(input.sourcePath ?? ''),
+    includeAnnotations: options.includeAnnotations ?? input.options?.includeAnnotations,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,16 @@
+export function parsePythonAstSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.pythonAst?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    mode: options.mode ?? input.options?.mode ?? 'exec',
+    typeComments: options.typeComments ?? input.options?.typeComments,
+    featureVersion: options.featureVersion ?? input.options?.featureVersion,
+    optimize: options.optimize ?? input.options?.optimize,
+    includeAttributes: options.includeAttributes ?? input.options?.includeAttributes,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,13 @@
+export function parseRustSynSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.rustSyn?.parse ?? options.syn?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    edition: options.rustEdition ?? input.options?.rustEdition ?? '2021',
+    includeAttributes: options.includeAttributes ?? input.options?.includeAttributes,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,15 @@
+export function parseSwiftSyntaxSource(input, options) {
+  const parse = options.parse ?? options.parserModule?.parse ?? options.swiftSyntax?.parse ?? options.swiftParser?.parse;
+  if (typeof parse !== 'function') return undefined;
+  const parserOptions = {
+    sourcePath: input.sourcePath,
+    filename: input.sourcePath,
+    swiftVersion: options.swiftVersion ?? input.options?.swiftVersion,
+    languageMode: options.languageMode ?? input.options?.languageMode,
+    enableBareSlashRegex: options.enableBareSlashRegex ?? input.options?.enableBareSlashRegex,
+    parseTransition: options.parseTransition ?? input.options?.parseTransition,
+    ...(options.parserOptions ?? {}),
+    ...(input.options?.parserOptions ?? {})
+  };
+  return parse(input.sourceText, parserOptions);
+}

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

@@ -0,0 +1,6 @@
+export function parseTreeSitterSource(input, options) {
+  const parser = options.parserInstance ?? options.treeSitterParser ?? options.parser;
+  if (parser && typeof parser.parse === 'function') return parser.parse(input.sourceText);
+  if (typeof options.parse === 'function') return options.parse(input);
+  return undefined;
+}