bonescript-compiler 0.2.0

package/dist/index.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * BoneScript Compiler — Public API
+ * Import this module to use the compiler programmatically.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.validateExtensions = exports.extractImplementations = exports.mergeWithExisting = exports.listByCategory = exports.listAlgorithms = exports.lookupAlgorithm = exports.IR = exports.AST = exports.scaffold = exports.Formatter = exports.ModuleLoader = exports.optimize = exports.Verifier = exports.FullEmitter = exports.ConstraintSolver = exports.Lowering = exports.TypeChecker = exports.RecoveringParser = exports.ParseError = exports.Parser = exports.TokenKind = exports.LexerError = exports.Lexer = void 0;
+// Core pipeline
+var lexer_1 = require("./lexer");
+Object.defineProperty(exports, "Lexer", { enumerable: true, get: function () { return lexer_1.Lexer; } });
+Object.defineProperty(exports, "LexerError", { enumerable: true, get: function () { return lexer_1.LexerError; } });
+Object.defineProperty(exports, "TokenKind", { enumerable: true, get: function () { return lexer_1.TokenKind; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return parser_1.ParseError; } });
+var parser_recovery_1 = require("./parser_recovery");
+Object.defineProperty(exports, "RecoveringParser", { enumerable: true, get: function () { return parser_recovery_1.RecoveringParser; } });
+var typechecker_1 = require("./typechecker");
+Object.defineProperty(exports, "TypeChecker", { enumerable: true, get: function () { return typechecker_1.TypeChecker; } });
+var lowering_1 = require("./lowering");
+Object.defineProperty(exports, "Lowering", { enumerable: true, get: function () { return lowering_1.Lowering; } });
+var solver_1 = require("./solver");
+Object.defineProperty(exports, "ConstraintSolver", { enumerable: true, get: function () { return solver_1.ConstraintSolver; } });
+var emit_full_1 = require("./emit_full");
+Object.defineProperty(exports, "FullEmitter", { enumerable: true, get: function () { return emit_full_1.FullEmitter; } });
+var verifier_1 = require("./verifier");
+Object.defineProperty(exports, "Verifier", { enumerable: true, get: function () { return verifier_1.Verifier; } });
+var optimizer_1 = require("./optimizer");
+Object.defineProperty(exports, "optimize", { enumerable: true, get: function () { return optimizer_1.optimize; } });
+var module_loader_1 = require("./module_loader");
+Object.defineProperty(exports, "ModuleLoader", { enumerable: true, get: function () { return module_loader_1.ModuleLoader; } });
+var formatter_1 = require("./formatter");
+Object.defineProperty(exports, "Formatter", { enumerable: true, get: function () { return formatter_1.Formatter; } });
+var scaffold_1 = require("./scaffold");
+Object.defineProperty(exports, "scaffold", { enumerable: true, get: function () { return scaffold_1.scaffold; } });
+// AST types
+exports.AST = __importStar(require("./ast"));
+// IR types
+exports.IR = __importStar(require("./ir"));
+// Algorithm catalog
+var algorithm_catalog_1 = require("./algorithm_catalog");
+Object.defineProperty(exports, "lookupAlgorithm", { enumerable: true, get: function () { return algorithm_catalog_1.lookupAlgorithm; } });
+Object.defineProperty(exports, "listAlgorithms", { enumerable: true, get: function () { return algorithm_catalog_1.listAlgorithms; } });
+Object.defineProperty(exports, "listByCategory", { enumerable: true, get: function () { return algorithm_catalog_1.listByCategory; } });
+// Extension system
+var extension_manager_1 = require("./extension_manager");
+Object.defineProperty(exports, "mergeWithExisting", { enumerable: true, get: function () { return extension_manager_1.mergeWithExisting; } });
+Object.defineProperty(exports, "extractImplementations", { enumerable: true, get: function () { return extension_manager_1.extractImplementations; } });
+Object.defineProperty(exports, "validateExtensions", { enumerable: true, get: function () { return extension_manager_1.validateExtensions; } });
+/**
+ * Convenience function: compile a .bone source string to files.
+ */
+async function compile(source, sourceFile = "program.bone") {
+    const { createHash } = await Promise.resolve().then(() => __importStar(require("crypto")));
+    const { Lexer: L } = await Promise.resolve().then(() => __importStar(require("./lexer")));
+    const { Parser: P } = await Promise.resolve().then(() => __importStar(require("./parser")));
+    const { TypeChecker: TC } = await Promise.resolve().then(() => __importStar(require("./typechecker")));
+    const { Lowering: Lo } = await Promise.resolve().then(() => __importStar(require("./lowering")));
+    const { ConstraintSolver: CS } = await Promise.resolve().then(() => __importStar(require("./solver")));
+    const { FullEmitter: FE } = await Promise.resolve().then(() => __importStar(require("./emit_full")));
+    const { optimize: opt } = await Promise.resolve().then(() => __importStar(require("./optimizer")));
+    const errors = [];
+    const warnings = [];
+    const tokens = new L(source).tokenize();
+    const ast = new P(tokens).parse();
+    const typeErrors = new TC().check(ast);
+    for (const err of typeErrors) {
+        errors.push(`${err.code} at ${err.loc.line}:${err.loc.column}: ${err.message}`);
+    }
+    if (errors.length > 0)
+        return { files: [], errors, warnings };
+    const hash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+    const irSystems = new Lo().lower(ast, hash);
+    for (let i = 0; i < irSystems.length; i++) {
+        const result = opt(irSystems[i]);
+        irSystems[i] = result.system;
+        const solveResult = new CS().solve(irSystems[i]);
+        irSystems[i].resolution = solveResult.resolution;
+        for (const w of solveResult.warnings)
+            warnings.push(w);
+    }
+    const files = [];
+    const emitter = new FE();
+    for (const sys of irSystems) {
+        files.push(...emitter.emit(sys));
+    }
+    return { files, errors, warnings };
+}
+exports.compile = compile;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/ir.d.ts

@@ -0,0 +1,168 @@
+/**
+ * bone ir (Intermediate Representation) — Data structures.
+ * Implements spec/07_IR_SPEC.md.
+ *
+ * This is the canonical internal form: language-agnostic, fully resolved,
+ * strongly typed, and deterministically serializable.
+ */
+export type IRPrimitive = "string" | "uint" | "int" | "float" | "bool" | "timestamp" | "uuid" | "bytes" | "json";
+export interface IRField {
+    name: string;
+    type: string;
+    nullable: boolean;
+    unique: boolean;
+    indexed: boolean;
+    default_value: string | null;
+}
+export interface IRIndex {
+    fields: string[];
+    unique: boolean;
+}
+export interface IRModelConstraint {
+    kind: "unique" | "non_null" | "range" | "enum" | "check";
+    target: string;
+    params: Record<string, string | number | string[]>;
+}
+export interface IRModel {
+    name: string;
+    fields: IRField[];
+    primary_key: string;
+    indexes: IRIndex[];
+    constraints: IRModelConstraint[];
+}
+export interface IRPrecondition {
+    expression: string;
+    description: string;
+}
+export interface IREffect {
+    target: string;
+    op: "assign" | "add" | "remove";
+    value: string;
+}
+export interface IRMethod {
+    name: string;
+    input: IRField[];
+    output: string;
+    preconditions: IRPrecondition[];
+    effects: IREffect[];
+    emissions: string[];
+    idempotent: boolean;
+    authenticated: boolean;
+    timeout_ms: number;
+    retry: IRRetryPolicy | null;
+    pipeline: IRPipeline | null;
+    algorithm: IRAlgorithm | null;
+    sync: string | null;
+}
+export interface IRPipeline {
+    parallel: boolean;
+    steps: IRPipelineStep[];
+    on_error: IRPipelineErrorHandler | null;
+}
+export interface IRPipelineStep {
+    call_name: string;
+    call_args: string[];
+    bind_as: string | null;
+}
+export interface IRPipelineErrorHandler {
+    action: "rollback" | "compensate" | "ignore" | "retry";
+    call_name: string | null;
+    call_args: string[];
+}
+export interface IRAlgorithm {
+    catalog_name: string;
+    bindings: {
+        param: string;
+        value: string;
+    }[];
+}
+export interface IRRetryPolicy {
+    max_attempts: number;
+    backoff: "fixed" | "linear" | "exponential";
+    interval_ms: number;
+}
+export interface IRInterface {
+    name: string;
+    methods: IRMethod[];
+}
+export type IRDeliveryMode = "at_least_once" | "at_most_once" | "exactly_once";
+export type IROrderingMode = "fifo" | "causal" | "total" | "unordered";
+export interface IREvent {
+    id: string;
+    name: string;
+    payload: IRField[];
+    source: string;
+    delivery: IRDeliveryMode;
+    ordering: IROrderingMode;
+    ttl_ms: number | null;
+}
+export interface IRTransition {
+    from: string;
+    to: string;
+    trigger: string;
+    guard: string | null;
+}
+export interface IRStateMachine {
+    entity: string;
+    states: string[];
+    initial: string;
+    transitions: IRTransition[];
+}
+export type IRModuleKind = "api_service" | "worker_service" | "realtime_service" | "auth_service" | "data_store" | "event_bus" | "cache" | "gateway" | "frontend";
+export interface IRModule {
+    id: string;
+    kind: IRModuleKind;
+    name: string;
+    interfaces: IRInterface[];
+    models: IRModel[];
+    events: IREvent[];
+    state_machines: IRStateMachine[];
+    relations: IRRelation[];
+    dependencies: string[];
+    config: Record<string, string | number | boolean>;
+}
+export interface IRRelation {
+    name: string;
+    kind: "has_one" | "has_many" | "belongs_to" | "many_to_many";
+    from_entity: string;
+    to_entity: string;
+    from_table: string;
+    to_table: string;
+    foreign_key: string;
+    junction_table?: string;
+}
+export interface IRInvariant {
+    id: string;
+    expression: string;
+    scope: string;
+}
+export interface IRFlowStep {
+    name: string;
+    action: string;
+    compensation: string | null;
+}
+export interface IRFlow {
+    name: string;
+    steps: IRFlowStep[];
+}
+export interface IRSystem {
+    name: string;
+    version: string;
+    source_hash: string;
+    domain: string | null;
+    modules: IRModule[];
+    events: IREvent[];
+    flows: IRFlow[];
+    invariants: IRInvariant[];
+    resolution: Record<string, string>;
+    extension_points: IRExtensionPoint[];
+}
+export interface IRExtensionPoint {
+    name: string;
+    params: {
+        name: string;
+        type: string;
+    }[];
+    returns: string | null;
+    stable: boolean;
+}

package/dist/ir.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * bone ir (Intermediate Representation) — Data structures.
+ * Implements spec/07_IR_SPEC.md.
+ *
+ * This is the canonical internal form: language-agnostic, fully resolved,
+ * strongly typed, and deterministically serializable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ir.js.map

package/dist/ir.js.map

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

package/dist/lexer.d.ts

@@ -0,0 +1,195 @@
+/**
+ * bone lexer
+ * Converts source text into a token stream.
+ *
+ * This is a hand-written lexer (not regex-based) for precise error reporting
+ * and deterministic behavior. It implements the lexical rules from spec/02_GRAMMAR.peg.
+ */
+export declare enum TokenKind {
+    LBrace = "LBrace",
+    RBrace = "RBrace",
+    LBracket = "LBracket",
+    RBracket = "RBracket",
+    LParen = "LParen",
+    RParen = "RParen",
+    LAngle = "LAngle",
+    RAngle = "RAngle",
+    Colon = "Colon",
+    Comma = "Comma",
+    Dot = "Dot",
+    DotDot = "DotDot",
+    Arrow = "Arrow",
+    Pipe = "Pipe",
+    Semicolon = "Semicolon",
+    Equals = "Equals",
+    EqEq = "EqEq",
+    NotEq = "NotEq",
+    LtEq = "LtEq",
+    GtEq = "GtEq",
+    Plus = "Plus",
+    Minus = "Minus",
+    Star = "Star",
+    Slash = "Slash",
+    Percent = "Percent",
+    PlusEq = "PlusEq",
+    MinusEq = "MinusEq",
+    AppendEq = "AppendEq",
+    Question = "Question",
+    Bang = "Bang",
+    StringLiteral = "StringLiteral",
+    IntLiteral = "IntLiteral",
+    FloatLiteral = "FloatLiteral",
+    KwSystem = "KwSystem",
+    KwEntity = "KwEntity",
+    KwCapability = "KwCapability",
+    KwChannel = "KwChannel",
+    KwStore = "KwStore",
+    KwEvent = "KwEvent",
+    KwConstraint = "KwConstraint",
+    KwPolicy = "KwPolicy",
+    KwFlow = "KwFlow",
+    KwImport = "KwImport",
+    KwFrom = "KwFrom",
+    KwDomain = "KwDomain",
+    KwOwns = "KwOwns",
+    KwConstraints = "KwConstraints",
+    KwStates = "KwStates",
+    KwAuth = "KwAuth",
+    KwRelation = "KwRelation",
+    KwIndex = "KwIndex",
+    KwDerived = "KwDerived",
+    KwRequires = "KwRequires",
+    KwEffects = "KwEffects",
+    KwEmits = "KwEmits",
+    KwSync = "KwSync",
+    KwTimeout = "KwTimeout",
+    KwRetry = "KwRetry",
+    KwIdempotent = "KwIdempotent",
+    KwTransport = "KwTransport",
+    KwOrdering = "KwOrdering",
+    KwParticipants = "KwParticipants",
+    KwPersistence = "KwPersistence",
+    KwFilter = "KwFilter",
+    KwMaxSize = "KwMaxSize",
+    KwEngine = "KwEngine",
+    KwSchema = "KwSchema",
+    KwRetention = "KwRetention",
+    KwPartition = "KwPartition",
+    KwReplicas = "KwReplicas",
+    KwPayload = "KwPayload",
+    KwDelivery = "KwDelivery",
+    KwTtl = "KwTtl",
+    KwRateLimit = "KwRateLimit",
+    KwAccess = "KwAccess",
+    KwAudit = "KwAudit",
+    KwEncryption = "KwEncryption",
+    KwStep = "KwStep",
+    KwCompensate = "KwCompensate",
+    KwPer = "KwPer",
+    KwHasOne = "KwHasOne",
+    KwHasMany = "KwHasMany",
+    KwBelongsTo = "KwBelongsTo",
+    KwManyToMany = "KwManyToMany",
+    KwJwt = "KwJwt",
+    KwOauth2 = "KwOauth2",
+    KwApikey = "KwApikey",
+    KwSession = "KwSession",
+    KwWebsocket = "KwWebsocket",
+    KwSse = "KwSse",
+    KwPolling = "KwPolling",
+    KwGrpcStream = "KwGrpcStream",
+    KwCausal = "KwCausal",
+    KwFifo = "KwFifo",
+    KwTotal = "KwTotal",
+    KwUnordered = "KwUnordered",
+    KwPostgresql = "KwPostgresql",
+    KwRedis = "KwRedis",
+    KwMongodb = "KwMongodb",
+    KwSqlite = "KwSqlite",
+    KwS3 = "KwS3",
+    KwDynamodb = "KwDynamodb",
+    KwAtLeastOnce = "KwAtLeastOnce",
+    KwAtMostOnce = "KwAtMostOnce",
+    KwExactlyOnce = "KwExactlyOnce",
+    KwAtRest = "KwAtRest",
+    KwInTransit = "KwInTransit",
+    KwBoth = "KwBoth",
+    KwRealtime = "KwRealtime",
+    KwEventual = "KwEventual",
+    KwBatch = "KwBatch",
+    KwTransactional = "KwTransactional",
+    KwMaxAttempts = "KwMaxAttempts",
+    KwBackoff = "KwBackoff",
+    KwInterval = "KwInterval",
+    KwString = "KwString",
+    KwUint = "KwUint",
+    KwInt = "KwInt",
+    KwFloat = "KwFloat",
+    KwBool = "KwBool",
+    KwTimestamp = "KwTimestamp",
+    KwUuid = "KwUuid",
+    KwBytes = "KwBytes",
+    KwMap = "KwMap",
+    KwJson = "KwJson",
+    KwSet = "KwSet",
+    KwList = "KwList",
+    KwOptional = "KwOptional",
+    KwResult = "KwResult",
+    KwTrue = "KwTrue",
+    KwFalse = "KwFalse",
+    KwNone = "KwNone",
+    KwAnd = "KwAnd",
+    KwOr = "KwOr",
+    KwNot = "KwNot",
+    KwIn = "KwIn",
+    KwContains = "KwContains",
+    KwUnique = "KwUnique",
+    KwFull = "KwFull",
+    KwPipeline = "KwPipeline",
+    KwParallel = "KwParallel",
+    KwOnError = "KwOnError",
+    KwReturns = "KwReturns",
+    KwAlgorithm = "KwAlgorithm",
+    KwUsing = "KwUsing",
+    KwExtensionPoint = "KwExtensionPoint",
+    KwStable = "KwStable",
+    KwLanguage = "KwLanguage",
+    KwNow = "KwNow",
+    Identifier = "Identifier",
+    EOF = "EOF"
+}
+export interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface Token {
+    kind: TokenKind;
+    value: string;
+    loc: SourceLocation;
+}
+export declare class LexerError extends Error {
+    loc: SourceLocation;
+    constructor(message: string, loc: SourceLocation);
+}
+export declare class Lexer {
+    private source;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    constructor(source: string);
+    tokenize(): Token[];
+    private currentLoc;
+    private peek;
+    private peekAt;
+    private advance;
+    private skipWhitespaceAndComments;
+    private nextToken;
+    private readString;
+    private readNumber;
+    private readIdentifierOrKeyword;
+    private isDigit;
+    private isIdentStart;
+    private isIdentChar;
+}