@shapeshift-labs/frontier-lang-compiler 0.2.73 → 0.2.75

package/README.md

@@ -418,6 +418,38 @@ console.log(querySemanticHistoryRecordOverlaps([left, right])[0].conflict); // t
 
 The record stores base/target hashes, source and import IDs, ownership-region keys, semantic candidate IDs and conflict keys, evidence/proof IDs, reviewer and admission status, plus replay links. Overlap queries compare those compact indexes directly, so centralized and distributed swarms can find shared regions, stale-base conflicts, and replay targets without loading source text.
 
+Resolve old semantic anchors through move/rename/split/delete lineage before a coordinator decides whether a worker bundle still touches the current code shape:
+
+```js
+import {
+  createSemanticLineageEvent,
+  createSemanticLineageMap,
+  resolveSemanticLineage
+} from '@shapeshift-labs/frontier-lang-compiler';
+
+const lineage = createSemanticLineageMap([
+  createSemanticLineageEvent({
+    eventKind: 'moved',
+    from: { key: 'source#src/runtime.ts#function#step' },
+    to: { key: 'source#src/runtime-core.ts#function#step' },
+    evidenceIds: ['evidence_source_scan']
+  }),
+  createSemanticLineageEvent({
+    eventKind: 'renamed',
+    from: { key: 'source#src/runtime-core.ts#function#step' },
+    to: { key: 'source#src/runtime-core.ts#function#advance' }
+  })
+]);
+
+const resolution = resolveSemanticLineage(lineage, 'source#src/runtime.ts#function#step');
+
+console.log(resolution.status); // "resolved"
+console.log(resolution.currentAnchors[0].key); // current semantic anchor
+console.log(resolution.traversedEventIds); // compact history path
+```
+
+Resolver output is merge-admission evidence: it helps a swarm compare old worker bundles against current semantic anchors after code moved, split, or was deleted. It is not proof that the projected code is correct or semantically equivalent; admission still needs tests, source evidence, review status, and conflict scoring.
+
 Extract a surgical semantic slice when a worker only needs one symbol, region, native AST node, or source path:
 
 ```js

package/bench/native-transform-suite.mjs

@@ -2,12 +2,15 @@ import { performance } from 'node:perf_hooks';
 import {
   compileNativeSource,
   createNativeSourcePreservation,
+  createSemanticLineageEvent,
+  createSemanticLineageMap,
   createSemanticImportSidecar,
   createSemanticSlice,
   createSemanticSliceAdmissionRecord,
   createUniversalConversionArtifacts,
   createUniversalConversionPlan,
   projectNativeImportToSource,
+  resolveSemanticLineageBatch,
   summarizeNativeImportFeatureEvidence,
   testSemanticSlice
 } from '../dist/index.js';
@@ -59,6 +62,36 @@ export function measureNativeTransformations(nativeImportResults) {
   const conversionArtifacts = createUniversalConversionArtifacts(conversionPlan);
   const conversionArtifactsDurationMs = performance.now() - conversionArtifactsStart;
 
+  const lineageResolutionStart = performance.now();
+  const lineageEvents = [];
+  const lineageQueries = [];
+  for (let index = 0; index < 100; index += 1) {
+    const fromKey = `bench#lineage#${index}#0`;
+    const midKey = `bench#lineage#${index}#1`;
+    const targetKey = `bench#lineage#${index}#2`;
+    lineageQueries.push(fromKey);
+    lineageEvents.push(createSemanticLineageEvent({
+      id: `bench_lineage_${index}_move`,
+      createdAt: index * 2,
+      eventKind: 'moved',
+      from: { key: fromKey, sourcePath: `src/${index}.ts` },
+      to: { key: midKey, sourcePath: `src/runtime/${index}.ts` },
+      confidence: 0.96
+    }));
+    lineageEvents.push(createSemanticLineageEvent({
+      id: `bench_lineage_${index}_rename`,
+      createdAt: index * 2 + 1,
+      eventKind: index % 10 === 0 ? 'split' : 'renamed',
+      from: { key: midKey, sourcePath: `src/runtime/${index}.ts` },
+      to: index % 10 === 0
+        ? [{ key: `${targetKey}:a` }, { key: `${targetKey}:b` }]
+        : { key: targetKey, sourcePath: `src/runtime/${index}.ts` },
+      confidence: 0.91
+    }));
+  }
+  const lineageResolutions = resolveSemanticLineageBatch(createSemanticLineageMap(lineageEvents), lineageQueries);
+  const lineageResolutionDurationMs = performance.now() - lineageResolutionStart;
+
   const featureEvidenceStart = performance.now();
   const featureEvidenceSummaries = nativeImportResults.map((imported) => summarizeNativeImportFeatureEvidence(imported.losses, {
     evidence: imported.evidence
@@ -112,6 +145,10 @@ export function measureNativeTransformations(nativeImportResults) {
     conversionArtifactAdmissionEvidenceIds: conversionArtifacts.summary.evidenceIds,
     conversionArtifactAdmissionProofIds: conversionArtifacts.summary.proofIds,
     conversionArtifactsDurationMs,
+    lineageResolutionEvents: lineageEvents.length,
+    lineageResolutions: lineageResolutions.length,
+    lineageResolutionAmbiguous: lineageResolutions.filter((result) => result.status === 'ambiguous').length,
+    lineageResolutionDurationMs,
     featureEvidencePolicyMatches,
     featureEvidenceDurationMs,
     nativeProjections: nativeProjections.length,

package/bench/smoke.mjs

@@ -82,6 +82,10 @@ console.log(JSON.stringify({
   conversionArtifactAdmissionEvidenceIds: transformMetrics.conversionArtifactAdmissionEvidenceIds,
   conversionArtifactAdmissionProofIds: transformMetrics.conversionArtifactAdmissionProofIds,
   conversionArtifactsDurationMs: Number(transformMetrics.conversionArtifactsDurationMs.toFixed(2)),
+  lineageResolutionEvents: transformMetrics.lineageResolutionEvents,
+  lineageResolutions: transformMetrics.lineageResolutions,
+  lineageResolutionAmbiguous: transformMetrics.lineageResolutionAmbiguous,
+  lineageResolutionDurationMs: Number(transformMetrics.lineageResolutionDurationMs.toFixed(2)),
   featureEvidencePolicyMatches: transformMetrics.featureEvidencePolicyMatches,
   featureEvidenceDurationMs: Number(transformMetrics.featureEvidenceDurationMs.toFixed(2)),
   nativeProjections: transformMetrics.nativeProjections,

package/dist/declarations/semantic-lineage.d.ts

@@ -1,6 +1,7 @@
 import type { FrontierSourceLanguage, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
 
 export type SemanticLineageEventKind = 'unchanged' | 'moved' | 'renamed' | 'split' | 'merged' | 'deleted' | 'recreated' | 'unknown' | string;
+export type SemanticLineageResolutionStatus = 'unchanged' | 'resolved' | 'ambiguous' | 'deleted' | 'recreated' | 'cycle' | 'max-depth' | 'not-found' | string;
 
 export interface SemanticAnchor {
   readonly id?: string;
@@ -126,6 +127,50 @@ export interface SemanticLineageMap {
   };
 }
 
+export interface SemanticLineageResolutionQuery {
+  readonly id?: string;
+  readonly anchor?: SemanticAnchor | string;
+  readonly anchorKey?: string;
+  readonly key?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly maxDepth?: number;
+  readonly generatedAt?: number | string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticLineageResolution {
+  readonly kind: 'frontier.lang.semanticLineageResolution';
+  readonly version: 1;
+  readonly id: string;
+  readonly stableId: string;
+  readonly hash: string;
+  readonly generatedAt: number | string;
+  readonly query: {
+    readonly anchorKey?: string;
+    readonly anchorId?: string;
+    readonly sourcePath?: string;
+    readonly symbolName?: string;
+    readonly maxDepth?: number;
+  };
+  readonly startAnchor?: SemanticAnchor;
+  readonly currentAnchors: readonly SemanticAnchor[];
+  readonly traversedEventIds: readonly string[];
+  readonly terminalEventIds: readonly string[];
+  readonly status: SemanticLineageResolutionStatus;
+  readonly confidence?: number;
+  readonly conflictKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly crdtOperationIds: readonly string[];
+  readonly crdtHeads: readonly string[];
+  readonly lineageEventKinds: readonly SemanticLineageEventKind[];
+  readonly reasonCodes: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
 export interface SemanticLineageQuery {
   readonly eventKind?: SemanticLineageEventKind | readonly string[];
   readonly anchorKey?: string | readonly string[];
@@ -139,7 +184,10 @@ export interface SemanticLineageQuery {
 }
 
 export declare const SemanticLineageEventKinds: readonly SemanticLineageEventKind[];
+export declare const SemanticLineageResolutionStatuses: readonly SemanticLineageResolutionStatus[];
 export declare function createSemanticAnchor(input?: SemanticAnchor | string, defaults?: Partial<SemanticAnchor>): SemanticAnchor | undefined;
 export declare function createSemanticLineageEvent(input?: CreateSemanticLineageEventInput, options?: { readonly id?: string; readonly createdAt?: number | string; readonly actor?: SemanticLineageActor | string; readonly actorId?: string; readonly actorRole?: string }): SemanticLineageEvent;
 export declare function createSemanticLineageMap(events?: readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], options?: { readonly id?: string; readonly generatedAt?: number | string }): SemanticLineageMap;
 export declare function querySemanticLineageEvents(events: SemanticLineageEvent | readonly SemanticLineageEvent[], query?: SemanticLineageQuery): readonly SemanticLineageEvent[];
+export declare function resolveSemanticLineage(eventsOrMap?: SemanticLineageMap | readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], query?: SemanticLineageResolutionQuery | SemanticAnchor | string, options?: { readonly id?: string; readonly generatedAt?: number | string; readonly maxDepth?: number; readonly metadata?: Record<string, unknown> }): SemanticLineageResolution;
+export declare function resolveSemanticLineageBatch(eventsOrMap?: SemanticLineageMap | readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], queries?: readonly (SemanticLineageResolutionQuery | SemanticAnchor | string)[], options?: { readonly generatedAt?: number | string; readonly maxDepth?: number; readonly metadata?: Record<string, unknown> }): readonly SemanticLineageResolution[];

package/dist/index.js

@@ -69,6 +69,7 @@ export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandi
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';
 export { queryUniversalConversionPlan } from './internal/index-impl/queryUniversalConversionPlan.js';
 export { createSemanticAnchor, createSemanticLineageEvent, createSemanticLineageMap, querySemanticLineageEvents, SemanticLineageEventKinds } from './internal/index-impl/semanticLineageRecords.js';
+export { resolveSemanticLineage, resolveSemanticLineageBatch, SemanticLineageResolutionStatuses } from './internal/index-impl/semanticLineageResolutionRecords.js';
 export { createSemanticHistoryRecord, querySemanticHistoryRecordOverlaps, SemanticHistoryAdmissionStatuses, SemanticHistoryConflictReasons, SemanticHistoryOverlapKinds, SemanticHistoryReviewerStatuses, semanticHistoryRecordsConflict, semanticHistoryRecordsOverlap } from './internal/index-impl/semanticHistoryRecords.js';
 export { readSemanticSliceJson } from './internal/index-impl/readSemanticSliceJson.js';
 export { readUniversalAstJson } from './internal/index-impl/readUniversalAstJson.js';

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

@@ -0,0 +1,195 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings as uniqueRawStrings } from '../../native-import-utils.js';
+import { createSemanticAnchor, createSemanticLineageEvent } from './semanticLineageRecords.js';
+
+export const SemanticLineageResolutionStatuses = Object.freeze(['unchanged', 'resolved', 'ambiguous', 'deleted', 'recreated', 'cycle', 'max-depth', 'not-found']);
+
+export function resolveSemanticLineage(eventsOrMap = [], query = {}, options = {}) {
+  const events = lineageEventsFrom(eventsOrMap);
+  const resolutionQuery = normalizeResolutionQuery(query);
+  const start = createSemanticAnchor(resolutionQuery.anchor ?? resolutionQuery.anchorKey ?? resolutionQuery.key ?? resolutionQuery, resolutionQuery);
+  const maxDepth = positiveInteger(resolutionQuery.maxDepth ?? options.maxDepth, 64);
+  const byFromKey = new Map();
+  const byFromId = new Map();
+  for (const event of events.slice().sort(compareLineageEvents)) {
+    indexLineageEvent(byFromKey, event.from?.key, event);
+    indexLineageEvent(byFromId, event.from?.id, event);
+  }
+  const state = createResolutionState(start);
+  const visitedEvents = new Set();
+  const visitedStates = new Set([anchorStateKey(state.current)]);
+  for (let depth = 0; depth < maxDepth; depth += 1) {
+    const nextEvents = nextLineageEvents(state.current, byFromKey, byFromId).filter((event) => !visitedEvents.has(event.id));
+    if (nextEvents.length === 0) break;
+    for (const event of nextEvents) applyLineageEvent(state, event, visitedEvents);
+    const key = anchorStateKey(state.current);
+    if (visitedStates.has(key) && key) {
+      state.cycle = true;
+      state.status = 'cycle';
+      state.reasonCodes.push('lineage-cycle');
+      break;
+    }
+    visitedStates.add(key);
+  }
+  if (resolutionHitMaxDepth(state, maxDepth, byFromKey, byFromId, visitedEvents)) {
+    state.maxDepthHit = true;
+    state.status = 'max-depth';
+    state.reasonCodes.push('max-depth');
+  }
+  if (!state.cycle && !state.maxDepthHit) state.status = classifyResolutionStatus(state);
+  return buildResolutionRecord(state, start, maxDepth, resolutionQuery, options);
+}
+
+export function resolveSemanticLineageBatch(eventsOrMap = [], queries = [], options = {}) {
+  return array(queries).map((query) => resolveSemanticLineage(eventsOrMap, query, options));
+}
+
+function createResolutionState(start) {
+  return {
+    current: start ? [start] : [],
+    traversed: [],
+    terminal: [],
+    conflictKeys: [],
+    evidenceIds: [],
+    proofIds: [],
+    operationIds: [],
+    heads: [],
+    eventKinds: [],
+    reasonCodes: [],
+    confidence: start ? 1 : undefined,
+    status: start ? 'unchanged' : 'not-found',
+    cycle: false,
+    maxDepthHit: false
+  };
+}
+
+function buildResolutionRecord(state, start, maxDepth, query, options) {
+  const core = {
+    kind: 'frontier.lang.semanticLineageResolution',
+    version: 1,
+    query: compactRecord({ anchorKey: start?.key, anchorId: start?.id, sourcePath: start?.sourcePath, symbolName: start?.symbolName, maxDepth }),
+    startAnchor: start,
+    currentAnchors: uniqueAnchors(state.current),
+    traversedEventIds: uniqueStrings(state.traversed),
+    terminalEventIds: uniqueStrings(state.terminal),
+    status: state.status,
+    confidence: clampConfidence(state.confidence),
+    conflictKeys: uniqueStrings(state.conflictKeys),
+    evidenceIds: uniqueStrings(state.evidenceIds),
+    proofIds: uniqueStrings(state.proofIds),
+    crdtOperationIds: uniqueStrings(state.operationIds),
+    crdtHeads: uniqueStrings(state.heads),
+    lineageEventKinds: uniqueStrings(state.eventKinds),
+    reasonCodes: uniqueStrings(state.reasonCodes),
+    metadata: compactRecord(options.metadata ?? query.metadata)
+  };
+  const hash = hashSemanticValue(core);
+  return {
+    ...core,
+    id: options.id ?? query.id ?? `semantic_lineage_resolution_${idFragment(firstString(start?.key, start?.id, hash))}`,
+    stableId: `semantic_lineage_resolution_${idFragment(hash)}`,
+    hash,
+    generatedAt: options.generatedAt ?? query.generatedAt ?? Date.now()
+  };
+}
+
+function applyLineageEvent(state, event, visitedEvents) {
+  visitedEvents.add(event.id);
+  state.traversed.push(event.id);
+  state.conflictKeys.push(...(event.conflictKeys ?? []));
+  state.evidenceIds.push(...(event.evidenceIds ?? []));
+  state.proofIds.push(...(event.proofIds ?? []));
+  state.operationIds.push(event.crdt?.operationId);
+  state.heads.push(...(event.crdt?.heads ?? []));
+  state.eventKinds.push(event.eventKind);
+  if (event.confidence !== undefined) state.confidence = state.confidence === undefined ? event.confidence : Math.min(state.confidence, event.confidence);
+  const matched = state.current.filter((anchor) => anchorsMatch(anchor, event.from));
+  const unmatched = state.current.filter((anchor) => !anchorsMatch(anchor, event.from));
+  if (event.eventKind === 'deleted' || event.to.length === 0) {
+    state.current = unmatched;
+    state.terminal.push(event.id);
+    state.reasonCodes.push(event.eventKind === 'deleted' ? 'anchor-deleted' : 'lineage-event-without-target-anchor');
+    return;
+  }
+  state.current = uniqueAnchors([...unmatched, ...event.to]);
+  if (matched.length === 0) state.reasonCodes.push('lineage-event-applied-by-index');
+  if (event.eventKind === 'split' || event.to.length > 1) state.reasonCodes.push('anchor-split');
+  if (event.eventKind === 'merged') state.reasonCodes.push('anchor-merged');
+  if (event.eventKind === 'recreated') state.reasonCodes.push('anchor-recreated');
+}
+
+function lineageEventsFrom(value) {
+  const source = value?.kind === 'frontier.lang.semanticLineageMap' ? value.events : value;
+  return array(source).map((event) => event?.kind === 'frontier.lang.semanticLineageEvent' ? event : createSemanticLineageEvent(event)).filter(Boolean);
+}
+
+function resolutionHitMaxDepth(state, maxDepth, byFromKey, byFromId, visitedEvents) {
+  return !state.cycle && state.traversed.length >= maxDepth && nextLineageEvents(state.current, byFromKey, byFromId).some((event) => !visitedEvents.has(event.id));
+}
+
+function nextLineageEvents(anchors, byFromKey, byFromId) {
+  const records = [];
+  for (const anchor of anchors) {
+    for (const event of byFromKey.get(String(anchor.key ?? '')) ?? []) records.push(event);
+    for (const event of byFromId.get(String(anchor.id ?? '')) ?? []) records.push(event);
+  }
+  return uniqueEvents(records).sort(compareLineageEvents);
+}
+
+function classifyResolutionStatus(state) {
+  if (state.current.length === 0 && state.traversed.length > 0) return 'deleted';
+  if (state.eventKinds.includes('recreated')) return 'recreated';
+  if (state.current.length > 1 || state.eventKinds.includes('split') || state.eventKinds.includes('merged')) return 'ambiguous';
+  if (state.traversed.length > 0) return 'resolved';
+  return 'unchanged';
+}
+
+function indexLineageEvent(index, key, event) {
+  if (!key) return;
+  const value = String(key);
+  if (!index.has(value)) index.set(value, []);
+  index.get(value).push(event);
+}
+
+function normalizeResolutionQuery(query) { return typeof query === 'string' ? { anchorKey: query } : query ?? {}; }
+function anchorsMatch(left, right) { return Boolean(left && right && ((left.key && left.key === right.key) || (left.id && left.id === right.id))); }
+function anchorStateKey(anchors) { return uniqueStrings(anchors.map((anchor) => anchor.key ?? anchor.id)).sort().join('|'); }
+function compareLineageEvents(left, right) { return compareCreatedAt(left.createdAt, right.createdAt) || String(left.id).localeCompare(String(right.id)); }
+function compareCreatedAt(left, right) {
+  const leftNumber = Number(left);
+  const rightNumber = Number(right);
+  if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber) && leftNumber !== rightNumber) return leftNumber - rightNumber;
+  return String(left ?? '').localeCompare(String(right ?? ''));
+}
+function uniqueAnchors(anchors) {
+  const seen = new Set();
+  return anchors.filter(Boolean).filter((anchor) => {
+    const key = anchor.key ?? anchor.id;
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function uniqueEvents(events) {
+  const seen = new Set();
+  return events.filter((event) => {
+    if (!event?.id || seen.has(event.id)) return false;
+    seen.add(event.id);
+    return true;
+  });
+}
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}
+function clampConfidence(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const number = Number(value);
+  if (!Number.isFinite(number)) return undefined;
+  return Math.max(0, Math.min(1, number));
+}
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+function uniqueStrings(values) { return uniqueRawStrings(strings(values)); }
+function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -1,9 +1,9 @@
 const packageRows = [
-  row('@shapeshift-labs/frontier-lang-typescript', '0.3.8', 'typescript', 'typescript-compiler-api', { target: 'typescript' }),
-  row('@shapeshift-labs/frontier-lang-javascript', '0.2.8', 'javascript', 'estree', { target: 'javascript', formats: ['estree', 'babel'] }),
-  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'] }),
+  row('@shapeshift-labs/frontier-lang-typescript', '0.3.9', 'typescript', 'typescript-compiler-api', { target: 'typescript' }),
+  row('@shapeshift-labs/frontier-lang-javascript', '0.2.9', 'javascript', 'estree', { target: 'javascript', formats: ['estree', 'babel'] }),
+  row('@shapeshift-labs/frontier-lang-rust', '0.2.9', 'rust', 'rust-syn', { target: 'rust', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'macroExpansionEvidence'] }),
+  row('@shapeshift-labs/frontier-lang-python', '0.2.9', 'python', 'python-ast', { target: 'python', formats: ['python-ast', 'libcst'] }),
+  row('@shapeshift-labs/frontier-lang-c', '0.2.9', 'c', 'clang-ast-json', { target: 'c', proofKeys: ['parserAst', 'sourceMap', 'semanticSidecar', 'compileCommandsHash', 'preprocessorRecordsHash'] }),
   platform('@shapeshift-labs/frontier-lang-java', '0.1.8', 'java', 'java-ast', ['semanticdb', 'lsp']),
   platform('@shapeshift-labs/frontier-lang-kotlin', '0.1.8', 'kotlin', 'kotlin-psi', ['semanticdb', 'lsp']),
   platform('@shapeshift-labs/frontier-lang-swift', '0.1.8', 'swift', 'swift-syntax', ['sourcekit-lsp', 'lsp']),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.73",
+  "version": "0.2.75",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -61,14 +61,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@shapeshift-labs/frontier-lang-c": "0.2.8",
-    "@shapeshift-labs/frontier-lang-checker": "0.3.7",
-    "@shapeshift-labs/frontier-lang-javascript": "0.2.8",
+    "@shapeshift-labs/frontier-lang-c": "0.2.9",
+    "@shapeshift-labs/frontier-lang-checker": "0.3.8",
+    "@shapeshift-labs/frontier-lang-javascript": "0.2.9",
     "@shapeshift-labs/frontier-lang-kernel": "0.3.12",
-    "@shapeshift-labs/frontier-lang-parser": "0.3.7",
-    "@shapeshift-labs/frontier-lang-python": "0.2.8",
-    "@shapeshift-labs/frontier-lang-rust": "0.2.8",
-    "@shapeshift-labs/frontier-lang-typescript": "0.3.8"
+    "@shapeshift-labs/frontier-lang-parser": "0.3.8",
+    "@shapeshift-labs/frontier-lang-python": "0.2.9",
+    "@shapeshift-labs/frontier-lang-rust": "0.2.9",
+    "@shapeshift-labs/frontier-lang-typescript": "0.3.9"
   },
   "devDependencies": {
     "typescript": "^5.9.3"