@shapeshift-labs/frontier-lang-compiler 0.2.46 → 0.2.48

package/README.md

@@ -333,6 +333,7 @@ Extract a surgical semantic slice when a worker only needs one symbol, region, n
 
 ```js
 import {
+  createSemanticSliceAdmissionRecord,
   createSemanticSlice,
   importNativeSource,
   testSemanticSlice,
@@ -362,11 +363,16 @@ const gate = testSemanticSlice(slice, {
 });
 
 console.log(gate.status); // "passed", "needs-review", or "failed"
+const admission = createSemanticSliceAdmissionRecord(slice, { testResult: gate });
+console.log(admission.mergeScore.value); // sortable 0-100 semantic merge score
+console.log(admission.autoMergeClaim); // always false
 console.log(writeSemanticSliceJson(slice)); // stable JSON for worker inputs
 ```
 
 A semantic slice is the small unit a swarm can hand to a worker instead of copying a full repository. It carries the selected symbols, ownership regions, native nodes, relations, occurrences, source-map links, source spans, source excerpts, source hashes, focused verification commands, fixture hints, and merge-admission metadata. It does not claim the patch is correct; it makes the context and conflicts machine-readable so admission scoring can combine changed ownership, focused test status, stale/source-hash checks, evidence, and semantic risk in one sortable record.
 
+Slice admission records add a compact `frontier.lang.semanticMergeScore.v1` score with semantic-selection, source-freshness, ownership-isolation, verification-evidence, and review-risk components. They are built for coordinator queues and dashboards: sort likely useful slices first, reject stale or empty slices early, and keep correctness proof separate from merge metadata.
+
 Compile native source imports through the same reader/IR/writer facade that swarms use for sidecar evidence. Same-language targets preserve exact source when hashes match; cross-language targets emit declaration stubs until a real adapter provides stronger evidence:
 
 ```js

package/bench/native-transform-suite.mjs

@@ -4,6 +4,7 @@ import {
   createNativeSourcePreservation,
   createSemanticImportSidecar,
   createSemanticSlice,
+  createSemanticSliceAdmissionRecord,
   projectNativeImportToSource,
   summarizeNativeImportFeatureEvidence,
   testSemanticSlice
@@ -40,6 +41,11 @@ export function measureNativeTransformations(nativeImportResults) {
   const semanticSliceGates = semanticSlices.map((slice) => testSemanticSlice(slice, { requireSourceMapLinks: false }));
   const sliceGateDurationMs = performance.now() - sliceGateStart;
   const sliceGateFailures = semanticSliceGates.filter((gate) => gate.status === 'failed').length;
+  const sliceAdmissionStart = performance.now();
+  const semanticSliceAdmissions = semanticSlices.map((slice, index) => createSemanticSliceAdmissionRecord(slice, {
+    testResult: semanticSliceGates[index]
+  }));
+  const sliceAdmissionDurationMs = performance.now() - sliceAdmissionStart;
 
   const featureEvidenceStart = performance.now();
   const featureEvidenceSummaries = nativeImportResults.map((imported) => summarizeNativeImportFeatureEvidence(imported.losses, {
@@ -65,9 +71,12 @@ export function measureNativeTransformations(nativeImportResults) {
     semanticSlices: semanticSlices.length,
     sliceDurationMs,
     sliceGateDurationMs,
+    sliceAdmissionDurationMs,
     sliceSourceMapLinks,
     sliceConflictKeys,
     sliceGateFailures,
+    sliceAdmissions: semanticSliceAdmissions.length,
+    sliceAdmissionRejected: semanticSliceAdmissions.filter((admission) => admission.action === 'reject').length,
     featureEvidencePolicyMatches,
     featureEvidenceDurationMs,
     nativeProjections: nativeProjections.length,

package/bench/smoke.mjs

@@ -51,9 +51,12 @@ console.log(JSON.stringify({
   semanticSlices: transformMetrics.semanticSlices,
   sliceDurationMs: Number(transformMetrics.sliceDurationMs.toFixed(2)),
   sliceGateDurationMs: Number(transformMetrics.sliceGateDurationMs.toFixed(2)),
+  sliceAdmissionDurationMs: Number(transformMetrics.sliceAdmissionDurationMs.toFixed(2)),
   sliceSourceMapLinks: transformMetrics.sliceSourceMapLinks,
   sliceConflictKeys: transformMetrics.sliceConflictKeys,
   sliceGateFailures: transformMetrics.sliceGateFailures,
+  sliceAdmissions: transformMetrics.sliceAdmissions,
+  sliceAdmissionRejected: transformMetrics.sliceAdmissionRejected,
   featureEvidencePolicyMatches: transformMetrics.featureEvidencePolicyMatches,
   featureEvidenceDurationMs: Number(transformMetrics.featureEvidenceDurationMs.toFixed(2)),
   nativeProjections: transformMetrics.nativeProjections,

package/dist/declarations/runtime.d.ts

@@ -43,6 +43,7 @@ import type { NativeSourceTokenKind, NativeSourcePreservedToken, NativeSourcePre
 import type { SemanticImportOwnershipRegion, SemanticImportSidecarSymbol, SemanticImportRegionTaxonomySummary, SemanticImportPatchHint, SemanticImportSidecarImportEntry, SemanticImportSidecarSourcePreservationRecord, SemanticImportSidecarUniversalAstLayerSummary, SemanticImportSidecarProofSpecSummary, SemanticImportSidecarParadigmSemanticsSummary, SemanticImportSidecar, SemanticImportSidecarOptions } from './semantic-sidecar.js';
 import type { NativeSourceChangeKind, NativeSourceChangeProjectionEndpoint, NativeSourceChangeProjectionSourceMapLink, NativeSourceChangeProjectionMetadata, NativeSourceChangeProjectionSummary, NativeSourceChangeSymbol, NativeSourceChangeRegion, NativeSourceChangeSummary, DiffNativeSourceImportsOptions, DiffNativeSourcesOptions, NativeSourceChangeSet } from './native-diff.js';
 import type { SemanticSliceInput, CreateSemanticSliceOptions, SemanticSliceSourceMapLink, SemanticSliceSourceFile, SemanticSliceExpectedAssertion, SemanticSlice, TestSemanticSliceOptions, SemanticSliceTestAssertion, SemanticSliceTestResult } from './semantic-slice.js';
+import type { CreateSemanticSliceAdmissionRecordOptions, SemanticSliceAdmissionRecord } from './semantic-slice-admission.js';
 import type { NativeImporterAdapterExactness, NativeImporterAdapterSemanticCoverage, NativeImporterAdapterCoverageSnapshot, NativeImporterAdapterCoverageObserved, NativeImporterAdapterCoverageCapabilityRow, NativeImporterAdapterCoverageCapabilityEvidence, NativeImporterAdapterCoverageSummary, NativeImporterAdapterCoverageInput } from './adapter-coverage.js';
 import type { NativeImporterAdapterDiagnostic, ImportNativeSourceOptions, NativeSourceImportResult, ExternalSemanticIndexFormat, ImportExternalSemanticIndexOptions, ExternalSemanticIndexImportSummary, ExternalSemanticIndexImportResult, NativeImporterAdapterParseInput, NativeImporterAdapterParseResult, NativeImporterAdapter, NativeImporterAdapterSummary, RunNativeImporterAdapterOptions, NativeImporterAdapterImportResult } from './import-adapter-core.js';
 import type { JavaScriptNativeImporterAdapterOptions, TypeScriptCompilerNativeImporterAdapterOptions, PythonAstNativeImporterAdapterOptions, RustSynNativeImporterAdapterOptions, ClangAstNativeImporterAdapterOptions, GoAstNativeImporterAdapterOptions } from './import-adapter-options-native.js';
@@ -109,6 +110,7 @@ export declare function importNativeSource(input: ImportNativeSourceOptions): Na
 export declare function diffNativeSources(input: DiffNativeSourcesOptions): NativeSourceChangeSet;
 export declare function diffNativeSourceImports(input: DiffNativeSourceImportsOptions): NativeSourceChangeSet;
 export declare function createSemanticSlice(input: SemanticSliceInput, options?: CreateSemanticSliceOptions): SemanticSlice;
+export declare function createSemanticSliceAdmissionRecord(slice: SemanticSlice, options?: CreateSemanticSliceAdmissionRecordOptions): SemanticSliceAdmissionRecord;
 export declare function testSemanticSlice(slice: SemanticSlice, options?: TestSemanticSliceOptions): SemanticSliceTestResult;
 export declare function readSemanticSliceJson(source: string): SemanticSlice;
 export declare function writeSemanticSliceJson(slice: SemanticSlice): string;

package/dist/declarations/semantic-slice-admission.d.ts

@@ -0,0 +1,82 @@
+import type { EvidenceRecord, SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
+import type { SemanticSlice, SemanticSliceTestResult, TestSemanticSliceOptions } from './semantic-slice.js';
+
+export type SemanticSliceAdmissionAction = 'admit' | 'prioritize' | 'reject';
+export type SemanticSliceAdmissionPriority = 'low' | 'normal' | 'high' | 'blocker';
+export type SemanticSliceAdmissionRisk = 'low' | 'medium' | 'high' | 'unknown';
+export type SemanticSliceAdmissionScoreComponentKey =
+  | 'semanticSelection'
+  | 'sourceFreshness'
+  | 'ownershipIsolation'
+  | 'verificationEvidence'
+  | 'reviewRisk';
+export type SemanticSliceAdmissionScoreComponentStatus = 'strong' | 'partial' | 'weak' | 'blocked';
+
+export interface SemanticSliceAdmissionScoreComponent {
+  readonly key: SemanticSliceAdmissionScoreComponentKey;
+  readonly score: number;
+  readonly weight: number;
+  readonly weightedScore: number;
+  readonly status: SemanticSliceAdmissionScoreComponentStatus;
+  readonly reasons: readonly string[];
+  readonly signals: Record<string, unknown>;
+}
+
+export interface SemanticSliceAdmissionMergeScore {
+  readonly schema: 'frontier.lang.semanticMergeScore.v1';
+  readonly version: 1;
+  readonly value: number;
+  readonly uncappedValue: number;
+  readonly sortKey: number;
+  readonly higherIsBetter: true;
+  readonly readiness: SemanticMergeReadiness;
+  readonly risk: SemanticSliceAdmissionRisk;
+  readonly action: SemanticSliceAdmissionAction;
+  readonly components: Readonly<Record<SemanticSliceAdmissionScoreComponentKey, SemanticSliceAdmissionScoreComponent>>;
+  readonly penalties: readonly string[];
+}
+
+export interface SemanticSliceAdmissionRecord {
+  readonly kind: 'frontier.lang.semanticSliceAdmission';
+  readonly version: 1;
+  readonly id: string;
+  readonly generatedAt: number;
+  readonly sliceId?: string;
+  readonly importId?: string;
+  readonly sourcePath?: string;
+  readonly action: SemanticSliceAdmissionAction;
+  readonly priority: SemanticSliceAdmissionPriority;
+  readonly readiness: SemanticMergeReadiness;
+  readonly risk: SemanticSliceAdmissionRisk;
+  readonly autoMergeClaim: false;
+  readonly reviewRequired: boolean;
+  readonly mergeScore: SemanticSliceAdmissionMergeScore;
+  readonly counts: {
+    readonly symbols: number;
+    readonly ownershipRegions: number;
+    readonly nativeNodes: number;
+    readonly sourceMapLinks: number;
+    readonly sourceFiles: number;
+    readonly focusedCommands: number;
+    readonly fixtureHints: number;
+    readonly assertions: number;
+    readonly failedAssertions: number;
+    readonly warningAssertions: number;
+  };
+  readonly conflictKeys: readonly string[];
+  readonly ownershipKeys: readonly string[];
+  readonly sourceHashes: SemanticSlice['mergeAdmission']['sourceHashes'];
+  readonly testResult?: SemanticSliceTestResult;
+  readonly reasons: readonly string[];
+  readonly metadata: Record<string, unknown>;
+}
+
+export interface CreateSemanticSliceAdmissionRecordOptions extends TestSemanticSliceOptions {
+  readonly testResult?: SemanticSliceTestResult;
+  readonly evidence?: readonly EvidenceRecord[];
+}
+
+export declare function createSemanticSliceAdmissionRecord(
+  slice: SemanticSlice,
+  options?: CreateSemanticSliceAdmissionRecordOptions
+): SemanticSliceAdmissionRecord;

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-sidecar.js';
 export * from './declarations/native-diff.js';
 export * from './declarations/semantic-slice.js';
+export * from './declarations/semantic-slice-admission.js';
 export * from './declarations/adapter-coverage.js';
 export * from './declarations/import-adapter-core.js';
 export * from './declarations/import-adapter-options-native.js';

package/dist/index.js

@@ -23,6 +23,7 @@ export { createPythonAstNativeImporterAdapter } from './internal/index-impl/crea
 export { createRustSynNativeImporterAdapter } from './internal/index-impl/createRustSynNativeImporterAdapter.js';
 export { createSemanticImportSidecar } from './internal/index-impl/createSemanticImportSidecar.js';
 export { createSemanticSlice } from './internal/index-impl/createSemanticSlice.js';
+export { createSemanticSliceAdmissionRecord } from './internal/index-impl/createSemanticSliceAdmissionRecord.js';
 export { createSwiftSyntaxNativeImporterAdapter } from './internal/index-impl/createSwiftSyntaxNativeImporterAdapter.js';
 export { createTreeSitterNativeImporterAdapter } from './internal/index-impl/createTreeSitterNativeImporterAdapter.js';
 export { createTypeScriptCompilerNativeImporterAdapter } from './internal/index-impl/createTypeScriptCompilerNativeImporterAdapter.js';

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

@@ -0,0 +1,180 @@
+import{idFragment,maxSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{testSemanticSlice}from'./testSemanticSlice.js';
+
+const readinessScore=Object.freeze({ready:100,'ready-with-losses':78,'needs-review':48,blocked:0});
+const readinessRank=Object.freeze({ready:3,'ready-with-losses':2,'needs-review':1,blocked:0});
+const actionRank=Object.freeze({admit:2,prioritize:1,reject:0});
+const riskRank=Object.freeze({low:3,medium:2,unknown:1,high:0});
+
+export function createSemanticSliceAdmissionRecord(slice,options={}){
+  const testResult=options.testResult??(options.currentSources?testSemanticSlice(slice,options):undefined);
+  const readiness=worstReadiness(slice?.mergeAdmission?.readiness??slice?.summary?.readiness??'needs-review',testResult?.readiness??'ready');
+  const components={
+    semanticSelection:semanticSelectionScore(slice),
+    sourceFreshness:sourceFreshnessScore(slice,testResult),
+    ownershipIsolation:ownershipIsolationScore(slice),
+    verificationEvidence:verificationEvidenceScore(slice,testResult,options),
+    reviewRisk:reviewRiskScore(slice,readiness,testResult)
+  };
+  const value=mergeScoreValue(components,readiness);
+  const action=admissionAction(slice,readiness,components,testResult);
+  const risk=admissionRisk(readiness,components,testResult);
+  return{
+    kind:'frontier.lang.semanticSliceAdmission',
+    version:1,
+    id:options.id??`semantic_slice_admission_${idFragment(slice?.id??'slice')}`,
+    generatedAt:options.generatedAt??Date.now(),
+    sliceId:slice?.id,
+    importId:slice?.importId,
+    sourcePath:slice?.sourcePath,
+    action,
+    priority:admissionPriority(action,risk,readiness),
+    readiness,
+    risk,
+    autoMergeClaim:false,
+    reviewRequired:action!=='admit'||readiness!=='ready',
+    mergeScore:{
+      schema:'frontier.lang.semanticMergeScore.v1',
+      version:1,
+      value,
+      uncappedValue:value,
+      sortKey:mergeScoreSortKey(value,action,risk,readiness),
+      higherIsBetter:true,
+      readiness,
+      risk,
+      action,
+      components,
+      penalties:uniqueStrings(Object.values(components).flatMap((component)=>component.score<100?component.reasons:[]))
+    },
+    counts:{
+      symbols:slice?.summary?.symbols??slice?.symbols?.length??0,
+      ownershipRegions:slice?.summary?.ownershipRegions??slice?.ownershipRegions?.length??0,
+      nativeNodes:slice?.summary?.nativeNodes??slice?.nativeNodes?.length??0,
+      sourceMapLinks:slice?.summary?.sourceMapLinks??slice?.sourceMapLinks?.length??0,
+      sourceFiles:slice?.summary?.sourceFiles??slice?.sourceFiles?.length??0,
+      focusedCommands:slice?.verification?.focusedCommands?.length??0,
+      fixtureHints:slice?.verification?.fixtureHints?.length??0,
+      assertions:testResult?.summary?.assertions??0,
+      failedAssertions:testResult?.summary?.failed??0,
+      warningAssertions:testResult?.summary?.warnings??0
+    },
+    conflictKeys:uniqueStrings(slice?.mergeAdmission?.conflictKeys??[]),
+    ownershipKeys:uniqueStrings(slice?.mergeAdmission?.ownershipKeys??[]),
+    sourceHashes:slice?.mergeAdmission?.sourceHashes??[],
+    testResult,
+    reasons:uniqueStrings([
+      ...(slice?.mergeAdmission?.reasons??[]),
+      ...Object.values(components).flatMap((component)=>component.reasons)
+    ]),
+    metadata:{
+      note:'Semantic slice admission is sortable merge-review evidence for isolated worker inputs; it is not a correctness proof and never grants auto-merge by itself.',
+      ...(options.metadata??{})
+    }
+  };
+}
+
+function semanticSelectionScore(slice){
+  const symbols=slice?.summary?.symbols??slice?.symbols?.length??0;
+  const regions=slice?.summary?.ownershipRegions??slice?.ownershipRegions?.length??0;
+  const nativeNodes=slice?.summary?.nativeNodes??slice?.nativeNodes?.length??0;
+  const links=slice?.summary?.sourceMapLinks??slice?.sourceMapLinks?.length??0;
+  const unresolved=slice?.summary?.unresolvedEntryRefs??slice?.unresolvedEntryRefs?.length??0;
+  const selected=symbols+regions+nativeNodes;
+  let score=selected>0?70:0;
+  if(symbols>0)score+=12;
+  if(regions>0)score+=10;
+  if(links>0)score+=8;
+  score=Math.max(0,Math.min(100,score-unresolved*25));
+  return scoreComponent('semanticSelection',score,[
+    ...(selected===0?['Slice selected no symbols, ownership regions, or native nodes.']:[]),
+    ...(unresolved?[`${unresolved} semantic slice entry ref(s) did not resolve.`]:[])
+  ],{symbols,ownershipRegions:regions,nativeNodes,sourceMapLinks:links,unresolvedEntryRefs:unresolved});
+}
+
+function sourceFreshnessScore(slice,testResult){
+  const sourceHashes=slice?.mergeAdmission?.sourceHashes??[];
+  const checks=(testResult?.assertions??[]).filter((assertion)=>String(assertion.id??'').startsWith('sourceHash:'));
+  const failed=checks.filter((assertion)=>assertion.status==='failed').length;
+  const warnings=checks.filter((assertion)=>assertion.status==='warning').length;
+  const passed=checks.filter((assertion)=>assertion.status==='passed').length;
+  const score=failed?0:checks.length?Math.max(20,Math.round((passed*100+warnings*55)/checks.length)):sourceHashes.length?55:35;
+  return scoreComponent('sourceFreshness',score,[
+    ...(failed?[`${failed} source hash check(s) failed.`]:[]),
+    ...(!checks.length&&sourceHashes.length?['Slice has source hashes but no current source check was run.']:[]),
+    ...(!sourceHashes.length?['Slice has no source hashes for stale-check admission.']:[])
+  ],{sourceHashes:sourceHashes.length,checks:checks.length,passed,warnings,failed});
+}
+
+function ownershipIsolationScore(slice){
+  const conflictKeys=slice?.mergeAdmission?.conflictKeys?.length??0;
+  const ownershipKeys=slice?.mergeAdmission?.ownershipKeys?.length??0;
+  const reviewRequired=slice?.mergeAdmission?.reviewRequired===true;
+  const score=conflictKeys?Math.max(45,100-Math.max(0,conflictKeys-1)*8-(reviewRequired?16:0)):15;
+  return scoreComponent('ownershipIsolation',score,[
+    ...(!conflictKeys?['Slice exposes no conflict keys for ownership isolation.']:[]),
+    ...(reviewRequired?['Slice merge admission already requires review.']:[])
+  ],{conflictKeys,ownershipKeys,reviewRequired});
+}
+
+function verificationEvidenceScore(slice,testResult,options){
+  const focused=slice?.verification?.focusedCommands?.length??0;
+  const fixtures=slice?.verification?.fixtureHints?.length??0;
+  const evidence=[...(options.evidence??[]),...(slice?.evidence??[])];
+  const failed=(testResult?.summary?.failed??0)+evidence.filter((record)=>record?.status==='failed').length;
+  const warnings=testResult?.summary?.warnings??0;
+  let score=focused||fixtures||evidence.length?72:45;
+  score+=Math.min(18,focused*8+fixtures*4+evidence.length*3);
+  score-=failed*35+warnings*8;
+  return scoreComponent('verificationEvidence',Math.max(0,Math.min(100,score)),[
+    ...(!focused?['Slice has no focused verification command.']:[]),
+    ...(failed?[`${failed} failed assertion or evidence record(s).`]:[])
+  ],{focusedCommands:focused,fixtureHints:fixtures,evidenceRecords:evidence.length,failed,warnings});
+}
+
+function reviewRiskScore(slice,readiness,testResult){
+  const losses=slice?.summary?.losses??slice?.losses?.length??0;
+  const failed=testResult?.summary?.failed??0;
+  const base=readinessScore[readiness]??48;
+  const score=Math.max(0,Math.min(100,base-losses*4-failed*25));
+  return scoreComponent('reviewRisk',score,[
+    ...(readiness!=='ready'?[`Slice readiness is ${readiness}.`]:[]),
+    ...(losses?[`Slice carries ${losses} native import loss record(s).`]:[])
+  ],{readiness,losses,failedAssertions:failed});
+}
+
+function scoreComponent(key,score,reasons,signals){
+  const rounded=Math.round(Math.max(0,Math.min(100,score)));
+  return{key,score:rounded,weight:20,weightedScore:rounded*20/100,status:rounded>=85?'strong':rounded>=60?'partial':rounded>0?'weak':'blocked',reasons,signals};
+}
+
+function mergeScoreValue(components,readiness){
+  const values=Object.values(components);
+  const score=values.reduce((sum,component)=>sum+component.weightedScore,0)/values.reduce((sum,component)=>sum+component.weight,0)*100;
+  return Math.round(Math.max(0,Math.min(readiness==='blocked'?35:100,score)));
+}
+
+function admissionAction(slice,readiness,components,testResult){
+  if(readiness==='blocked'||(testResult?.summary?.failed??0)>0||components.semanticSelection.score===0||components.sourceFreshness.score===0)return'reject';
+  if(readiness!=='ready'||slice?.mergeAdmission?.reviewRequired||Object.values(components).some((component)=>component.score<70))return'prioritize';
+  return'admit';
+}
+
+function admissionRisk(readiness,components,testResult){
+  if(readiness==='blocked'||(testResult?.summary?.failed??0)>0)return'high';
+  if(readiness==='needs-review'||Object.values(components).some((component)=>component.score<60))return'medium';
+  return'low';
+}
+
+function admissionPriority(action,risk,readiness){
+  if(action==='reject')return'blocker';
+  if(readiness==='needs-review'||risk==='medium')return'high';
+  return action==='prioritize'?'normal':'low';
+}
+
+function mergeScoreSortKey(value,action,risk,readiness){
+  return value+(actionRank[action]??0)*1000+(riskRank[risk]??0)*100+(readinessRank[readiness]??0)*10;
+}
+
+function worstReadiness(...values){
+  return values.reduce((current,value)=>maxSemanticMergeReadiness(current,value??'ready'),'ready');
+}

package/dist/language-adapter-package-contracts.js

@@ -24,12 +24,12 @@ const packageRows = [
   row('@shapeshift-labs/frontier-lang-rust', '0.2.8', 'rust', 'rust-syn', { target: 'rust', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'macroExpansionEvidence'] }),
   row('@shapeshift-labs/frontier-lang-python', '0.2.8', 'python', 'python-ast', { target: 'python', formats: ['python-ast', 'libcst'] }),
   row('@shapeshift-labs/frontier-lang-c', '0.2.8', 'c', 'clang-ast-json', { target: 'c', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'compileCommandsHash', 'preprocessorRecordsHash'] }),
-  platform('@shapeshift-labs/frontier-lang-java', '0.1.5', 'java', 'java-ast', ['semanticdb', 'lsp']),
-  platform('@shapeshift-labs/frontier-lang-kotlin', '0.1.5', 'kotlin', 'kotlin-psi', ['semanticdb', 'lsp']),
-  platform('@shapeshift-labs/frontier-lang-swift', '0.1.5', 'swift', 'swift-syntax', ['sourcekit-lsp', 'lsp']),
-  platform('@shapeshift-labs/frontier-lang-csharp', '0.1.5', 'csharp', 'roslyn-csharp', ['lsp']),
-  platform('@shapeshift-labs/frontier-lang-go', '0.1.5', 'go', 'go-ast', ['lsp']),
-  platform('@shapeshift-labs/frontier-lang-clang', '0.1.5', 'c', 'clang-ast-json', ['lsp'], {
+  platform('@shapeshift-labs/frontier-lang-java', '0.1.6', 'java', 'java-ast', ['semanticdb', 'lsp']),
+  platform('@shapeshift-labs/frontier-lang-kotlin', '0.1.6', 'kotlin', 'kotlin-psi', ['semanticdb', 'lsp']),
+  platform('@shapeshift-labs/frontier-lang-swift', '0.1.6', 'swift', 'swift-syntax', ['sourcekit-lsp', 'lsp']),
+  platform('@shapeshift-labs/frontier-lang-csharp', '0.1.6', 'csharp', 'roslyn-csharp', ['lsp']),
+  platform('@shapeshift-labs/frontier-lang-go', '0.1.6', 'go', 'go-ast', ['lsp']),
+  platform('@shapeshift-labs/frontier-lang-clang', '0.1.6', 'c', 'clang-ast-json', ['lsp'], {
     supportedLanguages: ['c', 'cpp'],
     proofKeys: ['parserAst', 'semanticIndex', 'compileCommandsHash', 'preprocessorRecordsHash']
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.46",
+  "version": "0.2.48",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",