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

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

@@ -0,0 +1,252 @@
+import{countBy,maxSemanticMergeReadiness,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+
+const riskRank=Object.freeze({low:0,medium:1,unknown:2,high:3});
+const preservationRank=Object.freeze({exact:0,lossy:1,missing:2,stale:3,empty:4});
+
+export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
+  return imports.map((imported,index)=>{
+    const source=sourceRows?.[index]??compactAdmissionSource(imported,index);
+    const sourcePath=source.sourcePath??imported?.sourcePath;
+    const candidates=mergeCandidates.filter((candidate)=>
+      candidate.importResultId===imported?.id||candidate.sourcePath===sourcePath||candidate.patchId===imported?.patch?.id
+    );
+    const semanticIndex=imported?.semanticIndex??imported?.universalAst?.semanticIndex;
+    const semanticCounts={
+      symbols:semanticIndex?.symbols?.length??source.symbolCount??0,
+      occurrences:semanticIndex?.occurrences?.length??0,
+      relations:semanticIndex?.relations?.length??0,
+      facts:semanticIndex?.facts?.length??0
+    };
+    return {
+      id:source.id??imported?.id,
+      language:source.language??imported?.language??'unknown',
+      sourcePath,
+      sourceHash:source.sourceHash,
+      readiness:source.readiness??imported?.metadata?.semanticMergeReadiness??candidates[0]?.readiness??'ready',
+      semanticCounts,
+      emptySemanticEvidence:Object.values(semanticCounts).reduce((sum,value)=>sum+value,0)===0,
+      sourcePreservation:summarizeImportPreservation(imported,source),
+      mergeCandidates:candidates
+    };
+  });
+}
+
+export function admissionLanguages(importSummaries){
+  const grouped=new Map();
+  for(const entry of importSummaries){
+    const key=entry.language??'unknown';
+    if(!grouped.has(key)) grouped.set(key,emptyLanguageRow(key));
+    const row=grouped.get(key);
+    row.sourceCount+=1;
+    row.sourcePaths.push(entry.sourcePath);
+    row.readiness=maxSemanticMergeReadiness(row.readiness,entry.readiness);
+    row.semanticSymbols+=entry.semanticCounts.symbols;
+    if(entry.emptySemanticEvidence) row.emptySemanticEvidenceSources+=1;
+    row.sourcePreservationQuality=maxPreservationQuality(row.sourcePreservationQuality,entry.sourcePreservation.quality);
+    if(entry.sourcePreservation.stale&&entry.sourcePath) row.staleSourcePaths.push(entry.sourcePath);
+    row.mergeCandidates+=entry.mergeCandidates.length;
+    row.highestRisk=maxRisk(row.highestRisk,entry.mergeCandidates.reduce((current,candidate)=>maxRisk(current,candidateRisk(candidate)),'low'));
+  }
+  const rows=[...grouped.values()].map((row)=>({
+    ...row,
+    sourcePaths:uniqueStrings(row.sourcePaths.filter(Boolean)),
+    staleSourcePaths:uniqueStrings(row.staleSourcePaths.filter(Boolean))
+  })).sort((left,right)=>left.language.localeCompare(right.language));
+  return {
+    total:rows.length,
+    byReadiness:countBy(rows.map((row)=>row.readiness)),
+    bySourcePreservationQuality:countBy(rows.map((row)=>row.sourcePreservationQuality)),
+    rows
+  };
+}
+
+export function admissionSemanticEvidence(projectResult,imports,importSummaries){
+  const projectIndex=projectResult?.semanticIndex??projectResult?.universalAst?.semanticIndex;
+  const indexes=projectIndex?[projectIndex]:imports.flatMap((imported)=>[
+    imported?.semanticIndex,
+    imported?.universalAst?.semanticIndex
+  ]).filter(Boolean);
+  const totals=indexes.reduce((summary,semanticIndex)=>{
+    summary.symbols+=semanticIndex.symbols?.length??0;
+    summary.occurrences+=semanticIndex.occurrences?.length??0;
+    summary.relations+=semanticIndex.relations?.length??0;
+    summary.facts+=semanticIndex.facts?.length??0;
+    return summary;
+  },{symbols:0,occurrences:0,relations:0,facts:0});
+  const emptySourcePaths=uniqueStrings(importSummaries
+    .filter((entry)=>entry.emptySemanticEvidence)
+    .map((entry)=>entry.sourcePath)
+    .filter(Boolean));
+  return {
+    empty:Object.values(totals).reduce((sum,value)=>sum+value,0)===0,
+    emptySourceCount:importSummaries.filter((entry)=>entry.emptySemanticEvidence).length,
+    emptySourcePaths,
+    ...totals,
+    evidenceRecords:uniqueRecordsById([
+      ...(projectResult?.evidence??[]),
+      ...imports.flatMap((imported)=>imported?.evidence??[])
+    ]).length
+  };
+}
+
+export function admissionSourcePreservation(importSummaries,contract){
+  const qualities=importSummaries.map((entry)=>entry.sourcePreservation.quality);
+  const quality=qualities.length?qualities.reduce(maxPreservationQuality,'exact'):'empty';
+  const staleSourcePaths=uniqueStrings(importSummaries
+    .filter((entry)=>entry.sourcePreservation.stale)
+    .map((entry)=>entry.sourcePath)
+    .filter(Boolean));
+  const lossySourcePaths=uniqueStrings(importSummaries
+    .filter((entry)=>entry.sourcePreservation.quality==='lossy'||entry.sourcePreservation.quality==='missing')
+    .map((entry)=>entry.sourcePath)
+    .filter(Boolean));
+  return {
+    quality,
+    total:contract?.sourcePreservation?.total??importSummaries.filter((entry)=>!entry.sourcePreservation.missing).length,
+    exactSourceAvailable:contract?.sourcePreservation?.exactSourceAvailable??importSummaries.filter((entry)=>entry.sourcePreservation.exactSourceAvailable).length,
+    sourceBytes:contract?.sourcePreservation?.sourceBytes??0,
+    tokens:contract?.sourcePreservation?.tokens??0,
+    trivia:contract?.sourcePreservation?.trivia??0,
+    directives:contract?.sourcePreservation?.directives??0,
+    comments:contract?.sourcePreservation?.comments??0,
+    truncated:Boolean(contract?.sourcePreservation?.truncated)||importSummaries.some((entry)=>entry.sourcePreservation.truncated),
+    stale:staleSourcePaths.length,
+    missing:importSummaries.filter((entry)=>entry.sourcePreservation.missing).length,
+    lossy:lossySourcePaths.length,
+    staleSourcePaths,
+    lossySourcePaths,
+    byQuality:countBy(qualities)
+  };
+}
+
+export function admissionOwnership(contract,mergeCandidates){
+  const regions=contract?.regions??{};
+  const candidateRegionConflictKeys=uniqueStrings(mergeCandidates.flatMap((candidate)=>
+    (candidate.conflictKeys??[]).filter((key)=>String(key).startsWith('region:'))
+  ));
+  const changedIds=uniqueStrings([
+    ...(regions.ids??[]),
+    ...mergeCandidates.flatMap((candidate)=>candidate.nativeSpans??[]).map((span)=>span.metadata?.ownershipRegionId).filter(Boolean),
+    ...mergeCandidates.flatMap((candidate)=>candidate.touchedSymbols??[]).map((symbol)=>symbol.ownershipRegionId??symbol.metadata?.ownershipRegionId).filter(Boolean)
+  ]);
+  const changedKeys=uniqueStrings([
+    ...(regions.keys??[]),
+    ...mergeCandidates.flatMap((candidate)=>candidate.nativeSpans??[]).map((span)=>span.metadata?.ownershipRegionKey).filter(Boolean),
+    ...mergeCandidates.flatMap((candidate)=>candidate.touchedSymbols??[]).map((symbol)=>symbol.ownershipKey??symbol.metadata?.ownershipRegionKey).filter(Boolean)
+  ]);
+  return {
+    total:regions.total??0,
+    changed:Math.max(changedIds.length,changedKeys.length,candidateRegionConflictKeys.length),
+    ids:regions.ids??[],
+    keys:regions.keys??[],
+    changedIds,
+    changedKeys,
+    candidateRegionConflictKeys,
+    sourcePaths:regions.sourcePaths??[],
+    byKind:regions.byKind??{},
+    byGranularity:regions.byGranularity??{},
+    byPrecision:regions.byPrecision??{},
+    byLanguage:regions.byLanguage??{}
+  };
+}
+
+export function admissionMergeCandidates(projectResult,imports,mergeCandidates,lossSummary){
+  const patchById=new Map([
+    projectResult?.patch,
+    ...imports.map((imported)=>imported?.patch)
+  ].filter((patch)=>patch?.id).map((patch)=>[patch.id,patch]));
+  const risks=mergeCandidates.map((candidate)=>candidateRisk(candidate,patchById.get(candidate.patchId)));
+  const readiness=mergeCandidates.reduce(
+    (current,candidate)=>maxSemanticMergeReadiness(current,candidate.readiness),
+    lossSummary?.semanticMergeReadiness??'ready'
+  );
+  return {
+    total:mergeCandidates.length,
+    readiness,
+    highestRisk:risks.reduce(maxRisk,'low'),
+    byRisk:countBy(risks),
+    byReadiness:countBy(mergeCandidates.map((candidate)=>candidate.readiness??'needs-review')),
+    highRiskCandidateIds:mergeCandidates.filter((candidate,index)=>risks[index]==='high').map((candidate)=>candidate.id).filter(Boolean),
+    reviewCandidateIds:mergeCandidates.filter((candidate)=>candidate.readiness==='needs-review').map((candidate)=>candidate.id).filter(Boolean),
+    blockedCandidateIds:mergeCandidates.filter((candidate)=>candidate.readiness==='blocked').map((candidate)=>candidate.id).filter(Boolean),
+    conflictKeys:uniqueStrings(mergeCandidates.flatMap((candidate)=>candidate.conflictKeys??[])),
+    patchRisk:normalizeRisk(projectResult?.patch?.risk)
+  };
+}
+
+export function candidateRisk(candidate,patch){
+  return normalizeRisk(candidate?.risk)??normalizeRisk(patch?.risk)??readinessRisk(candidate?.readiness);
+}
+
+export function maxRisk(left,right){
+  return riskRank[left]>=riskRank[right]?left:right;
+}
+
+export function maxPreservationQuality(left,right){
+  return preservationRank[left]>=preservationRank[right]?left:right;
+}
+
+function compactAdmissionSource(imported,index){
+  const semanticIndex=imported?.semanticIndex??imported?.universalAst?.semanticIndex;
+  const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
+  const sourceMaps=imported?.sourceMaps??imported?.universalAst?.sourceMaps??[];
+  return {
+    id:imported?.id??`import_${index+1}`,
+    language:imported?.language??imported?.nativeSource?.language??nativeAst?.language,
+    sourcePath:imported?.sourcePath??imported?.nativeSource?.sourcePath??nativeAst?.sourcePath,
+    sourceHash:imported?.nativeSource?.sourceHash??nativeAst?.sourceHash,
+    parser:nativeAst?.parser??imported?.nativeSource?.parser,
+    sourceMapIds:sourceMaps.map((sourceMap)=>sourceMap.id).filter(Boolean),
+    sourceMapMappings:sourceMaps.reduce((sum,sourceMap)=>sum+(sourceMap.mappings?.length??0),0),
+    symbolCount:semanticIndex?.symbols?.length??0,
+    lossCount:imported?.losses?.length??nativeAst?.losses?.length??0,
+    evidenceCount:imported?.evidence?.length??0,
+    readiness:imported?.metadata?.semanticMergeReadiness??imported?.mergeCandidates?.[0]?.readiness
+  };
+}
+
+function summarizeImportPreservation(imported,source){
+  const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
+  const record=imported?.metadata?.sourcePreservation
+    ??imported?.nativeSource?.metadata?.sourcePreservation
+    ??nativeAst?.metadata?.sourcePreservation
+    ??imported?.universalAst?.metadata?.sourcePreservation;
+  const sourceHash=source?.sourceHash??imported?.nativeSource?.sourceHash??nativeAst?.sourceHash;
+  const sourcePreservationLosses=(imported?.losses??nativeAst?.losses??[]).filter((loss)=>loss.kind==='sourcePreservation');
+  const stale=imported?.metadata?.sourceHashVerified===false
+    ||imported?.nativeSource?.metadata?.sourceHashVerified===false
+    ||nativeAst?.metadata?.sourceHashVerified===false
+    ||record?.metadata?.sourceHashVerified===false
+    ||Boolean(record?.sourceHash&&sourceHash&&record.sourceHash!==sourceHash);
+  const missing=!record;
+  const truncated=record?.summary?.truncated===true;
+  const exactSourceAvailable=record?.summary?.exactSourceAvailable===true;
+  const quality=stale?'stale':missing?'missing':truncated||!exactSourceAvailable||sourcePreservationLosses.length?'lossy':'exact';
+  return {quality,missing,stale,truncated,exactSourceAvailable,lossCount:sourcePreservationLosses.length,id:record?.id};
+}
+
+function emptyLanguageRow(language){
+  return {
+    language,
+    sourceCount:0,
+    sourcePaths:[],
+    readiness:'ready',
+    semanticSymbols:0,
+    emptySemanticEvidenceSources:0,
+    sourcePreservationQuality:'exact',
+    staleSourcePaths:[],
+    mergeCandidates:0,
+    highestRisk:'low'
+  };
+}
+
+function readinessRisk(readiness){
+  if(readiness==='blocked') return 'high';
+  if(readiness==='needs-review'||readiness==='ready-with-losses') return 'medium';
+  return 'low';
+}
+
+function normalizeRisk(value){
+  const risk=String(value??'').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(riskRank,risk)?risk:undefined;
+}

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

@@ -0,0 +1,90 @@
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{classifyNativeImportReadiness}from'./classifyNativeImportReadiness.js';import{createNativeRoundtripEvidence}from'./createNativeRoundtripEvidence.js';import{nativeImportProjectionContext}from'./nativeImportProjectionContext.js';import{nativeProjectionDeclarations}from'./nativeProjectionDeclarations.js';import{nativeProjectionSourceCandidate}from'./nativeProjectionSourceCandidate.js';import{nativeProjectionStubLosses}from'./nativeProjectionStubLosses.js';import{renderNativeProjectionStubs}from'./renderNativeProjectionStubs.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
+export function projectNativeImportToSource(importResult, options = {}) {
+  if (!importResult || typeof importResult !== 'object') {
+    throw new Error('projectNativeImportToSource requires a native import result');
+  }
+  const context = nativeImportProjectionContext(importResult, options);
+  const candidateSource = nativeProjectionSourceCandidate(context, options);
+  const declarations = nativeProjectionDeclarations(importResult, context);
+  const preserveSource = options.preferPreservedSource !== false && candidateSource?.exact === true;
+  const mode = preserveSource ? 'preserved-source' : 'native-source-stubs';
+  const sourceText = preserveSource
+    ? candidateSource.sourceText
+    : renderNativeProjectionStubs(context, declarations, options);
+  const losses = preserveSource ? [] : nativeProjectionStubLosses(context, candidateSource, declarations, options);
+  const evidence = [{
+    id: options.evidenceId ?? `evidence_${context.idPart}_native_source_projection`,
+    kind: 'projection',
+    status: losses.some((loss) => loss.severity === 'error') ? 'failed' : 'passed',
+    path: context.sourcePath,
+    summary: preserveSource
+      ? `Preserved exact ${context.language} source for native projection.`
+      : `Projected ${context.language} native import to ${declarations.length} declaration stub(s).`,
+    metadata: {
+      mode,
+      language: context.language,
+      sourcePath: context.sourcePath,
+      expectedSourceHash: context.sourceHash,
+      providedSourceHash: candidateSource?.sourceHash,
+      sourcePreservationId: candidateSource?.sourcePreservationId,
+      sourceHashVerified: candidateSource?.hashVerified ?? false,
+      declarationCount: declarations.length
+    }
+  }];
+  const lossSummary = summarizeNativeImportLosses(losses, {
+    evidence,
+    parser: context.parser,
+    scanKind: 'native-source-projection',
+    semanticStatus: context.semanticStatus
+  });
+  const readiness = classifyNativeImportReadiness(losses, {
+    evidence,
+    parser: context.parser,
+    scanKind: 'native-source-projection',
+    semanticStatus: context.semanticStatus
+  });
+  const nativeImportLossSummary = importResult.metadata?.nativeImportLossSummary ?? summarizeNativeImportLosses(importResult.losses ?? context.nativeAst?.losses ?? [], {
+    evidence: importResult.evidence,
+    parser: context.parser,
+    semanticStatus: context.semanticStatus
+  });
+  const result = {
+    kind: 'frontier.lang.nativeSourceProjection',
+    version: 1,
+    id: options.id ?? `native_source_projection_${context.idPart}`,
+    language: context.language,
+    sourcePath: context.sourcePath,
+    sourceHash: context.sourceHash,
+    mode,
+    sourceText,
+    outputHash: hashSemanticValue(sourceText),
+    declarations,
+    losses,
+    lossSummary,
+    readiness,
+    evidence,
+    metadata: {
+      nativeImportId: importResult.id,
+      nativeSourceId: context.nativeSource?.id,
+      nativeAstId: context.nativeAst?.id,
+      semanticIndexId: context.semanticIndex?.id,
+      universalAstId: importResult.universalAst?.id,
+      exactSourceAvailable: candidateSource?.exact === true,
+      sourceTextAvailable: typeof candidateSource?.sourceText === 'string',
+      sourcePreservationId: candidateSource?.sourcePreservationId,
+      sourceHashVerified: candidateSource?.hashVerified ?? false,
+      nativeImportLossSummary,
+      ...options.metadata
+    }
+  };
+  const roundtripEvidence = createNativeRoundtripEvidence(importResult, { projection: result });
+  return {
+    ...result,
+    evidence: [...evidence, roundtripEvidence],
+    metadata: {
+      ...result.metadata,
+      roundtripEvidence: roundtripEvidence.metadata.roundtripEvidence
+    }
+  };
+}

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

@@ -0,0 +1,8 @@
+import{toCAst}from'@shapeshift-labs/frontier-lang-c';import{toJavaScriptAst}from'@shapeshift-labs/frontier-lang-javascript';import{toPythonAst}from'@shapeshift-labs/frontier-lang-python';import{toRustAst}from'@shapeshift-labs/frontier-lang-rust';import{toTypeScriptAst}from'@shapeshift-labs/frontier-lang-typescript';
+export const projectors = Object.freeze({
+  typescript: toTypeScriptAst,
+  javascript: toJavaScriptAst,
+  rust: toRustAst,
+  python: toPythonAst,
+  c: toCAst
+});

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

@@ -0,0 +1,5 @@
+export function pythonAliasName(alias) {
+  if (!alias) return undefined;
+  if (typeof alias === 'string') return alias;
+  return alias.name ?? alias.asname ?? alias.id;
+}

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

@@ -0,0 +1,9 @@
+import{pythonTargetName}from'./pythonTargetName.js';
+export function pythonAssignmentName(node) {
+  if (node.target) return pythonTargetName(node.target);
+  for (const target of node.targets ?? []) {
+    const name = pythonTargetName(target);
+    if (name) return name;
+  }
+  return undefined;
+}

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

@@ -0,0 +1,11 @@
+import{ignoredPythonAstField}from'./ignoredPythonAstField.js';import{isPythonAstNode}from'./isPythonAstNode.js';
+export function pythonAstChildEntries(node) {
+  const fieldNames = Array.isArray(node._fields)
+    ? node._fields
+    : Object.keys(node).filter((key) => !ignoredPythonAstField(key));
+  return fieldNames
+    .map((field) => [field, node[field]])
+    .filter(([, value]) => Array.isArray(value)
+      ? value.some(isPythonAstNode)
+      : isPythonAstNode(value));
+}

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

@@ -0,0 +1,18 @@
+import{declarationRecord}from'./declarationRecord.js';import{nativeNodeId}from'./nativeNodeId.js';import{pythonAliasName}from'./pythonAliasName.js';import{pythonAssignmentName}from'./pythonAssignmentName.js';
+export function pythonAstDeclaration(node, kind, nativeNodeId, input) {
+  if (kind === 'Import') {
+    const name = (node.names ?? []).map((entry) => pythonAliasName(entry)).find(Boolean);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'ImportFrom') {
+    const name = node.module ?? (node.names ?? []).map((entry) => pythonAliasName(entry)).find(Boolean);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+  }
+  if (kind === 'FunctionDef' || kind === 'AsyncFunctionDef') return declarationRecord(input, nativeNodeId, node.name, 'function', 'definition');
+  if (kind === 'ClassDef') return declarationRecord(input, nativeNodeId, node.name, 'class', 'definition');
+  if (kind === 'AnnAssign' || kind === 'Assign') {
+    const name = pythonAssignmentName(node);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', 'definition');
+  }
+  return undefined;
+}

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

@@ -0,0 +1,3 @@
+export function pythonAstKind(node) {
+  return node?._type ?? node?.type ?? node?.kind ?? node?.nodeType;
+}

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

@@ -0,0 +1,6 @@
+export function pythonAstLiteralValue(node) {
+  if (node.value === null || typeof node.value === 'string' || typeof node.value === 'number' || typeof node.value === 'boolean') return node.value;
+  if (typeof node.s === 'string' || typeof node.s === 'number') return node.s;
+  if (typeof node.n === 'number') return node.n;
+  return undefined;
+}

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

@@ -0,0 +1,4 @@
+import{pythonAstLiteralValue}from'./pythonAstLiteralValue.js';
+export function pythonAstNodeValue(node) {
+  return node.name ?? node.id ?? node.arg ?? node.module ?? pythonAstLiteralValue(node);
+}

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

@@ -0,0 +1,9 @@
+import{isPythonAstNode}from'./isPythonAstNode.js';
+export function pythonAstRoot(value) {
+  if (!value || typeof value !== 'object') return undefined;
+  if (isPythonAstNode(value)) return value;
+  if (isPythonAstNode(value.ast)) return value.ast;
+  if (isPythonAstNode(value.root)) return value.root;
+  if (isPythonAstNode(value.module)) return value.module;
+  return undefined;
+}

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

@@ -0,0 +1,12 @@
+export function pythonTargetName(target) {
+  if (!target) return undefined;
+  if (typeof target === 'string') return target;
+  if (typeof target.id === 'string') return target.id;
+  if (typeof target.name === 'string') return target.name;
+  if (typeof target.arg === 'string') return target.arg;
+  if (target.attr && target.value) {
+    const base = pythonTargetName(target.value);
+    return base ? `${base}.${target.attr}` : target.attr;
+  }
+  return undefined;
+}

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

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

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

@@ -0,0 +1,5 @@
+import{queryProjectionReadinessMatrix as queryProjectionReadinessMatrixImpl}from'../../projection-readiness-matrix.js';
+import{coverageMatrixContext}from'./coverageMatrixContext.js';
+export function queryProjectionReadinessMatrix(matrixOrInput = {}, query = {}) {
+  return queryProjectionReadinessMatrixImpl(matrixOrInput, query, coverageMatrixContext());
+}

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

@@ -0,0 +1,7 @@
+export function readSemanticSliceJson(source) {
+  const slice = JSON.parse(source);
+  if (slice?.kind !== 'frontier.lang.semanticSlice') {
+    throw new Error('Invalid Frontier semantic slice JSON: expected kind frontier.lang.semanticSlice');
+  }
+  return slice;
+}

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

@@ -0,0 +1,5 @@
+export function readStringArray(value) {
+  if (value === undefined || value === null) return [];
+  if (Array.isArray(value)) return value.flatMap((entry) => readStringArray(entry));
+  return String(value).split(',').map((entry) => entry.trim()).filter(Boolean);
+}

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

@@ -0,0 +1,9 @@
+import{validateUniversalAstEnvelope}from'@shapeshift-labs/frontier-lang-kernel';
+export function readUniversalAstJson(source) {
+  const envelope = JSON.parse(source);
+  const issues = validateUniversalAstEnvelope(envelope);
+  if (issues.length > 0) {
+    throw new Error(`Invalid Frontier universal AST JSON: ${issues.join('; ')}`);
+  }
+  return envelope;
+}

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

@@ -0,0 +1,5 @@
+export function relationPredicateForDeclaration(declaration) {
+  if (declaration.role === 'import') return 'imports';
+  if (declaration.role === 'export') return 'exports';
+  return 'defines';
+}

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

@@ -0,0 +1,11 @@
+import{upperFirst}from'../../native-import-utils.js';
+import{safeProjectionIdentifier}from'./safeProjectionIdentifier.js';
+export function renderCProjectionStubs(declarations) {
+  if (!declarations.length) return '';
+  return declarations.map((declaration) => {
+    const name = safeProjectionIdentifier(declaration.name);
+    if (declaration.kind === 'function') return `void ${name}(void);`;
+    if (declaration.kind === 'type' || declaration.kind === 'class') return `typedef struct ${upperFirst(name)} ${upperFirst(name)};`;
+    return `extern const int ${name};`;
+  }).join('\n');
+}

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

@@ -0,0 +1,5 @@
+import{nativeProjectionLineComment}from'./nativeProjectionLineComment.js';
+export function renderGenericProjectionStubs(declarations, language) {
+  if (!declarations.length) return `${nativeProjectionLineComment(language)} no declarations available`;
+  return declarations.map((declaration) => `${declaration.kind} ${declaration.name}`).join('\n');
+}

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

@@ -0,0 +1,12 @@
+import{reserveUniqueId}from'../../native-import-utils.js';
+import{safeProjectionIdentifier}from'./safeProjectionIdentifier.js';
+export function renderJavaScriptProjectionStubs(declarations) {
+  const used = new Set();
+  if (!declarations.length) return 'export {};';
+  return declarations.map((declaration) => {
+    const name = reserveUniqueId(safeProjectionIdentifier(declaration.name), used);
+    if (declaration.kind === 'function') return `export function ${name}(...args) {\n  throw new Error('Frontier native source stub: implementation unavailable.');\n}`;
+    if (declaration.kind === 'class') return `export class ${name} {}`;
+    return `export const ${name} = undefined;`;
+  }).join('\n\n');
+}

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

@@ -0,0 +1,13 @@
+import{ensureTrailingNewline}from'./ensureTrailingNewline.js';import{nativeProjectionStubHeader}from'./nativeProjectionStubHeader.js';import{renderCProjectionStubs}from'./renderCProjectionStubs.js';import{renderGenericProjectionStubs}from'./renderGenericProjectionStubs.js';import{renderJavaScriptProjectionStubs}from'./renderJavaScriptProjectionStubs.js';import{renderPythonProjectionStubs}from'./renderPythonProjectionStubs.js';import{renderRustProjectionStubs}from'./renderRustProjectionStubs.js';import{renderTypeScriptProjectionStubs}from'./renderTypeScriptProjectionStubs.js';
+export function renderNativeProjectionStubs(context, declarations, options) {
+  const language = String(context.language ?? 'source').toLowerCase();
+  const header = nativeProjectionStubHeader(language, context, options);
+  let body;
+  if (language === 'typescript' || language === 'ts') body = renderTypeScriptProjectionStubs(declarations);
+  else if (language === 'javascript' || language === 'js') body = renderJavaScriptProjectionStubs(declarations);
+  else if (language === 'python' || language === 'py') body = renderPythonProjectionStubs(declarations);
+  else if (language === 'rust' || language === 'rs') body = renderRustProjectionStubs(declarations);
+  else if (language === 'c' || language === 'cpp' || language === 'c++' || language === 'h') body = renderCProjectionStubs(declarations);
+  else body = renderGenericProjectionStubs(declarations, language);
+  return ensureTrailingNewline([header, body].filter(Boolean).join('\n'));
+}

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

@@ -0,0 +1,10 @@
+import{safeProjectionIdentifier}from'./safeProjectionIdentifier.js';
+export function renderPythonProjectionStubs(declarations) {
+  if (!declarations.length) return 'pass';
+  return declarations.map((declaration) => {
+    const name = safeProjectionIdentifier(declaration.name);
+    if (declaration.kind === 'function') return `def ${name}(*args, **kwargs):\n    raise NotImplementedError("Frontier native source stub")`;
+    if (declaration.kind === 'class') return `class ${name}:\n    pass`;
+    return `${name} = None`;
+  }).join('\n\n');
+}

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

@@ -0,0 +1,11 @@
+import{upperFirst}from'../../native-import-utils.js';
+import{safeProjectionIdentifier}from'./safeProjectionIdentifier.js';
+export function renderRustProjectionStubs(declarations) {
+  if (!declarations.length) return '';
+  return declarations.map((declaration) => {
+    const name = safeProjectionIdentifier(declaration.name);
+    if (declaration.kind === 'function') return `pub fn ${name}() {\n    unimplemented!(\"Frontier native source stub\");\n}`;
+    if (declaration.kind === 'type' || declaration.kind === 'class') return `pub struct ${upperFirst(name)};`;
+    return `pub const ${name.toUpperCase()}: () = ();`;
+  }).join('\n\n');
+}

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

@@ -0,0 +1,6 @@
+import{normalizeCompileTarget}from'./normalizeCompileTarget.js';import{renderers}from'./renderers.js';
+export function renderTargetAst(ast, target = 'typescript') {
+  const normalized = normalizeCompileTarget(target);
+  const renderer = renderers[normalized];
+  return renderer(ast);
+}

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

@@ -0,0 +1,6 @@
+import{normalizeCompileTarget}from'./normalizeCompileTarget.js';import{sourceMapRenderers}from'./sourceMapRenderers.js';
+export function renderTargetAstWithSourceMap(ast, target = 'typescript', options = {}) {
+  const normalized = normalizeCompileTarget(target);
+  const renderer = sourceMapRenderers[normalized];
+  return renderer(ast, options);
+}

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

@@ -0,0 +1,14 @@
+import{reserveUniqueId}from'../../native-import-utils.js';
+import{safeProjectionIdentifier}from'./safeProjectionIdentifier.js';
+export function renderTypeScriptProjectionStubs(declarations) {
+  const used = new Set();
+  if (!declarations.length) return 'export {};';
+  return declarations.map((declaration) => {
+    const name = reserveUniqueId(safeProjectionIdentifier(declaration.name), used);
+    if (declaration.kind === 'function') return `export function ${name}(...args: unknown[]): never {\n  throw new Error('Frontier native source stub: implementation unavailable.');\n}`;
+    if (declaration.kind === 'class') return `export class ${name} {}`;
+    if (declaration.kind === 'interface') return `export interface ${name} {}`;
+    if (declaration.kind === 'type' || declaration.kind === 'trait') return `export type ${name} = unknown;`;
+    return `export const ${name}: unknown = undefined;`;
+  }).join('\n\n');
+}

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

@@ -0,0 +1,8 @@
+import{renderCAst}from'@shapeshift-labs/frontier-lang-c';import{renderJavaScriptAst}from'@shapeshift-labs/frontier-lang-javascript';import{renderPythonAst}from'@shapeshift-labs/frontier-lang-python';import{renderRustAst}from'@shapeshift-labs/frontier-lang-rust';import{renderTypeScriptAst}from'@shapeshift-labs/frontier-lang-typescript';
+export const renderers = Object.freeze({
+  typescript: renderTypeScriptAst,
+  javascript: renderJavaScriptAst,
+  rust: renderRustAst,
+  python: renderPythonAst,
+  c: renderCAst
+});

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

@@ -0,0 +1,29 @@
+import{normalizeCompileTarget}from'./normalizeCompileTarget.js';
+export function resolveCapabilityAdapters(document, target = 'typescript', options = {}) {
+  const normalized = normalizeCompileTarget(target);
+  const platform = options.platform;
+  return Object.values(document.nodes)
+    .filter((node) => node.kind === 'capability')
+    .map((node) => {
+      const adapters = (node.adapters ?? []).filter((adapter) => {
+        if (adapter.target?.language !== normalized) return false;
+        if (platform && adapter.target?.platform && adapter.target.platform !== platform) return false;
+        return true;
+      });
+      const unsupported = (node.unsupportedTargets ?? []).find((item) => {
+        if (item.target?.language !== normalized) return false;
+        if (platform && item.target?.platform && item.target.platform !== platform) return false;
+        return true;
+      });
+      return {
+        nodeId: node.id,
+        name: node.name,
+        capability: node.capability,
+        target: { language: normalized, platform },
+        status: adapters.length ? 'bound' : unsupported ? 'unsupported' : 'unbound',
+        adapters,
+        unsupported,
+        reason: unsupported?.reason
+      };
+    });
+}