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

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

@@ -0,0 +1,210 @@
+import{idFragment}from'../../native-import-utils.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+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{withExternalEmptyLoss}from'./withExternalEmptyLoss.js';
+
+export function normalizeGleanPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: 'glean', factStore: true });
+  const root = context.projectRoot ?? payload.repo ?? payload.repository ?? payload.projectRoot;
+  result.repository = root ? { root } : undefined;
+  const documents = new Map();
+  const symbols = new Map();
+  const ensureDocument = (path, language, sourceHash) => {
+    const normalizedPath = path ?? context.sourcePath ?? 'glean-facts';
+    const id = `doc_${idFragment(normalizedPath)}`;
+    if (!documents.has(id)) {
+      const document = {
+        id,
+        path: normalizedPath,
+        language: normalizeExternalSemanticLanguage(language ?? context.language),
+        sourceHash: sourceHash ?? context.sourceHash,
+        metadata: { format: 'glean', root }
+      };
+      documents.set(id, document);
+      result.documents.push(document);
+    }
+    return documents.get(id);
+  };
+  const ensureSymbol = (fact, document, name, kind) => {
+    const rawSymbol = firstString(name, fact.symbol, fact.key?.symbol, fact.key?.name, fact.id);
+    const symbolId = `sym_${idFragment(document.id)}_${idFragment(rawSymbol ?? fact.predicate)}`;
+    if (!symbols.has(symbolId)) {
+      const symbol = {
+        id: symbolId,
+        scheme: 'glean',
+        name: name ?? nameFromExternalSymbol(rawSymbol ?? fact.predicate),
+        kind: normalizeExternalSymbolKind(kind ?? fact.kind ?? fact.key?.kind ?? fact.predicate),
+        language: document.language,
+        signatureHash: hashSemanticValue([fact.predicate, rawSymbol, fact.value?.signature]),
+        metadata: {
+          format: 'glean',
+          predicate: fact.predicate,
+          factId: fact.id,
+          rawSymbol
+        }
+      };
+      symbols.set(symbolId, symbol);
+      result.symbols.push(symbol);
+    }
+    return symbols.get(symbolId);
+  };
+  for (const [index, fact] of collectGleanFacts(payload).entries()) {
+    const path = gleanPath(fact) ?? context.sourcePath;
+    const document = ensureDocument(path, gleanLanguage(fact, context), gleanSourceHash(fact, context));
+    const name = gleanName(fact);
+    const symbol = name ? ensureSymbol(fact, document, name, gleanKind(fact)) : undefined;
+    const subjectId = symbol?.id ?? document.id;
+    const factId = `fact_${idFragment(fact.predicate)}_${idFragment(fact.id ?? index + 1)}`;
+    result.facts.push({
+      id: factId,
+      predicate: fact.predicate,
+      subjectId,
+      objectId: undefined,
+      value: { key: fact.key, value: fact.value },
+      metadata: { format: 'glean', factId: fact.id, schema: fact.schema }
+    });
+    const span = spanFromGleanFact(fact, document.path, document.sourceHash);
+    if (symbol && span) {
+      result.occurrences.push({
+        id: `occ_${idFragment(factId)}`,
+        documentId: document.id,
+        symbolId: symbol.id,
+        role: gleanRole(fact),
+        span,
+        metadata: { format: 'glean', predicate: fact.predicate, factId: fact.id }
+      });
+    }
+    const relation = gleanRelation(fact, subjectId);
+    if (relation) {
+      const target = ensureSymbol(fact, document, relation.targetName, relation.targetKind);
+      result.relations.push({
+        id: `rel_${idFragment(factId)}_${idFragment(target.id)}`,
+        sourceId: subjectId,
+        predicate: relation.predicate,
+        targetId: target.id,
+        metadata: { format: 'glean', factId: fact.id, sourcePredicate: fact.predicate }
+      });
+    }
+  }
+  return withExternalEmptyLoss(result, context);
+}
+
+function collectGleanFacts(payload) {
+  const facts = [];
+  const addFact = (fact, predicate) => {
+    if (!fact || typeof fact !== 'object') return;
+    facts.push(normalizeGleanFact({
+      ...fact,
+      predicate: fact.predicate ?? fact.predicateName ?? predicate ?? fact.name
+    }));
+  };
+  const addFactGroup = (group, predicate) => {
+    if (!group || typeof group !== 'object') return false;
+    const groupPredicate = group.predicate ?? group.predicateName ?? group.name ?? predicate;
+    if (!groupPredicate) return false;
+    const groupedFacts = [...normalizeArray(group.facts), ...normalizeArray(group.results)];
+    if (!groupedFacts.length) return false;
+    for (const fact of groupedFacts) addFact(fact, groupPredicate);
+    return true;
+  };
+  const topLevelGroup = !Array.isArray(payload) && addFactGroup(payload);
+  if (!topLevelGroup) {
+    for (const entry of Array.isArray(payload) ? payload : []) {
+      if (!addFactGroup(entry)) addFact(entry);
+    }
+  }
+  if (!topLevelGroup) {
+    for (const fact of normalizeArray(payload.facts)) {
+      if (!addFactGroup(fact)) addFact(fact);
+    }
+    for (const fact of normalizeArray(payload.results)) {
+      if (!addFactGroup(fact)) addFact(fact);
+    }
+  }
+  for (const [predicate, entries] of Object.entries(payload.predicates ?? payload.factsByPredicate ?? {})) {
+    for (const entry of normalizeArray(entries)) facts.push(normalizeGleanFact({ predicate, ...entry }));
+  }
+  return facts.filter((fact) => fact.predicate);
+}
+
+function normalizeGleanFact(fact) {
+  const key = fact.key ?? fact.value?.key ?? fact.data?.key ?? fact;
+  const value = fact.value?.value ?? fact.val ?? fact.data?.value ?? fact.value;
+  return {
+    id: fact.id ?? fact.factId ?? fact.fact_id,
+    predicate: fact.predicate ?? fact.predicateName ?? fact.name,
+    key,
+    value,
+    schema: fact.schema ?? fact.schemaId,
+    symbol: fact.symbol,
+    kind: fact.kind
+  };
+}
+
+function gleanPath(fact) {
+  return firstString(fact.key?.file?.key?.name, fact.key?.file?.key?.path, fact.key?.file?.name, fact.key?.file?.path, fact.key?.path, fact.key?.uri, fact.value?.file?.path, fact.value?.path);
+}
+
+function gleanLanguage(fact, context) {
+  return firstString(fact.key?.language, fact.value?.language, context.language);
+}
+
+function gleanSourceHash(fact, context) {
+  return firstString(fact.key?.file?.key?.hash, fact.key?.file?.hash, fact.key?.sourceHash, fact.value?.sourceHash, context.sourceHash);
+}
+
+function gleanName(fact) {
+  return firstString(fact.key?.name, fact.key?.decl?.name, fact.key?.target?.name, fact.key?.function?.name, fact.key?.className, fact.value?.name, fact.symbol);
+}
+
+function gleanKind(fact) {
+  const predicate = String(fact.predicate ?? '').toLowerCase();
+  if (predicate.includes('function') || predicate.includes('method')) return 'function';
+  if (predicate.includes('class')) return 'class';
+  if (predicate.includes('module')) return 'module';
+  if (predicate.includes('variable') || predicate.includes('local')) return 'variable';
+  return firstString(fact.key?.kind, fact.value?.kind, fact.kind);
+}
+
+function gleanRole(fact) {
+  const predicate = String(fact.predicate ?? '').toLowerCase();
+  if (predicate.includes('reference') || predicate.includes('use')) return 'reference';
+  if (predicate.includes('import')) return 'import';
+  if (predicate.includes('definition') || predicate.includes('declaration') || predicate.includes('decl')) return 'definition';
+  return 'definition';
+}
+
+function spanFromGleanFact(fact, path, sourceHash) {
+  const range = fact.key?.range ?? fact.key?.loc ?? fact.key?.location ?? fact.value?.range ?? fact.value?.location;
+  const start = range?.start ?? range;
+  const end = range?.end ?? range;
+  const line = numberValue(start?.line ?? start?.lineStart ?? range?.line);
+  const column = numberValue(start?.column ?? start?.character ?? start?.col ?? range?.column);
+  if (line === undefined || column === undefined) return undefined;
+  return {
+    sourceId: sourceHash,
+    path,
+    startLine: line + 1,
+    startColumn: column + 1,
+    endLine: numberValue(end?.line ?? end?.lineEnd ?? line) + 1,
+    endColumn: numberValue(end?.column ?? end?.character ?? end?.col ?? column) + 1
+  };
+}
+
+function gleanRelation(fact, sourceId) {
+  const predicate = String(fact.predicate ?? '').toLowerCase();
+  const targetName = firstString(fact.key?.target?.name, fact.key?.callee?.name, fact.key?.parent?.name, fact.value?.target?.name, fact.value?.callee?.name, fact.value?.parent?.name);
+  if (!targetName) return undefined;
+  const relationPredicate = predicate.includes('call') ? 'calls' : predicate.includes('parent') || predicate.includes('inherit') ? 'extends' : 'references';
+  return { predicate: relationPredicate, sourceId, targetName, targetKind: fact.key?.target?.kind ?? fact.value?.target?.kind };
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value;
+  }
+  return undefined;
+}
+
+function numberValue(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : undefined;
+}

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

@@ -0,0 +1,14 @@
+export function normalizeGoAstKind(kind) {
+  const text = String(kind).replace(/^(?:ast\.)?\*/, '').replace(/^(?:go\/ast\.)/, '');
+  if (/^file$/i.test(text)) return 'File';
+  if (/^package$/i.test(text)) return 'Package';
+  if (/^funcdecl$/i.test(text) || /^func_decl$/i.test(text)) return 'FuncDecl';
+  if (/^gendecl$/i.test(text) || /^gen_decl$/i.test(text)) return 'GenDecl';
+  if (/^importspec$/i.test(text) || /^import_spec$/i.test(text)) return 'ImportSpec';
+  if (/^typespec$/i.test(text) || /^type_spec$/i.test(text)) return 'TypeSpec';
+  if (/^valuespec$/i.test(text) || /^value_spec$/i.test(text)) return 'ValueSpec';
+  if (/^structtype$/i.test(text) || /^struct_type$/i.test(text)) return 'StructType';
+  if (/^interfacetype$/i.test(text) || /^interface_type$/i.test(text)) return 'InterfaceType';
+  if (/^fieldlist$/i.test(text) || /^field_list$/i.test(text)) return 'FieldList';
+  return text;
+}

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

@@ -0,0 +1,24 @@
+import{upperFirst}from'../../native-import-utils.js';
+export function normalizeJavaAstKind(kind) {
+  const text = String(kind).replace(/^(?:com\.sun\.source\.tree\.|org\.eclipse\.jdt\.core\.dom\.|com\.github\.javaparser\.ast\.)/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').replace(/Tree$/, '').toLowerCase();
+  if (compact === 'compilationunit' || compact === 'compilationunitnode') return 'CompilationUnit';
+  if (compact === 'package' || compact === 'packagedeclaration' || compact === 'packageclause') return 'PackageDeclaration';
+  if (compact === 'import' || compact === 'importdeclaration') return 'ImportDeclaration';
+  if (compact === 'class' || compact === 'classdeclaration' || compact === 'normalclassdeclaration' || compact === 'classorinterfacedeclaration') return 'ClassDeclaration';
+  if (compact === 'interface' || compact === 'interfacedeclaration' || compact === 'normalinterfacedeclaration') return 'InterfaceDeclaration';
+  if (compact === 'enum' || compact === 'enumdeclaration') return 'EnumDeclaration';
+  if (compact === 'record' || compact === 'recorddeclaration') return 'RecordDeclaration';
+  if (compact === 'annotation' || compact === 'annotationdeclaration' || compact === 'annotationtypedeclaration' || compact === 'annotationinterface') return 'AnnotationDeclaration';
+  if (compact === 'method' || compact === 'methoddeclaration') return 'MethodDeclaration';
+  if (compact === 'constructor' || compact === 'constructordeclaration') return 'ConstructorDeclaration';
+  if (compact === 'variable' || compact === 'variabledeclaration' || compact === 'variabledeclarator' || compact === 'variabletree') return 'VariableDeclarator';
+  if (compact === 'field' || compact === 'fielddeclaration') return 'FieldDeclaration';
+  if (compact === 'enumconstant' || compact === 'enumconstantdeclaration') return 'EnumConstantDeclaration';
+  if (compact === 'parameter' || compact === 'formalparameter' || compact === 'receiverparameter') return 'Parameter';
+  if (compact === 'modifiers' || compact === 'modifier') return 'Modifiers';
+  if (compact === 'markerannotationexpr' || compact === 'singlememberannotationexpr' || compact === 'normalannotationexpr' || compact === 'annotationexpr') return 'Annotation';
+  if (compact === 'erroneous' || compact === 'erroneoustree' || compact === 'malformed' || compact === 'error' || compact === 'errornode' || compact === 'problem' || compact === 'problemtree' || compact === 'recovered') return 'Erroneous';
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}

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

@@ -0,0 +1,54 @@
+import{upperFirst}from'../../native-import-utils.js';
+export function normalizeKotlinPsiKind(kind) {
+  const text = String(kind)
+    .replace(/^org\.jetbrains\.kotlin\.psi\./, '')
+    .replace(/^KtNodeTypes\./, '')
+    .replace(/ElementType$/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
+  const known = {
+    kotlinfile: 'KtFile',
+    ktfile: 'KtFile',
+    file: 'KtFile',
+    script: 'KtScript',
+    ktscript: 'KtScript',
+    packagedirective: 'KtPackageDirective',
+    ktpackagedirective: 'KtPackageDirective',
+    importdirective: 'KtImportDirective',
+    ktimportdirective: 'KtImportDirective',
+    class: 'KtClass',
+    ktclass: 'KtClass',
+    classorobject: 'KtClassOrObject',
+    ktclassorobject: 'KtClassOrObject',
+    objectdeclaration: 'KtObjectDeclaration',
+    ktobjectdeclaration: 'KtObjectDeclaration',
+    enumentry: 'KtEnumEntry',
+    ktenumentry: 'KtEnumEntry',
+    namedfunction: 'KtNamedFunction',
+    ktnamedfunction: 'KtNamedFunction',
+    function: 'KtNamedFunction',
+    property: 'KtProperty',
+    ktproperty: 'KtProperty',
+    typealias: 'KtTypeAlias',
+    kttypealias: 'KtTypeAlias',
+    parameter: 'KtParameter',
+    ktparameter: 'KtParameter',
+    primaryconstructor: 'KtPrimaryConstructor',
+    ktprimaryconstructor: 'KtPrimaryConstructor',
+    secondaryconstructor: 'KtSecondaryConstructor',
+    ktsecondaryconstructor: 'KtSecondaryConstructor',
+    classinitializer: 'KtClassInitializer',
+    ktclassinitializer: 'KtClassInitializer',
+    annotationentry: 'KtAnnotationEntry',
+    ktannotationentry: 'KtAnnotationEntry',
+    contracteffect: 'KtContractEffect',
+    ktcontracteffect: 'KtContractEffect',
+    contractdescription: 'KtContractDescription',
+    ktcontractdescription: 'KtContractDescription',
+    error: 'PsiErrorElement',
+    psierror: 'PsiErrorElement',
+    psierrorelement: 'PsiErrorElement'
+  };
+  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/normalizeLossSeverity.js

@@ -0,0 +1,6 @@
+export function normalizeLossSeverity(value) {
+  const severity = String(value ?? 'warning').toLowerCase();
+  if (severity === 'error') return 'error';
+  if (severity === 'info') return 'info';
+  return 'warning';
+}

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

@@ -0,0 +1,91 @@
+import{idFragment}from'../../native-import-utils.js';
+import{externalSemanticBase}from'./externalSemanticBase.js';import{normalizeArray}from'./normalizeArray.js';import{normalizeExternalSemanticLanguage}from'./normalizeExternalSemanticLanguage.js';import{spanFromLspRange}from'./spanFromLspRange.js';import{uriToPath}from'./uriToPath.js';import{withExternalEmptyLoss}from'./withExternalEmptyLoss.js';
+export function normalizeLsifPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: 'lsif' });
+  const records = Array.isArray(payload) ? payload : [...normalizeArray(payload.vertices), ...normalizeArray(payload.edges)];
+  const vertices = new Map(records.filter((record) => record?.type === 'vertex').map((record) => [record.id, record]));
+  const edges = records.filter((record) => record?.type === 'edge');
+  const documentByVertex = new Map();
+  const documentIdByRange = new Map();
+  const resultSetByRange = new Map();
+  const monikerByOut = new Map();
+  const definitionRangeIds = new Set();
+  for (const vertex of vertices.values()) {
+    if (vertex.label === 'document') {
+      const path = uriToPath(vertex.uri) ?? vertex.uri ?? context.sourcePath ?? `lsif-document-${result.documents.length + 1}`;
+      const documentId = `doc_${idFragment(vertex.id ?? path)}`;
+      documentByVertex.set(vertex.id, { id: documentId, path, language: normalizeExternalSemanticLanguage(vertex.languageId ?? context.language) });
+      result.documents.push({
+        id: documentId,
+        path,
+        language: normalizeExternalSemanticLanguage(vertex.languageId ?? context.language),
+        metadata: { format: 'lsif', vertexId: vertex.id, uri: vertex.uri }
+      });
+    }
+    if (vertex.label === 'moniker') monikerByOut.set(vertex.id, vertex);
+  }
+  for (const edge of edges) {
+    if (edge.label === 'next') resultSetByRange.set(edge.outV, edge.inV);
+    if (edge.label === 'moniker') monikerByOut.set(edge.outV, vertices.get(edge.inV) ?? edge);
+    if (edge.label === 'contains') {
+      const document = documentByVertex.get(edge.outV);
+      if (document) {
+        for (const rangeId of normalizeArray(edge.inVs ?? edge.inV)) {
+          documentIdByRange.set(rangeId, document.id);
+        }
+      }
+    }
+    if (edge.label === 'item' && (edge.property === 'definitions' || edge.property === 'declarations')) {
+      for (const rangeId of normalizeArray(edge.inVs ?? edge.inV)) definitionRangeIds.add(rangeId);
+    }
+  }
+  const documentIds = result.documents.map((document) => document.id);
+  const defaultDocument = result.documents[0] ?? {
+    id: `doc_${idFragment(context.sourcePath ?? 'lsif')}`,
+    path: context.sourcePath ?? 'lsif:memory',
+    language: context.language
+  };
+  if (!result.documents.length) result.documents.push(defaultDocument);
+  for (const [vertexId, vertex] of vertices.entries()) {
+    if (vertex.label !== 'range') continue;
+    const resultSetId = resultSetByRange.get(vertexId);
+    const moniker = monikerByOut.get(resultSetId) ?? monikerByOut.get(vertexId);
+    const symbolId = moniker?.identifier
+      ? `symbol:lsif:${idFragment(moniker.scheme ?? moniker.kind ?? 'moniker')}:${idFragment(moniker.identifier)}`
+      : `symbol:lsif:${idFragment(resultSetId ?? vertexId)}`;
+    const documentId = documentIdByRange.get(vertexId) ?? documentIds[0] ?? defaultDocument.id;
+    const owningDocument = result.documents.find((document) => document.id === documentId) ?? defaultDocument;
+    const span = spanFromLspRange(vertex, owningDocument.path, context.sourceHash, 0);
+    if (!result.symbols.some((symbol) => symbol.id === symbolId)) {
+      result.symbols.push({
+        id: symbolId,
+        scheme: 'lsif',
+        name: moniker?.identifier ?? `range:${vertexId}`,
+        kind: moniker?.kind ?? 'symbol',
+        language: owningDocument.language,
+        definitionSpan: definitionRangeIds.has(vertexId) ? span : undefined,
+        metadata: { format: 'lsif', resultSetId, moniker }
+      });
+    }
+    result.occurrences.push({
+      id: `occ_${idFragment(vertexId)}`,
+      documentId,
+      symbolId,
+      role: definitionRangeIds.has(vertexId) ? 'definition' : 'reference',
+      span,
+      metadata: { format: 'lsif', vertexId, resultSetId }
+    });
+  }
+  for (const edge of edges) {
+    if (edge.label === 'textDocument/definition' || edge.label === 'textDocument/references' || edge.label === 'textDocument/declaration') {
+      result.relations.push({
+        id: `rel_${idFragment(edge.id ?? `${edge.outV}_${edge.inV}_${edge.label}`)}`,
+        sourceId: `lsif:${edge.outV}`,
+        predicate: edge.label,
+        targetId: `lsif:${edge.inV}`,
+        metadata: { format: 'lsif', edge }
+      });
+    }
+  }
+  return withExternalEmptyLoss(result, context);
+}

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

@@ -0,0 +1,15 @@
+export function normalizeLspDocuments(payload, context) {
+  if (Array.isArray(payload.documents)) return payload.documents;
+  if (payload.textDocument || payload.uri || payload.documentSymbols || payload.symbols || payload.semanticTokens || payload.diagnostics) {
+    return [{
+      ...payload,
+      uri: payload.uri ?? payload.textDocument?.uri,
+      languageId: payload.languageId ?? payload.language ?? context.language,
+      documentSymbols: payload.documentSymbols,
+      symbols: payload.symbols,
+      semanticTokens: payload.semanticTokens,
+      diagnostics: payload.diagnostics
+    }];
+  }
+  return [{ uri: context.sourcePath, languageId: context.language }];
+}

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

@@ -0,0 +1,33 @@
+import{idFragment}from'../../native-import-utils.js';
+import{addLspSemanticTokens}from'./addLspSemanticTokens.js';import{addLspSymbol}from'./addLspSymbol.js';import{externalDiagnosticFact}from'./externalDiagnosticFact.js';import{externalDiagnosticLoss}from'./externalDiagnosticLoss.js';import{externalSemanticBase}from'./externalSemanticBase.js';import{normalizeArray}from'./normalizeArray.js';import{normalizeExternalSemanticLanguage}from'./normalizeExternalSemanticLanguage.js';import{normalizeLspDocuments}from'./normalizeLspDocuments.js';import{uriToPath}from'./uriToPath.js';import{withExternalEmptyLoss}from'./withExternalEmptyLoss.js';
+export function normalizeLspPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: 'lsp' });
+  const documents = normalizeLspDocuments(payload, context);
+  for (const [documentIndex, document] of documents.entries()) {
+    const sourcePath = uriToPath(document.uri) ?? document.sourcePath ?? document.path ?? context.sourcePath ?? `lsp-document-${documentIndex + 1}`;
+    const language = normalizeExternalSemanticLanguage(document.languageId ?? document.language ?? context.language);
+    const documentId = document.id ?? `doc_${idFragment(sourcePath)}`;
+    result.documents.push({
+      id: documentId,
+      path: sourcePath,
+      language,
+      sourceHash: document.sourceHash ?? context.sourceHash,
+      metadata: { format: 'lsp', uri: document.uri, documentIndex }
+    });
+    const symbols = normalizeArray(document.documentSymbols ?? document.symbols ?? payload.documentSymbols ?? payload.symbols);
+    for (const symbol of symbols) addLspSymbol(result, symbol, {
+      context,
+      documentId,
+      sourcePath,
+      language,
+      parentName: symbol.containerName
+    });
+    const semanticTokens = document.semanticTokens ?? payload.semanticTokens;
+    if (semanticTokens) addLspSemanticTokens(result, semanticTokens, { context, documentId, sourcePath, language });
+    for (const diagnostic of normalizeArray(document.diagnostics ?? payload.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/normalizeLspSymbolKind.js

@@ -0,0 +1,5 @@
+import{lspSymbolKindByNumber}from'./lspSymbolKindByNumber.js';import{normalizeExternalSymbolKind}from'./normalizeExternalSymbolKind.js';
+export function normalizeLspSymbolKind(kind) {
+  if (typeof kind === 'number') return lspSymbolKindByNumber[kind] ?? `kind${kind}`;
+  return normalizeExternalSymbolKind(kind);
+}

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

@@ -0,0 +1,15 @@
+import{importNativeSource}from'./importNativeSource.js';
+export function normalizeNativeDiffImport(value, input, side) {
+  if (!value) return undefined;
+  if (value.kind === 'frontier.lang.importResult' && value.nativeSource) return value;
+  return importNativeSource({
+    ...value,
+    language: value.language ?? input.language,
+    sourcePath: value.sourcePath ?? input.sourcePath,
+    parser: value.parser ?? input.parser,
+    metadata: {
+      ...(value.metadata ?? {}),
+      nativeSourceDiffSide: side
+    }
+  });
+}

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

@@ -0,0 +1,33 @@
+import{normalizeStringList}from'../../native-import-utils.js';
+import{normalizeAdapterDiagnostics}from'./normalizeAdapterDiagnostics.js';import{normalizeNativeImporterAdapterCoverage}from'./normalizeNativeImporterAdapterCoverage.js';
+export function normalizeNativeImporterAdapter(adapter) {
+  if (!adapter || typeof adapter !== 'object') {
+    throw new Error('Native importer adapter must be an object');
+  }
+  if (!adapter.id) throw new Error('Native importer adapter requires an id');
+  if (!adapter.language) throw new Error(`Native importer adapter ${adapter.id} requires a language`);
+  if (!adapter.parser) throw new Error(`Native importer adapter ${adapter.id} requires a parser`);
+  if (typeof adapter.parse !== 'function') throw new Error(`Native importer adapter ${adapter.id} requires a parse function`);
+  const summaryInput = {
+    id: String(adapter.id),
+    language: adapter.language,
+    parser: String(adapter.parser),
+    version: adapter.version === undefined ? undefined : String(adapter.version)
+  };
+  const capabilities = normalizeStringList(adapter.capabilities);
+  return Object.freeze({
+    ...summaryInput,
+    capabilities,
+    coverage: normalizeNativeImporterAdapterCoverage(adapter.coverage, {
+      capabilities,
+      language: adapter.language,
+      parser: String(adapter.parser)
+    }),
+    supportedExtensions: normalizeStringList(adapter.supportedExtensions).map((extension) => extension.startsWith('.') ? extension.toLowerCase() : `.${extension.toLowerCase()}`),
+    diagnostics: normalizeAdapterDiagnostics(adapter.diagnostics, summaryInput, {
+      language: adapter.language,
+      parser: String(adapter.parser),
+      parserVersion: adapter.version === undefined ? undefined : String(adapter.version)
+    }, 'adapter')
+  });
+}

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

@@ -0,0 +1,38 @@
+import{normalizeStringList,uniqueStrings}from'../../native-import-utils.js';
+import{effectiveNativeImporterAdapterCoverage}from'./effectiveNativeImporterAdapterCoverage.js';import{freezeNativeImporterAdapterCoverageSnapshot}from'./freezeNativeImporterAdapterCoverageSnapshot.js';import{inferredAdapterCoverageNotes}from'./inferredAdapterCoverageNotes.js';import{inferredAdapterExactness}from'./inferredAdapterExactness.js';import{nativeImporterAdapterCapabilityEvidence}from'./nativeImporterAdapterCapabilityEvidence.js';import{normalizeNativeImporterAdapterObservedCoverage}from'./normalizeNativeImporterAdapterObservedCoverage.js';import{normalizeNativeImporterSemanticCoverage}from'./normalizeNativeImporterSemanticCoverage.js';
+export function normalizeNativeImporterAdapterCoverage(value = {}, context = {}) {
+  const capabilities = new Set(normalizeStringList(context.capabilities).map((capability) => capability.toLowerCase()));
+  const hasCapability = (...names) => names.some((name) => capabilities.has(String(name).toLowerCase()));
+  const exactAst = Boolean(value.exactAst ?? hasCapability('exactAst', 'exactAstImport'));
+  const sourceRanges = Boolean(value.sourceRanges ?? hasCapability('sourceRanges', 'sourceRange', 'ranges', 'sourceMaps'));
+  const generatedRanges = Boolean(value.generatedRanges ?? hasCapability('generatedRanges', 'generatedRange', 'generatedSourceMaps'));
+  const diagnostics = Boolean(value.diagnostics ?? hasCapability('diagnostics', 'parserDiagnostics'));
+  const declared = freezeNativeImporterAdapterCoverageSnapshot({
+    exactness: String(value.exactness ?? inferredAdapterExactness(exactAst, capabilities)),
+    exactAst,
+    tokens: Boolean(value.tokens ?? hasCapability('tokens', 'tokenStream')),
+    trivia: Boolean(value.trivia ?? hasCapability('trivia', 'comments', 'formatting')),
+    diagnostics,
+    sourceRanges,
+    generatedRanges,
+    semanticCoverage: normalizeNativeImporterSemanticCoverage(value.semanticCoverage, {
+      capabilities,
+      sourceRanges,
+      generatedRanges
+    })
+  });
+  const observed = normalizeNativeImporterAdapterObservedCoverage(value.observed, declared);
+  const effective = effectiveNativeImporterAdapterCoverage(declared, observed);
+  return Object.freeze({
+    ...effective,
+    declared,
+    observed,
+    notes: uniqueStrings(value.notes ?? inferredAdapterCoverageNotes(context, {
+      exactAst,
+      sourceRanges,
+      generatedRanges,
+      diagnostics
+    })),
+    capabilityEvidence: nativeImporterAdapterCapabilityEvidence(declared, observed, effective)
+  });
+}

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

@@ -0,0 +1,43 @@
+import{nativeAstNodes}from'./nativeAstNodes.js';import{normalizeNativeImporterSemanticCoverage}from'./normalizeNativeImporterSemanticCoverage.js';import{observedAdapterExactness}from'./observedAdapterExactness.js';
+export function normalizeNativeImporterAdapterObservedCoverage(value = {}, declared = {}) {
+  const diagnostics = Number(value.diagnostics ?? value.parserDiagnostics ?? 0) || 0;
+  const semanticCoverage = normalizeNativeImporterSemanticCoverage({
+    ...(value.semanticCoverage ?? {}),
+    declarations: value.semanticCoverage?.declarations ?? value.declarations,
+    symbols: value.semanticCoverage?.symbols ?? value.symbols,
+    references: value.semanticCoverage?.references ?? value.references,
+    types: value.semanticCoverage?.types ?? value.types,
+    controlFlow: value.semanticCoverage?.controlFlow ?? value.controlFlow
+  }, {});
+  const nativeAstNodes = Number(value.nativeAstNodes ?? 0) || 0;
+  const exactness = String(value.exactness ?? observedAdapterExactness(declared, nativeAstNodes));
+  return Object.freeze({
+    exactness,
+    exactAst: Boolean(value.exactAst ?? (declared.exactAst && nativeAstNodes > 0)),
+    tokens: Boolean(value.tokens),
+    tokenCount: Number(value.tokenCount ?? 0) || 0,
+    trivia: Boolean(value.trivia),
+    triviaCount: Number(value.triviaCount ?? 0) || 0,
+    diagnostics,
+    parserDiagnostics: diagnostics,
+    diagnosticErrors: Number(value.diagnosticErrors ?? 0) || 0,
+    diagnosticWarnings: Number(value.diagnosticWarnings ?? 0) || 0,
+    diagnosticInfos: Number(value.diagnosticInfos ?? 0) || 0,
+    losses: Number(value.losses ?? 0) || 0,
+    nativeAstNodes,
+    semanticSymbols: Number(value.semanticSymbols ?? 0) || 0,
+    semanticReferences: Number(value.semanticReferences ?? 0) || 0,
+    semanticTypes: Number(value.semanticTypes ?? 0) || 0,
+    semanticControlFlow: Number(value.semanticControlFlow ?? 0) || 0,
+    references: Boolean(value.references ?? semanticCoverage.references),
+    types: Boolean(value.types ?? semanticCoverage.types),
+    controlFlow: Boolean(value.controlFlow ?? semanticCoverage.controlFlow),
+    sourceMapMappings: Number(value.sourceMapMappings ?? 0) || 0,
+    sourceRanges: Boolean(value.sourceRanges),
+    sourceRangeNodes: Number(value.sourceRangeNodes ?? 0) || 0,
+    sourceRangeMappings: Number(value.sourceRangeMappings ?? 0) || 0,
+    generatedRanges: Boolean(value.generatedRanges),
+    generatedRangeMappings: Number(value.generatedRangeMappings ?? 0) || 0,
+    semanticCoverage
+  });
+}

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

@@ -0,0 +1,18 @@
+import{inferredSemanticCoverageLevel}from'./inferredSemanticCoverageLevel.js';
+export function normalizeNativeImporterSemanticCoverage(value = {}, context = {}) {
+  const capabilities = context.capabilities ?? new Set();
+  const hasCapability = (...names) => names.some((name) => capabilities.has(String(name).toLowerCase()));
+  const declarations = Boolean(value.declarations ?? hasCapability('semanticIndex', 'declarations'));
+  const symbols = Boolean(value.symbols ?? declarations);
+  const references = Boolean(value.references ?? hasCapability('references', 'referenceIndex'));
+  const types = Boolean(value.types ?? hasCapability('types', 'typeResolution', 'typeChecking'));
+  const controlFlow = Boolean(value.controlFlow ?? hasCapability('controlFlow', 'cfg'));
+  return Object.freeze({
+    level: String(value.level ?? inferredSemanticCoverageLevel({ declarations, symbols, references, types, controlFlow })),
+    declarations,
+    symbols,
+    references,
+    types,
+    controlFlow
+  });
+}

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

@@ -0,0 +1,8 @@
+export function normalizeNativeLossKind(loss, severity) {
+  const kind = String(loss.kind ?? '').trim();
+  if (kind) return kind;
+  if (loss.metadata?.diagnosticId || loss.metadata?.diagnosticCode) {
+    return severity === 'error' ? 'unsupportedSyntax' : 'parserDiagnostic';
+  }
+  return severity === 'error' ? 'unsupportedSyntax' : 'opaqueNative';
+}

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

@@ -0,0 +1,20 @@
+import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';import{normalizeLossSeverity}from'./normalizeLossSeverity.js';import{normalizeNativeLossKind}from'./normalizeNativeLossKind.js';import{semanticMergeAdmissionForSeverity}from'./semanticMergeAdmissionForSeverity.js';
+export function normalizeNativeLossRecord(loss, fallbackId) {
+  const record = typeof loss === 'string' ? { message: loss } : loss ?? {};
+  const severity = normalizeLossSeverity(record.severity);
+  const kind = normalizeNativeLossKind(record, severity);
+  const category = nativeImportCategoryForLossKind(kind);
+  return {
+    ...record,
+    id: String(record.id ?? fallbackId),
+    severity,
+    kind,
+    message: String(record.message ?? `${kind} loss during native import.`),
+    metadata: {
+      lossCategory: category,
+      semanticMergeAdmission: semanticMergeAdmissionForSeverity(severity),
+      dashboardSeverity: severity,
+      ...record.metadata
+    }
+  };
+}