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

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

@@ -0,0 +1,125 @@
+import{idFragment}from'../../native-import-utils.js';
+import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitTreeSitterNode}from'./visitTreeSitterNode.js';
+export function createNativeImportFromTreeSitter(root, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitTreeSitterNode(root, context, 'root');
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  const semanticSymbols = semantic.semanticIndex?.symbols?.length ?? 0;
+  const declarationMappings = semantic.mappings.length;
+  const syntaxEvidence = treeSitterCstEvidence(context, input, options, { semanticSymbols, declarationMappings });
+  const syntaxBoundaryLosses = semanticSymbols > 0 && declarationMappings > 0 ? [] : [treeSitterSyntaxOnlyLoss(context, input, options, syntaxEvidence)];
+  const losses = [...context.losses, ...syntaxBoundaryLosses];
+  const nativeSyntaxEvidence = syntaxEvidence.metadata.nativeSyntaxEvidence;
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    ...(semantic.mappings.length ? { mappings: semantic.mappings } : {}),
+    losses,
+    evidence: [syntaxEvidence, ...semantic.evidence],
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      nativeSyntaxEvidence,
+      parserMetadata: nativeSyntaxEvidence.parser,
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      declarationSourceMapMappings: declarationMappings,
+      truncated: context.truncated
+    },
+    nativeAstMetadata: {
+      nativeSyntaxEvidence,
+      semanticExactnessRequires: nativeSyntaxEvidence.semantic.requiredEvidence
+    },
+    nativeSourceMetadata: {
+      nativeSyntaxEvidence
+    },
+    universalAstMetadata: {
+      nativeSyntaxEvidence
+    }
+  };
+}
+
+function treeSitterCstEvidence(context, input, options, semantic) {
+  const cstSummary = context.treeSitterCstSummary ?? {
+    totalNodes: Object.keys(context.nodes).length,
+    namedNodes: 0,
+    anonymousNodes: 0,
+    missingNodes: 0,
+    errorNodes: 0,
+    containingErrorNodes: 0,
+    leafNodes: 0,
+    maxDepth: 0,
+    kinds: {}
+  };
+  const importIdPart = idFragment(input.sourcePath ?? input.language);
+  const sourcePreservationId = typeof input.sourceText === 'string'
+    ? `native_source_preservation_${idFragment(input.sourcePath ?? input.language)}_${idFragment(input.sourceHash)}`
+    : undefined;
+  const parser = {
+    name: options.parser,
+    version: input.parserVersion,
+    astFormat: options.astFormat,
+    tolerant: true,
+    mode: 'tree-sitter-tolerant-cst',
+    status: cstSummary.errorNodes || cstSummary.missingNodes || cstSummary.containingErrorNodes ? 'recovered-with-errors' : 'ok',
+    errors: cstSummary.errorNodes,
+    missingNodes: cstSummary.missingNodes,
+    containingErrorNodes: cstSummary.containingErrorNodes,
+    truncated: context.truncated
+  };
+  const nativeSyntaxEvidence = {
+    kind: 'frontier.lang.nativeSyntaxEvidence',
+    version: 1,
+    syntaxKind: 'tree-sitter-cst',
+    astFormat: options.astFormat,
+    parser: { ...parser, sourcePath: input.sourcePath, sourceHash: input.sourceHash },
+    sourcePreservation: {
+      sourcePath: input.sourcePath,
+      sourceHash: input.sourceHash,
+      sourcePreservationId,
+      rootNodeId: context.rootId,
+      rootSpan: context.rootId ? context.nodes[context.rootId]?.span : undefined,
+      exactSourceAvailable: typeof input.sourceText === 'string'
+    },
+    losslessSource: Boolean(typeof input.sourceText === 'string' && !context.truncated),
+    cst: { ...cstSummary, kinds: { ...cstSummary.kinds } },
+    semantic: {
+      symbols: semantic.semanticSymbols,
+      declarationSourceMapMappings: semantic.declarationMappings,
+      exactness: semantic.semanticSymbols > 0 && semantic.declarationMappings > 0 ? 'declaration-linked' : 'syntax-only',
+      requiredEvidence: ['semanticSymbols', 'declarationSourceMapMappings']
+    }
+  };
+  return {
+    id: `evidence_${importIdPart}_${idFragment(options.astFormat ?? options.parser)}_cst`,
+    kind: 'nativeSyntax',
+    status: parser.status === 'ok' ? 'passed' : 'failed',
+    path: input.sourcePath,
+    summary: `Imported ${options.parser} CST evidence with ${cstSummary.totalNodes} node(s), ${semantic.semanticSymbols} symbol(s), ${cstSummary.errorNodes} parse error node(s), and ${cstSummary.missingNodes} missing node(s).`,
+    metadata: { parser: options.parser, astFormat: options.astFormat, language: input.language, sourceHash: input.sourceHash, nativeSyntaxEvidence }
+  };
+}
+
+function treeSitterSyntaxOnlyLoss(context, input, options, syntaxEvidence) {
+  return {
+    id: `loss_${idFragment(input.sourcePath ?? input.language)}_${idFragment(options.astFormat ?? options.parser)}_syntax_only`,
+    severity: 'warning',
+    phase: 'index',
+    sourceFormat: input.language,
+    kind: 'partialSemanticIndex',
+    message: 'Tree-sitter CST evidence preserves native syntax but does not prove semantic exactness without declaration symbols and declaration source-map mappings.',
+    nodeId: context.rootId,
+    metadata: {
+      reason: 'tree-sitter-cst-syntax-only',
+      parser: options.parser,
+      astFormat: options.astFormat,
+      evidenceIds: [syntaxEvidence.id],
+      requiredEvidence: ['semanticSymbols', 'declarationSourceMapMappings'],
+      semantic: syntaxEvidence.metadata.nativeSyntaxEvidence.semantic
+    }
+  };
+}

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

@@ -0,0 +1,24 @@
+import{createAstNormalizationContext}from'./createAstNormalizationContext.js';import{semanticIndexFromNativeDeclarations}from'./semanticIndexFromNativeDeclarations.js';import{truncatedAstLoss}from'./truncatedAstLoss.js';import{visitTypeScriptAstNode}from'./visitTypeScriptAstNode.js';
+export function createNativeImportFromTypeScriptAst(sourceFile, input, options) {
+  const context = createAstNormalizationContext(input, options);
+  visitTypeScriptAstNode(sourceFile, sourceFile, context, 'root', options.ts);
+  if (context.truncated) {
+    context.losses.push(truncatedAstLoss(input, context, options));
+  }
+  const semantic = semanticIndexFromNativeDeclarations(context.declarations, input, options);
+  return {
+    rootId: context.rootId,
+    nodes: context.nodes,
+    semanticIndex: semantic.semanticIndex,
+    mappings: semantic.mappings,
+    losses: context.losses,
+    evidence: semantic.evidence,
+    metadata: {
+      astFormat: options.astFormat,
+      parser: options.parser,
+      normalizedNodeCount: Object.keys(context.nodes).length,
+      declarationCount: context.declarations.length,
+      truncated: context.truncated
+    }
+  };
+}

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

@@ -0,0 +1,78 @@
+import{normalizeStringList,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{collectImportSourceMaps,compactImportContractSource,defaultSemanticImportSidecarId,summarizeImportAdapterCoverage,summarizeImportContractReadiness,summarizeImportRegions,summarizeImportSourceMaps}from'../../semantic-import-contract-summary.js';import{summarizeImportSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{nativeImportEntries}from'./nativeImportEntries.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function createNativeImportResultContract(importResult, options = {}) {
+  if (!importResult || typeof importResult !== 'object') {
+    throw new Error('createNativeImportResultContract requires a native import result');
+  }
+  const imports = nativeImportEntries(importResult);
+  const evidence = uniqueByEvidenceId([
+    ...(importResult.evidence ?? []),
+    ...imports.flatMap((imported) => imported?.evidence ?? [])
+  ]);
+  const losses = uniqueByLossId([
+    ...(importResult.losses ?? []),
+    ...imports.flatMap((imported) => imported?.losses ?? imported?.nativeAst?.losses ?? [])
+  ]);
+  const sourceMaps = collectImportSourceMaps(importResult, imports);
+  const regionSummary = summarizeImportRegions(importResult, imports, options);
+  const sourceMapSummary = summarizeImportSourceMaps(sourceMaps);
+  const sourcePreservation = summarizeImportSourcePreservation(importResult, imports);
+  const adapterCoverage = summarizeImportAdapterCoverage(importResult, imports);
+  const primary = imports[0] ?? importResult;
+  const nativeSource = importResult.nativeSource ?? importResult.nativeSources?.[0] ?? primary?.nativeSource;
+  const nativeAst = importResult.nativeAst ?? nativeSource?.ast ?? primary?.nativeAst ?? primary?.nativeSource?.ast;
+  const semanticIndex = importResult.semanticIndex ?? importResult.universalAst?.semanticIndex ?? primary?.semanticIndex ?? primary?.universalAst?.semanticIndex;
+  const lossSummary = options.lossSummary ?? importResult.metadata?.nativeImportLossSummary ?? summarizeNativeImportLosses(losses, {
+    evidence,
+    parser: nativeAst?.parser,
+    scanKind: importResult.metadata?.scanKind,
+    semanticStatus: importResult.metadata?.semanticStatus ?? importResult.universalAst?.metadata?.semanticStatus
+  });
+  const mergeCandidates = [
+    ...(importResult.mergeCandidates ?? []),
+    ...imports.flatMap((imported) => imported?.mergeCandidates ?? [])
+  ];
+  const readiness = summarizeImportContractReadiness(importResult, mergeCandidates, lossSummary);
+  const defaultSidecarId = defaultSemanticImportSidecarId(importResult, imports);
+  return {
+    kind: 'frontier.lang.nativeImportResultContract',
+    version: 1,
+    importResultId: importResult.id,
+    language: importResult.language ?? (imports.length === 1 ? imports[0]?.language : 'mixed'),
+    sourcePath: importResult.sourcePath ?? primary?.sourcePath ?? nativeSource?.sourcePath ?? nativeAst?.sourcePath,
+    sourceHash: nativeSource?.sourceHash ?? nativeAst?.sourceHash,
+    sourceCount: imports.length,
+    sources: imports.map((imported, index) => compactImportContractSource(imported, index)),
+    ids: {
+      nativeSourceId: nativeSource?.id,
+      nativeAstId: nativeAst?.id,
+      semanticIndexId: semanticIndex?.id,
+      universalAstId: importResult.universalAst?.id ?? primary?.universalAst?.id,
+      patchId: importResult.patch?.id,
+      sourceMapIds: sourceMapSummary.ids,
+      semanticSidecarIds: uniqueStrings([
+        ...normalizeStringList(options.semanticSidecarIds ?? options.sidecarIds ?? options.sidecarId),
+        defaultSidecarId
+      ])
+    },
+    sourcePreservation,
+    adapterCoverage,
+    lossSummary,
+    regions: regionSummary,
+    sourceMaps: sourceMapSummary,
+    readiness,
+    evidence: {
+      total: evidence.length,
+      failed: evidence.filter((record) => record?.status === 'failed').map((record) => record.id).filter(Boolean),
+      ids: evidence.map((record) => record.id).filter(Boolean)
+    },
+    metadata: {
+      parser: nativeAst?.parser,
+      semanticStatus: importResult.metadata?.semanticStatus ?? importResult.universalAst?.metadata?.semanticStatus,
+      projectRoot: importResult.projectRoot,
+      defaultSemanticSidecarId: defaultSidecarId,
+      note: 'Contract summarizes import-result evidence for merge admission; it does not upgrade lightweight scans into exact semantic imports.',
+      ...options.metadata
+    }
+  };
+}

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

@@ -0,0 +1,5 @@
+import{createNativeParserAstFormatMatrix as createNativeParserAstFormatMatrixImpl}from'../../native-parser-ast-format-matrix.js';
+import{coverageMatrixContext}from'./coverageMatrixContext.js';
+export function createNativeParserAstFormatMatrix(input = {}) {
+  return createNativeParserAstFormatMatrixImpl(input, coverageMatrixContext());
+}

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

@@ -0,0 +1,5 @@
+import{createNativeParserFeatureMatrix as createNativeParserFeatureMatrixImpl}from'../../native-parser-feature-matrix.js';
+import{coverageMatrixContext}from'./coverageMatrixContext.js';
+export function createNativeParserFeatureMatrix(input = {}) {
+  return createNativeParserFeatureMatrixImpl(input, coverageMatrixContext());
+}

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

@@ -0,0 +1,126 @@
+import{idFragment,uniqueByEvidenceId,uniqueByLossId,uniqueStrings}from'../../native-import-utils.js';import{createDocument,createPatch,createUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
+import{createNativeImportResultContract}from'./createNativeImportResultContract.js';import{createProjectImportAdmissionRecord}from'./createProjectImportAdmissionRecord.js';import{mergeSemanticIndexes}from'./mergeSemanticIndexes.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{summarizeProjectSourcePreservation}from'./summarizeProjectSourcePreservation.js';
+export function createNativeProjectImportResult(input, imports) {
+  const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
+  const nodes = {};
+  const rootIds = [];
+  const semanticIndex = mergeSemanticIndexes(imports, input, idPart);
+  const nativeSources = [];
+  const sourceMaps = [];
+  const losses = [];
+  const evidence = [];
+  const mergeCandidates = [];
+  const operations = [];
+  for (const result of imports) {
+    for (const node of Object.values(result.document?.nodes ?? {})) {
+      nodes[node.id] = node;
+    }
+    rootIds.push(...(result.document?.rootIds ?? []));
+    if (result.nativeSource) nativeSources.push(result.nativeSource);
+    sourceMaps.push(...(result.sourceMaps ?? []));
+    losses.push(...(result.losses ?? []));
+    evidence.push(...(result.evidence ?? []));
+    mergeCandidates.push(...(result.mergeCandidates ?? []));
+    operations.push(...(result.patch?.operations ?? []));
+  }
+  const uniqueLosses = uniqueByLossId(losses);
+  const uniqueEvidence = uniqueByEvidenceId(evidence);
+  const nativeImportLossSummary = summarizeNativeImportLosses(uniqueLosses, {
+    evidence: uniqueEvidence,
+    scanKind: 'native-project-import',
+    semanticStatus: uniqueLosses.some((loss) => loss.severity === 'error') ? 'partial' : 'mapped'
+  });
+  const sourcePreservationSummary = summarizeProjectSourcePreservation(imports);
+  const document = createDocument({
+    id: input.documentId ?? `document_${idPart}`,
+    name: input.documentName ?? input.name ?? 'NativeProject',
+    nodes: Object.values(nodes),
+    rootIds: uniqueStrings(rootIds),
+    metadata: {
+      sourceLanguage: input.language ?? 'mixed',
+      semanticStatus: losses.some((loss) => loss.severity === 'error') ? 'partial' : 'mapped',
+      projectRoot: input.projectRoot,
+      sourceCount: imports.length,
+      nativeImportLossSummary,
+      sourcePreservationSummary,
+      ...input.documentMetadata
+    }
+  });
+  const universalAst = createUniversalAstEnvelope({
+    id: input.universalAstId ?? `universal_ast_${idPart}`,
+    document,
+    nativeSources,
+    semanticIndex,
+    sourceMaps,
+    losses: uniqueLosses,
+    evidence: uniqueEvidence,
+    metadata: {
+      sourceLanguage: input.language ?? 'mixed',
+      projectRoot: input.projectRoot,
+      sourceCount: imports.length,
+      nativeImportLossSummary,
+      sourcePreservationSummary,
+      ...input.universalAstMetadata
+    }
+  });
+  const patch = createPatch({
+    id: input.patchId ?? `patch_${idPart}_project_import`,
+    author: input.author ?? '@shapeshift-labs/frontier-lang-compiler/importNativeProject',
+    risk: losses.some((loss) => loss.severity === 'error') ? 'high' : losses.some((loss) => loss.severity === 'warning') ? 'medium' : 'low',
+    operations,
+    evidence: uniqueEvidence,
+    metadata: {
+      semanticIndexId: semanticIndex?.id,
+      universalAstId: universalAst.id,
+      sourceMapIds: sourceMaps.map((sourceMap) => sourceMap.id),
+      sourceCount: imports.length,
+      nativeImportLossSummary,
+      sourcePreservationSummary
+    }
+  });
+  const projectResult = {
+    kind: 'frontier.lang.projectImportResult',
+    version: 1,
+    id: input.id ?? `project_import_${idPart}`,
+    language: input.language ?? 'mixed',
+    projectRoot: input.projectRoot,
+    imports,
+    document,
+    patch,
+    nativeSources,
+    semanticIndex,
+    universalAst,
+    sourceMaps,
+    losses: uniqueLosses,
+    evidence: uniqueEvidence,
+    mergeCandidates,
+    metadata: {
+      sourceCount: imports.length,
+      sourcePaths: imports.map((result) => result.sourcePath).filter(Boolean),
+      nativeImportLossSummary,
+      sourcePreservationSummary,
+      ...input.metadata
+    }
+  };
+  const importResultContract = createNativeImportResultContract(projectResult, {
+    lossSummary: nativeImportLossSummary
+  });
+  const projectAdmission = createProjectImportAdmissionRecord(projectResult, {
+    importResultContract,
+    lossSummary: nativeImportLossSummary
+  });
+  return {
+    ...projectResult,
+    metadata: {
+      ...projectResult.metadata,
+      importResultContract,
+      projectAdmission,
+      semanticMergeAdmission: projectAdmission,
+      semanticMergeReadiness: importResultContract.readiness.semanticMergeReadiness,
+      readinessReasons: importResultContract.readiness.reasons,
+      regionSummary: importResultContract.regions,
+      sourceMapSummary: importResultContract.sourceMaps,
+      adapterCoverageSummary: importResultContract.adapterCoverage
+    }
+  };
+}

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

@@ -0,0 +1,117 @@
+import{validateUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
+import{countBy,idFragment,maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{nativeImportEntries}from'./nativeImportEntries.js';import{nativeImportHasExactAstCoverage}from'./nativeImportHasExactAstCoverage.js';
+const precisionRank=Object.freeze({exact:0,line:1,declaration:2,estimated:3,unknown:4,none:5});
+export function createNativeRoundtripEvidence(importResult,options={}) {
+  if(!importResult||typeof importResult!=='object') throw new Error('createNativeRoundtripEvidence requires a native import result');
+  const projection=options.projection;
+  const universalAst=importResult.universalAst;
+  const universalIssues=universalAst?validateUniversalAstEnvelope(universalAst):['missing-universal-ast'];
+  const universalSourceMaps=importResult.sourceMaps??universalAst?.sourceMaps??[];
+  const outputSourceMaps=options.sourceMaps??options.targetProjection?.sourceMaps??[];
+  const hasOutputSourceMaps=Object.prototype.hasOwnProperty.call(options,'sourceMaps')||Boolean(options.targetProjection);
+  const importLosses=[...(importResult.losses??[]),...(importResult.imports??[]).flatMap((entry)=>entry?.losses??[])];
+  const projectionLosses=projection?.losses??[];
+  const targetLosses=options.targetProjection?.losses??[];
+  const losses=options.losses??[...importLosses,...projectionLosses,...targetLosses];
+  const lossSummary=summarizeLosses(losses);
+  const importReadiness=readinessOf(importResult.readiness,importResult.metadata?.nativeImportLossSummary?.semanticMergeReadiness)??'needs-review';
+  const projectionReadiness=readinessOf(projection?.readiness,projection?.lossSummary?.semanticMergeReadiness)??'needs-review';
+  const targetReadiness=options.targetCoverage?.readiness??options.targetProjection?.readiness?.readiness;
+  const resultReadiness=readinessOf(options.readiness);
+  const semanticMerge=[importReadiness,projectionReadiness,targetReadiness,resultReadiness,lossSummary.blockingLossIds.length?'blocked':undefined]
+    .filter(Boolean).reduce((current,next)=>maxSemanticMergeReadiness(current,next),'ready');
+  const outputMode=options.outputMode??options.targetProjection?.outputMode??projection?.mode;
+  const sourceHashVerified=Boolean(projection?.sourceHash&&projection?.outputHash===projection.sourceHash)||projection?.metadata?.sourceHashVerified===true;
+  const status=semanticMerge==='blocked'?'blocked':outputMode==='target-adapter'?'target-adapter':projection?.mode==='native-source-stubs'||outputMode==='target-stubs'?'stub-only':sourceHashVerified?'preserved-source':'needs-review';
+  const sourceMapEvidence=summarizeSourceMaps(hasOutputSourceMaps?outputSourceMaps:universalSourceMaps);
+  const metadata={
+    schema:'frontier.lang.nativeRoundtripEvidence',
+    version:1,
+    roundtripEvidence:{
+      status,
+      semanticMergeReadiness:semanticMerge,
+      reviewRequired:semanticMerge!=='ready',
+      sourcePath:projection?.sourcePath??importResult.sourcePath,
+      language:projection?.language??importResult.language,
+      target:options.target??options.targetCoverage?.target??options.targetProjection?.target,
+      import:{
+        id:importResult.id,
+        readiness:importReadiness,
+        exactAst:exactAst(importResult),
+        lossCount:importLosses.length,
+        evidenceIds:evidenceIds(importResult.evidence)
+      },
+      universalAst:{
+        id:universalAst?.id,
+        present:Boolean(universalAst),
+        valid:universalIssues.length===0,
+        issues:universalIssues,
+        nativeSources:universalAst?.nativeSources?.length??importResult.nativeSources?.length??(importResult.nativeSource?1:0),
+        semanticSymbols:(importResult.semanticIndex??universalAst?.semanticIndex)?.symbols?.length??0,
+        sourceMaps:summarizeSourceMaps(universalSourceMaps)
+      },
+      projection:{
+        id:projection?.id,
+        mode:projection?.mode,
+        readiness:projectionReadiness,
+        sourceHashVerified,
+        outputHash:projection?.outputHash,
+        declarationCount:projection?.declarations?.length??0,
+        lossCount:projectionLosses.length,
+        evidenceIds:evidenceIds(projection?.evidence)
+      },
+      output:{
+        mode:outputMode,
+        targetProjectionId:options.targetProjection?.id,
+        targetProjectionAdapterId:options.targetProjection?.adapter?.id,
+        targetCoverageLossClass:options.targetCoverage?.lossClass,
+        targetReadiness:targetReadiness,
+        targetSupported:options.targetCoverage?.supported,
+        sourceMaps:sourceMapEvidence
+      },
+      losses:lossSummary
+    }
+  };
+  return{
+    id:options.id??`evidence_${idFragment(projection?.id??importResult.id??importResult.sourcePath)}_native_roundtrip`,
+    kind:'import',
+    status:semanticMerge==='blocked'?'failed':'passed',
+    path:projection?.sourcePath??importResult.sourcePath,
+    summary:`Recorded native roundtrip evidence for ${metadata.roundtripEvidence.language??'native'} as ${status}.`,
+    metadata
+  };
+}
+function exactAst(importResult){const imports=nativeImportEntries(importResult);return imports.length>0&&imports.every((entry)=>nativeImportHasExactAstCoverage(entry));}
+function evidenceIds(evidence){return uniqueStrings((evidence??[]).map((record)=>record?.id));}
+function readinessOf(classification,fallback){return classification?.readiness??fallback;}
+function summarizeLosses(losses){
+  const records=losses??[];
+  return{
+    total:records.length,
+    bySeverity:countBy(records.map((loss)=>loss?.severity??'unknown')),
+    byKind:countBy(records.map((loss)=>loss?.kind??'unknown')),
+    blockingLossIds:uniqueStrings(records.filter((loss)=>loss?.severity==='error').map((loss)=>loss.id)),
+    reviewLossIds:uniqueStrings(records.filter((loss)=>loss?.severity==='warning').map((loss)=>loss.id)),
+    informationalLossIds:uniqueStrings(records.filter((loss)=>loss?.severity!=='error'&&loss?.severity!=='warning').map((loss)=>loss.id))
+  };
+}
+function summarizeSourceMaps(sourceMaps){
+  const maps=sourceMaps??[];
+  const mappings=maps.flatMap((sourceMap)=>sourceMap?.mappings??[]);
+  const precisions=mappings.map((mapping)=>normalizePrecision(mapping?.precision));
+  return{
+    total:maps.length,
+    ids:uniqueStrings(maps.map((sourceMap)=>sourceMap?.id)),
+    mappings:mappings.length,
+    precision:worstPrecision(precisions),
+    byPrecision:countBy(precisions),
+    byOrigin:countBy(mappings.map((mapping)=>mapping?.metadata?.sourceMapOrigin??'native-import')),
+    withSourceSpan:mappings.filter((mapping)=>mapping?.sourceSpan).length,
+    withGeneratedSpan:mappings.filter((mapping)=>mapping?.generatedSpan).length,
+    withSemanticSymbol:mappings.filter((mapping)=>mapping?.semanticSymbolId||mapping?.semanticNodeId).length,
+    targetPaths:uniqueStrings(maps.map((sourceMap)=>sourceMap?.targetPath).concat(mappings.map((mapping)=>mapping?.generatedSpan?.targetPath)))
+  };
+}
+function normalizePrecision(value){const precision=String(value??'unknown');return Object.prototype.hasOwnProperty.call(precisionRank,precision)?precision:'unknown';}
+function worstPrecision(precisions){if(!precisions.length)return'none';return precisions.reduce((worst,next)=>precisionRank[next]>precisionRank[worst]?next:worst,'exact');}

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

@@ -0,0 +1,64 @@
+import{idFragment}from'../../native-import-utils.js';import{detectNewlineStyle,scanPreservedSourceDirectives,scanPreservedSourceTokens}from'../../native-region-scanner.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+export function createNativeSourcePreservation(options) {
+  if (!options || typeof options.sourceText !== 'string') {
+    throw new Error('createNativeSourcePreservation requires sourceText');
+  }
+  const language = options.language ?? 'source';
+  const sourceText = options.sourceText;
+  const computedSourceHash = hashSemanticValue(sourceText);
+  const declaredSourceHash = options.sourceHash;
+  const sourceHash = computedSourceHash;
+  const tokensAndTrivia = scanPreservedSourceTokens(sourceText, {
+    language,
+    sourcePath: options.sourcePath,
+    sourceHash,
+    includeTokens: options.includeTokens !== false,
+    includeTrivia: options.includeTrivia !== false,
+    maxTokens: options.maxTokens,
+    maxTrivia: options.maxTrivia
+  });
+  const directiveScan = options.includeDirectives === false
+    ? { directives: [], truncated: false }
+    : scanPreservedSourceDirectives(sourceText, {
+      language,
+      sourcePath: options.sourcePath,
+      sourceHash,
+      maxDirectives: options.maxDirectives
+    });
+  const directives = directiveScan.directives;
+  const newline = detectNewlineStyle(sourceText);
+  return {
+    kind: 'frontier.lang.nativeSourcePreservation',
+    version: 1,
+    id: options.id ?? `native_source_preservation_${idFragment(options.sourcePath ?? language)}_${idFragment(sourceHash)}`,
+    language,
+    sourcePath: options.sourcePath,
+    sourceHash,
+    sourceBytes: Buffer.byteLength(sourceText, options.encoding ?? 'utf8'),
+    lineCount: sourceText.length ? sourceText.split(/\r\n|\r|\n/).length : 0,
+    newline,
+    encoding: options.encoding ?? 'utf8',
+    ...(options.includeSourceText === false ? {} : { sourceText }),
+    tokens: tokensAndTrivia.tokens,
+    trivia: tokensAndTrivia.trivia,
+    directives,
+    summary: {
+      tokens: tokensAndTrivia.tokens.length,
+      trivia: tokensAndTrivia.trivia.length,
+      directives: directives.length,
+      comments: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'comment').length,
+      whitespace: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'whitespace' || entry.kind === 'newline').length,
+      exactSourceAvailable: options.includeSourceText !== false,
+      truncated: tokensAndTrivia.truncated || directiveScan.truncated
+    },
+    metadata: {
+      preservation: 'source-text-token-trivia-directive-evidence',
+      tokenization: 'frontier-lightweight-lexical-scan',
+      ...(declaredSourceHash ? {
+        declaredSourceHash,
+        sourceHashVerified: declaredSourceHash === computedSourceHash
+      } : {}),
+      ...options.metadata
+    }
+  };
+}

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

@@ -0,0 +1,91 @@
+import{maxSemanticMergeReadiness,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+import{nativeImportEntries}from'./nativeImportEntries.js';
+import{admissionPriority,admissionPriorityReasons,admissionRejectionReasons}from'./projectImportAdmissionDecision.js';
+import{admissionMergeScore}from'./projectImportAdmissionMergeScore.js';
+import{
+  admissionLanguages,
+  admissionMergeCandidates,
+  admissionOwnership,
+  admissionSemanticEvidence,
+  admissionSourcePreservation,
+  projectAdmissionImports
+}from'./projectImportAdmissionSummaries.js';
+
+export function createProjectImportAdmissionRecord(projectResult,options={}){
+  const imports=nativeImportEntries(projectResult);
+  const contract=options.importResultContract??projectResult?.metadata?.importResultContract;
+  const lossSummary=options.lossSummary??contract?.lossSummary??projectResult?.metadata?.nativeImportLossSummary;
+  const mergeCandidates=uniqueRecordsById([
+    ...(projectResult?.mergeCandidates??[]),
+    ...imports.flatMap((imported)=>imported?.mergeCandidates??[])
+  ]);
+  const importSummaries=projectAdmissionImports(imports,contract?.sources??[],mergeCandidates);
+  const languages=admissionLanguages(importSummaries);
+  const semanticEvidence=admissionSemanticEvidence(projectResult,imports,importSummaries);
+  const sourcePreservation=admissionSourcePreservation(importSummaries,contract);
+  const ownership=admissionOwnership(contract,mergeCandidates);
+  const mergeCandidateRisk=admissionMergeCandidates(projectResult,imports,mergeCandidates,lossSummary);
+  const readiness=maxSemanticMergeReadiness(
+    contract?.readiness?.semanticMergeReadiness??lossSummary?.semanticMergeReadiness??projectResult?.metadata?.semanticMergeReadiness??'ready',
+    mergeCandidateRisk.readiness
+  );
+  const failedEvidenceIds=uniqueStrings([
+    ...(contract?.readiness?.failedEvidenceIds??[]),
+    ...(lossSummary?.failedEvidenceIds??[]),
+    ...(projectResult?.evidence??[]).filter((record)=>record?.status==='failed').map((record)=>record.id)
+  ].filter(Boolean));
+  const rejectionReasons=admissionRejectionReasons({
+    readiness,
+    semanticEvidence,
+    sourcePreservation,
+    failedEvidenceIds,
+    blockingLossIds:contract?.readiness?.blockingLossIds??lossSummary?.blockingLossIds??[]
+  });
+  const priorityReasons=admissionPriorityReasons({readiness,semanticEvidence,sourcePreservation,ownership,mergeCandidateRisk});
+  const action=rejectionReasons.length?'reject':priorityReasons.length?'prioritize':'admit';
+  const priority=admissionPriority(action,readiness,sourcePreservation,mergeCandidateRisk);
+  const mergeScore=admissionMergeScore({
+    projectResult,
+    imports,
+    contract,
+    lossSummary,
+    action,
+    priority,
+    readiness,
+    sourceCount:imports.length,
+    semanticEvidence,
+    sourcePreservation,
+    ownership,
+    mergeCandidateRisk,
+    failedEvidenceIds
+  });
+  return {
+    kind:'frontier.lang.projectImportAdmission',
+    version:1,
+    projectImportId:projectResult?.id,
+    language:projectResult?.language??(languages.rows.length===1?languages.rows[0].language:'mixed'),
+    projectRoot:projectResult?.projectRoot,
+    action,
+    priority,
+    readiness,
+    sourceCount:imports.length,
+    languages,
+    semanticEvidence,
+    sourcePreservation,
+    ownership,
+    mergeCandidates:mergeCandidateRisk,
+    mergeScore,
+    reasons:uniqueStrings([
+      ...rejectionReasons,
+      ...priorityReasons,
+      ...(contract?.readiness?.reasons??[]),
+      ...(lossSummary?.readinessReasons??[])
+    ]),
+    metadata:{
+      importResultContractId:contract?.importResultId,
+      nativeImportLossSummaryReadiness:lossSummary?.semanticMergeReadiness,
+      compact:true,
+      note:'Project import admission compacts language readiness, semantic evidence, source preservation, ownership regions, merge-candidate risk, and a sortable merge score for coordinator queue decisions.'
+    }
+  };
+}

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

@@ -0,0 +1,5 @@
+import{createProjectionReadinessMatrix as createProjectionReadinessMatrixImpl}from'../../projection-readiness-matrix.js';
+import{coverageMatrixContext}from'./coverageMatrixContext.js';
+export function createProjectionReadinessMatrix(input = {}) {
+  return createProjectionReadinessMatrixImpl(input, coverageMatrixContext());
+}

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

@@ -0,0 +1,5 @@
+import{createProjectionTargetLossMatrix as createProjectionTargetLossMatrixImpl}from'../../projection-target-loss-matrix.js';
+import{coverageMatrixContext}from'./coverageMatrixContext.js';
+export function createProjectionTargetLossMatrix(input = {}) {
+  return createProjectionTargetLossMatrixImpl(input, coverageMatrixContext());
+}