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

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

@@ -0,0 +1,16 @@
+export function nativeImportCategoryForLossKind(kind) {
+  if (kind === 'declarationOnlyCoverage') return 'declarationsOnly';
+  if (kind === 'opaqueNative') return 'opaqueBodies';
+  if (kind === 'macroExpansion') return 'macroExpansion';
+  if (kind === 'preprocessor' || kind === 'conditionalCompilation' || kind === 'macroHygiene') return 'preprocessor';
+  if (kind === 'metaprogramming' || kind === 'reflection' || kind === 'dynamicDispatch' || kind === 'dynamicRuntime') return 'metaprogramming';
+  if (kind === 'generatedCode') return 'generatedCode';
+  if (kind === 'overloadResolution' || kind === 'typeInference') return 'overloadTypeInference';
+  if (kind === 'sourcePreservation' || kind === 'commentsTrivia' || kind === 'nonRoundTrippable') return 'sourcePreservation';
+  if (kind === 'parserDiagnostic') return 'parserDiagnostics';
+  if (kind === 'unsupportedSyntax' || kind === 'unsupportedSemantic') return 'unsupportedSyntax';
+  if (kind === 'partialSemanticIndex' || kind === 'unverifiedNativeAst') return 'partialSemanticIndex';
+  if (kind === 'sourceMapApproximation') return 'sourceMapApproximation';
+  if (kind === 'targetProjectionLoss') return 'targetProjectionLoss';
+  return String(kind ?? 'opaqueNative');
+}

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

@@ -0,0 +1,4 @@
+export function nativeImportEntries(importResult) {
+  if (Array.isArray(importResult?.imports)) return importResult.imports.filter(Boolean);
+  return [importResult].filter(Boolean);
+}

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

@@ -0,0 +1,5 @@
+import{nativeImportFeatureEvidenceValue}from'./nativeImportFeatureEvidenceValue.js';import{nativeImportFeatureEvidenceValuePresent}from'./nativeImportFeatureEvidenceValuePresent.js';
+export function nativeImportFeatureEvidenceHasKey(loss, evidence, key) {
+  return nativeImportFeatureEvidenceValuePresent(nativeImportFeatureEvidenceValue(loss, key))
+    || (evidence ?? []).some((record) => nativeImportFeatureEvidenceValuePresent(nativeImportFeatureEvidenceValue(record, key)));
+}

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

@@ -0,0 +1,10 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{nativeImportFeatureEvidenceValue}from'./nativeImportFeatureEvidenceValue.js';import{nativeImportFeatureEvidenceValuePresent}from'./nativeImportFeatureEvidenceValuePresent.js';
+export function nativeImportFeatureEvidenceIds(loss, evidence, policy) {
+  const keys = [...policy.requiredEvidenceKeys, ...policy.recommendedEvidenceKeys];
+  return uniqueStrings((evidence ?? [])
+    .filter((record) => keys.some((key) => nativeImportFeatureEvidenceValuePresent(nativeImportFeatureEvidenceValue(record, key))))
+    .map((record) => record.id)
+    .filter(Boolean)
+    .concat(loss.evidenceIds ?? []));
+}

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

@@ -0,0 +1,14 @@
+import{normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';
+export function nativeImportFeatureEvidencePolicy(kind, input = {}) {
+  return Object.freeze({
+    kind,
+    category: input.category ?? nativeImportCategoryForLossKind(kind),
+    risk: input.risk ?? 'medium',
+    minimumReadiness: normalizeSemanticMergeReadiness(input.minimumReadiness) ?? 'needs-review',
+    missingEvidenceReadiness: normalizeSemanticMergeReadiness(input.missingEvidenceReadiness) ?? 'needs-review',
+    requiredEvidenceKeys: Object.freeze(uniqueStrings(input.requiredEvidenceKeys ?? [])),
+    recommendedEvidenceKeys: Object.freeze(uniqueStrings(input.recommendedEvidenceKeys ?? [])),
+    notes: Object.freeze(uniqueStrings(input.notes ?? []))
+  });
+}

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

@@ -0,0 +1,8 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+export function nativeImportFeatureEvidenceReasons(issues) {
+  return uniqueStrings((issues ?? []).flatMap((issue) => {
+    const missing = issue.missingRequiredEvidence ?? [];
+    if (!missing.length) return [];
+    return [`${issue.kind} loss ${issue.lossId} is missing required evidence: ${missing.join(', ')}.`];
+  }));
+}

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

@@ -0,0 +1,11 @@
+export function nativeImportFeatureEvidenceValue(record, key) {
+  if (!record || !key) return undefined;
+  const candidates = [record, record.metadata].filter(Boolean);
+  for (const candidate of candidates) {
+    const direct = candidate[key];
+    if (direct !== undefined) return direct;
+    const dotted = String(key).split('.').reduce((current, part) => current?.[part], candidate);
+    if (dotted !== undefined) return dotted;
+  }
+  return undefined;
+}

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

@@ -0,0 +1,7 @@
+export function nativeImportFeatureEvidenceValuePresent(value) {
+  if (value === undefined || value === null) return false;
+  if (typeof value === 'string') return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === 'object') return Object.keys(value).length > 0;
+  return true;
+}

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

@@ -0,0 +1,5 @@
+export function nativeImportHasExactAstCoverage(imported) {
+  if (imported?.metadata?.nativeImportLossSummary?.exactAst === true) return true;
+  if (imported?.adapter?.coverage?.exactAst === true && !(imported?.losses?.length)) return true;
+  return false;
+}

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

@@ -0,0 +1,40 @@
+import{idFragment}from'../../native-import-utils.js';
+export function nativeImportProjectionContext(importResult, options) {
+  const nativeSource = options.nativeSource
+    ?? importResult.nativeSource
+    ?? importResult.nativeSources?.[0]
+    ?? importResult.universalAst?.nativeSources?.[0];
+  const nativeAst = options.nativeAst
+    ?? importResult.nativeAst
+    ?? nativeSource?.ast
+    ?? importResult.universalAst?.nativeSources?.[0]?.ast;
+  const semanticIndex = options.semanticIndex
+    ?? importResult.semanticIndex
+    ?? importResult.universalAst?.semanticIndex;
+  const language = options.language
+    ?? importResult.language
+    ?? nativeSource?.language
+    ?? nativeAst?.language
+    ?? importResult.universalAst?.metadata?.sourceLanguage
+    ?? 'source';
+  const sourcePath = options.sourcePath
+    ?? importResult.sourcePath
+    ?? nativeSource?.sourcePath
+    ?? nativeAst?.sourcePath
+    ?? importResult.universalAst?.metadata?.sourcePath;
+  const sourceHash = options.expectedSourceHash
+    ?? importResult.sourceHash
+    ?? nativeSource?.sourceHash
+    ?? nativeAst?.sourceHash;
+  return {
+    nativeSource,
+    nativeAst,
+    semanticIndex,
+    language,
+    sourcePath,
+    sourceHash,
+    parser: options.parser ?? nativeAst?.parser ?? nativeSource?.parser,
+    semanticStatus: options.semanticStatus ?? importResult.metadata?.semanticStatus ?? nativeSource?.metadata?.semanticStatus,
+    idPart: idFragment(options.id ?? importResult.id ?? nativeSource?.id ?? sourcePath ?? language)
+  };
+}

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

@@ -0,0 +1,6 @@
+export function nativeImportReadiness(imported) {
+  return imported?.metadata?.semanticMergeReadiness
+    ?? imported?.metadata?.nativeImportLossSummary?.semanticMergeReadiness
+    ?? imported?.mergeCandidates?.[0]?.readiness
+    ?? 'ready';
+}

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

@@ -0,0 +1,16 @@
+export function nativeImportReadinessReasons(input) {
+  if (input.failedEvidenceIds.length) {
+    return [`Failed native import evidence prevents merge: ${input.failedEvidenceIds.join(', ')}`];
+  }
+  if (input.blockingLossIds.length) {
+    return [`Native import error loss(es) block semantic merge: ${input.blockingLossIds.join(', ')}`];
+  }
+  if (input.reviewLossIds.length) {
+    return [`Native import warning loss(es) require review: ${input.reviewLossIds.join(', ')}`];
+  }
+  if (input.informationalLossIds.length) {
+    return [`Native import recorded informational loss(es): ${input.informationalLossIds.join(', ')}`];
+  }
+  if (input.exactAst) return ['Native import supplied exact AST coverage with no recorded loss.'];
+  return ['Native import has no recorded loss.'];
+}

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

@@ -0,0 +1,10 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+export function nativeImportRoundtripParser(importResult, imports) {
+  const parsers = uniqueStrings([
+    importResult.nativeAst?.parser,
+    importResult.nativeSource?.parser,
+    importResult.metadata?.parser,
+    ...imports.map((imported) => imported?.nativeAst?.parser ?? imported?.nativeSource?.parser ?? imported?.metadata?.parser)
+  ].filter(Boolean));
+  return parsers.length === 1 ? parsers[0] : parsers.length ? parsers.join(',') : undefined;
+}

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

@@ -0,0 +1,22 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+export function nativeImportRoundtripReasons(status, input) {
+  if (status === 'blocked') return uniqueStrings(input.blockingReasons);
+  if (status === 'stub-only') {
+    return uniqueStrings([
+      `Native source projection emitted declaration stubs in ${input.projection.mode} mode.`,
+      ...input.projectionReadiness.reasons,
+      ...input.importReadiness.reasons.filter((reason) => input.importReadiness.readiness !== 'ready')
+    ]);
+  }
+  if (status === 'needs-review') return uniqueStrings(input.reviewReasons);
+  if (status === 'exact') {
+    return ['Exact native AST import and verified preserved source projection are available.'];
+  }
+  if (status === 'preserved-source') {
+    return uniqueStrings([
+      'Verified native source text is preserved for projection; semantic import evidence may still require review.',
+      ...input.importReadiness.reasons.filter((reason) => input.importReadiness.readiness !== 'ready')
+    ]);
+  }
+  return ['Native import roundtrip readiness requires review.'];
+}

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

@@ -0,0 +1,6 @@
+export function nativeImportSourcePreservationRecord(imported) {
+  return imported?.metadata?.sourcePreservation
+    ?? imported?.nativeSource?.metadata?.sourcePreservation
+    ?? imported?.nativeAst?.metadata?.sourcePreservation
+    ?? imported?.universalAst?.metadata?.sourcePreservation;
+}

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

@@ -0,0 +1,6 @@
+export function nativeImportSourceText(imported) {
+  return imported?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText;
+}

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

@@ -0,0 +1,59 @@
+import{adapterCoverageCapabilityRow}from'./adapterCoverageCapabilityRow.js';import{nativeAstNodes}from'./nativeAstNodes.js';
+export function nativeImporterAdapterCapabilityEvidence(declared, observed, effective) {
+  const capabilityRows = [
+    adapterCoverageCapabilityRow('exactAst', declared.exactAst, observed.exactAst, effective.exactAst, observed.nativeAstNodes),
+    adapterCoverageCapabilityRow('tokens', declared.tokens, observed.tokens, effective.tokens, observed.tokenCount),
+    adapterCoverageCapabilityRow('trivia', declared.trivia, observed.trivia, effective.trivia, observed.triviaCount),
+    adapterCoverageCapabilityRow('parserDiagnostics', declared.diagnostics, observed.parserDiagnostics > 0, effective.diagnostics, observed.parserDiagnostics),
+    adapterCoverageCapabilityRow('sourceRanges', declared.sourceRanges, observed.sourceRanges, effective.sourceRanges, observed.sourceRangeNodes + observed.sourceRangeMappings),
+    adapterCoverageCapabilityRow('generatedRanges', declared.generatedRanges, observed.generatedRanges, effective.generatedRanges, observed.generatedRangeMappings),
+    adapterCoverageCapabilityRow('semanticDeclarations', declared.semanticCoverage.declarations, observed.semanticCoverage.declarations, effective.semanticCoverage.declarations, observed.semanticSymbols),
+    adapterCoverageCapabilityRow('semanticSymbols', declared.semanticCoverage.symbols, observed.semanticCoverage.symbols, effective.semanticCoverage.symbols, observed.semanticSymbols),
+    adapterCoverageCapabilityRow('references', declared.semanticCoverage.references, observed.semanticCoverage.references, effective.semanticCoverage.references, observed.semanticReferences),
+    adapterCoverageCapabilityRow('types', declared.semanticCoverage.types, observed.semanticCoverage.types, effective.semanticCoverage.types, observed.semanticTypes),
+    adapterCoverageCapabilityRow('controlFlow', declared.semanticCoverage.controlFlow, observed.semanticCoverage.controlFlow, effective.semanticCoverage.controlFlow, observed.semanticControlFlow)
+  ];
+  const reviewCapabilities = new Set(['exactAst', 'tokens', 'trivia', 'parserDiagnostics', 'sourceRanges', 'generatedRanges', 'references', 'types', 'controlFlow']);
+  return Object.freeze({
+    declared,
+    observed,
+    effective,
+    capabilities: Object.freeze(capabilityRows),
+    gaps: Object.freeze(capabilityRows.filter((row) => reviewCapabilities.has(row.capability) && !row.effective).map((row) => row.capability)),
+    declaredOnly: Object.freeze(capabilityRows.filter((row) => row.declared && !row.observed).map((row) => row.capability)),
+    observedOnly: Object.freeze(capabilityRows.filter((row) => !row.declared && row.observed).map((row) => row.capability)),
+    parserDiagnostics: Object.freeze({
+      declared: declared.diagnostics,
+      observed: observed.parserDiagnostics > 0,
+      count: observed.parserDiagnostics,
+      errors: observed.diagnosticErrors,
+      warnings: observed.diagnosticWarnings,
+      infos: observed.diagnosticInfos
+    }),
+    sourceRanges: Object.freeze({
+      declared: declared.sourceRanges,
+      observed: observed.sourceRanges,
+      nativeAstNodes: observed.nativeAstNodes,
+      sourceRangeNodes: observed.sourceRangeNodes,
+      sourceMapMappings: observed.sourceMapMappings,
+      sourceRangeMappings: observed.sourceRangeMappings,
+      generatedRangeMappings: observed.generatedRangeMappings
+    }),
+    tokensTrivia: Object.freeze({
+      tokens: Object.freeze({ declared: declared.tokens, observed: observed.tokens, count: observed.tokenCount }),
+      trivia: Object.freeze({ declared: declared.trivia, observed: observed.trivia, count: observed.triviaCount })
+    }),
+    semantic: Object.freeze({
+      level: Object.freeze({
+        declared: declared.semanticCoverage.level,
+        observed: observed.semanticCoverage.level,
+        effective: effective.semanticCoverage.level
+      }),
+      declarations: adapterCoverageCapabilityRow('semanticDeclarations', declared.semanticCoverage.declarations, observed.semanticCoverage.declarations, effective.semanticCoverage.declarations, observed.semanticSymbols),
+      symbols: adapterCoverageCapabilityRow('semanticSymbols', declared.semanticCoverage.symbols, observed.semanticCoverage.symbols, effective.semanticCoverage.symbols, observed.semanticSymbols),
+      references: adapterCoverageCapabilityRow('references', declared.semanticCoverage.references, observed.semanticCoverage.references, effective.semanticCoverage.references, observed.semanticReferences),
+      types: adapterCoverageCapabilityRow('types', declared.semanticCoverage.types, observed.semanticCoverage.types, effective.semanticCoverage.types, observed.semanticTypes),
+      controlFlow: adapterCoverageCapabilityRow('controlFlow', declared.semanticCoverage.controlFlow, observed.semanticCoverage.controlFlow, effective.semanticCoverage.controlFlow, observed.semanticControlFlow)
+    })
+  });
+}

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

@@ -0,0 +1,12 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+export function nativeImporterAdapterCoverage(defaults = {}, overrides = {}) {
+  return {
+    ...defaults,
+    ...overrides,
+    semanticCoverage: {
+      ...(defaults.semanticCoverage ?? {}),
+      ...(overrides.semanticCoverage ?? {})
+    },
+    notes: uniqueStrings([...(defaults.notes ?? []), ...(overrides.notes ?? [])])
+  };
+}

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

@@ -0,0 +1,12 @@
+import{uniqueStrings}from'../../native-import-utils.js';
+import{createNativeImportFromSyntaxAst}from'./createNativeImportFromSyntaxAst.js';import{declarationSemanticCoverage}from'./declarationSemanticCoverage.js';import{missingInjectedParserResult}from'./missingInjectedParserResult.js';import{nativeImporterAdapterCoverage}from'./nativeImporterAdapterCoverage.js';import{normalizeParserErrors}from'./normalizeParserErrors.js';
+export function nativeJavaScriptImporterDeps() {
+  return {
+    createNativeImportFromSyntaxAst,
+    declarationSemanticCoverage,
+    missingInjectedParserResult,
+    nativeImporterAdapterCoverage,
+    normalizeParserErrors,
+    uniqueStrings
+  };
+}

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

@@ -0,0 +1,8 @@
+import{idFragment}from'../../native-import-utils.js';
+export function nativeNodeId(context, kind, loc, propertyPath) {
+  context.counter += 1;
+  const start = loc?.start;
+  const line = start?.line ?? 'x';
+  const column = start?.column ?? 'x';
+  return `native_${idFragment(kind)}_${idFragment(line)}_${idFragment(column)}_${context.counter}_${idFragment(propertyPath)}`;
+}

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

@@ -0,0 +1,12 @@
+export function nativeProjectionDeclarationKind(kind) {
+  const normalized = String(kind ?? 'value').toLowerCase();
+  if (normalized === 'function' || normalized === 'method' || normalized === 'procedure') return 'function';
+  if (normalized === 'class') return 'class';
+  if (normalized === 'interface' || normalized === 'protocol') return 'interface';
+  if (normalized === 'trait') return 'trait';
+  if (normalized === 'type' || normalized === 'struct' || normalized === 'enum' || normalized === 'record') return 'type';
+  if (normalized === 'constant' || normalized === 'const') return 'constant';
+  if (normalized === 'variable' || normalized === 'property' || normalized === 'field') return 'variable';
+  if (normalized === 'module' || normalized === 'namespace' || normalized === 'package') return 'module';
+  return normalized;
+}

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

@@ -0,0 +1,48 @@
+import{nativeProjectionDeclarationKind}from'./nativeProjectionDeclarationKind.js';import{nativeProjectionImportOnlySymbol}from'./nativeProjectionImportOnlySymbol.js';import{nativeProjectionKindForNode}from'./nativeProjectionKindForNode.js';import{uniqueNativeProjectionDeclarations}from'./uniqueNativeProjectionDeclarations.js';
+export function nativeProjectionDeclarations(importResult, context) {
+  const semanticIndex = context.semanticIndex;
+  const occurrencesBySymbol = new Map();
+  for (const occurrence of semanticIndex?.occurrences ?? []) {
+    const list = occurrencesBySymbol.get(occurrence.symbolId) ?? [];
+    list.push(occurrence);
+    occurrencesBySymbol.set(occurrence.symbolId, list);
+  }
+  const declarations = (semanticIndex?.symbols ?? [])
+    .filter((symbol) => !nativeProjectionImportOnlySymbol(symbol, occurrencesBySymbol.get(symbol.id)))
+    .map((symbol) => {
+      const occurrence = occurrencesBySymbol.get(symbol.id)?.find((item) => item.role !== 'import');
+      const mapping = (importResult.sourceMaps ?? importResult.universalAst?.sourceMaps ?? [])
+        .flatMap((sourceMap) => sourceMap.mappings ?? [])
+        .find((item) => item.semanticSymbolId === symbol.id);
+      return {
+        name: symbol.name,
+        kind: nativeProjectionDeclarationKind(symbol.kind),
+        symbolId: symbol.id,
+        nativeAstNodeId: symbol.nativeAstNodeId ?? occurrence?.nativeAstNodeId,
+        sourceSpan: symbol.definitionSpan ?? occurrence?.span ?? mapping?.sourceSpan,
+        ownershipRegionId: mapping?.ownershipRegionId ?? symbol.metadata?.ownershipRegionId,
+        metadata: {
+          semanticKind: symbol.kind,
+          language: symbol.language,
+          signatureHash: symbol.signatureHash
+        }
+      };
+    })
+    .filter((declaration) => declaration.name);
+  if (declarations.length) return uniqueNativeProjectionDeclarations(declarations);
+  return uniqueNativeProjectionDeclarations(Object.values(context.nativeAst?.nodes ?? {})
+    .map((node) => {
+      const name = typeof node.value === 'string' && node.value.trim() ? node.value.trim() : node.fields?.name;
+      const kind = nativeProjectionKindForNode(node);
+      if (!name || !kind) return undefined;
+      return {
+        name,
+        kind,
+        nativeAstNodeId: node.id,
+        sourceSpan: node.span,
+        ownershipRegionId: node.metadata?.ownershipRegionId,
+        metadata: { nativeKind: node.kind, language: context.language }
+      };
+    })
+    .filter(Boolean));
+}

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

@@ -0,0 +1,5 @@
+export function nativeProjectionImportOnlySymbol(symbol, occurrences = []) {
+  if (String(symbol.id ?? '').includes(':import:')) return true;
+  if (occurrences.length && occurrences.every((occurrence) => occurrence.role === 'import')) return true;
+  return symbol.kind === 'module' && occurrences.some((occurrence) => occurrence.role === 'import');
+}

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

@@ -0,0 +1,12 @@
+export function nativeProjectionKindForNode(node) {
+  const kind = String(node?.kind ?? node?.languageKind ?? '').toLowerCase();
+  if (/function|method|procedure|funcdecl|itemfn|fndeclaration|\bdef\b/.test(kind)) return 'function';
+  if (/class/.test(kind)) return 'class';
+  if (/interface|protocol/.test(kind)) return 'interface';
+  if (/trait/.test(kind)) return 'trait';
+  if (/struct|enum|record|typedef|typealias|type/.test(kind)) return 'type';
+  if (/const|constant|macro|define/.test(kind)) return 'constant';
+  if (/var|property|field/.test(kind)) return 'variable';
+  if (/module|namespace|package/.test(kind)) return 'module';
+  return undefined;
+}

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

@@ -0,0 +1,5 @@
+export function nativeProjectionLineComment(language) {
+  if (language === 'python' || language === 'py' || language === 'ruby' || language === 'rb' || language === 'shell' || language === 'sh') return '#';
+  if (language === 'sql') return '--';
+  return '//';
+}

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

@@ -0,0 +1,23 @@
+export function nativeProjectionLoss(context, input) {
+  const rootSpan = context.nativeAst?.nodes?.[context.nativeAst.rootId]?.span;
+  return {
+    id: input.id,
+    severity: input.severity,
+    phase: 'emit',
+    sourceFormat: context.language,
+    kind: input.kind,
+    message: input.message,
+    span: rootSpan ?? {
+      sourceId: context.sourceHash,
+      path: context.sourcePath,
+      startLine: 1,
+      startColumn: 1
+    },
+    metadata: {
+      nativeSourceId: context.nativeSource?.id,
+      nativeAstId: context.nativeAst?.id,
+      parser: context.parser,
+      ...input.metadata
+    }
+  };
+}

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

@@ -0,0 +1,22 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{sourcePreservationFromProjectionContext}from'./sourcePreservationFromProjectionContext.js';
+export function nativeProjectionSourceCandidate(context, options) {
+  const preservation = sourcePreservationFromProjectionContext(context);
+  const explicitSourceText = options.sourceText ?? options.preservedSourceText ?? options.exactSourceText;
+  const sourceText = explicitSourceText ?? preservation?.sourceText;
+  if (typeof sourceText !== 'string') return undefined;
+  const computedSourceHash = hashSemanticValue(sourceText);
+  const declaredSourceHash = options.sourceHash ?? (explicitSourceText === undefined ? preservation?.sourceHash : undefined);
+  const sourceHash = computedSourceHash;
+  const hashVerified = Boolean(context.sourceHash);
+  const exact = !context.sourceHash || sourceHash === context.sourceHash || options.verifySourceHash === false;
+  return {
+    sourceText,
+    sourceHash,
+    declaredSourceHash,
+    hashVerified,
+    exact,
+    mismatch: hashVerified && sourceHash !== context.sourceHash && options.verifySourceHash !== false,
+    sourcePreservationId: preservation?.id
+  };
+}

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

@@ -0,0 +1,11 @@
+import{ensureTrailingNewline}from'./ensureTrailingNewline.js';import{nativeProjectionLineComment}from'./nativeProjectionLineComment.js';import{oneLine}from'./oneLine.js';
+export function nativeProjectionStubHeader(language, context, options) {
+  if (options.stubBanner === false) return '';
+  if (typeof options.stubBanner === 'string') return ensureTrailingNewline(options.stubBanner).trimEnd();
+  const comment = nativeProjectionLineComment(language);
+  const suffix = context.sourcePath ? ` for ${oneLine(context.sourcePath)}` : '';
+  return [
+    `${comment} Frontier native source stubs${suffix}`,
+    `${comment} Exact source text was unavailable; declarations are reconstructed from native import metadata.`
+  ].join('\n');
+}

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

@@ -0,0 +1,36 @@
+import{nativeProjectionLoss}from'./nativeProjectionLoss.js';
+export function nativeProjectionStubLosses(context, candidateSource, declarations, options) {
+  const reason = candidateSource?.mismatch
+    ? 'source-hash-mismatch'
+    : options.preferPreservedSource === false && candidateSource?.sourceText
+      ? 'preserved-source-disabled'
+      : 'exact-source-unavailable';
+  const message = candidateSource?.mismatch
+    ? 'Provided native source text hash did not match the import result source hash; emitted declaration stubs instead of preserving stale source.'
+    : options.preferPreservedSource === false && candidateSource?.sourceText
+      ? 'Native source projection was asked to emit declaration stubs instead of preserving available source text.'
+      : 'Exact native source text was not provided; emitted declaration stubs reconstructed from import metadata.';
+  const losses = [nativeProjectionLoss(context, {
+    id: `loss_${context.idPart}_native_source_stub`,
+    kind: candidateSource?.mismatch ? 'sourcePreservation' : 'targetProjectionLoss',
+    severity: 'warning',
+    message,
+    metadata: {
+      reason,
+      projectionMode: 'native-source-stubs',
+      expectedSourceHash: context.sourceHash,
+      providedSourceHash: candidateSource?.sourceHash,
+      declaredSourceHash: candidateSource?.declaredSourceHash
+    }
+  })];
+  if (!declarations.length) {
+    losses.push(nativeProjectionLoss(context, {
+      id: `loss_${context.idPart}_native_source_stub_empty`,
+      kind: 'declarationOnlyCoverage',
+      severity: 'warning',
+      message: 'Native import result did not expose semantic declarations for source stub generation.',
+      metadata: { reason: 'no-stub-declarations', projectionMode: 'native-source-stubs' }
+    }));
+  }
+  return losses;
+}

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

@@ -0,0 +1,11 @@
+export function nativeSourceChangeReasons(input) {
+  if (!input.before) return ['Native source was added.'];
+  if (!input.after) return ['Native source was removed.'];
+  if (input.changedSymbols.length) {
+    return [`Native source changed ${input.changedSymbols.length} symbol(s) across ${input.changedRegions.length} ownership region(s).`];
+  }
+  if (input.beforeHash && input.afterHash && input.beforeHash !== input.afterHash) {
+    return ['Native source hash changed without declaration-level symbol changes; file-level review is required.'];
+  }
+  return ['Native source imports are semantically unchanged at available scanner precision.'];
+}

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

@@ -0,0 +1,13 @@
+import{countBy}from'../../native-import-utils.js';
+export function nativeSourceChangeSummary(changedSymbols, changedRegions, sourceChanged) {
+  return {
+    sourceChanged,
+    symbols: changedSymbols.length,
+    regions: changedRegions.length,
+    addedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'added').length,
+    removedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'removed').length,
+    modifiedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'modified').length,
+    byRegionKind: countBy(changedRegions.map((region) => region.regionKind ?? 'unknown')),
+    byChangeKind: countBy([...changedSymbols.map((symbol) => symbol.changeKind), ...changedRegions.map((region) => region.changeKind)])
+  };
+}

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

@@ -0,0 +1,25 @@
+import{uniqueStrings,upperFirst}from'../../native-import-utils.js';
+import{nativeSourceCompileFullGeneratedSpan}from'./nativeSourceCompileFullGeneratedSpan.js';import{nativeSourceCompileGeneratedSpanForOffset}from'./nativeSourceCompileGeneratedSpanForOffset.js';import{safeProjectionIdentifier}from'./safeProjectionIdentifier.js';
+export function nativeSourceCompileDeclarationGeneratedSpan(input, declaration) {
+  const identifiers = uniqueStrings([
+    declaration.name,
+    safeProjectionIdentifier(declaration.name),
+    upperFirst(safeProjectionIdentifier(declaration.name)),
+    safeProjectionIdentifier(declaration.name).toUpperCase()
+  ]).filter(Boolean);
+  for (const identifier of identifiers) {
+    const offset = input.output.indexOf(identifier);
+    if (offset >= 0) {
+      return {
+        name: identifier,
+        exactName: true,
+        span: nativeSourceCompileGeneratedSpanForOffset(input, offset, identifier.length, identifier)
+      };
+    }
+  }
+  return {
+    name: safeProjectionIdentifier(declaration.name),
+    exactName: false,
+    span: nativeSourceCompileFullGeneratedSpan(input, safeProjectionIdentifier(declaration.name))
+  };
+}

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

@@ -0,0 +1,31 @@
+import{idFragment,reserveUniqueId}from'../../native-import-utils.js';import{lossIdsForNativeNode}from'../../native-source-maps.js';
+import{nativeSourceCompileDeclarationGeneratedSpan}from'./nativeSourceCompileDeclarationGeneratedSpan.js';
+export function nativeSourceCompileDeclarationMappings(input) {
+  const usedIds = new Set();
+  return (input.projection.declarations ?? []).map((declaration, index) => {
+    const generated = nativeSourceCompileDeclarationGeneratedSpan(input, declaration);
+    return {
+      id: reserveUniqueId(`compile_map_${idFragment(declaration.symbolId ?? declaration.nativeAstNodeId ?? declaration.name ?? index + 1)}`, usedIds),
+      nativeSourceId: input.importResult.nativeSource?.id,
+      nativeAstNodeId: declaration.nativeAstNodeId,
+      semanticSymbolId: declaration.symbolId,
+      sourceSpan: declaration.sourceSpan,
+      generatedSpan: generated.span,
+      target: input.target,
+      generatedName: generated.name,
+      evidenceIds: (input.evidence ?? []).map((record) => record.id).filter(Boolean),
+      lossIds: lossIdsForNativeNode(input.losses ?? [], declaration.nativeAstNodeId),
+      ownershipRegionId: declaration.ownershipRegionId,
+      ownershipRegionKey: declaration.metadata?.ownershipRegionKey,
+      ownershipRegionKind: declaration.metadata?.ownershipRegionKind,
+      precision: generated.exactName ? 'declaration' : 'estimated',
+      preservation: generated.exactName ? 'declaration' : 'estimated',
+      metadata: {
+        ...declaration.metadata,
+        compileResultId: input.compileResultId,
+        declarationKind: declaration.kind,
+        sourceMapOrigin: input.outputMode === 'target-adapter' ? 'target-adapter-fallback' : 'declaration-stub'
+      }
+    };
+  });
+}

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

@@ -0,0 +1,30 @@
+export function nativeSourceCompileEvidence(input) {
+  const failed = input.targetLosses.some((loss) => loss.severity === 'error')
+    || input.projection.evidence?.some((record) => record.status === 'failed')
+    || input.targetCoverage.readiness === 'blocked';
+  return {
+    id: input.id,
+    kind: 'projection',
+    status: failed ? 'failed' : 'passed',
+    path: input.importResult.sourcePath ?? input.importResult.nativeSource?.sourcePath,
+    summary: failed
+      ? `Compiled ${input.sourceLanguage} native source to ${input.target} with blocked projection evidence.`
+      : `Compiled ${input.sourceLanguage} native source to ${input.target} as ${input.outputMode}.`,
+    metadata: {
+      importId: input.importResult.id,
+      projectionId: input.projection.id,
+      targetProjectionId: input.targetProjection?.id,
+      targetProjectionAdapterId: input.targetProjection?.adapter?.id,
+      sourceLanguage: input.sourceLanguage,
+      target: input.target,
+      outputHash: input.outputHash ?? input.projection.outputHash,
+      outputMode: input.outputMode,
+      projectionMode: input.projection.mode,
+      targetLossClass: input.targetCoverage.lossClass,
+      targetReadiness: input.targetCoverage.readiness,
+      targetSupported: input.targetCoverage.supported,
+      targetReason: input.targetCoverage.reason,
+      targetLossIds: input.targetLosses.map((loss) => loss.id)
+    }
+  };
+}