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

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

@@ -0,0 +1,11 @@
+export function resolveNativeProjectAdapter(source, adapters, input) {
+  if (typeof input.adapterResolver === 'function') return input.adapterResolver(source, adapters);
+  const language = source.language;
+  const sourcePath = source.sourcePath ?? '';
+  return adapters.find((adapter) => {
+    if (source.adapter && adapter.id === source.adapter) return true;
+    if (language && adapter.language !== language) return false;
+    const extensions = adapter.supportedExtensions ?? [];
+    return !extensions.length || extensions.some((extension) => sourcePath.toLowerCase().endsWith(extension.toLowerCase()));
+  });
+}

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

@@ -0,0 +1,14 @@
+import{matchingNativeTargetProjectionAdapter}from'./matchingNativeTargetProjectionAdapter.js';
+export function resolveNativeTargetProjectionAdapter(input, options = {}) {
+  const adapters = options.targetAdapters ?? [];
+  if (options.targetAdapter && typeof options.targetAdapter === 'object') return options.targetAdapter;
+  if (typeof options.targetAdapter === 'string') {
+    const explicit = adapters.find((adapter) => adapter?.id === options.targetAdapter);
+    if (explicit) return explicit;
+  }
+  if (typeof options.targetAdapterResolver === 'function') {
+    const resolved = options.targetAdapterResolver(input, adapters);
+    if (resolved) return resolved;
+  }
+  return matchingNativeTargetProjectionAdapter(input, adapters);
+}

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

@@ -0,0 +1,130 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{adapterDiagnosticsEvidence}from'./adapterDiagnosticsEvidence.js';import{adapterDiagnosticToLoss}from'./adapterDiagnosticToLoss.js';import{importNativeSource}from'./importNativeSource.js';import{mergeNativeLosses}from'./mergeNativeLosses.js';import{normalizeAdapterDiagnostics}from'./normalizeAdapterDiagnostics.js';import{normalizeNativeImporterAdapter}from'./normalizeNativeImporterAdapter.js';import{observeNativeImporterAdapterCoverage}from'./observeNativeImporterAdapterCoverage.js';import{serializableDiagnostic}from'./serializableDiagnostic.js';
+export async function runNativeImporterAdapter(adapter, input = {}) {
+  const summary = normalizeNativeImporterAdapter(adapter);
+  const language = input.language ?? summary.language;
+  const parser = input.parser ?? summary.parser;
+  const parserVersion = input.parserVersion ?? summary.version;
+  const sourceText = input.sourceText ?? '';
+  const sourceHash = input.sourceHash ?? hashSemanticValue(sourceText);
+  const parseInput = {
+    sourceText,
+    sourcePath: input.sourcePath,
+    sourceHash,
+    language,
+    parser,
+    parserVersion,
+    adapterId: summary.id,
+    adapterVersion: summary.version,
+    options: input.adapterOptions ?? {},
+    metadata: input.adapterMetadata ?? {}
+  };
+  let parsed;
+  let thrownDiagnostic;
+  try {
+    parsed = await adapter.parse(parseInput);
+  } catch (error) {
+    thrownDiagnostic = {
+      severity: 'error',
+      code: 'adapter.parse.threw',
+      phase: 'parse',
+      kind: 'unsupportedSyntax',
+      message: error instanceof Error ? error.message : String(error),
+      metadata: {
+        errorName: error instanceof Error ? error.name : undefined
+      }
+    };
+    parsed = {
+      rootId: 'adapter_error_root',
+      nodes: {
+        adapter_error_root: {
+          id: 'adapter_error_root',
+          kind: 'AdapterParseError',
+          languageKind: `${language}.adapterParseError`,
+          value: thrownDiagnostic.message,
+          metadata: { adapterId: summary.id, parser }
+        }
+      }
+    };
+  }
+  const parseResult = parsed ?? {};
+  const diagnostics = [
+    ...normalizeAdapterDiagnostics(summary.diagnostics, summary, parseInput, 'adapter'),
+    ...(thrownDiagnostic ? normalizeAdapterDiagnostics([thrownDiagnostic], summary, parseInput, 'throw') : []),
+    ...normalizeAdapterDiagnostics(parseResult.diagnostics, summary, parseInput, 'parse')
+  ];
+  const losses = mergeNativeLosses(
+    parseResult.losses,
+    diagnostics.map((diagnostic, index) => adapterDiagnosticToLoss(diagnostic, index, summary, parseInput))
+  );
+  const adapterSummary = {
+    ...summary,
+    coverage: observeNativeImporterAdapterCoverage(summary.coverage, parseResult, {
+      diagnostics,
+      losses
+    })
+  };
+  const sourceEvidence = adapterDiagnosticsEvidence(adapterSummary, diagnostics, {
+    language,
+    parser,
+    parserVersion,
+    sourcePath: parseResult.sourcePath ?? input.sourcePath,
+    sourceHash: parseResult.sourceHash ?? sourceHash
+  });
+  const evidence = [...(parseResult.evidence ?? []), sourceEvidence];
+  const importInput = {
+    ...input,
+    ...parseResult,
+    language,
+    parser,
+    parserVersion,
+    sourceText,
+    sourcePath: parseResult.sourcePath ?? input.sourcePath,
+    sourceHash: parseResult.sourceHash ?? sourceHash,
+    losses,
+    evidence,
+    metadata: {
+      adapterId: summary.id,
+      adapterVersion: summary.version,
+      adapterCapabilities: adapterSummary.capabilities,
+      adapterCoverage: adapterSummary.coverage,
+      supportedExtensions: adapterSummary.supportedExtensions,
+      diagnostics: diagnostics.map(serializableDiagnostic),
+      ...input.metadata,
+      ...parseResult.metadata
+    },
+    nativeAstMetadata: {
+      adapterId: summary.id,
+      adapterVersion: summary.version,
+      parser,
+      adapterCoverage: adapterSummary.coverage,
+      ...input.nativeAstMetadata,
+      ...parseResult.nativeAstMetadata
+    },
+    nativeSourceMetadata: {
+      adapterId: summary.id,
+      adapterVersion: summary.version,
+      parser,
+      adapterCoverage: adapterSummary.coverage,
+      ...input.nativeSourceMetadata,
+      ...parseResult.nativeSourceMetadata
+    },
+    documentMetadata: {
+      nativeImporterAdapterId: summary.id,
+      nativeImporterAdapterVersion: summary.version,
+      ...input.documentMetadata,
+      ...parseResult.documentMetadata
+    },
+    universalAstMetadata: {
+      nativeImporterAdapterId: summary.id,
+      nativeImporterAdapterVersion: summary.version,
+      ...input.universalAstMetadata,
+      ...parseResult.universalAstMetadata
+    }
+  };
+  return {
+    ...importNativeSource(importInput),
+    adapter: adapterSummary,
+    diagnostics
+  };
+}

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

@@ -0,0 +1,115 @@
+import{normalizeProjectionMatrixTargets}from'../../coverage-matrix-profiles.js';import{idFragment,maxSemanticMergeReadiness,normalizeNativeLanguageId,normalizeSemanticMergeReadiness,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{nativeTargetProjectionAdapterEvidence}from'./nativeTargetProjectionAdapterEvidence.js';import{nativeTargetProjectionDiagnosticToLoss}from'./nativeTargetProjectionDiagnosticToLoss.js';import{normalizeAdapterDiagnostics}from'./normalizeAdapterDiagnostics.js';import{normalizeNativeTargetProjectionAdapter}from'./normalizeNativeTargetProjectionAdapter.js';import{serializableDiagnostic}from'./serializableDiagnostic.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function runNativeTargetProjectionAdapter(adapter, input = {}) {
+  const summary = normalizeNativeTargetProjectionAdapter(adapter);
+  const sourceLanguage = normalizeNativeLanguageId(input.sourceLanguage ?? summary.sourceLanguage);
+  const target = normalizeProjectionMatrixTargets([input.target ?? summary.target])[0] ?? summary.target;
+  const diagnosticContext = {
+    sourcePath: input.importResult?.sourcePath ?? input.importResult?.nativeSource?.sourcePath,
+    sourceHash: input.importResult?.sourceHash ?? input.importResult?.nativeSource?.sourceHash,
+    language: sourceLanguage,
+    parser: `target:${target}`,
+    parserVersion: summary.version
+  };
+  const projectInput = {
+    importResult: input.importResult,
+    sourceProjection: input.sourceProjection,
+    sourceLanguage,
+    target,
+    targetPath: input.targetPath,
+    targetCoverage: input.targetCoverage,
+    options: input.options ?? {},
+    metadata: input.metadata ?? {}
+  };
+  let projected;
+  let thrownDiagnostic;
+  try {
+    projected = adapter.project(projectInput) ?? {};
+  } catch (error) {
+    thrownDiagnostic = {
+      severity: 'error',
+      code: 'targetAdapter.project.threw',
+      phase: 'emit',
+      kind: 'targetProjectionLoss',
+      message: error instanceof Error ? error.message : String(error),
+      metadata: {
+        errorName: error instanceof Error ? error.name : undefined
+      }
+    };
+    projected = {};
+  }
+  const diagnostics = [
+    ...normalizeAdapterDiagnostics(summary.diagnostics, summary, diagnosticContext, 'target-adapter'),
+    ...(thrownDiagnostic ? normalizeAdapterDiagnostics([thrownDiagnostic], summary, diagnosticContext, 'throw') : []),
+    ...normalizeAdapterDiagnostics(projected.diagnostics, summary, diagnosticContext, 'project')
+  ];
+  const output = typeof projected.output === 'string' ? projected.output : input.sourceProjection?.sourceText ?? '';
+  const outputHash = projected.outputHash ?? hashSemanticValue(output);
+  const adapterEvidence = nativeTargetProjectionAdapterEvidence(summary, diagnostics, {
+    ...diagnosticContext,
+    sourceLanguage,
+    target,
+    outputHash,
+    targetPath: input.targetPath
+  });
+  const evidence = uniqueByEvidenceId([
+    ...(projected.evidence ?? []),
+    adapterEvidence
+  ]);
+  const losses = uniqueByLossId([
+    ...(projected.losses ?? []),
+    ...diagnostics.map((diagnostic, index) => nativeTargetProjectionDiagnosticToLoss(diagnostic, index, summary, {
+      ...diagnosticContext,
+      sourceLanguage,
+      target
+    }))
+  ]);
+  const lossSummary = summarizeNativeImportLosses(losses, {
+    evidence,
+    parser: diagnosticContext.parser,
+    scanKind: 'native-target-projection',
+    semanticStatus: input.importResult?.metadata?.semanticStatus
+  });
+  const classifiedReadiness = classifyNativeImportReadiness(losses, {
+    evidence,
+    parser: diagnosticContext.parser,
+    scanKind: 'native-target-projection',
+    semanticStatus: input.importResult?.metadata?.semanticStatus
+  });
+  const declaredReadiness = normalizeSemanticMergeReadiness(projected.readiness ?? summary.coverage.readiness);
+  const readiness = declaredReadiness
+    ? {
+      ...classifiedReadiness,
+      readiness: maxSemanticMergeReadiness(classifiedReadiness.readiness, declaredReadiness),
+      reasons: uniqueStrings([
+        ...classifiedReadiness.reasons,
+        ...(declaredReadiness === classifiedReadiness.readiness ? [] : [`Target adapter declared readiness ${declaredReadiness}.`])
+      ])
+    }
+    : classifiedReadiness;
+  return {
+    kind: 'frontier.lang.nativeTargetProjection',
+    version: 1,
+    id: projected.id ?? `native_target_projection_${idFragment(summary.id)}_${idFragment(sourceLanguage)}_${idFragment(target)}`,
+    sourceLanguage,
+    target,
+    targetPath: input.targetPath,
+    adapter: summary,
+    output,
+    outputHash,
+    outputMode: 'target-adapter',
+    sourceMaps: projected.sourceMaps ?? [],
+    losses,
+    lossSummary,
+    readiness,
+    evidence,
+    diagnostics: diagnostics.map(serializableDiagnostic),
+    metadata: {
+      importId: input.importResult?.id,
+      projectionId: input.sourceProjection?.id,
+      targetCoverageLossClass: input.targetCoverage?.lossClass,
+      targetCoverageReadiness: input.targetCoverage?.readiness,
+      ...projected.metadata
+    }
+  };
+}

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

@@ -0,0 +1,11 @@
+import{isRustSynAstNode}from'./isRustSynAstNode.js';
+export function rustSynAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isRustSynAstNode(value)) return value;
+  if (isRustSynAstNode(value.ast)) return value.ast;
+  if (isRustSynAstNode(value.file)) return value.file;
+  if (isRustSynAstNode(value.root)) return value.root;
+  if (isRustSynAstNode(value.module)) return value.module;
+  if (isRustSynAstNode(value.sourceFile)) return value.sourceFile;
+  return undefined;
+}

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

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

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

@@ -0,0 +1,3 @@
+export function rustSynColumnToOneBased(column, span) {
+  return span.columnBase === 1 || span.columnsOneBased ? column : column + 1;
+}

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

@@ -0,0 +1,40 @@
+import{declarationRecord}from'./declarationRecord.js';import{nativeNodeId}from'./nativeNodeId.js';import{rustSynIdentName}from'./rustSynIdentName.js';import{rustSynImplName}from'./rustSynImplName.js';import{rustSynMacroKind}from'./rustSynMacroKind.js';import{rustSynUseName}from'./rustSynUseName.js';
+export function rustSynDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'ItemUse' || kind === 'UseTree' || kind === 'UsePath' || kind === 'UseName') {
+    const name = rustSynUseName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'ItemFn' || kind === 'ForeignItemFn') {
+    const name = rustSynIdentName(node.sig?.ident ?? node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'function', 'definition');
+  }
+  if (kind === 'ImplItemFn' || kind === 'TraitItemFn') {
+    const name = rustSynIdentName(node.sig?.ident ?? node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'method', 'definition');
+  }
+  if (kind === 'ItemStruct' || kind === 'ItemUnion') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'class', 'definition');
+  }
+  if (kind === 'ItemEnum' || kind === 'ItemTrait' || kind === 'ItemType') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  if (kind === 'ItemMod') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'definition');
+  }
+  if (kind === 'ItemConst' || kind === 'ItemStatic') {
+    const name = rustSynIdentName(node.ident ?? node.name);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', 'definition');
+  }
+  if (kind === 'ItemImpl') {
+    const name = rustSynImplName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
+  }
+  if (rustSynMacroKind(kind)) {
+    const name = rustSynIdentName(node.ident ?? node.mac?.path ?? node.path);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'macro', 'definition');
+  }
+  return undefined;
+}

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

@@ -0,0 +1,12 @@
+import{rustSynPathName}from'./rustSynPathName.js';
+export function rustSynIdentName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.ident === 'string') return value.ident;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.sym === 'string') return value.sym;
+  if (typeof value.value === 'string') return value.value;
+  if (typeof value.path === 'string') return value.path;
+  return rustSynPathName(value.path ?? value);
+}

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

@@ -0,0 +1,11 @@
+import{rustSynPathName}from'./rustSynPathName.js';
+export function rustSynImplName(node) {
+  const selfType = rustSynPathName(node.self_ty ?? node.selfType ?? node.ty);
+  const traitPath = Array.isArray(node.trait_)
+    ? rustSynPathName(node.trait_[1] ?? node.trait_[0])
+    : rustSynPathName(node.trait_);
+  if (selfType && traitPath) return `${selfType}.${traitPath}.impl`;
+  if (selfType) return `${selfType}.impl`;
+  if (traitPath) return `${traitPath}.impl`;
+  return undefined;
+}

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

@@ -0,0 +1,15 @@
+import{normalizeRustSynKind}from'./normalizeRustSynKind.js';import{rustSynWrapperKind}from'./rustSynWrapperKind.js';
+export function rustSynKind(node) {
+  const declared = node?._type ?? node?.type ?? node?.kind ?? node?.nodeType ?? node?.synKind;
+  if (typeof declared === 'string') return normalizeRustSynKind(declared);
+  const wrapper = rustSynWrapperKind(node);
+  if (wrapper) return normalizeRustSynKind(wrapper);
+  if (Array.isArray(node?.items)) return 'File';
+  if (node?.sig && node?.block) return 'ItemFn';
+  if (node?.ident && node?.fields && Array.isArray(node?.variants)) return 'ItemEnum';
+  if (node?.ident && node?.fields) return 'ItemStruct';
+  if (node?.ident && Array.isArray(node?.items)) return 'ItemMod';
+  if (node?.trait_ || node?.self_ty || node?.selfType) return 'ItemImpl';
+  if (node?.path && (node?.tree || node?.trees)) return 'ItemUse';
+  return undefined;
+}

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

@@ -0,0 +1,5 @@
+export function rustSynLiteralValue(node) {
+  const value = node.value ?? node.lit?.value ?? node.lit;
+  if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value;
+  return undefined;
+}

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

@@ -0,0 +1,3 @@
+export function rustSynMacroKind(kind) {
+  return /Macro|MacroRules|MacroCall/.test(String(kind));
+}

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

@@ -0,0 +1,6 @@
+import{rustSynIdentName}from'./rustSynIdentName.js';import{rustSynLiteralValue}from'./rustSynLiteralValue.js';import{rustSynPathName}from'./rustSynPathName.js';
+export function rustSynNodeValue(node) {
+  return rustSynIdentName(node.ident ?? node.name ?? node.sig?.ident)
+    ?? rustSynPathName(node.path ?? node.trait_ ?? node.self_ty ?? node.selfType ?? node.ty)
+    ?? rustSynLiteralValue(node);
+}

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

@@ -0,0 +1,21 @@
+import{rustSynIdentName}from'./rustSynIdentName.js';
+export function rustSynPathName(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.ident === 'string') return value.ident;
+  if (typeof value.name === 'string') return value.name;
+  if (typeof value.path === 'string') return value.path;
+  if (value.path && typeof value.path === 'object') return rustSynPathName(value.path);
+  if (Array.isArray(value.segments)) {
+    const names = value.segments
+      .map((segment) => rustSynIdentName(segment.ident ?? segment))
+      .filter(Boolean);
+    return names.length ? names.join('::') : undefined;
+  }
+  if (Array.isArray(value.qself)) return value.qself.map(rustSynPathName).filter(Boolean).join('::');
+  if (value.leading_colon && value.segments) {
+    const name = rustSynPathName({ segments: value.segments });
+    return name ? `::${name}` : undefined;
+  }
+  return undefined;
+}

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

@@ -0,0 +1,6 @@
+import{rustSynWrapperKind}from'./rustSynWrapperKind.js';
+export function rustSynPayload(node) {
+  if (!node || typeof node !== 'object') return node;
+  const wrapper = rustSynWrapperKind(node);
+  return wrapper ? node[wrapper] : node;
+}

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

@@ -0,0 +1,5 @@
+export function rustSynSpanKind(node) {
+  const span = node.span ?? node.ident?.span ?? node.sig?.ident?.span ?? node.name?.span;
+  if (!span || typeof span !== 'object') return undefined;
+  return span.kind ?? span.source ?? 'host-span';
+}

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

@@ -0,0 +1,26 @@
+import{rustSynIdentName}from'./rustSynIdentName.js';import{rustSynPathName}from'./rustSynPathName.js';
+export function rustSynUseName(node) {
+  if (!node) return undefined;
+  if (node.prefix && node.tree) {
+    const prefix = rustSynPathName(node.prefix);
+    const child = rustSynUseName(node.tree);
+    return [prefix, child].filter(Boolean).join('::') || undefined;
+  }
+  if (node.ident && node.tree) {
+    const prefix = rustSynIdentName(node.ident);
+    const child = rustSynUseName(node.tree);
+    return [prefix, child].filter(Boolean).join('::') || undefined;
+  }
+  if (node.path && node.tree) {
+    const prefix = rustSynPathName(node.path);
+    const child = rustSynUseName(node.tree);
+    return [prefix, child].filter(Boolean).join('::') || undefined;
+  }
+  if (Array.isArray(node.trees)) return node.trees.map(rustSynUseName).find(Boolean);
+  if (node.tree) return rustSynUseName(node.tree);
+  if (node.path) return rustSynPathName(node.path);
+  if (node.name) return rustSynIdentName(node.name);
+  if (node.ident) return rustSynIdentName(node.ident);
+  if (node.rename) return rustSynIdentName(node.rename);
+  return undefined;
+}

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

@@ -0,0 +1,9 @@
+export function rustSynVisibility(value) {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (typeof value.kind === 'string') return value.kind;
+  if (typeof value.type === 'string') return value.type;
+  if (value.pub || value.Public) return 'pub';
+  if (value.restricted || value.Restricted) return 'restricted';
+  return undefined;
+}

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

@@ -0,0 +1,12 @@
+import{ignoredRustSynField}from'./ignoredRustSynField.js';
+export function rustSynWrapperKind(node) {
+  if (!node || typeof node !== 'object') return undefined;
+  const keys = Object.keys(node).filter((key) => !ignoredRustSynField(key));
+  if (keys.length !== 1) return undefined;
+  const key = keys[0];
+  const value = node[key];
+  if (!value || typeof value !== 'object') return undefined;
+  if (/^(?:Fn|Struct|Enum|Trait|Impl|Use|Mod|Type|Const|Static|Union|Macro)$/.test(key)) return key;
+  if (/^(?:Item|ImplItem|TraitItem|ForeignItem)/.test(key)) return key;
+  return undefined;
+}

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

@@ -0,0 +1,8 @@
+import{normalizeNativeImporterAdapter}from'./normalizeNativeImporterAdapter.js';
+export function safeNativeImporterAdapterSummary(adapter) {
+  try {
+    return normalizeNativeImporterAdapter(adapter);
+  } catch {
+    return undefined;
+  }
+}

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

@@ -0,0 +1,8 @@
+import{normalizeNativeTargetProjectionAdapter}from'./normalizeNativeTargetProjectionAdapter.js';
+export function safeNativeTargetProjectionAdapterSummary(adapter) {
+  try {
+    return normalizeNativeTargetProjectionAdapter(adapter);
+  } catch {
+    return undefined;
+  }
+}

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

@@ -0,0 +1,5 @@
+export function safeProjectionIdentifier(name) {
+  const text = String(name ?? 'value').split('.').at(-1).replace(/[^A-Za-z0-9_$]/g, '_');
+  const identifier = text || 'value';
+  return /^[A-Za-z_$]/.test(identifier) ? identifier : `_${identifier}`;
+}

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

@@ -0,0 +1,8 @@
+export function scipOccurrenceRole(value) {
+  const role = Number(value ?? 0);
+  if ((role & 0x1) > 0) return 'definition';
+  if ((role & 0x2) > 0) return 'import';
+  if ((role & 0x4) > 0) return 'write';
+  if ((role & 0x8) > 0) return 'read';
+  return 'reference';
+}

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

@@ -0,0 +1,12 @@
+export function scipOccurrenceRoleSet(value) {
+  const role = Number(value ?? 0);
+  const roles = [];
+  if ((role & 0x1) > 0) roles.push('definition');
+  if ((role & 0x2) > 0) roles.push('import');
+  if ((role & 0x4) > 0) roles.push('write');
+  if ((role & 0x8) > 0) roles.push('read');
+  if ((role & 0x10) > 0) roles.push('generated');
+  if ((role & 0x20) > 0) roles.push('test');
+  if ((role & 0x40) > 0) roles.push('forwardDefinition');
+  return roles.length ? roles : ['reference'];
+}

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

@@ -0,0 +1,20 @@
+import{idFragment}from'../../native-import-utils.js';
+import{normalizeArray}from'./normalizeArray.js';import{scipSymbolId}from'./scipSymbolId.js';
+export function scipRelationshipRelations(symbolInfo, symbolId, context) {
+  return normalizeArray(symbolInfo.relationships).flatMap((relationship, index) => {
+    const targetId = scipSymbolId(relationship.symbol, context);
+    if (!targetId) return [];
+    const predicates = [];
+    if (relationship.is_reference ?? relationship.isReference) predicates.push('references');
+    if (relationship.is_implementation ?? relationship.isImplementation) predicates.push('implements');
+    if (relationship.is_type_definition ?? relationship.isTypeDefinition) predicates.push('typeDefinition');
+    if (relationship.is_definition ?? relationship.isDefinition) predicates.push('definitionOf');
+    return (predicates.length ? predicates : ['related']).map((predicate) => ({
+      id: `rel_${idFragment(symbolId)}_${idFragment(targetId)}_${idFragment(predicate)}_${index + 1}`,
+      sourceId: symbolId,
+      predicate,
+      targetId,
+      metadata: { format: 'scip', relationship }
+    }));
+  });
+}

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

@@ -0,0 +1,31 @@
+import{idFragment}from'../../native-import-utils.js';
+import{normalizeArray}from'./normalizeArray.js';
+export function scipSymbolFacts(symbolInfo, symbolId) {
+  const facts = [];
+  if (symbolInfo.documentation) {
+    facts.push({
+      id: `fact_${idFragment(symbolId)}_documentation`,
+      predicate: 'documentation',
+      subjectId: symbolId,
+      value: normalizeArray(symbolInfo.documentation)
+    });
+  }
+  const signature = symbolInfo.signature_documentation ?? symbolInfo.signatureDocumentation;
+  if (signature) {
+    facts.push({
+      id: `fact_${idFragment(symbolId)}_signature`,
+      predicate: 'signature',
+      subjectId: symbolId,
+      value: signature
+    });
+  }
+  for (const [index, relationship] of normalizeArray(symbolInfo.relationships).entries()) {
+    facts.push({
+      id: `fact_${idFragment(symbolId)}_relationship_${index + 1}`,
+      predicate: 'relationship',
+      subjectId: symbolId,
+      value: relationship
+    });
+  }
+  return facts;
+}

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

@@ -0,0 +1,8 @@
+import{idFragment}from'../../native-import-utils.js';
+export function scipSymbolId(symbol, context, documentId) {
+  if (!symbol) return undefined;
+  const raw = String(symbol);
+  if (raw.startsWith('symbol:')) return raw;
+  const scope = /^local\b/i.test(raw) ? `${documentId ?? context.idPart}:` : '';
+  return `symbol:scip:${idFragment(scope + raw)}`;
+}

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

@@ -0,0 +1,8 @@
+export function scipSyntaxKind(kind) {
+  const normalized = typeof kind === 'number' ? kind : Number(kind);
+  if (normalized === 15 || normalized === 16) return 'function';
+  if (normalized === 19 || normalized === 20) return 'type';
+  if (normalized === 25 || normalized === 26) return 'module';
+  if (normalized === 9 || normalized === 10 || normalized === 12) return 'variable';
+  return 'symbol';
+}