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

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

@@ -0,0 +1,21 @@
+import{idFragment}from'../../native-import-utils.js';
+import{nativeSourceCompileFullGeneratedSpan}from'./nativeSourceCompileFullGeneratedSpan.js';
+export function nativeSourceCompileFileMapping(input) {
+  const rootSpan = input.importResult.nativeAst?.nodes?.[input.importResult.nativeAst?.rootId]?.span
+    ?? input.importResult.nativeSource?.ast?.nodes?.[input.importResult.nativeSource?.ast?.rootId]?.span
+    ?? input.projection.declarations?.find((declaration) => declaration.sourceSpan)?.sourceSpan;
+  return {
+    id: `compile_map_${idFragment(input.compileResultId ?? input.id)}_file`,
+    nativeSourceId: input.importResult.nativeSource?.id,
+    sourceSpan: rootSpan,
+    generatedSpan: nativeSourceCompileFullGeneratedSpan(input),
+    target: input.target,
+    evidenceIds: (input.evidence ?? []).map((record) => record.id).filter(Boolean),
+    precision: input.projection.mode === 'preserved-source' && input.outputHash === input.projection.sourceHash ? 'line' : 'estimated',
+    preservation: input.losses?.some((loss) => loss.severity === 'error') ? 'blocked' : 'estimated',
+    metadata: {
+      compileResultId: input.compileResultId,
+      sourceMapOrigin: 'file-fallback'
+    }
+  };
+}

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

@@ -0,0 +1,16 @@
+export function nativeSourceCompileFullGeneratedSpan(input, generatedName) {
+  const lines = String(input.output ?? '').split(/\r?\n/);
+  const lastLine = lines.at(-1) ?? '';
+  return {
+    sourceId: input.targetHash ?? input.outputHash,
+    path: input.targetPath,
+    startLine: 1,
+    startColumn: 1,
+    endLine: Math.max(1, lines.length),
+    endColumn: Math.max(1, lastLine.length + 1),
+    target: input.target,
+    targetPath: input.targetPath,
+    targetHash: input.targetHash ?? input.outputHash,
+    generatedName
+  };
+}

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

@@ -0,0 +1,17 @@
+import{lineColumnForOffset}from'./lineColumnForOffset.js';
+export function nativeSourceCompileGeneratedSpanForOffset(input, offset, length, generatedName) {
+  const start = lineColumnForOffset(input.output, offset);
+  const end = lineColumnForOffset(input.output, offset + Math.max(1, length));
+  return {
+    sourceId: input.targetHash ?? input.outputHash,
+    path: input.targetPath,
+    startLine: start.line,
+    startColumn: start.column,
+    endLine: end.line,
+    endColumn: end.column,
+    target: input.target,
+    targetPath: input.targetPath,
+    targetHash: input.targetHash ?? input.outputHash,
+    generatedName
+  };
+}

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

@@ -0,0 +1,13 @@
+import{nativeSourceCompileFullGeneratedSpan}from'./nativeSourceCompileFullGeneratedSpan.js';
+export function nativeSourceCompileGeneratedSpanFromSource(sourceSpan, input, generatedName) {
+  if (!sourceSpan) return nativeSourceCompileFullGeneratedSpan(input, generatedName);
+  return {
+    ...sourceSpan,
+    sourceId: input.targetHash ?? input.outputHash,
+    path: input.targetPath,
+    target: input.target,
+    targetPath: input.targetPath,
+    targetHash: input.targetHash ?? input.outputHash,
+    generatedName
+  };
+}

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

@@ -0,0 +1,6 @@
+export function nativeSourceCompileMapTarget(input, targetPath) {
+  return {
+    language: input.target,
+    emitPath: targetPath
+  };
+}

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

@@ -0,0 +1,51 @@
+import{idFragment,normalizeSourcePreservationLevel,reserveUniqueId,uniqueStrings}from'../../native-import-utils.js';import{lossIdsForNativeNode}from'../../native-source-maps.js';
+import{nativeSourceCompileGeneratedSpanFromSource}from'./nativeSourceCompileGeneratedSpanFromSource.js';
+export function nativeSourceCompilePreservedMappings(input) {
+  const sourceMaps = input.importResult.sourceMaps ?? input.importResult.universalAst?.sourceMaps ?? [];
+  const sourceHash = input.importResult.nativeSource?.sourceHash ?? input.importResult.nativeAst?.sourceHash ?? input.importResult.sourceHash;
+  const exact = input.projection.mode === 'preserved-source' && (!input.projection.sourceHash || input.outputHash === input.projection.sourceHash);
+  const usedIds = new Set();
+  return sourceMaps
+    .flatMap((sourceMap) => sourceMap?.mappings ?? [])
+    .filter((mapping) => mapping?.sourceSpan)
+    .map((mapping, index) => ({
+      id: reserveUniqueId(`compile_map_${idFragment(mapping.id ?? mapping.semanticSymbolId ?? mapping.nativeAstNodeId ?? index + 1)}`, usedIds),
+      nativeSourceId: mapping.nativeSourceId ?? input.importResult.nativeSource?.id,
+      nativeAstNodeId: mapping.nativeAstNodeId,
+      semanticSymbolId: mapping.semanticSymbolId,
+      semanticOccurrenceId: mapping.semanticOccurrenceId,
+      semanticNodeId: mapping.semanticNodeId,
+      mergeCandidateId: mapping.mergeCandidateId,
+      sourceSpan: {
+        ...mapping.sourceSpan,
+        sourceId: mapping.sourceSpan.sourceId ?? sourceHash,
+        path: mapping.sourceSpan.path ?? input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath
+      },
+      generatedSpan: nativeSourceCompileGeneratedSpanFromSource(mapping.sourceSpan, input, mapping.generatedName),
+      target: input.target,
+      generatedName: mapping.generatedName,
+      evidenceIds: uniqueStrings([
+        ...(mapping.evidenceIds ?? []),
+        ...(input.evidence ?? []).map((record) => record.id).filter(Boolean)
+      ]),
+      lossIds: uniqueStrings([
+        ...(mapping.lossIds ?? []),
+        ...lossIdsForNativeNode(input.losses ?? [], mapping.nativeAstNodeId)
+      ]),
+      ownershipRegionId: mapping.ownershipRegionId,
+      ownershipRegionKey: mapping.ownershipRegionKey,
+      ownershipRegionKind: mapping.ownershipRegionKind,
+      precision: exact ? 'exact' : mapping.precision === 'exact' ? 'line' : mapping.precision ?? 'line',
+      preservation: exact ? 'exact' : normalizeSourcePreservationLevel(mapping.preservation, {
+        precision: mapping.precision === 'exact' ? 'line' : mapping.precision ?? 'line',
+        lossIds: mapping.lossIds,
+        losses: input.losses ?? [],
+        sourcePreservation: input.importResult.metadata?.sourcePreservation
+      }),
+      metadata: {
+        ...mapping.metadata,
+        compileResultId: input.compileResultId,
+        sourceMapOrigin: 'preserved-source'
+      }
+    }));
+}

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

@@ -0,0 +1,41 @@
+import{commonGeneratedTargetPath}from'../../native-import-utils.js';import{createSourceMapRecord}from'@shapeshift-labs/frontier-lang-kernel';
+import{nativeSourceCompileDeclarationMappings}from'./nativeSourceCompileDeclarationMappings.js';import{nativeSourceCompileFileMapping}from'./nativeSourceCompileFileMapping.js';import{nativeSourceCompileMapTarget}from'./nativeSourceCompileMapTarget.js';import{nativeSourceCompilePreservedMappings}from'./nativeSourceCompilePreservedMappings.js';import{nativeSourceCompileTargetPath}from'./nativeSourceCompileTargetPath.js';
+export function nativeSourceCompileSourceMaps(input) {
+  const adapterSourceMaps = input.targetProjection?.sourceMaps ?? [];
+  if (adapterSourceMaps.length) return adapterSourceMaps;
+  const targetPath = nativeSourceCompileTargetPath(input);
+  const targetHash = input.targetHash ?? input.outputHash;
+  const target = nativeSourceCompileMapTarget(input, targetPath);
+  const mappings = input.projection.mode === 'preserved-source'
+    ? nativeSourceCompilePreservedMappings({ ...input, targetPath, targetHash, target })
+    : nativeSourceCompileDeclarationMappings({ ...input, targetPath, targetHash, target });
+  const resolvedMappings = mappings.length
+    ? mappings
+    : [nativeSourceCompileFileMapping({ ...input, targetPath, targetHash, target })];
+  return [createSourceMapRecord({
+    id: input.id,
+    sourcePath: input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath,
+    sourceHash: input.importResult.nativeSource?.sourceHash ?? input.importResult.nativeAst?.sourceHash ?? input.importResult.sourceHash,
+    target,
+    targetPath: targetPath ?? commonGeneratedTargetPath(resolvedMappings),
+    targetHash,
+    semanticIndexId: input.importResult.semanticIndex?.id ?? input.importResult.universalAst?.semanticIndex?.id,
+    universalAstId: input.importResult.universalAst?.id,
+    nativeAstId: input.importResult.nativeAst?.id ?? input.importResult.nativeSource?.ast?.id,
+    nativeSourceId: input.importResult.nativeSource?.id,
+    mappings: resolvedMappings,
+    evidence: input.evidence ?? [],
+    metadata: {
+      compileResultId: input.compileResultId,
+      importId: input.importResult.id,
+      projectionId: input.projection.id,
+      targetProjectionId: input.targetProjection?.id,
+      targetProjectionAdapterId: input.targetProjection?.adapter?.id,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      outputMode: input.outputMode,
+      outputHash: input.outputHash,
+      generatedBy: 'compileNativeSource'
+    }
+  })];
+}

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

@@ -0,0 +1,21 @@
+import{normalizeNativeLanguageId}from'../../native-import-utils.js';
+export function nativeSourceCompileTargetCoverage(matrix, language, target) {
+  const sourceLanguage = normalizeNativeLanguageId(language);
+  const entry = (matrix.languages ?? []).find((candidate) => {
+    const ids = [candidate.language, ...(candidate.aliases ?? [])].map(normalizeNativeLanguageId);
+    return ids.includes(sourceLanguage);
+  });
+  const coverage = entry?.targets?.find((candidate) => candidate.target === target);
+  if (coverage) return coverage;
+  return {
+    target,
+    lossClass: 'missingAdapter',
+    supported: false,
+    readiness: 'blocked',
+    lossKinds: ['targetProjectionLoss'],
+    categories: ['targetProjectionLoss'],
+    reason: `No native-to-${target} projection coverage is available for ${language}.`,
+    adapter: undefined,
+    notes: ['Inject a source-language parser and target projection adapter before treating this cross-language output as merge-ready.']
+  };
+}

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

@@ -0,0 +1,10 @@
+import{normalizeNativeLanguageId}from'../../native-import-utils.js';
+export function nativeSourceCompileTargetExtension(target) {
+  const normalized = normalizeNativeLanguageId(target);
+  if (normalized === 'typescript') return '.ts';
+  if (normalized === 'javascript') return '.js';
+  if (normalized === 'rust') return '.rs';
+  if (normalized === 'python') return '.py';
+  if (normalized === 'c') return '.h';
+  return undefined;
+}

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

@@ -0,0 +1,32 @@
+import{semanticMergeAdmissionForSeverity}from'./semanticMergeAdmissionForSeverity.js';
+export function nativeSourceCompileTargetLoss(input) {
+  const rootSpan = input.importResult.nativeAst?.nodes?.[input.importResult.nativeAst?.rootId]?.span
+    ?? input.importResult.nativeSource?.ast?.nodes?.[input.importResult.nativeSource?.ast?.rootId]?.span;
+  return {
+    id: input.id,
+    severity: input.severity,
+    phase: 'emit',
+    sourceFormat: input.sourceLanguage,
+    kind: 'targetProjectionLoss',
+    message: input.message,
+    span: rootSpan ?? {
+      sourceId: input.importResult.nativeSource?.sourceHash ?? input.importResult.sourceHash,
+      path: input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath,
+      startLine: 1,
+      startColumn: 1
+    },
+    metadata: {
+      target: input.target,
+      sourceLanguage: input.sourceLanguage,
+      projectionId: input.projection.id,
+      projectionMode: input.projection.mode,
+      targetLossClass: input.targetCoverage.lossClass,
+      targetReadiness: input.targetCoverage.readiness,
+      targetSupported: input.targetCoverage.supported,
+      targetAdapter: input.targetCoverage.adapter,
+      targetLossKinds: input.targetCoverage.lossKinds,
+      lossCategory: 'targetProjectionLoss',
+      semanticMergeAdmission: semanticMergeAdmissionForSeverity(input.severity)
+    }
+  };
+}

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

@@ -0,0 +1,43 @@
+import{idFragment}from'../../native-import-utils.js';
+import{nativeSourceCompileTargetLoss}from'./nativeSourceCompileTargetLoss.js';
+export function nativeSourceCompileTargetLosses(input) {
+  const { importResult, projection, targetCoverage, sourceLanguage, target, idPart } = input;
+  if (!targetCoverage || targetCoverage.lossClass === 'exactSourceProjection') return [];
+  if (targetCoverage.lossClass === 'missingAdapter') {
+    return [nativeSourceCompileTargetLoss({
+      id: `loss_${idPart}_${idFragment(target)}_missing_projection_adapter`,
+      severity: 'error',
+      message: targetCoverage.reason,
+      importResult,
+      projection,
+      targetCoverage,
+      sourceLanguage,
+      target
+    })];
+  }
+  if (targetCoverage.lossClass === 'unsupportedTargetFeatures') {
+    return [nativeSourceCompileTargetLoss({
+      id: `loss_${idPart}_${idFragment(target)}_unsupported_target_features`,
+      severity: 'warning',
+      message: targetCoverage.reason,
+      importResult,
+      projection,
+      targetCoverage,
+      sourceLanguage,
+      target
+    })];
+  }
+  if (targetCoverage.lossClass === 'nativeSourceStubs') {
+    return [nativeSourceCompileTargetLoss({
+      id: `loss_${idPart}_${idFragment(target)}_target_stubs`,
+      severity: 'warning',
+      message: targetCoverage.reason,
+      importResult,
+      projection,
+      targetCoverage,
+      sourceLanguage,
+      target
+    })];
+  }
+  return [];
+}

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

@@ -0,0 +1,9 @@
+import{nativeSourceCompileTargetExtension}from'./nativeSourceCompileTargetExtension.js';
+export function nativeSourceCompileTargetPath(input) {
+  if (input.targetPath) return input.targetPath;
+  const sourcePath = input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath;
+  if (!sourcePath) return undefined;
+  const targetExt = nativeSourceCompileTargetExtension(input.target);
+  if (!targetExt) return sourcePath;
+  return sourcePath.replace(/(\.[^./\\]+)?$/, targetExt);
+}

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

@@ -0,0 +1,26 @@
+import{idFragment}from'../../native-import-utils.js';
+import{serializableDiagnostic}from'./serializableDiagnostic.js';
+export function nativeTargetProjectionAdapterEvidence(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_target_projection_adapter`,
+    kind: 'projection',
+    status: errors ? 'failed' : 'passed',
+    path: input.sourcePath,
+    summary: `Ran ${adapter.id} native target projection adapter from ${input.sourceLanguage} to ${input.target} with ${diagnostics.length} diagnostic(s).`,
+    metadata: {
+      adapterId: adapter.id,
+      adapterVersion: adapter.version,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      targetPath: input.targetPath,
+      outputHash: input.outputHash,
+      capabilities: adapter.capabilities,
+      coverage: adapter.coverage,
+      diagnostics: diagnostics.map(serializableDiagnostic),
+      errors,
+      warnings
+    }
+  };
+}

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

@@ -0,0 +1,16 @@
+import{normalizeProjectionMatrixTargets}from'../../coverage-matrix-profiles.js';import{normalizeNativeLanguageId}from'../../native-import-utils.js';
+import{safeNativeTargetProjectionAdapterSummary}from'./safeNativeTargetProjectionAdapterSummary.js';
+export function nativeTargetProjectionAdapterMatches(adapter, input = {}) {
+  const summary = safeNativeTargetProjectionAdapterSummary(adapter);
+  if (!summary) return false;
+  if (input.sourceLanguage && normalizeNativeLanguageId(input.sourceLanguage) !== summary.sourceLanguage) return false;
+  const target = normalizeProjectionMatrixTargets([input.target])[0] ?? String(input.target ?? '').toLowerCase();
+  if (target && target !== summary.target) return false;
+  const parser = input.parser ? String(input.parser).toLowerCase() : undefined;
+  if (parser && summary.supportedParsers.length && !summary.supportedParsers.map((item) => item.toLowerCase()).includes(parser)) return false;
+  const sourcePath = String(input.sourcePath ?? '').toLowerCase();
+  if (sourcePath && summary.supportedExtensions.length) {
+    return summary.supportedExtensions.some((extension) => sourcePath.endsWith(extension));
+  }
+  return true;
+}

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

@@ -0,0 +1,22 @@
+import{idFragment}from'../../native-import-utils.js';
+export function nativeTargetProjectionDiagnosticToLoss(diagnostic, index, adapter, input) {
+  return {
+    id: `loss_${idFragment(diagnostic.id ?? `${adapter.id}_${index}_${diagnostic.code ?? diagnostic.severity}`)}`,
+    severity: diagnostic.severity,
+    phase: diagnostic.phase ?? 'emit',
+    sourceFormat: input.sourceLanguage,
+    kind: diagnostic.kind ?? 'targetProjectionLoss',
+    message: diagnostic.message,
+    span: diagnostic.span,
+    metadata: {
+      adapterId: adapter.id,
+      adapterVersion: adapter.version,
+      diagnosticId: diagnostic.id,
+      diagnosticCode: diagnostic.code,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      path: diagnostic.path,
+      ...diagnostic.metadata
+    }
+  };
+}

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

@@ -0,0 +1,28 @@
+import{idFragment}from'../../native-import-utils.js';
+import{normalizeDiagnosticSeverity}from'./normalizeDiagnosticSeverity.js';
+export function normalizeAdapterDiagnostics(value, adapter, input, scope = 'diagnostic') {
+  if (value === undefined || value === null) return [];
+  const diagnostics = Array.isArray(value) ? value : [value];
+  return diagnostics.map((diagnostic, index) => {
+    const normalized = typeof diagnostic === 'string' ? { message: diagnostic } : diagnostic ?? {};
+    const severity = normalizeDiagnosticSeverity(normalized.severity);
+    return Object.freeze({
+      id: normalized.id ?? `diagnostic_${idFragment(adapter.id)}_${idFragment(scope)}_${index + 1}`,
+      severity,
+      code: normalized.code,
+      phase: normalized.phase ?? 'parse',
+      kind: normalized.kind,
+      message: String(normalized.message ?? `${adapter.id} reported a ${severity} diagnostic.`),
+      path: normalized.path ?? input.sourcePath,
+      span: normalized.span,
+      metadata: {
+        adapterId: adapter.id,
+        adapterVersion: adapter.version,
+        language: input.language ?? adapter.language,
+        parser: input.parser ?? adapter.parser,
+        parserVersion: input.parserVersion,
+        ...normalized.metadata
+      }
+    });
+  });
+}

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

@@ -0,0 +1,4 @@
+export function normalizeArray(value) {
+  if (value === undefined || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}

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

@@ -0,0 +1,38 @@
+import{upperFirst}from'../../native-import-utils.js';
+export function normalizeCSharpRoslynKind(kind) {
+  const text = String(kind)
+    .replace(/^(?:Microsoft\.CodeAnalysis\.CSharp\.Syntax\.|Microsoft\.CodeAnalysis\.CSharp\.)/, '')
+    .replace(/Syntax$/, '');
+  const compact = text.replace(/[_\s.-]+/g, '').toLowerCase();
+  if (compact === 'compilationunit') return 'CompilationUnit';
+  if (compact === 'usingdirective') return 'UsingDirective';
+  if (compact === 'namespacedeclaration') return 'NamespaceDeclaration';
+  if (compact === 'filescopednamespacedeclaration') return 'FileScopedNamespaceDeclaration';
+  if (compact === 'classdeclaration') return 'ClassDeclaration';
+  if (compact === 'interfacedeclaration') return 'InterfaceDeclaration';
+  if (compact === 'structdeclaration') return 'StructDeclaration';
+  if (compact === 'recorddeclaration') return 'RecordDeclaration';
+  if (compact === 'recordstructdeclaration') return 'RecordStructDeclaration';
+  if (compact === 'enumdeclaration') return 'EnumDeclaration';
+  if (compact === 'methoddeclaration') return 'MethodDeclaration';
+  if (compact === 'constructordeclaration') return 'ConstructorDeclaration';
+  if (compact === 'destructordeclaration') return 'DestructorDeclaration';
+  if (compact === 'operatordeclaration') return 'OperatorDeclaration';
+  if (compact === 'conversionoperatordeclaration') return 'ConversionOperatorDeclaration';
+  if (compact === 'propertydeclaration') return 'PropertyDeclaration';
+  if (compact === 'indexerdeclaration') return 'IndexerDeclaration';
+  if (compact === 'fielddeclaration') return 'FieldDeclaration';
+  if (compact === 'variabledeclarator') return 'VariableDeclarator';
+  if (compact === 'eventdeclaration') return 'EventDeclaration';
+  if (compact === 'eventfielddeclaration') return 'EventFieldDeclaration';
+  if (compact === 'delegatedeclaration') return 'DelegateDeclaration';
+  if (compact === 'enummemberdeclaration') return 'EnumMemberDeclaration';
+  if (compact === 'attributelist') return 'AttributeList';
+  if (compact === 'attribute') return 'Attribute';
+  if (compact === 'parameter') return 'Parameter';
+  if (compact === 'incompletemember') return 'IncompleteMember';
+  if (compact === 'skippedtokenstrivia' || compact === 'skippedtokens') return 'SkippedTokensTrivia';
+  if (compact.endsWith('directivetrivia')) return `${upperFirst(compact.slice(0, -'directivetrivia'.length))}DirectiveTrivia`;
+  if (/^[A-Z0-9_]+$/.test(text)) return text.toLowerCase().split('_').map(upperFirst).join('');
+  return text;
+}

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

@@ -0,0 +1,9 @@
+import{canonicalTargets}from'./canonicalTargets.js';import{FrontierCompileTargets}from'./FrontierCompileTargets.js';
+export function normalizeCompileTarget(target) {
+  const normalized = String(target ?? 'typescript').toLowerCase();
+  const canonical = canonicalTargets[normalized] ?? normalized;
+  if (!FrontierCompileTargets.includes(canonical)) {
+    throw new Error(`Unknown Frontier compile target: ${target}`);
+  }
+  return canonical;
+}

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

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

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

@@ -0,0 +1,9 @@
+export function normalizeExternalOccurrenceRole(role) {
+  const value = String(role ?? 'reference').toLowerCase();
+  if (value.includes('def')) return 'definition';
+  if (value.includes('decl')) return 'declaration';
+  if (value.includes('import')) return 'import';
+  if (value.includes('write')) return 'write';
+  if (value.includes('read')) return 'read';
+  return value === '2' ? 'definition' : value === '1' ? 'reference' : 'reference';
+}

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

@@ -0,0 +1,34 @@
+export function normalizeExternalSemanticIndexFormat(format) {
+  const normalized = String(format ?? 'frontier-semantic-index').trim().toLowerCase();
+  const aliases = {
+    frontier: 'frontier-semantic-index',
+    'frontier.semantic-index': 'frontier-semantic-index',
+    'frontier.lang.semanticindex': 'frontier-semantic-index',
+    'frontier.lang.semantic-index': 'frontier-semantic-index',
+    'frontier-semanticindex': 'frontier-semantic-index',
+    scipindex: 'scip',
+    'scip-index': 'scip',
+    'sourcegraph-scip': 'scip',
+    'sourcegraph.scip': 'scip',
+    'sourcegraph-scip-index': 'scip',
+    'sourcegraph.scip-index': 'scip',
+    'code-intelligence-protocol': 'scip',
+    lsp: 'lsp',
+    'language-server-protocol': 'lsp',
+    'language-server-index-format': 'lsif',
+    'language-server-index': 'lsif',
+    'lsp-document-symbols': 'lsp',
+    'lsp-semantic-tokens': 'lsp',
+    semanticdb: 'semanticdb',
+    'semantic-db': 'semanticdb',
+    'scala-semanticdb': 'semanticdb',
+    'metals-semanticdb': 'semanticdb',
+    'scalameta-semanticdb': 'semanticdb',
+    'glean-db': 'glean',
+    'glean-facts': 'glean',
+    'glean-schema': 'glean',
+    'glean-predicates': 'glean',
+    'facebook-glean': 'glean'
+  };
+  return aliases[normalized] ?? normalized;
+}

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

@@ -0,0 +1,10 @@
+import{normalizeFrontierSemanticIndexPayload}from'./normalizeFrontierSemanticIndexPayload.js';import{normalizeGenericExternalSemanticIndexPayload}from'./normalizeGenericExternalSemanticIndexPayload.js';import{normalizeGleanPayload}from'./normalizeGleanPayload.js';import{normalizeLsifPayload}from'./normalizeLsifPayload.js';import{normalizeLspPayload}from'./normalizeLspPayload.js';import{normalizeScipPayload}from'./normalizeScipPayload.js';import{normalizeSemanticDbPayload}from'./normalizeSemanticDbPayload.js';
+export function normalizeExternalSemanticIndexPayload(payload, context) {
+  if (context.format === 'frontier-semantic-index') return normalizeFrontierSemanticIndexPayload(payload, context);
+  if (context.format === 'scip') return normalizeScipPayload(payload, context);
+  if (context.format === 'lsif') return normalizeLsifPayload(payload, context);
+  if (context.format === 'lsp') return normalizeLspPayload(payload, context);
+  if (context.format === 'semanticdb') return normalizeSemanticDbPayload(payload, context);
+  if (context.format === 'glean') return normalizeGleanPayload(payload, context);
+  return normalizeGenericExternalSemanticIndexPayload(payload, context);
+}

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

@@ -0,0 +1,7 @@
+import{normalizeNativeLanguageId}from'../../native-import-utils.js';
+import{externalLanguageNameByNumber}from'./externalLanguageNameByNumber.js';
+export function normalizeExternalSemanticLanguage(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const raw = typeof value === 'number' ? externalLanguageNameByNumber[value] : String(value);
+  return normalizeNativeLanguageId(raw);
+}

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

@@ -0,0 +1,21 @@
+import{spanFromLspRange}from'./spanFromLspRange.js';import{spanFromScipOccurrence}from'./spanFromScipOccurrence.js';
+export function normalizeExternalSpan(value, sourcePath, sourceHash) {
+  if (!value) return undefined;
+  if (Array.isArray(value)) {
+    return spanFromScipOccurrence({ range: value }, sourcePath, sourceHash);
+  }
+  if (value.start || value.end || value.line !== undefined) return spanFromLspRange(value, sourcePath, sourceHash, 0);
+  if (value.startLine !== undefined || value.start_line !== undefined) {
+    return {
+      sourceId: value.sourceId ?? sourceHash,
+      path: value.path ?? sourcePath,
+      start: value.start,
+      end: value.end,
+      startLine: Number(value.startLine ?? value.start_line),
+      startColumn: value.startColumn ?? value.start_character,
+      endLine: value.endLine ?? value.end_line,
+      endColumn: value.endColumn ?? value.end_character
+    };
+  }
+  return undefined;
+}

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

@@ -0,0 +1,6 @@
+import{externalSymbolKindByNumber}from'./externalSymbolKindByNumber.js';import{lspSymbolKindByNumber}from'./lspSymbolKindByNumber.js';
+export function normalizeExternalSymbolKind(kind) {
+  if (kind === undefined || kind === null || kind === '') return 'symbol';
+  if (typeof kind === 'number') return externalSymbolKindByNumber[kind] ?? lspSymbolKindByNumber[kind] ?? `kind${kind}`;
+  return String(kind).replace(/^[A-Z_]+_/, '').replace(/^[A-Z]/, (letter) => letter.toLowerCase());
+}

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

@@ -0,0 +1,14 @@
+import{uniqueByEvidenceId}from'../../native-import-utils.js';
+import{externalDocument}from'./externalDocument.js';import{externalFact}from'./externalFact.js';import{externalOccurrence}from'./externalOccurrence.js';import{externalRelation}from'./externalRelation.js';import{externalSemanticBase}from'./externalSemanticBase.js';import{externalSymbol}from'./externalSymbol.js';import{normalizeArray}from'./normalizeArray.js';import{withExternalEmptyLoss}from'./withExternalEmptyLoss.js';
+export function normalizeFrontierSemanticIndexPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: payload.kind ?? 'frontier.lang.semanticIndex' });
+  result.repository = payload.repository ?? result.repository;
+  result.documents = normalizeArray(payload.documents).map((document, index) => externalDocument(document, context, index));
+  result.symbols = normalizeArray(payload.symbols).map((symbol, index) => externalSymbol(symbol, context, index));
+  result.occurrences = normalizeArray(payload.occurrences).map((occurrence, index) => externalOccurrence(occurrence, context, index));
+  result.relations = normalizeArray(payload.relations).map((relation, index) => externalRelation(relation, context, index));
+  result.facts = normalizeArray(payload.facts).map((fact, index) => externalFact(fact, context, index));
+  result.evidence = uniqueByEvidenceId([...(payload.evidence ?? []), ...result.evidence]);
+  if (payload.metadata) result.metadata = { ...result.metadata, ...payload.metadata };
+  return withExternalEmptyLoss(result, context);
+}

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

@@ -0,0 +1,15 @@
+import{idFragment}from'../../native-import-utils.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{externalSemanticBase}from'./externalSemanticBase.js';
+export function normalizeGenericExternalSemanticIndexPayload(payload, context) {
+  const result = externalSemanticBase(context, { sourceFormat: context.format, genericPayload: true });
+  result.losses.push({
+    id: `loss_${context.idPart}_${idFragment(context.format)}_unsupported_payload`,
+    severity: 'warning',
+    phase: 'index',
+    sourceFormat: context.format,
+    kind: 'unsupportedSemantic',
+    message: `External semantic index format ${context.format} is not recognized; payload hash is preserved as evidence only.`,
+    metadata: { format: context.format, payloadHash: hashSemanticValue(payload) }
+  });
+  return result;
+}