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

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

@@ -0,0 +1,8 @@
+export const ExternalSemanticIndexFormats = Object.freeze([
+  'frontier-semantic-index',
+  'scip',
+  'lsif',
+  'lsp',
+  'semanticdb',
+  'glean'
+]);

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

@@ -0,0 +1,7 @@
+export const FrontierCompileTargets = Object.freeze([
+  'typescript',
+  'javascript',
+  'rust',
+  'python',
+  'c'
+]);

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

@@ -0,0 +1,111 @@
+import{nativeImportFeatureEvidencePolicy}from'./nativeImportFeatureEvidencePolicy.js';
+export const NativeImportFeatureEvidencePolicies = Object.freeze({
+  macroExpansion: nativeImportFeatureEvidencePolicy('macroExpansion', {
+    category: 'macroExpansion',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['macroDefinitionsHash', 'expandedSourceHash'],
+    recommendedEvidenceKeys: ['expansionMapId', 'sourceMapId', 'macroCallSites'],
+    notes: ['Macro-expanded code must retain a link from generated output back to macro call sites before semantic merges can be trusted.']
+  }),
+  macroHygiene: nativeImportFeatureEvidencePolicy('macroHygiene', {
+    category: 'macroExpansion',
+    risk: 'critical',
+    minimumReadiness: 'needs-review',
+    missingEvidenceReadiness: 'blocked',
+    requiredEvidenceKeys: ['hygieneContextHash', 'bindingMapId'],
+    recommendedEvidenceKeys: ['expansionMapId', 'captureSetHash'],
+    notes: ['Hygiene-sensitive macros can change binding identity even when emitted text looks equivalent.']
+  }),
+  preprocessor: nativeImportFeatureEvidencePolicy('preprocessor', {
+    category: 'preprocessor',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['preprocessedOutputHash', 'definesHash'],
+    recommendedEvidenceKeys: ['includeGraphHash', 'conditionalBranches', 'sourceMapId'],
+    notes: ['Preprocessor imports need the active defines/includes and preprocessed output hash to make replayable claims.']
+  }),
+  conditionalCompilation: nativeImportFeatureEvidencePolicy('conditionalCompilation', {
+    category: 'conditionalCompilation',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['activeBranches', 'inactiveBranchesHash'],
+    recommendedEvidenceKeys: ['compileTarget', 'featureFlags', 'preprocessedOutputHash'],
+    notes: ['Conditional branches that were not active still affect portability and conflict review.']
+  }),
+  metaprogramming: nativeImportFeatureEvidencePolicy('metaprogramming', {
+    category: 'metaprogramming',
+    risk: 'critical',
+    minimumReadiness: 'needs-review',
+    missingEvidenceReadiness: 'blocked',
+    requiredEvidenceKeys: ['generatedArtifactHash', 'generatorIdentity'],
+    recommendedEvidenceKeys: ['generatorInputsHash', 'generatedRanges', 'replayCommand'],
+    notes: ['Generated or metaprogrammed declarations need replayable generator identity and input evidence.']
+  }),
+  reflection: nativeImportFeatureEvidencePolicy('reflection', {
+    category: 'reflection',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['reflectionSurface', 'runtimeContract'],
+    recommendedEvidenceKeys: ['observedMembers', 'fixtureIds', 'runtimeVersion'],
+    notes: ['Reflection-heavy code needs a declared runtime contract because static AST evidence is incomplete.']
+  }),
+  dynamicRuntime: nativeImportFeatureEvidencePolicy('dynamicRuntime', {
+    category: 'reflection',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['runtimeContract'],
+    recommendedEvidenceKeys: ['fixtureIds', 'observedEffects', 'runtimeVersion'],
+    notes: ['Dynamic runtime behavior should stay review-required until fixtures or traces describe the observed contract.']
+  }),
+  dynamicDispatch: nativeImportFeatureEvidencePolicy('dynamicDispatch', {
+    category: 'overloadTypeInference',
+    risk: 'medium',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['dispatchTargets'],
+    recommendedEvidenceKeys: ['callGraphId', 'typeEvidenceId', 'fixtureIds'],
+    notes: ['Dynamic dispatch needs candidate target evidence before call graph or porting claims are merge-ready.']
+  }),
+  generatedCode: nativeImportFeatureEvidencePolicy('generatedCode', {
+    category: 'generatedCode',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['generatedArtifactHash', 'generatedRanges'],
+    recommendedEvidenceKeys: ['generatorIdentity', 'generatorInputsHash', 'sourceMapId'],
+    notes: ['Generated code must preserve generated ranges and artifact hashes so workers can avoid editing derived output blindly.']
+  }),
+  overloadResolution: nativeImportFeatureEvidencePolicy('overloadResolution', {
+    category: 'overloadTypeInference',
+    risk: 'medium',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['resolvedOverloads'],
+    recommendedEvidenceKeys: ['typeEvidenceId', 'compilerVersion', 'callSiteSpans'],
+    notes: ['Overload-sensitive imports should record compiler/type evidence for each call site.']
+  }),
+  typeInference: nativeImportFeatureEvidencePolicy('typeInference', {
+    category: 'overloadTypeInference',
+    risk: 'medium',
+    minimumReadiness: 'needs-review',
+    requiredEvidenceKeys: ['inferredTypesHash'],
+    recommendedEvidenceKeys: ['typeEvidenceId', 'compilerVersion', 'symbolTableHash'],
+    notes: ['Inferred types need a stable type-evidence hash before cross-language projection can claim fidelity.']
+  }),
+  unsupportedSyntax: nativeImportFeatureEvidencePolicy('unsupportedSyntax', {
+    category: 'unsupportedSyntax',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    missingEvidenceReadiness: 'blocked',
+    requiredEvidenceKeys: ['unsupportedSyntaxKind', 'sourceSpan'],
+    recommendedEvidenceKeys: ['parserDiagnosticId', 'nativeAstNodeId', 'sourceSnippetHash'],
+    notes: ['Unsupported syntax must remain anchored to source spans and parser diagnostics for later adapter work.']
+  }),
+  unsupportedSemantic: nativeImportFeatureEvidencePolicy('unsupportedSemantic', {
+    category: 'unsupportedSyntax',
+    risk: 'high',
+    minimumReadiness: 'needs-review',
+    missingEvidenceReadiness: 'blocked',
+    requiredEvidenceKeys: ['unsupportedSemanticKind', 'semanticSymbolId'],
+    recommendedEvidenceKeys: ['semanticIndexId', 'sourceMapId', 'reason'],
+    notes: ['Unsupported semantics should name the affected symbol so merge tools can isolate the unsafe region.']
+  })
+});

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

@@ -0,0 +1,24 @@
+export const NativeImportLossKinds = Object.freeze([
+  'declarationOnlyCoverage',
+  'opaqueNative',
+  'macroExpansion',
+  'macroHygiene',
+  'preprocessor',
+  'conditionalCompilation',
+  'metaprogramming',
+  'reflection',
+  'dynamicRuntime',
+  'dynamicDispatch',
+  'generatedCode',
+  'overloadResolution',
+  'typeInference',
+  'sourcePreservation',
+  'commentsTrivia',
+  'parserDiagnostic',
+  'unsupportedSyntax',
+  'unsupportedSemantic',
+  'unverifiedNativeAst',
+  'partialSemanticIndex',
+  'sourceMapApproximation',
+  'targetProjectionLoss'
+]);

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

@@ -0,0 +1,6 @@
+export const NativeImportReadinessBySeverity = Object.freeze({
+  none: 'ready',
+  info: 'ready-with-losses',
+  warning: 'needs-review',
+  error: 'blocked'
+});

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

@@ -0,0 +1,7 @@
+export const NativeImportRoundtripReadinessStatuses = Object.freeze([
+  'exact',
+  'preserved-source',
+  'stub-only',
+  'blocked',
+  'needs-review'
+]);

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

@@ -0,0 +1,19 @@
+export const NativeImportTaxonomyKinds = Object.freeze([
+  'exactAstImport',
+  'declarationsOnly',
+  'opaqueBodies',
+  'macroExpansion',
+  'preprocessor',
+  'conditionalCompilation',
+  'metaprogramming',
+  'reflection',
+  'generatedCode',
+  'overloadTypeInference',
+  'sourcePreservation',
+  'commentsTrivia',
+  'parserDiagnostics',
+  'unsupportedSyntax',
+  'partialSemanticIndex',
+  'sourceMapApproximation',
+  'targetProjectionLoss'
+]);

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

@@ -0,0 +1,13 @@
+export function adapterCoverageCapabilityRow(capability, declared, observed, effective, count = 0) {
+  const status = declared && observed
+    ? 'declared-and-observed'
+    : declared ? 'declared-unobserved' : observed ? 'observed-undeclared' : 'absent';
+  return Object.freeze({
+    capability,
+    declared: Boolean(declared),
+    observed: Boolean(observed),
+    effective: Boolean(effective),
+    count: Number(count ?? 0) || 0,
+    status
+  });
+}

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

@@ -0,0 +1,13 @@
+import{freezeNativeImporterAdapterCoverageSnapshot}from'./freezeNativeImporterAdapterCoverageSnapshot.js';
+export function adapterCoverageSnapshotFromSummary(coverage = {}) {
+  return freezeNativeImporterAdapterCoverageSnapshot({
+    exactness: coverage.exactness ?? 'unknown',
+    exactAst: coverage.exactAst,
+    tokens: coverage.tokens,
+    trivia: coverage.trivia,
+    diagnostics: coverage.diagnostics,
+    sourceRanges: coverage.sourceRanges,
+    generatedRanges: coverage.generatedRanges,
+    semanticCoverage: coverage.semanticCoverage
+  });
+}

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

@@ -0,0 +1,6 @@
+export function adapterCoverageSourcePreservation(parseResult = {}) {
+  return parseResult.sourcePreservation
+    ?? parseResult.nativeAst?.metadata?.sourcePreservation
+    ?? parseResult.nativeAstMetadata?.sourcePreservation
+    ?? parseResult.metadata?.sourcePreservation;
+}

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

@@ -0,0 +1,23 @@
+import{idFragment}from'../../native-import-utils.js';
+export function adapterDiagnosticToLoss(diagnostic, index, adapter, input) {
+  const code = diagnostic.code ?? diagnostic.kind ?? diagnostic.severity;
+  return {
+    id: `loss_${idFragment(diagnostic.id ?? `${adapter.id}_${index}_${code}`)}`,
+    severity: diagnostic.severity,
+    phase: diagnostic.phase,
+    sourceFormat: input.language,
+    kind: diagnostic.kind ?? (diagnostic.severity === 'error' ? 'unsupportedSyntax' : 'opaqueNative'),
+    message: diagnostic.message,
+    span: diagnostic.span,
+    metadata: {
+      adapterId: adapter.id,
+      adapterVersion: adapter.version,
+      diagnosticId: diagnostic.id,
+      diagnosticCode: diagnostic.code,
+      parser: input.parser,
+      parserVersion: input.parserVersion,
+      path: diagnostic.path,
+      ...diagnostic.metadata
+    }
+  };
+}

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

@@ -0,0 +1,27 @@
+import{idFragment}from'../../native-import-utils.js';
+import{serializableDiagnostic}from'./serializableDiagnostic.js';
+export function adapterDiagnosticsEvidence(adapter, diagnostics, input) {
+  const errors = diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+  const warnings = diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length;
+  return {
+    id: `evidence_${idFragment(adapter.id)}_native_importer_adapter`,
+    kind: 'import',
+    status: errors ? 'failed' : 'passed',
+    path: input.sourcePath,
+    summary: `Ran ${adapter.id} native importer for ${input.language} with ${diagnostics.length} diagnostic(s).`,
+    metadata: {
+      adapterId: adapter.id,
+      adapterVersion: adapter.version,
+      language: input.language,
+      parser: input.parser,
+      parserVersion: input.parserVersion,
+      sourceHash: input.sourceHash,
+      capabilities: adapter.capabilities,
+      coverage: adapter.coverage,
+      supportedExtensions: adapter.supportedExtensions,
+      diagnostics: diagnostics.map(serializableDiagnostic),
+      errors,
+      warnings
+    }
+  };
+}

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

@@ -0,0 +1,32 @@
+import{idFragment}from'../../native-import-utils.js';
+import{normalizeArray}from'./normalizeArray.js';import{semanticTokenModifiers}from'./semanticTokenModifiers.js';
+export function addLspSemanticTokens(result, semanticTokens, input) {
+  const data = normalizeArray(semanticTokens.data);
+  const legend = semanticTokens.legend ?? {};
+  let line = 0;
+  let character = 0;
+  for (let index = 0; index + 4 < data.length; index += 5) {
+    line += Number(data[index] ?? 0);
+    character = Number(data[index] ?? 0) === 0 ? character + Number(data[index + 1] ?? 0) : Number(data[index + 1] ?? 0);
+    const length = Number(data[index + 2] ?? 0);
+    const tokenType = legend.tokenTypes?.[Number(data[index + 3] ?? 0)] ?? `tokenType${data[index + 3] ?? 0}`;
+    const span = {
+      path: input.sourcePath,
+      startLine: line + 1,
+      startColumn: character + 1,
+      endLine: line + 1,
+      endColumn: character + length + 1
+    };
+    result.facts.push({
+      id: `fact_${idFragment(input.documentId)}_semantic_token_${index / 5 + 1}`,
+      predicate: 'semanticToken',
+      subjectId: input.documentId,
+      value: {
+        tokenType,
+        tokenModifiers: semanticTokenModifiers(Number(data[index + 4] ?? 0), legend.tokenModifiers),
+        span
+      },
+      metadata: { format: 'lsp' }
+    });
+  }
+}

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

@@ -0,0 +1,44 @@
+import{idFragment}from'../../native-import-utils.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{normalizeArray}from'./normalizeArray.js';import{normalizeLspSymbolKind}from'./normalizeLspSymbolKind.js';import{spanFromLspRange}from'./spanFromLspRange.js';import{uriToPath}from'./uriToPath.js';
+export function addLspSymbol(result, symbol, input) {
+  const location = symbol.location ?? {};
+  const range = symbol.range ?? location.range ?? symbol.selectionRange;
+  const sourcePath = uriToPath(location.uri ?? symbol.uri) ?? input.sourcePath;
+  const symbolName = symbol.name ?? symbol.containerName ?? `symbol_${result.symbols.length + 1}`;
+  const symbolId = symbol.id ?? `symbol:lsp:${idFragment(input.language ?? 'unknown')}:${idFragment([input.parentName, symbolName].filter(Boolean).join('.'))}`;
+  const ownershipSpan = spanFromLspRange(range, sourcePath, input.context.sourceHash, 0);
+  const selectionSpan = spanFromLspRange(symbol.selectionRange ?? range, sourcePath, input.context.sourceHash, 0);
+  if (!result.symbols.some((entry) => entry.id === symbolId)) {
+    result.symbols.push({
+      id: symbolId,
+      scheme: 'lsp',
+      name: symbolName,
+      kind: normalizeLspSymbolKind(symbol.kind),
+      language: input.language,
+      definitionSpan: ownershipSpan,
+      signatureHash: hashSemanticValue([symbolName, symbol.kind, symbol.detail]),
+      metadata: {
+        format: 'lsp',
+        detail: symbol.detail,
+        tags: symbol.tags,
+        deprecated: symbol.deprecated,
+        containerName: symbol.containerName,
+        parentName: input.parentName
+      }
+    });
+  }
+  result.occurrences.push({
+    id: `occ_${idFragment(symbolId)}_${result.occurrences.length + 1}`,
+    documentId: input.documentId,
+    symbolId,
+    role: 'definition',
+    span: selectionSpan,
+    metadata: { format: 'lsp', range, selectionRange: symbol.selectionRange }
+  });
+  for (const child of normalizeArray(symbol.children)) {
+    addLspSymbol(result, child, {
+      ...input,
+      parentName: [input.parentName, symbolName].filter(Boolean).join('.')
+    });
+  }
+}

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

@@ -0,0 +1,5 @@
+export function addSet(set, value) {
+  if (!value || set.has(value)) return false;
+  set.add(value);
+  return true;
+}

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

@@ -0,0 +1,79 @@
+import{idFragment}from'../../native-import-utils.js';import{semanticRegionKindForSymbol,semanticRegionMergePolicy}from'../../semantic-import-regions.js';
+import{externalRelationPredicateForOccurrence}from'./externalRelationPredicateForOccurrence.js';
+export function attachExternalOwnership(result, context) {
+  const occurrencesBySymbol = new Map();
+  for (const occurrence of result.occurrences) {
+    if (!occurrencesBySymbol.has(occurrence.symbolId)) occurrencesBySymbol.set(occurrence.symbolId, []);
+    occurrencesBySymbol.get(occurrence.symbolId).push(occurrence);
+    result.relations.push({
+      id: `rel_${idFragment(occurrence.documentId)}_${idFragment(occurrence.id)}_${idFragment(occurrence.role)}`,
+      sourceId: occurrence.documentId,
+      predicate: externalRelationPredicateForOccurrence(occurrence),
+      targetId: occurrence.symbolId,
+      metadata: {
+        format: context.format,
+        source: 'external-semantic-index',
+        occurrenceId: occurrence.id,
+        role: occurrence.role
+      }
+    });
+  }
+  result.symbols = result.symbols.map((symbol) => {
+    const occurrences = occurrencesBySymbol.get(symbol.id) ?? [];
+    const definition = occurrences.find((occurrence) => occurrence.role === 'definition') ?? occurrences[0];
+    const sourceSpan = symbol.definitionSpan ?? definition?.span;
+    const regionKind = semanticRegionKindForSymbol(symbol, undefined, undefined);
+    const key = [
+      'external',
+      symbol.language ?? context.language ?? 'unknown',
+      sourceSpan?.path ?? context.sourcePath ?? 'memory',
+      regionKind,
+      symbol.name ?? symbol.id
+    ].join('#');
+    const region = {
+      id: `region_${idFragment(key)}`,
+      key,
+      regionKind,
+      granularity: 'symbol',
+      language: symbol.language ?? context.language,
+      documentId: definition?.documentId,
+      sourcePath: sourceSpan?.path ?? context.sourcePath,
+      sourceHash: context.sourceHash,
+      symbolId: symbol.id,
+      symbolName: symbol.name,
+      symbolKind: symbol.kind,
+      sourceSpan,
+      precision: sourceSpan ? 'declaration' : 'unknown',
+      mergePolicy: semanticRegionMergePolicy(regionKind),
+      metadata: {
+        format: context.format,
+        source: 'external-semantic-index'
+      }
+    };
+    result.facts.push({
+      id: `fact_${idFragment(symbol.id)}_ownership_region`,
+      predicate: 'semanticOwnershipRegion',
+      subjectId: symbol.id,
+      value: region
+    }, {
+      id: `fact_${idFragment(symbol.id)}_ownership_region_taxonomy`,
+      predicate: 'semanticOwnershipRegionTaxonomy',
+      subjectId: symbol.id,
+      value: {
+        regionKind: region.regionKind,
+        granularity: region.granularity,
+        key: region.key
+      }
+    });
+    return {
+      ...symbol,
+      definitionSpan: symbol.definitionSpan ?? definition?.span,
+      metadata: {
+        ...symbol.metadata,
+        ownershipRegionId: symbol.metadata?.ownershipRegionId ?? region.id,
+        ownershipRegionKey: symbol.metadata?.ownershipRegionKey ?? region.key,
+        ownershipRegionKind: symbol.metadata?.ownershipRegionKind ?? region.regionKind
+      }
+    };
+  });
+}

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

@@ -0,0 +1,13 @@
+import{nativeChangedRegionProjectionMetadata}from'./nativeChangedRegionProjectionMetadata.js';
+export function attachNativeChangeRegionProjectionMetadata(regions, context) {
+  return (regions ?? []).map((region) => {
+    const projection = nativeChangedRegionProjectionMetadata(region, context);
+    return {
+      ...region,
+      metadata: {
+        ...(region.metadata ?? {}),
+        changedRegionProjection: projection
+      }
+    };
+  });
+}

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

@@ -0,0 +1,11 @@
+export function attachNativeImportLossSummary(evidence, lossSummary) {
+  return (evidence ?? []).map((record) => ({
+    ...record,
+    metadata: {
+      ...record.metadata,
+      nativeImportLossSummary: lossSummary,
+      semanticMergeReadiness: lossSummary.semanticMergeReadiness,
+      lossCategories: lossSummary.categories
+    }
+  }));
+}

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

@@ -0,0 +1,7 @@
+export const canonicalTargets = Object.freeze({
+  ts: 'typescript',
+  js: 'javascript',
+  rs: 'rust',
+  py: 'python',
+  h: 'c'
+});

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

@@ -0,0 +1,9 @@
+import{ignoredClangAstField}from'./ignoredClangAstField.js';import{isClangAstNode}from'./isClangAstNode.js';
+export function clangAstChildEntries(node) {
+  const fieldNames = Object.keys(node).filter((key) => !ignoredClangAstField(key));
+  return fieldNames
+    .map((field) => [field, node[field]])
+    .filter(([, value]) => Array.isArray(value)
+      ? value.some(isClangAstNode)
+      : isClangAstNode(value));
+}

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

@@ -0,0 +1,44 @@
+import{clangDeclarationAction}from'./clangDeclarationAction.js';import{clangDeclarationName}from'./clangDeclarationName.js';import{clangIncludePath}from'./clangIncludePath.js';import{declarationRecord}from'./declarationRecord.js';import{nativeNodeId}from'./nativeNodeId.js';
+export function clangAstDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'FunctionDecl' || kind === 'CXXMethodDecl' || kind === 'FunctionTemplateDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, kind === 'CXXMethodDecl' ? 'method' : 'function', clangDeclarationAction(node));
+  }
+  if (kind === 'ParmVarDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'parameter', 'definition');
+  }
+  if (kind === 'RecordDecl' || kind === 'CXXRecordDecl' || kind === 'ClassTemplateDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, kind === 'CXXRecordDecl' ? 'class' : 'type', clangDeclarationAction(node));
+  }
+  if (kind === 'FieldDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'property', 'definition');
+  }
+  if (kind === 'TypedefDecl' || kind === 'TypeAliasDecl' || kind === 'TypeAliasTemplateDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  if (kind === 'EnumDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', clangDeclarationAction(node));
+  }
+  if (kind === 'EnumConstantDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'enumMember', 'definition');
+  }
+  if (kind === 'VarDecl') {
+    const name = clangDeclarationName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', clangDeclarationAction(node));
+  }
+  if (/IncludeDirective|InclusionDirective/.test(kind)) {
+    const name = clangIncludePath(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (/MacroDefinition|MacroExpansion|MacroInstantiation/.test(kind)) {
+    const name = clangDeclarationName(node) ?? clangIncludePath(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'macro', 'definition');
+  }
+  return undefined;
+}

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

@@ -0,0 +1,7 @@
+export function clangAstKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const declared = node.kind ?? node._type ?? node.type ?? node.nodeType ?? node.declKind ?? node.stmtKind;
+  if (typeof declared === 'string') return declared;
+  if (Array.isArray(node.inner) || Array.isArray(node.children) || Array.isArray(node.decls)) return 'TranslationUnitDecl';
+  return undefined;
+}

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

@@ -0,0 +1,7 @@
+import{clangDeclarationName}from'./clangDeclarationName.js';import{clangIncludePath}from'./clangIncludePath.js';import{clangLiteralValue}from'./clangLiteralValue.js';import{clangTypeName}from'./clangTypeName.js';
+export function clangAstNodeValue(node) {
+  return clangDeclarationName(node)
+    ?? clangIncludePath(node)
+    ?? clangTypeName(node.type ?? node.qualType)
+    ?? clangLiteralValue(node);
+}

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

@@ -0,0 +1,14 @@
+import{isClangAstNode}from'./isClangAstNode.js';
+export function clangAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (Array.isArray(value)) return { kind: 'TranslationUnitDecl', inner: value };
+  if (isClangAstNode(value)) return value;
+  if (Array.isArray(value.ast)) return { kind: 'TranslationUnitDecl', inner: value.ast };
+  if (isClangAstNode(value.ast)) return value.ast;
+  if (isClangAstNode(value.root)) return value.root;
+  if (isClangAstNode(value.translationUnit)) return value.translationUnit;
+  if (isClangAstNode(value.tu)) return value.tu;
+  if (isClangAstNode(value.file)) return value.file;
+  if (isClangAstNode(value.sourceFile)) return value.sourceFile;
+  return undefined;
+}

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

@@ -0,0 +1,7 @@
+import{clangAstKind}from'./clangAstKind.js';
+export function clangDeclarationAction(node) {
+  if (node.isThisDeclarationADefinition === false) return 'declaration';
+  if (node.isThisDeclarationADefinition === true) return 'definition';
+  if (Array.isArray(node.inner) && node.inner.some((entry) => ['CompoundStmt', 'FieldDecl', 'EnumConstantDecl'].includes(clangAstKind(entry)))) return 'definition';
+  return 'declaration';
+}

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

@@ -0,0 +1,10 @@
+export function clangDeclarationName(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['qualifiedName', 'displayName', 'name', 'mangledName']) {
+    if (typeof node[key] === 'string' && node[key]) return node[key];
+  }
+  if (node.name && typeof node.name === 'object') return clangDeclarationName(node.name);
+  if (node.referencedDecl && typeof node.referencedDecl === 'object') return clangDeclarationName(node.referencedDecl);
+  if (node.decl && typeof node.decl === 'object') return clangDeclarationName(node.decl);
+  return undefined;
+}

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

@@ -0,0 +1,8 @@
+export function clangIncludePath(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  for (const key of ['file', 'filename', 'path', 'spelling', 'source']) {
+    if (typeof node[key] === 'string' && node[key]) return node[key];
+  }
+  if (node.include && typeof node.include === 'object') return clangIncludePath(node.include);
+  return undefined;
+}

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

@@ -0,0 +1,6 @@
+export function clangLiteralValue(node) {
+  const value = node.value ?? node.val ?? node.literal;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  if (typeof node.valueAsString === 'string') return node.valueAsString;
+  return undefined;
+}

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

@@ -0,0 +1,12 @@
+export function clangLocPosition(loc) {
+  if (!loc || typeof loc !== 'object') return undefined;
+  const expanded = loc.expansionLoc ?? loc.spellingLoc ?? loc;
+  const line = expanded.line ?? expanded.startLine ?? expanded.begin?.line;
+  const column = expanded.col ?? expanded.column ?? expanded.startColumn ?? expanded.begin?.col ?? expanded.begin?.column;
+  if (typeof line !== 'number') return undefined;
+  return {
+    path: expanded.file ?? expanded.filename ?? expanded.path,
+    line,
+    column: typeof column === 'number' ? column : undefined
+  };
+}

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

@@ -0,0 +1,8 @@
+export function clangLocationKind(node) {
+  const loc = node.loc ?? node.range?.begin;
+  if (!loc || typeof loc !== 'object') return undefined;
+  if (loc.expansionLoc) return 'expansionLoc';
+  if (loc.spellingLoc) return 'spellingLoc';
+  if (loc.includedFrom) return 'includedFrom';
+  return 'clang-loc';
+}

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

@@ -0,0 +1,3 @@
+export function clangPreprocessorKind(kind) {
+  return /Macro|Preprocess|Preprocessor|IfDirective|IfdefDirective|IfndefDirective|ElifDirective|ElseDirective|EndifDirective/.test(String(kind));
+}

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

@@ -0,0 +1,8 @@
+import{isClangAstNode}from'./isClangAstNode.js';
+export function clangPreprocessorRecords(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.filter(isClangAstNode);
+  if (typeof value === 'object' && Array.isArray(value.records)) return value.records.filter(isClangAstNode);
+  if (isClangAstNode(value)) return [value];
+  return [];
+}