@shapeshift-labs/frontier-lang-compiler 0.2.111 → 0.2.113

package/README.md

@@ -198,6 +198,7 @@ import { safeMergeJsTsProject } from '@shapeshift-labs/frontier-lang-compiler';
 
 const project = safeMergeJsTsProject({
   language: 'typescript',
+  moduleResolution: { baseUrl: '.', paths: { '@app/*': ['src/*'] } },
   baseFiles: { 'src/index.ts': 'export const stable = 1;\n' },
   workerFiles: { 'src/index.ts': 'export const stable = 1;\nexport const workerOnly = 1;\n' },
   headFiles: { 'src/index.ts': 'export const stable = 1;\n' }
@@ -208,6 +209,35 @@ console.log(project.outputFiles[0].sourcePath); // "src/index.ts"
 console.log(project.files[0].semanticArtifacts.status); // "verified"
 ```
 
+When `includeOutputProjectSymbolGraph` is enabled, the same
+`moduleResolution` shape is used for output graph artifacts. Resolution is
+runtime-neutral: `baseUrl`, `paths`, `aliases`, and `compilerOptions.paths`
+are matched against the supplied project files, not the host filesystem.
+Bare package imports also get explicit package identity. If `packages` is
+provided, package export maps can resolve back to supplied workspace sources
+and record the selected export condition:
+
+```js
+const project = safeMergeJsTsProject({
+  includeOutputProjectSymbolGraph: true,
+  moduleResolution: {
+    packages: {
+      '@pkg/core': {
+        root: 'packages/core',
+        exports: { './utils': { import: './src/utils.ts', default: './dist/utils.js' } }
+      }
+    },
+    packageExportConditions: ['import', 'default']
+  },
+  baseFiles,
+  workerFiles,
+  headFiles
+});
+
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageName); // "@pkg/core"
+console.log(project.outputProjectSymbolGraph.importEdges[0].packageExportCondition); // "import"
+```
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js
@@ -817,6 +847,7 @@ const imported = await runNativeImporterAdapter(babelAdapter, {
 
 const project = await importNativeProject({
   projectRoot: 'src',
+  moduleResolution: { baseUrl: '.', paths: { '@app/*': ['src/*'] } },
   adapters: [babelAdapter, pythonAstAdapter, rustSynAdapter, clangAstAdapter, goAstAdapter, javaAstAdapter, kotlinPsiAdapter, csharpRoslynAdapter, swiftSyntaxAdapter],
   sources: [
     { language: 'typescript', adapter: babelAdapter.id, sourcePath: 'src/todo.ts', sourceText },

package/dist/declarations/js-ts-safe-project-merge.d.ts

@@ -8,6 +8,7 @@ import type {
 } from './js-ts-safe-merge.js';
 import type { JsTsSafeMemberMergePolicy, JsTsSafeMemberMergePolicyRegion } from './js-ts-safe-member-merge.js';
 import type { NativeProjectImportResult, NativeProjectSymbolGraphSummary } from './native-project.js';
+import type { NativeProjectModuleResolutionOptions } from './native-project-module-resolution.js';
 
 export type JsTsProjectSafeMergeStatus = 'merged' | 'blocked';
 export type JsTsProjectSafeMergeFileStatus = 'merged' | 'blocked';
@@ -55,6 +56,8 @@ export interface JsTsProjectSafeMergeInput {
   readonly allowFileAdditions?: boolean;
   readonly allowFileDeletes?: boolean;
   readonly includeOutputProjectSymbolGraph?: boolean;
+  readonly moduleResolution?: NativeProjectModuleResolutionOptions;
+  readonly tsconfig?: NativeProjectModuleResolutionOptions;
   readonly workerChangeSetId?: string;
   readonly headChangeSetId?: string;
   readonly policy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];

package/dist/declarations/native-project-module-resolution.d.ts

@@ -0,0 +1,28 @@
+export type NativeProjectModuleResolutionPaths = Readonly<Record<string, readonly string[] | string>>;
+export type NativeProjectPackageExportTarget = string | readonly string[] | NativeProjectPackageConditionalExports;
+export type NativeProjectPackageExports = NativeProjectPackageExportTarget | Readonly<Record<string, NativeProjectPackageExportTarget>>;
+
+export interface NativeProjectPackageConditionalExports {
+  readonly [condition: string]: NativeProjectPackageExportTarget;
+}
+
+export interface NativeProjectPackageResolutionOptions {
+  readonly root?: string;
+  readonly sourceRoot?: string;
+  readonly main?: string;
+  readonly types?: string;
+  readonly exports?: NativeProjectPackageExports;
+}
+
+export interface NativeProjectModuleResolutionOptions {
+  readonly baseUrl?: string;
+  readonly paths?: NativeProjectModuleResolutionPaths;
+  readonly aliases?: NativeProjectModuleResolutionPaths;
+  readonly packages?: Readonly<Record<string, NativeProjectPackageResolutionOptions>>;
+  readonly conditions?: readonly string[];
+  readonly packageExportConditions?: readonly string[];
+  readonly compilerOptions?: {
+    readonly baseUrl?: string;
+    readonly paths?: NativeProjectModuleResolutionPaths;
+  };
+}

package/dist/declarations/native-project.d.ts

@@ -49,11 +49,11 @@ import type { JavaScriptNativeImporterAdapterOptions, TypeScriptCompilerNativeIm
 import type { JavaAstNativeImporterAdapterOptions, KotlinPsiNativeImporterAdapterOptions, CSharpRoslynNativeImporterAdapterOptions, SwiftSyntaxNativeImporterAdapterOptions, TreeSitterNativeImporterAdapterOptions } from './import-adapter-options-platform.js';
 import type { NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
 import type { NativeImportRoundtripReadinessStatus, NativeImportRoundtripReadinessOptions, NativeImportRoundtripReadinessClassification } from './roundtrip.js';
+import type { NativeProjectModuleResolutionOptions } from './native-project-module-resolution.js';
 
 export interface NativeProjectSourceInput extends ImportNativeSourceOptions {
   readonly adapter?: NativeImporterAdapter | string;
-  readonly adapterOptions?: Record<string, unknown>;
-  readonly adapterMetadata?: Record<string, unknown>;
+  readonly adapterOptions?: Record<string, unknown>; readonly adapterMetadata?: Record<string, unknown>;
 }
 
 export interface ImportNativeProjectOptions {
@@ -70,17 +70,15 @@ export interface ImportNativeProjectOptions {
   readonly patchId?: string;
   readonly author?: string;
   readonly metadata?: Record<string, unknown>;
-  readonly adapterOptions?: Record<string, unknown>;
-  readonly adapterMetadata?: Record<string, unknown>;
+  readonly moduleResolution?: NativeProjectModuleResolutionOptions;
+  readonly tsconfig?: NativeProjectModuleResolutionOptions;
+  readonly adapterOptions?: Record<string, unknown>; readonly adapterMetadata?: Record<string, unknown>;
   readonly adapters?: readonly NativeImporterAdapter[];
   readonly adapterResolver?: (source: NativeProjectSourceInput, adapters: readonly NativeImporterAdapter[]) => NativeImporterAdapter | undefined;
   readonly sources: readonly NativeProjectSourceInput[];
 }
 
 export type NativeProjectSymbolGraphRemainingField =
-  | 'moduleEdges[].resolutionKind'
-  | 'moduleEdges[].packageName'
-  | 'moduleEdges[].packageExportCondition'
   | 'reExportIdentities[].originSymbolId'
   | 'reExportIdentities[].exportedSymbolId'
   | 'reExportIdentities[].localSymbolId'
@@ -112,13 +110,15 @@ export interface NativeProjectSymbolGraphModuleEdgeRecord {
   readonly resolvedModulePath?: string;
   readonly targetDocumentId?: string;
   readonly resolvedTargetSymbolId?: string;
-  readonly resolutionKind?: 'relative-source' | 'relative-missing' | string;
+  readonly resolutionKind?: 'relative-source' | 'relative-missing' | 'alias-source' | 'alias-missing' | 'path-alias-source' | 'path-alias-missing' | 'base-url-source' | 'base-url-missing' | 'package-source' | 'package-missing' | 'package-external' | string;
+  readonly packageName?: string;
+  readonly packageSubpath?: string;
+  readonly packageExportCondition?: string;
   readonly importKind?: string;
   readonly exportKind?: string;
   readonly importedName?: string;
   readonly exportedName?: string;
-  readonly localName?: string;
-  readonly namespace?: string;
+  readonly localName?: string; readonly namespace?: string;
   readonly isTypeOnly?: boolean;
   readonly isReExport?: boolean;
   readonly publicContract?: boolean;

package/dist/index.d.ts

@@ -40,6 +40,7 @@ export * from './declarations/import-adapter-options-native.js';
 export * from './declarations/import-adapter-options-platform.js';
 export * from './declarations/target-adapters.js';
 export * from './declarations/native-project-admission.js';
+export * from './declarations/native-project-module-resolution.js';
 export * from './declarations/native-project.js';
 export * from './declarations/roundtrip.js';
 export * from './declarations/runtime.js';

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

@@ -1,6 +1,6 @@
 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';
-import{createProjectModuleSymbolResolver,resolveRelativeProjectModule}from'./projectSymbolGraphModuleResolution.js';
+import{createProjectModuleSymbolResolver,resolveProjectModule}from'./projectSymbolGraphModuleResolution.js';
 export function createNativeProjectImportResult(input, imports) {
   const idPart = idFragment(input.id ?? input.projectRoot ?? 'native_project');
   const nodes = {};
@@ -141,9 +141,6 @@ export function createNativeProjectImportResult(input, imports) {
 }
 
 const PROJECT_SYMBOL_GRAPH_REMAINING_FIELDS = Object.freeze([
-  'moduleEdges[].resolutionKind',
-  'moduleEdges[].packageName',
-  'moduleEdges[].packageExportCondition',
   'reExportIdentities[].originSymbolId',
   'reExportIdentities[].exportedSymbolId',
   'reExportIdentities[].localSymbolId',
@@ -157,6 +154,7 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const symbolsById = new Map((semanticIndex?.symbols ?? []).map((symbol) => [symbol.id, symbol]));
   const documentsById = new Map(documents.map((document) => [document.id, document]));
   const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
+  const moduleResolution = input.moduleResolution ?? input.tsconfig;
   const resolveTargetSymbolId = createProjectModuleSymbolResolver(semanticIndex?.symbols ?? [], documents);
   const facts = semanticIndex?.facts ?? [];
   const moduleEdgeFacts = facts.filter((fact) => fact.predicate === 'moduleEdge');
@@ -164,10 +162,10 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   const relations = semanticIndex?.relations ?? [];
   const importEdges = relations
     .filter((relation) => relation.predicate === 'imports')
-    .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, resolveTargetSymbolId));
+    .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, moduleResolution, resolveTargetSymbolId));
   const exportEdges = relations
     .filter((relation) => relation.predicate === 'exports')
-    .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, resolveTargetSymbolId));
+    .map((relation) => moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, moduleResolution, resolveTargetSymbolId));
   const reExportIdentities = uniqueRecords([
     ...facts
       .filter((fact) => fact.predicate === 'reExportIdentity' && fact.value)
@@ -213,7 +211,7 @@ function createProjectSymbolGraphSummary(semanticIndex, imports, input) {
   };
 }
 
-function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, resolveTargetSymbolId) {
+function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documentsById, documentsByPath, moduleResolution, resolveTargetSymbolId) {
   const fact = moduleEdgeByRelation.get(relation.id);
   const value = objectValue(fact?.value);
   const metadata = objectValue(relation.metadata);
@@ -231,7 +229,7 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     symbolMetadata.source,
     symbol?.kind === 'module' ? symbol.name : undefined
   );
-  const resolution = resolveRelativeProjectModule(document?.path, moduleSpecifier, documentsByPath);
+  const resolution = resolveProjectModule(document?.path, moduleSpecifier, documentsByPath, moduleResolution);
   const record = {
     id: relation.id,
     sourceDocumentId: relation.sourceId,
@@ -244,6 +242,9 @@ function moduleEdgeRecord(relation, moduleEdgeByRelation, symbolsById, documents
     resolvedModulePath: resolution?.path,
     targetDocumentId: resolution?.documentId,
     resolutionKind: resolution?.kind,
+    packageName: resolution?.packageName,
+    packageSubpath: resolution?.packageSubpath,
+    packageExportCondition: resolution?.packageExportCondition,
     importKind: firstString(moduleEdge.importKind, value.importKind, symbolMetadata.importKind),
     exportKind: firstString(moduleEdge.exportKind, value.exportKind, symbolMetadata.exportKind),
     importedName: firstString(moduleEdge.importedName, value.importedName, symbolMetadata.importedName),

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

@@ -10,6 +10,12 @@ export function resolveRelativeProjectModule(sourcePath, moduleSpecifier, docume
   };
 }
 
+export function resolveProjectModule(sourcePath, moduleSpecifier, documentsByPath, moduleResolution) {
+  if (!sourcePath || !moduleSpecifier) return undefined;
+  if (String(moduleSpecifier).startsWith('.')) return resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath);
+  return resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution);
+}
+
 export function createProjectModuleSymbolResolver(symbols, documents) {
   const documentsByPath = new Map(documents.filter((document) => document.path).map((document) => [document.path, document]));
   const exportedByDocumentAndName = new Map();
@@ -27,6 +33,115 @@ export function createProjectModuleSymbolResolver(symbols, documents) {
   };
 }
 
+function resolveConfiguredProjectModule(moduleSpecifier, documentsByPath, moduleResolution) {
+  const packageInfo = packageSpecifierInfo(moduleSpecifier);
+  const candidates = configuredModuleCandidates(moduleSpecifier, moduleResolution, packageInfo);
+  let firstMissing;
+  for (const candidate of candidates) {
+    const target = moduleTargetDocument(candidate.path, documentsByPath);
+    const packageFields = packageResolutionFields(candidate, packageInfo);
+    if (target) return { path: target.path, documentId: target.id, kind: `${candidate.kind}-source`, ...packageFields };
+    firstMissing ??= { path: candidate.path, kind: `${candidate.kind}-missing`, ...packageFields };
+  }
+  return firstMissing ?? (packageInfo ? { kind: 'package-external', ...packageInfo } : undefined);
+}
+
+function configuredModuleCandidates(moduleSpecifier, moduleResolution = {}, packageInfo) {
+  const compilerOptions = moduleResolution.compilerOptions ?? {};
+  const baseUrl = normalizeProjectPath(moduleResolution.baseUrl ?? compilerOptions.baseUrl ?? '');
+  return uniquePaths([
+    ...aliasCandidates(moduleSpecifier, moduleResolution.aliases, 'alias', baseUrl),
+    ...aliasCandidates(moduleSpecifier, moduleResolution.paths ?? compilerOptions.paths, 'path-alias', baseUrl),
+    ...packageCandidates(packageInfo, moduleResolution),
+    ...baseUrlCandidates(moduleSpecifier, baseUrl)
+  ]);
+}
+
+function aliasCandidates(moduleSpecifier, aliases, kind, baseUrl) {
+  return Object.entries(aliases ?? {}).flatMap(([pattern, targetPatterns]) => {
+    const capture = patternCapture(moduleSpecifier, pattern);
+    if (capture === undefined) return [];
+    const targets = Array.isArray(targetPatterns) ? targetPatterns : [targetPatterns];
+    return targets.map((targetPattern) => ({
+      kind,
+      path: normalizeProjectPath(joinProjectPath(baseUrl, String(targetPattern).replace('*', capture)))
+    }));
+  });
+}
+
+function baseUrlCandidates(moduleSpecifier, baseUrl) {
+  if (!baseUrl || String(moduleSpecifier).startsWith('@')) return [];
+  return [{ kind: 'base-url', path: normalizeProjectPath(joinProjectPath(baseUrl, moduleSpecifier)) }];
+}
+
+function packageCandidates(packageInfo, moduleResolution = {}) {
+  if (!packageInfo) return [];
+  const options = moduleResolution.packages?.[packageInfo.packageName];
+  if (!options) return [];
+  const root = normalizeProjectPath(options.root ?? '');
+  const subpath = packageInfo.packageSubpath === '.' ? '' : packageInfo.packageSubpath.slice(2);
+  return uniquePaths([
+    ...packageExportCandidates(packageInfo, options, moduleResolution).map((candidate) => ({
+      ...candidate,
+      path: normalizeProjectPath(joinProjectPath(root, candidate.path))
+    })),
+    ...packageFallbackTargets(options, subpath).map((path) => ({
+      kind: 'package',
+      path: normalizeProjectPath(joinProjectPath(root, path)),
+      ...packageInfo
+    }))
+  ]);
+}
+
+function packageExportCandidates(packageInfo, options, moduleResolution) {
+  const targets = packageExportTargets(options.exports, packageInfo.packageSubpath, packageConditions(moduleResolution));
+  return targets.map((target) => ({
+    kind: 'package',
+    path: target.path,
+    packageExportCondition: target.condition,
+    ...packageInfo
+  }));
+}
+
+function packageExportTargets(exportsValue, subpath, conditions) {
+  if (!exportsValue) return [];
+  return exportTargetsForValue(exportMapValue(exportsValue, subpath), conditions);
+}
+
+function exportMapValue(exportsValue, subpath) {
+  if (!isRecord(exportsValue) || !Object.keys(exportsValue).some((key) => key.startsWith('.'))) return subpath === '.' ? exportsValue : undefined;
+  return exportsValue[subpath] ?? patternExportMapValue(exportsValue, subpath);
+}
+
+function patternExportMapValue(exportsValue, subpath) {
+  for (const [pattern, target] of Object.entries(exportsValue)) {
+    const capture = patternCapture(subpath, pattern);
+    if (capture !== undefined) return replaceExportTargetCapture(target, capture);
+  }
+  return undefined;
+}
+
+function replaceExportTargetCapture(target, capture) {
+  if (typeof target === 'string') return target.replace('*', capture);
+  if (Array.isArray(target)) return target.map((entry) => replaceExportTargetCapture(entry, capture));
+  if (!isRecord(target)) return target;
+  return Object.fromEntries(Object.entries(target).map(([key, value]) => [key, replaceExportTargetCapture(value, capture)]));
+}
+
+function exportTargetsForValue(value, conditions, condition) {
+  if (!value) return [];
+  if (typeof value === 'string') return [{ path: value, condition }];
+  if (Array.isArray(value)) return value.flatMap((entry) => exportTargetsForValue(entry, conditions, condition));
+  if (!isRecord(value)) return [];
+  return conditions.flatMap((key) => exportTargetsForValue(value[key], conditions, key));
+}
+
+function packageFallbackTargets(options, subpath) {
+  const sourceRoot = normalizeProjectPath(options.sourceRoot ?? 'src');
+  if (subpath) return [joinProjectPath(sourceRoot, subpath), subpath];
+  return [options.types, options.main, joinProjectPath(sourceRoot, 'index')].filter(Boolean);
+}
+
 function moduleTargetDocument(path, documentsByPath) {
   for (const candidate of modulePathCandidates(path)) {
     const document = documentsByPath.get(candidate);
@@ -36,7 +151,7 @@ function moduleTargetDocument(path, documentsByPath) {
 }
 
 function modulePathCandidates(path) {
-  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}/index.js`, `${path}/index.ts`];
+  return [path, `${path}.js`, `${path}.ts`, `${path}.tsx`, `${path}.jsx`, `${path}.d.ts`, `${path}/index.js`, `${path}/index.ts`, `${path}/index.d.ts`];
 }
 
 function targetExportName(edge) {
@@ -49,6 +164,55 @@ function symbolKey(documentId, name) {
   return `${documentId}\u0000${name}`;
 }
 
+function patternCapture(value, pattern) {
+  if (pattern === value) return '';
+  if (!String(pattern).includes('*')) return undefined;
+  const [prefix, suffix = ''] = String(pattern).split('*');
+  if (!String(value).startsWith(prefix) || !String(value).endsWith(suffix)) return undefined;
+  return String(value).slice(prefix.length, String(value).length - suffix.length);
+}
+
+function uniquePaths(candidates) {
+  const seen = new Set();
+  return candidates.filter((candidate) => {
+    if (!candidate.path || seen.has(candidate.path)) return false;
+    seen.add(candidate.path);
+    return true;
+  });
+}
+
+function joinProjectPath(left, right) {
+  return left ? `${left}/${right}` : String(right);
+}
+
+function packageSpecifierInfo(moduleSpecifier) {
+  if (!moduleSpecifier || String(moduleSpecifier).startsWith('#')) return undefined;
+  const parts = String(moduleSpecifier).split('/');
+  if (!parts[0] || parts[0] === '.' || parts[0] === '..') return undefined;
+  const scoped = parts[0].startsWith('@');
+  if (scoped && parts.length < 2) return undefined;
+  const packageName = scoped ? `${parts[0]}/${parts[1]}` : parts[0];
+  const rest = parts.slice(scoped ? 2 : 1).join('/');
+  return { packageName, packageSubpath: rest ? `./${rest}` : '.' };
+}
+
+function packageResolutionFields(candidate, packageInfo) {
+  if (!candidate.packageName && candidate.kind !== 'package') return {};
+  return {
+    packageName: candidate.packageName ?? packageInfo?.packageName,
+    packageSubpath: candidate.packageSubpath ?? packageInfo?.packageSubpath,
+    packageExportCondition: candidate.packageExportCondition
+  };
+}
+
+function packageConditions(moduleResolution = {}) {
+  return moduleResolution.packageExportConditions ?? moduleResolution.conditions ?? ['types', 'import', 'module', 'require', 'default'];
+}
+
+function isRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
 function normalizeProjectPath(path) {
   const parts = [];
   for (const part of String(path).split('/')) {

package/dist/js-ts-safe-project-merge-graph.js

@@ -14,6 +14,7 @@ function createJsTsProjectSafeMergeGraphArtifacts(input, outputFiles, mergeId) {
   const projectImport = createNativeProjectImportResult({
     id: `${mergeId}_output_project_import`,
     projectRoot: input.projectRoot,
+    moduleResolution: input.moduleResolution ?? input.tsconfig,
     sources,
     metadata: {
       projectSafeMergeId: mergeId,

package/package.json

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