bonescript-compiler 0.5.2 → 0.5.4

package/src/module_loader.ts

@@ -1,112 +1,114 @@
-/**
- * BoneScript Module Loader — Resolves import declarations across multiple .bone files.
- *
- * Behavior:
- * - Tracks loaded files to avoid cycles
- * - Resolves relative paths from importing file
- * - Merges imported declarations into a single AST
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { Lexer } from "./lexer";
-import { RecoveringParser } from "./parser_recovery";
-import { ParseError } from "./parser_base";
-import * as AST from "./ast";
-
-export interface LoadResult {
-  ast: AST.ProgramNode | null;
-  errors: { file: string; error: ParseError }[];
-  loadedFiles: string[];
-}
-
-export class ModuleLoader {
-  private loaded = new Map<string, AST.ProgramNode>();
-  private inProgress = new Set<string>();
-  private errors: { file: string; error: ParseError }[] = [];
-
-  async load(entryFile: string): Promise<LoadResult> {
-    const resolved = path.resolve(entryFile);
-    const ast = await this.loadFile(resolved);
-    return {
-      ast,
-      errors: this.errors,
-      loadedFiles: Array.from(this.loaded.keys()),
-    };
-  }
-
-  private async loadFile(filePath: string): Promise<AST.ProgramNode | null> {
-    if (this.loaded.has(filePath)) return this.loaded.get(filePath)!;
-    if (this.inProgress.has(filePath)) {
-      this.errors.push({
-        file: filePath,
-        error: new ParseError(`Circular import detected: ${filePath}`, { line: 1, column: 1, offset: 0 }),
-      });
-      return null;
-    }
-
-    // Check existence without blocking the event loop
-    try {
-      await fs.promises.access(filePath);
-    } catch {
-      this.errors.push({
-        file: filePath,
-        error: new ParseError(`File not found: ${filePath}`, { line: 1, column: 1, offset: 0 }),
-      });
-      return null;
-    }
-
-    this.inProgress.add(filePath);
-
-    const source = await fs.promises.readFile(filePath, "utf-8");
-    const tokens = new Lexer(source).tokenize();
-    const result = new RecoveringParser(tokens).parse();
-
-    for (const err of result.errors) {
-      this.errors.push({ file: filePath, error: err });
-    }
-
-    if (!result.ast) {
-      this.inProgress.delete(filePath);
-      return null;
-    }
-
-    // Resolve imports recursively (in parallel where possible)
-    const importedSystems: AST.SystemDeclNode[] = [];
-    for (const sys of result.ast.systems) {
-      const imports = sys.declarations.filter((d): d is AST.ImportDeclNode => d.kind === "ImportDecl");
-      // Load all imports for this system in parallel
-      const importedAsts = await Promise.all(
-        imports.map(imp => {
-          const importPath = path.resolve(path.dirname(filePath), imp.from);
-          return this.loadFile(importPath);
-        })
-      );
-      for (const importedAst of importedAsts) {
-        if (importedAst) importedSystems.push(...importedAst.systems);
-      }
-    }
-
-    // Merge imported declarations into current systems
-    if (importedSystems.length > 0) {
-      result.ast.systems = result.ast.systems.map(sys => {
-        const importedDecls: AST.DeclarationNode[] = importedSystems.flatMap(imported =>
-          imported.declarations.filter(d => d.kind !== "ImportDecl")
-        );
-        return {
-          ...sys,
-          declarations: [...sys.declarations.filter(d => d.kind !== "ImportDecl"), ...importedDecls],
-        };
-      });
-    } else {
-      result.ast.systems = result.ast.systems.map(sys => ({
-        ...sys,
-        declarations: sys.declarations.filter(d => d.kind !== "ImportDecl"),
-      }));
-    }
-
-    this.loaded.set(filePath, result.ast);
-    this.inProgress.delete(filePath);
-    return result.ast;
-  }
-}
+/**
+ * BoneScript Module Loader — Resolves import declarations across multiple .bone files.
+ *
+ * Behavior:
+ * - Tracks loaded files to avoid cycles
+ * - Resolves relative paths from importing file
+ * - Merges imported declarations into a single AST
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { RecoveringParser } from "./parser_recovery";
+import { ParseError } from "./parser_base";
+import * as AST from "./ast";
+
+export interface LoadResult {
+  ast: AST.ProgramNode | null;
+  errors: { file: string; error: ParseError }[];
+  loadedFiles: string[];
+}
+
+export class ModuleLoader {
+  private loaded = new Map<string, AST.ProgramNode>();
+  private inProgress = new Set<string>();
+  private errors: { file: string; error: ParseError }[] = [];
+
+  load(entryFile: string): LoadResult {
+    const resolved = path.resolve(entryFile);
+    const ast = this.loadFile(resolved);
+
+    return {
+      ast,
+      errors: this.errors,
+      loadedFiles: Array.from(this.loaded.keys()),
+    };
+  }
+
+  private loadFile(filePath: string): AST.ProgramNode | null {
+    if (this.loaded.has(filePath)) return this.loaded.get(filePath)!;
+    if (this.inProgress.has(filePath)) {
+      this.errors.push({
+        file: filePath,
+        error: new ParseError(`Circular import detected: ${filePath}`, { line: 1, column: 1, offset: 0 }),
+      });
+      return null;
+    }
+
+    if (!fs.existsSync(filePath)) {
+      this.errors.push({
+        file: filePath,
+        error: new ParseError(`File not found: ${filePath}`, { line: 1, column: 1, offset: 0 }),
+      });
+      return null;
+    }
+
+    this.inProgress.add(filePath);
+
+    const source = fs.readFileSync(filePath, "utf-8");
+    const tokens = new Lexer(source).tokenize();
+    const result = new RecoveringParser(tokens).parse();
+
+    for (const err of result.errors) {
+      this.errors.push({ file: filePath, error: err });
+    }
+
+    if (!result.ast) {
+      this.inProgress.delete(filePath);
+      return null;
+    }
+
+    // Resolve imports recursively
+    const importedSystems: AST.SystemDeclNode[] = [];
+    for (const sys of result.ast.systems) {
+      const imports = sys.declarations.filter((d): d is AST.ImportDeclNode => d.kind === "ImportDecl");
+      for (const imp of imports) {
+        const importPath = path.resolve(path.dirname(filePath), imp.from);
+        const importedAst = this.loadFile(importPath);
+        if (importedAst) {
+          importedSystems.push(...importedAst.systems);
+        }
+      }
+    }
+
+    // Merge imported systems' declarations into current systems
+    if (importedSystems.length > 0) {
+      const mergedSystems = result.ast.systems.map(sys => {
+        const importedDecls: AST.DeclarationNode[] = [];
+        for (const imported of importedSystems) {
+          // Add imported entities, events, etc. (skip imports themselves)
+          for (const d of imported.declarations) {
+            if (d.kind !== "ImportDecl") importedDecls.push(d);
+          }
+        }
+        return {
+          ...sys,
+          declarations: [...sys.declarations.filter(d => d.kind !== "ImportDecl"), ...importedDecls],
+        };
+      });
+      result.ast.systems = mergedSystems;
+    } else {
+      // Remove import declarations from final AST
+      result.ast.systems = result.ast.systems.map(sys => ({
+        ...sys,
+        declarations: sys.declarations.filter(d => d.kind !== "ImportDecl"),
+      }));
+    }
+
+    this.loaded.set(filePath, result.ast);
+    this.inProgress.delete(filePath);
+    return result.ast;
+  }
+}

package/src/optimizer.ts

@@ -1,196 +1,196 @@
-/**
- * BoneScript IR Optimizer — Stage 4.5 (between lowering and codegen).
- * Implements spec/07_IR_SPEC.md §6 (IR Optimization).
- *
- * Passes (applied in order, each idempotent):
- * 1. Dead module elimination
- * 2. Store merging (same engine, no conflicting schemas)
- * 3. Event deduplication
- * 4. Dependency minimization (remove transitive deps)
- * 5. Index optimization (remove prefix indexes)
- */
-
-import * as IR from "./ir";
-
-interface OptimizationLog {
-  pass: string;
-  action: string;
-  target: string;
-}
-
-export interface OptimizationResult {
-  system: IR.IRSystem;
-  log: OptimizationLog[];
-  modulesRemoved: number;
-  eventsDeduped: number;
-  depsRemoved: number;
-}
-
-export function optimize(system: IR.IRSystem): OptimizationResult {
-  const log: OptimizationLog[] = [];
-  let s = system;
-
-  s = deadModuleElimination(s, log);
-  s = storeMerging(s, log);
-  s = eventDeduplication(s, log);
-  s = dependencyMinimization(s, log);
-  s = indexOptimization(s, log);
-
-  return {
-    system: s,
-    log,
-    modulesRemoved: log.filter(l => l.pass === "deadModuleElimination").length,
-    eventsDeduped: log.filter(l => l.pass === "eventDeduplication").length,
-    depsRemoved: log.filter(l => l.pass === "dependencyMinimization").length,
-  };
-}
-
-// ─── Pass 1: Dead Module Elimination ─────────────────────────────────────────
-
-function deadModuleElimination(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
-  const reachable = new Set<string>();
-
-  // Seed: always-reachable kinds
-  for (const m of s.modules) {
-    if (["gateway", "frontend", "auth_service", "api_service", "realtime_service", "data_store", "event_bus", "cache"].includes(m.kind)) {
-      reachable.add(m.id);
-    }
-  }
-
-  // Propagate reachability
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const m of s.modules) {
-      if (reachable.has(m.id)) {
-        for (const dep of m.dependencies) {
-          if (!reachable.has(dep)) {
-            reachable.add(dep);
-            changed = true;
-          }
-        }
-      }
-    }
-  }
-
-  const removed = s.modules.filter(m => !reachable.has(m.id));
-  for (const m of removed) {
-    log.push({ pass: "deadModuleElimination", action: "removed", target: m.name });
-  }
-
-  return { ...s, modules: s.modules.filter(m => reachable.has(m.id)) };
-}
-
-// ─── Pass 2: Store Merging ────────────────────────────────────────────────────
-
-function storeMerging(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
-  const stores = s.modules.filter(m => m.kind === "data_store");
-  const toRemove = new Set<string>();
-  const idRemap = new Map<string, string>();
-
-  for (let i = 0; i < stores.length; i++) {
-    for (let j = i + 1; j < stores.length; j++) {
-      const a = stores[i];
-      const b = stores[j];
-      // Only merge if same engine, both have no models (pure infra stores)
-      if (
-        a.config["engine"] === b.config["engine"] &&
-        a.models.length === 0 &&
-        b.models.length === 0 &&
-        !toRemove.has(a.id)
-      ) {
-        toRemove.add(b.id);
-        idRemap.set(b.id, a.id);
-        log.push({ pass: "storeMerging", action: "merged", target: `${b.name} → ${a.name}` });
-      }
-    }
-  }
-
-  if (toRemove.size === 0) return s;
-
-  const modules = s.modules
-    .filter(m => !toRemove.has(m.id))
-    .map(m => ({
-      ...m,
-      dependencies: [...new Set(m.dependencies.map(d => idRemap.get(d) ?? d))],
-    }));
-
-  return { ...s, modules };
-}
-
-// ─── Pass 3: Event Deduplication ─────────────────────────────────────────────
-
-function eventDeduplication(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
-  const seen = new Set<string>();
-  const events: IR.IREvent[] = [];
-
-  for (const ev of s.events) {
-    if (seen.has(ev.name)) {
-      log.push({ pass: "eventDeduplication", action: "removed duplicate", target: ev.name });
-    } else {
-      seen.add(ev.name);
-      events.push(ev);
-    }
-  }
-
-  return { ...s, events };
-}
-
-// ─── Pass 4: Dependency Minimization ─────────────────────────────────────────
-
-function dependencyMinimization(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
-  const modules = s.modules.map(m => {
-    // Remove self-references and duplicates
-    const original = m.dependencies.length;
-    const deps = [...new Set(m.dependencies.filter(d => d !== m.id))];
-
-    // Remove transitive dependencies: if A→B→C, remove A→C
-    const directDeps = new Set(deps);
-    const transitive = new Set<string>();
-
-    for (const dep of deps) {
-      const depModule = s.modules.find(x => x.id === dep);
-      if (depModule) {
-        for (const transitiveDep of depModule.dependencies) {
-          if (transitiveDep !== m.id) transitive.add(transitiveDep);
-        }
-      }
-    }
-
-    const minimized = deps.filter(d => !transitive.has(d));
-    const removed = original - minimized.length;
-
-    if (removed > 0) {
-      log.push({ pass: "dependencyMinimization", action: `removed ${removed} transitive deps`, target: m.name });
-    }
-
-    return { ...m, dependencies: minimized };
-  });
-
-  return { ...s, modules };
-}
-
-// ─── Pass 5: Index Optimization ──────────────────────────────────────────────
-
-function indexOptimization(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
-  const modules = s.modules.map(m => {
-    const models = m.models.map(model => {
-      // Remove indexes that are prefixes of other indexes
-      const indexes = model.indexes.filter((idx, i) => {
-        const isPrefix = model.indexes.some((other, j) => {
-          if (i === j) return false;
-          if (other.fields.length <= idx.fields.length) return false;
-          return idx.fields.every((f, k) => other.fields[k] === f);
-        });
-        if (isPrefix) {
-          log.push({ pass: "indexOptimization", action: "removed prefix index", target: `${model.name}.${idx.fields.join("_")}` });
-        }
-        return !isPrefix;
-      });
-      return { ...model, indexes };
-    });
-    return { ...m, models };
-  });
-
-  return { ...s, modules };
-}
+/**
+ * BoneScript IR Optimizer — Stage 4.5 (between lowering and codegen).
+ * Implements spec/07_IR_SPEC.md §6 (IR Optimization).
+ *
+ * Passes (applied in order, each idempotent):
+ * 1. Dead module elimination
+ * 2. Store merging (same engine, no conflicting schemas)
+ * 3. Event deduplication
+ * 4. Dependency minimization (remove transitive deps)
+ * 5. Index optimization (remove prefix indexes)
+ */
+
+import * as IR from "./ir";
+
+interface OptimizationLog {
+  pass: string;
+  action: string;
+  target: string;
+}
+
+export interface OptimizationResult {
+  system: IR.IRSystem;
+  log: OptimizationLog[];
+  modulesRemoved: number;
+  eventsDeduped: number;
+  depsRemoved: number;
+}
+
+export function optimize(system: IR.IRSystem): OptimizationResult {
+  const log: OptimizationLog[] = [];
+  let s = system;
+
+  s = deadModuleElimination(s, log);
+  s = storeMerging(s, log);
+  s = eventDeduplication(s, log);
+  s = dependencyMinimization(s, log);
+  s = indexOptimization(s, log);
+
+  return {
+    system: s,
+    log,
+    modulesRemoved: log.filter(l => l.pass === "deadModuleElimination").length,
+    eventsDeduped: log.filter(l => l.pass === "eventDeduplication").length,
+    depsRemoved: log.filter(l => l.pass === "dependencyMinimization").length,
+  };
+}
+
+// ─── Pass 1: Dead Module Elimination ─────────────────────────────────────────
+
+function deadModuleElimination(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const reachable = new Set<string>();
+
+  // Seed: always-reachable kinds
+  for (const m of s.modules) {
+    if (["gateway", "frontend", "auth_service", "api_service", "realtime_service"].includes(m.kind)) {
+      reachable.add(m.id);
+    }
+  }
+
+  // Propagate reachability
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const m of s.modules) {
+      if (reachable.has(m.id)) {
+        for (const dep of m.dependencies) {
+          if (!reachable.has(dep)) {
+            reachable.add(dep);
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+
+  const removed = s.modules.filter(m => !reachable.has(m.id));
+  for (const m of removed) {
+    log.push({ pass: "deadModuleElimination", action: "removed", target: m.name });
+  }
+
+  return { ...s, modules: s.modules.filter(m => reachable.has(m.id)) };
+}
+
+// ─── Pass 2: Store Merging ────────────────────────────────────────────────────
+
+function storeMerging(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const stores = s.modules.filter(m => m.kind === "data_store");
+  const toRemove = new Set<string>();
+  const idRemap = new Map<string, string>();
+
+  for (let i = 0; i < stores.length; i++) {
+    for (let j = i + 1; j < stores.length; j++) {
+      const a = stores[i];
+      const b = stores[j];
+      // Only merge if same engine, both have no models (pure infra stores)
+      if (
+        a.config["engine"] === b.config["engine"] &&
+        a.models.length === 0 &&
+        b.models.length === 0 &&
+        !toRemove.has(a.id)
+      ) {
+        toRemove.add(b.id);
+        idRemap.set(b.id, a.id);
+        log.push({ pass: "storeMerging", action: "merged", target: `${b.name} → ${a.name}` });
+      }
+    }
+  }
+
+  if (toRemove.size === 0) return s;
+
+  const modules = s.modules
+    .filter(m => !toRemove.has(m.id))
+    .map(m => ({
+      ...m,
+      dependencies: [...new Set(m.dependencies.map(d => idRemap.get(d) ?? d))],
+    }));
+
+  return { ...s, modules };
+}
+
+// ─── Pass 3: Event Deduplication ─────────────────────────────────────────────
+
+function eventDeduplication(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const seen = new Set<string>();
+  const events: IR.IREvent[] = [];
+
+  for (const ev of s.events) {
+    if (seen.has(ev.name)) {
+      log.push({ pass: "eventDeduplication", action: "removed duplicate", target: ev.name });
+    } else {
+      seen.add(ev.name);
+      events.push(ev);
+    }
+  }
+
+  return { ...s, events };
+}
+
+// ─── Pass 4: Dependency Minimization ─────────────────────────────────────────
+
+function dependencyMinimization(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const modules = s.modules.map(m => {
+    // Remove self-references and duplicates
+    const original = m.dependencies.length;
+    const deps = [...new Set(m.dependencies.filter(d => d !== m.id))];
+
+    // Remove transitive dependencies: if A→B→C, remove A→C
+    const directDeps = new Set(deps);
+    const transitive = new Set<string>();
+
+    for (const dep of deps) {
+      const depModule = s.modules.find(x => x.id === dep);
+      if (depModule) {
+        for (const transitiveDep of depModule.dependencies) {
+          if (transitiveDep !== m.id) transitive.add(transitiveDep);
+        }
+      }
+    }
+
+    const minimized = deps.filter(d => !transitive.has(d));
+    const removed = original - minimized.length;
+
+    if (removed > 0) {
+      log.push({ pass: "dependencyMinimization", action: `removed ${removed} transitive deps`, target: m.name });
+    }
+
+    return { ...m, dependencies: minimized };
+  });
+
+  return { ...s, modules };
+}
+
+// ─── Pass 5: Index Optimization ──────────────────────────────────────────────
+
+function indexOptimization(s: IR.IRSystem, log: OptimizationLog[]): IR.IRSystem {
+  const modules = s.modules.map(m => {
+    const models = m.models.map(model => {
+      // Remove indexes that are prefixes of other indexes
+      const indexes = model.indexes.filter((idx, i) => {
+        const isPrefix = model.indexes.some((other, j) => {
+          if (i === j) return false;
+          if (other.fields.length <= idx.fields.length) return false;
+          return idx.fields.every((f, k) => other.fields[k] === f);
+        });
+        if (isPrefix) {
+          log.push({ pass: "indexOptimization", action: "removed prefix index", target: `${model.name}.${idx.fields.join("_")}` });
+        }
+        return !isPrefix;
+      });
+      return { ...model, indexes };
+    });
+    return { ...m, models };
+  });
+
+  return { ...s, modules };
+}

package/src/parse_decls.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BoneScript Declaration Parsers
+ */
+import { TokenStream } from "./parser_base";
+import * as AST from "./ast";
+export declare function parseFieldList(s: TokenStream): AST.FieldNode[];
+export declare function parseField(s: TokenStream): AST.FieldNode;
+export declare function parseIdentList(s: TokenStream): string[];
+export declare function parseDuration(s: TokenStream): string;
+export declare function parseEntityDecl(s: TokenStream): AST.EntityDeclNode;
+export declare function parseCapabilityDecl(s: TokenStream): AST.CapabilityDeclNode;
+export declare function parsePipeline(s: TokenStream, parallel?: boolean): AST.PipelineNode;
+export declare function parseAlgorithm(s: TokenStream): AST.AlgorithmNode;