bonescript-compiler 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BoneScript Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/algorithm_catalog.d.ts

@@ -0,0 +1,32 @@
+/**
+ * BoneScript Algorithm Catalog (Leap 2)
+ *
+ * A closed catalog of named algorithms. Each entry has:
+ *   - inputs: typed parameters the user must bind
+ *   - outputs: return type
+ *   - description: human-readable explanation
+ *   - emit: function that produces a deterministic implementation
+ *
+ * NEW algorithms can ONLY be added by extending this catalog. The compiler
+ * never invents implementations — it picks from this list.
+ */
+export interface AlgorithmSpec {
+    name: string;
+    category: "graph" | "search" | "sort" | "matching" | "scheduling" | "stats" | "crypto";
+    description: string;
+    inputs: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    output: {
+        type: string;
+        description: string;
+    };
+    complexity: string;
+    emit: (bindings: Record<string, string>) => string;
+}
+export declare const CATALOG: Record<string, AlgorithmSpec>;
+export declare function lookupAlgorithm(name: string): AlgorithmSpec | null;
+export declare function listAlgorithms(): string[];
+export declare function listByCategory(): Record<string, string[]>;

package/dist/algorithm_catalog.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * BoneScript Algorithm Catalog (Leap 2)
+ *
+ * A closed catalog of named algorithms. Each entry has:
+ *   - inputs: typed parameters the user must bind
+ *   - outputs: return type
+ *   - description: human-readable explanation
+ *   - emit: function that produces a deterministic implementation
+ *
+ * NEW algorithms can ONLY be added by extending this catalog. The compiler
+ * never invents implementations — it picks from this list.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listByCategory = exports.listAlgorithms = exports.lookupAlgorithm = exports.CATALOG = void 0;
+// ─── Algorithm Implementations ───────────────────────────────────────────────
+exports.CATALOG = {
+    // ─── Graph Algorithms ──────────────────────────────────────────────────────
+    shortest_path: {
+        name: "shortest_path",
+        category: "graph",
+        description: "Dijkstra's algorithm for non-negative weighted shortest path.",
+        inputs: [
+            { name: "graph", type: "map<string, list<{node: string, weight: number}>>", description: "adjacency list" },
+            { name: "source", type: "string", description: "starting node" },
+            { name: "target", type: "string", description: "destination node" },
+        ],
+        output: { type: "{path: string[], distance: number} | null", description: "shortest path or null if unreachable" },
+        complexity: "O((V + E) log V)",
+        emit: (b) => `
+function shortestPath(
+  graph: Map<string, { node: string; weight: number }[]>,
+  source: string,
+  target: string
+): { path: string[]; distance: number } | null {
+  const distances = new Map<string, number>();
+  const previous = new Map<string, string>();
+  const queue: { node: string; distance: number }[] = [];
+
+  for (const node of graph.keys()) distances.set(node, Infinity);
+  distances.set(source, 0);
+  queue.push({ node: source, distance: 0 });
+
+  while (queue.length > 0) {
+    queue.sort((a, b) => a.distance - b.distance);
+    const current = queue.shift()!;
+    if (current.node === target) break;
+    if (current.distance > (distances.get(current.node) ?? Infinity)) continue;
+
+    for (const edge of graph.get(current.node) || []) {
+      const newDist = current.distance + edge.weight;
+      if (newDist < (distances.get(edge.node) ?? Infinity)) {
+        distances.set(edge.node, newDist);
+        previous.set(edge.node, current.node);
+        queue.push({ node: edge.node, distance: newDist });
+      }
+    }
+  }
+
+  if (!previous.has(target) && source !== target) return null;
+  const path: string[] = [];
+  let current: string | undefined = target;
+  while (current !== undefined) {
+    path.unshift(current);
+    current = previous.get(current);
+  }
+  return { path, distance: distances.get(target) || 0 };
+}
+`,
+    },
+    topological_sort: {
+        name: "topological_sort",
+        category: "graph",
+        description: "Kahn's algorithm — produces a linear ordering of a DAG.",
+        inputs: [
+            { name: "graph", type: "map<string, string[]>", description: "adjacency list" },
+        ],
+        output: { type: "string[] | null", description: "topological order, or null if cycle exists" },
+        complexity: "O(V + E)",
+        emit: (b) => `
+function topologicalSort(graph: Map<string, string[]>): string[] | null {
+  const inDegree = new Map<string, number>();
+  for (const node of graph.keys()) inDegree.set(node, 0);
+  for (const [, neighbors] of graph) {
+    for (const n of neighbors) inDegree.set(n, (inDegree.get(n) || 0) + 1);
+  }
+
+  const queue: string[] = [];
+  for (const [node, deg] of inDegree) if (deg === 0) queue.push(node);
+
+  const result: string[] = [];
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+    result.push(node);
+    for (const neighbor of graph.get(node) || []) {
+      inDegree.set(neighbor, (inDegree.get(neighbor) || 0) - 1);
+      if (inDegree.get(neighbor) === 0) queue.push(neighbor);
+    }
+  }
+
+  return result.length === graph.size ? result : null;
+}
+`,
+    },
+    // ─── Search ───────────────────────────────────────────────────────────────
+    binary_search: {
+        name: "binary_search",
+        category: "search",
+        description: "Find target in sorted array.",
+        inputs: [
+            { name: "items", type: "T[]", description: "sorted array" },
+            { name: "target", type: "T", description: "value to find" },
+        ],
+        output: { type: "number", description: "index of target or -1 if not found" },
+        complexity: "O(log n)",
+        emit: (b) => `
+function binarySearch<T>(items: T[], target: T): number {
+  let low = 0, high = items.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (items[mid] === target) return mid;
+    if (items[mid] < target) low = mid + 1;
+    else high = mid - 1;
+  }
+  return -1;
+}
+`,
+    },
+    // ─── Matching ─────────────────────────────────────────────────────────────
+    bipartite_matching: {
+        name: "bipartite_matching",
+        category: "matching",
+        description: "Hopcroft-Karp maximum bipartite matching.",
+        inputs: [
+            { name: "left", type: "string[]", description: "left vertex set" },
+            { name: "right", type: "string[]", description: "right vertex set" },
+            { name: "edges", type: "{from: string, to: string}[]", description: "valid pairings" },
+        ],
+        output: { type: "Map<string, string>", description: "matching from left to right" },
+        complexity: "O(E sqrt(V))",
+        emit: (b) => `
+function bipartiteMatching(
+  left: string[],
+  right: string[],
+  edges: { from: string; to: string }[]
+): Map<string, string> {
+  const adj = new Map<string, string[]>();
+  for (const e of edges) {
+    if (!adj.has(e.from)) adj.set(e.from, []);
+    adj.get(e.from)!.push(e.to);
+  }
+
+  const matchL = new Map<string, string>();
+  const matchR = new Map<string, string>();
+
+  function dfs(u: string, visited: Set<string>): boolean {
+    for (const v of adj.get(u) || []) {
+      if (visited.has(v)) continue;
+      visited.add(v);
+      if (!matchR.has(v) || dfs(matchR.get(v)!, visited)) {
+        matchL.set(u, v);
+        matchR.set(v, u);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  for (const u of left) dfs(u, new Set());
+  return matchL;
+}
+`,
+    },
+    // ─── Scheduling ────────────────────────────────────────────────────────────
+    round_robin: {
+        name: "round_robin",
+        category: "scheduling",
+        description: "Cyclic assignment of items to workers.",
+        inputs: [
+            { name: "items", type: "T[]", description: "items to assign" },
+            { name: "workers", type: "W[]", description: "workers" },
+        ],
+        output: { type: "Map<W, T[]>", description: "assignments per worker" },
+        complexity: "O(n)",
+        emit: (b) => `
+function roundRobin<T, W>(items: T[], workers: W[]): Map<W, T[]> {
+  const result = new Map<W, T[]>();
+  for (const w of workers) result.set(w, []);
+  for (let i = 0; i < items.length; i++) {
+    const w = workers[i % workers.length];
+    result.get(w)!.push(items[i]);
+  }
+  return result;
+}
+`,
+    },
+    // ─── Stats ─────────────────────────────────────────────────────────────────
+    weighted_average: {
+        name: "weighted_average",
+        category: "stats",
+        description: "Weighted arithmetic mean.",
+        inputs: [
+            { name: "items", type: "{value: number, weight: number}[]", description: "values with weights" },
+        ],
+        output: { type: "number", description: "weighted average" },
+        complexity: "O(n)",
+        emit: (b) => `
+function weightedAverage(items: { value: number; weight: number }[]): number {
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const item of items) {
+    totalWeight += item.weight;
+    weightedSum += item.value * item.weight;
+  }
+  return totalWeight === 0 ? 0 : weightedSum / totalWeight;
+}
+`,
+    },
+    percentile: {
+        name: "percentile",
+        category: "stats",
+        description: "Compute the kth percentile of a numeric dataset.",
+        inputs: [
+            { name: "values", type: "number[]", description: "dataset" },
+            { name: "k", type: "number", description: "percentile (0-100)" },
+        ],
+        output: { type: "number", description: "kth percentile value" },
+        complexity: "O(n log n)",
+        emit: (b) => `
+function percentile(values: number[], k: number): number {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = (k / 100) * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
+}
+`,
+    },
+    // ─── Sort ──────────────────────────────────────────────────────────────────
+    rank_by: {
+        name: "rank_by",
+        category: "sort",
+        description: "Stable sort by a numeric scoring function.",
+        inputs: [
+            { name: "items", type: "T[]", description: "items to rank" },
+            { name: "score_fn", type: "(item: T) => number", description: "scoring function" },
+            { name: "order", type: "'asc' | 'desc'", description: "sort direction" },
+        ],
+        output: { type: "T[]", description: "sorted array" },
+        complexity: "O(n log n)",
+        emit: (b) => `
+function rankBy<T>(items: T[], scoreFn: (item: T) => number, order: "asc" | "desc"): T[] {
+  const sign = order === "asc" ? 1 : -1;
+  return [...items].sort((a, b) => sign * (scoreFn(a) - scoreFn(b)));
+}
+`,
+    },
+    // ─── Crypto / Hashing ──────────────────────────────────────────────────────
+    consistent_hash: {
+        name: "consistent_hash",
+        category: "crypto",
+        description: "Consistent hashing for distributing keys across nodes.",
+        inputs: [
+            { name: "key", type: "string", description: "key to hash" },
+            { name: "nodes", type: "string[]", description: "available nodes" },
+            { name: "replicas", type: "number", description: "virtual nodes per real node" },
+        ],
+        output: { type: "string", description: "node assigned to key" },
+        complexity: "O(N log N) build, O(log N) lookup",
+        emit: (b) => `
+function consistentHash(key: string, nodes: string[], replicas: number = 100): string {
+  if (nodes.length === 0) throw new Error("No nodes available");
+
+  function fnv1a(s: string): number {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+      hash ^= s.charCodeAt(i);
+      hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0;
+    }
+    return hash;
+  }
+
+  const ring: { hash: number; node: string }[] = [];
+  for (const node of nodes) {
+    for (let i = 0; i < replicas; i++) {
+      ring.push({ hash: fnv1a(node + ":" + i), node });
+    }
+  }
+  ring.sort((a, b) => a.hash - b.hash);
+
+  const target = fnv1a(key);
+  for (const entry of ring) {
+    if (entry.hash >= target) return entry.node;
+  }
+  return ring[0].node;
+}
+`,
+    },
+};
+// ─── Public API ──────────────────────────────────────────────────────────────
+function lookupAlgorithm(name) {
+    return exports.CATALOG[name] || null;
+}
+exports.lookupAlgorithm = lookupAlgorithm;
+function listAlgorithms() {
+    return Object.keys(exports.CATALOG).sort();
+}
+exports.listAlgorithms = listAlgorithms;
+function listByCategory() {
+    const result = {};
+    for (const [name, spec] of Object.entries(exports.CATALOG)) {
+        if (!result[spec.category])
+            result[spec.category] = [];
+        result[spec.category].push(name);
+    }
+    for (const cat in result)
+        result[cat].sort();
+    return result;
+}
+exports.listByCategory = listByCategory;
+//# sourceMappingURL=algorithm_catalog.js.map

package/dist/algorithm_catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorithm_catalog.js","sourceRoot":"","sources":["../src/algorithm_catalog.ts"],"names":[],"mappings":"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"}

package/dist/ast.d.ts

@@ -0,0 +1,244 @@
+/**
+ * BoneScript Abstract Syntax Tree
+ * Direct representation of the grammar in spec/02_GRAMMAR.peg.
+ * Every node type corresponds to a grammar production.
+ */
+import { SourceLocation } from "./lexer";
+export interface ASTNode {
+    kind: string;
+    loc: SourceLocation;
+}
+export interface ProgramNode extends ASTNode {
+    kind: "Program";
+    systems: SystemDeclNode[];
+}
+export interface SystemDeclNode extends ASTNode {
+    kind: "SystemDecl";
+    name: string;
+    domain: string | null;
+    declarations: DeclarationNode[];
+}
+export type DeclarationNode = EntityDeclNode | CapabilityDeclNode | ChannelDeclNode | StoreDeclNode | EventDeclNode | ConstraintDeclNode | PolicyDeclNode | FlowDeclNode | ImportDeclNode | ExtensionPointDeclNode;
+export interface EntityDeclNode extends ASTNode {
+    kind: "EntityDecl";
+    name: string;
+    owns: FieldNode[];
+    constraints: ExprNode[];
+    states: StateGraphNode | null;
+    auth: string | null;
+    relations: RelationNode[];
+    indexes: string[][];
+    derived: DerivedFieldNode[];
+}
+export interface FieldNode extends ASTNode {
+    kind: "Field";
+    name: string;
+    type: TypeExprNode;
+    defaultValue: ExprNode | null;
+}
+export interface StateGraphNode extends ASTNode {
+    kind: "StateGraph";
+    nodes: StateNodeEntry[];
+}
+export interface StateNodeEntry {
+    name: string;
+    guard: ExprNode | null;
+    transitions: string[];
+    branches: string[];
+}
+export interface RelationNode extends ASTNode {
+    kind: "Relation";
+    name: string;
+    relationType: "has_one" | "has_many" | "belongs_to" | "many_to_many";
+    target: string;
+    cardinality: {
+        min: number;
+        max: number | "*";
+    } | null;
+}
+export interface DerivedFieldNode extends ASTNode {
+    kind: "DerivedField";
+    name: string;
+    expr: ExprNode;
+}
+export interface CapabilityDeclNode extends ASTNode {
+    kind: "CapabilityDecl";
+    name: string;
+    params: ParamNode[];
+    requires: ExprNode[];
+    effects: EffectNode[];
+    emits: EmitNode[];
+    sync: string | null;
+    timeout: string | null;
+    retry: RetryPolicyNode | null;
+    idempotent: boolean | null;
+    pipeline: PipelineNode | null;
+    algorithm: AlgorithmNode | null;
+    returns: TypeExprNode | null;
+}
+export interface PipelineNode extends ASTNode {
+    kind: "Pipeline";
+    steps: PipelineStepNode[];
+    parallel: boolean;
+    onError: PipelineErrorHandler | null;
+}
+export interface PipelineStepNode extends ASTNode {
+    kind: "PipelineStep";
+    call: CallExprNode;
+    bindAs: string | null;
+}
+export interface PipelineErrorHandler {
+    kind: "PipelineErrorHandler";
+    action: "rollback" | "compensate" | "ignore" | "retry";
+    call: CallExprNode | null;
+}
+export interface AlgorithmNode extends ASTNode {
+    kind: "Algorithm";
+    name: string;
+    using: AlgorithmBinding[];
+}
+export interface AlgorithmBinding {
+    param: string;
+    value: ExprNode;
+}
+export interface ParamNode extends ASTNode {
+    kind: "Param";
+    name: string;
+    type: TypeExprNode;
+}
+export interface EffectNode extends ASTNode {
+    kind: "Effect";
+    target: FieldRefNode;
+    op: "=" | "+=" | "-=";
+    value: ExprNode;
+}
+export interface EmitNode extends ASTNode {
+    kind: "Emit";
+    eventName: string;
+    args: ExprNode[];
+}
+export interface RetryPolicyNode extends ASTNode {
+    kind: "RetryPolicy";
+    maxAttempts: number | null;
+    backoff: string | null;
+    interval: string | null;
+}
+export interface ChannelDeclNode extends ASTNode {
+    kind: "ChannelDecl";
+    name: string;
+    transport: string | null;
+    ordering: string | null;
+    participants: TypeExprNode | null;
+    persistence: string | null;
+    filter: ExprNode | null;
+    maxSize: number | null;
+}
+export interface StoreDeclNode extends ASTNode {
+    kind: "StoreDecl";
+    name: string;
+    engine: string | null;
+    schema: FieldNode[];
+    retention: string | null;
+    partition: string | null;
+    replicas: number | null;
+}
+export interface EventDeclNode extends ASTNode {
+    kind: "EventDecl";
+    name: string;
+    payload: FieldNode[];
+    delivery: string | null;
+    ttl: string | null;
+}
+export interface ConstraintDeclNode extends ASTNode {
+    kind: "ConstraintDecl";
+    name: string;
+    expr: ExprNode;
+}
+export interface PolicyDeclNode extends ASTNode {
+    kind: "PolicyDecl";
+    name: string;
+    rateLimit: {
+        count: number;
+        per: string;
+    } | null;
+    access: string[];
+    audit: boolean | null;
+    encryption: string | null;
+}
+export interface FlowDeclNode extends ASTNode {
+    kind: "FlowDecl";
+    name: string;
+    steps: FlowStepNode[];
+}
+export interface FlowStepNode extends ASTNode {
+    kind: "FlowStep";
+    name: string;
+    action: CallExprNode;
+    compensate: CallExprNode | null;
+}
+export interface ImportDeclNode extends ASTNode {
+    kind: "ImportDecl";
+    name: string;
+    from: string;
+}
+export type TypeExprNode = PrimitiveTypeNode | GenericTypeNode | EntityRefTypeNode | TupleTypeNode | UnionTypeNode;
+export interface PrimitiveTypeNode extends ASTNode {
+    kind: "PrimitiveType";
+    name: string;
+}
+export interface GenericTypeNode extends ASTNode {
+    kind: "GenericType";
+    name: string;
+    typeArgs: TypeExprNode[];
+}
+export interface EntityRefTypeNode extends ASTNode {
+    kind: "EntityRefType";
+    name: string;
+}
+export interface TupleTypeNode extends ASTNode {
+    kind: "TupleType";
+    elements: TypeExprNode[];
+}
+export interface UnionTypeNode extends ASTNode {
+    kind: "UnionType";
+    members: TypeExprNode[];
+}
+export type ExprNode = BinaryExprNode | UnaryExprNode | FieldRefNode | LiteralNode | CallExprNode | TernaryExprNode;
+export interface BinaryExprNode extends ASTNode {
+    kind: "BinaryExpr";
+    op: string;
+    left: ExprNode;
+    right: ExprNode;
+}
+export interface UnaryExprNode extends ASTNode {
+    kind: "UnaryExpr";
+    op: string;
+    operand: ExprNode;
+}
+export interface FieldRefNode extends ASTNode {
+    kind: "FieldRef";
+    path: string[];
+}
+export interface LiteralNode extends ASTNode {
+    kind: "Literal";
+    type: "string" | "int" | "float" | "bool" | "none" | "list" | "map";
+    value: string | number | boolean | null | ExprNode[] | [ExprNode, ExprNode][];
+}
+export interface CallExprNode extends ASTNode {
+    kind: "CallExpr";
+    name: string;
+    args: ExprNode[];
+}
+export interface TernaryExprNode extends ASTNode {
+    kind: "TernaryExpr";
+    condition: ExprNode;
+    consequent: ExprNode;
+    alternate: ExprNode;
+}
+export interface ExtensionPointDeclNode extends ASTNode {
+    kind: "ExtensionPointDecl";
+    name: string;
+    params: ParamNode[];
+    returns: TypeExprNode | null;
+    stable: boolean;
+}

package/dist/ast.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * BoneScript Abstract Syntax Tree
+ * Direct representation of the grammar in spec/02_GRAMMAR.peg.
+ * Every node type corresponds to a grammar production.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ast.js.map

package/dist/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../src/ast.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+/**
+ * BoneScript compiler CLI
+ */
+export {};