interscript 2.4.1 → 3.0.0

package/dist/ml/session/litert-web.js.map

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

package/dist/ml/session/onnx-node.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Node.js backend — wraps onnxruntime-node.
+ *
+ * Server-only: requires Node native modules. Imported lazily by the
+ * session factory only when the runtime detects a Node environment.
+ * Don't import this from browser bundles.
+ */
+import type { InferenceSession } from "../types.js";
+export declare function createNodeSession(modelData: ArrayBuffer | Uint8Array): Promise<InferenceSession>;
+//# sourceMappingURL=onnx-node.d.ts.map

package/dist/ml/session/onnx-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnx-node.d.ts","sourceRoot":"","sources":["../../../src/ml/session/onnx-node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAKjB,MAAM,aAAa,CAAA;AA8EpB,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,WAAW,GAAG,UAAU,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAE3B"}

package/dist/ml/session/onnx-node.js

@@ -0,0 +1,62 @@
+/**
+ * Node.js backend — wraps onnxruntime-node.
+ *
+ * Server-only: requires Node native modules. Imported lazily by the
+ * session factory only when the runtime detects a Node environment.
+ * Don't import this from browser bundles.
+ */
+async function loadOrt() {
+    try {
+        return (await import("onnxruntime-node"));
+    }
+    catch (e) {
+        throw new Error("onnxruntime-node is required for ML inference in Node. Install with: npm install onnxruntime-node", { cause: e });
+    }
+}
+class NodeInferenceSession {
+    session;
+    ort;
+    inputNames;
+    outputNames;
+    inputMetadata;
+    constructor(session, ort) {
+        this.session = session;
+        this.ort = ort;
+        this.inputNames = session.inputNames;
+        this.outputNames = session.outputNames;
+        const raw = session.inputMetadata;
+        if (Array.isArray(raw)) {
+            this.inputMetadata = raw;
+        }
+    }
+    static async create(modelData) {
+        const ort = await loadOrt();
+        const session = await ort.InferenceSession.create(modelData);
+        return new NodeInferenceSession(session, ort);
+    }
+    async run(inputs) {
+        const feeds = {};
+        for (const [name, tensor] of Object.entries(inputs)) {
+            feeds[name] = new this.ort.Tensor(tensor.type, tensor.data, tensor.dims);
+        }
+        const outputs = await this.session.run(feeds);
+        const out = {};
+        for (const [name, value] of Object.entries(outputs)) {
+            const v = value;
+            out[name] = {
+                name,
+                type: v.type,
+                data: v.data,
+                dims: v.dims,
+            };
+        }
+        return out;
+    }
+    async dispose() {
+        await this.session.release();
+    }
+}
+export async function createNodeSession(modelData) {
+    return NodeInferenceSession.create(modelData);
+}
+//# sourceMappingURL=onnx-node.js.map

package/dist/ml/session/onnx-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnx-node.js","sourceRoot":"","sources":["../../../src/ml/session/onnx-node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA0BH,KAAK,UAAU,OAAO;IACpB,IAAI,CAAC;QACH,OAAO,CAAC,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAA8B,CAAA;IACxE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,mGAAmG,EACnG,EAAE,KAAK,EAAE,CAAC,EAAE,CACb,CAAA;IACH,CAAC;AACH,CAAC;AAED,MAAM,oBAAoB;IACP,OAAO,CAAiB;IACxB,GAAG,CAAgB;IAC3B,UAAU,CAAmB;IAC7B,WAAW,CAAmB;IAC9B,aAAa,CAC4E;IAElG,YAAoB,OAAwB,EAAE,GAAmB;QAC/D,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QACd,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAA;QACpC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;QACtC,MAAM,GAAG,GAAI,OAAuC,CAAC,aAAa,CAAA;QAClE,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,GAAG,GAA4C,CAAA;QACnE,CAAC;IACH,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,SAAmC;QACrD,MAAM,GAAG,GAAG,MAAM,OAAO,EAAE,CAAA;QAC3B,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;QAC5D,OAAO,IAAI,oBAAoB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;IAC/C,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,MAAuB;QAC/B,MAAM,KAAK,GAA4B,EAAE,CAAA;QACzC,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACpD,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;QAC1E,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAC7C,MAAM,GAAG,GAA2B,EAAE,CAAA;QACtC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACpD,MAAM,CAAC,GAAG,KAA2D,CAAA;YACrE,GAAG,CAAC,IAAI,CAAC,GAAG;gBACV,IAAI;gBACJ,IAAI,EAAE,CAAC,CAAC,IAAsB;gBAC9B,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAA;QACH,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;IAC9B,CAAC;CACF;AAED,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAmC;IAEnC,OAAO,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;AAC/C,CAAC"}

package/dist/ml/session/onnx-web.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Browser backend — wraps onnxruntime-web with WebGPU + WASM fallback.
+ *
+ * Imported lazily by the session factory. Bundlers will only include
+ * this in browser builds.
+ *
+ * onnxruntime-web is a peer dep; users install it if they need ML.
+ * Without it, calling rababa() from the browser throws a clear error.
+ */
+import type { InferenceSession } from "../types.js";
+export interface WebSessionOptions {
+    /**
+     * Try WebGPU first, fall back to WASM if WebGPU is unavailable or
+     * fails to initialize. Default: `true` — most browsers shipped WebGPU
+     * by default as of Nov 2025 (Chrome 113+, Safari 17+, Firefox 141+).
+     *
+     * Set to `false` to force WASM only — useful for debugging WebGPU
+     * quirks or in environments where the GPU driver is known to be bad.
+     */
+    webgpu?: boolean;
+}
+export declare function createWebSession(modelData: ArrayBuffer | Uint8Array, opts?: WebSessionOptions): Promise<InferenceSession>;
+//# sourceMappingURL=onnx-web.d.ts.map

package/dist/ml/session/onnx-web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnx-web.d.ts","sourceRoot":"","sources":["../../../src/ml/session/onnx-web.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAKjB,MAAM,aAAa,CAAA;AAEpB,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAuGD,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,WAAW,GAAG,UAAU,EACnC,IAAI,GAAE,iBAAsB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAE3B"}

package/dist/ml/session/onnx-web.js

@@ -0,0 +1,74 @@
+/**
+ * Browser backend — wraps onnxruntime-web with WebGPU + WASM fallback.
+ *
+ * Imported lazily by the session factory. Bundlers will only include
+ * this in browser builds.
+ *
+ * onnxruntime-web is a peer dep; users install it if they need ML.
+ * Without it, calling rababa() from the browser throws a clear error.
+ */
+let cached;
+async function loadOrt() {
+    if (!cached) {
+        cached = (async () => {
+            try {
+                const mod = (await import("onnxruntime-web"));
+                // Use SIMD when available (~2x faster for WASM fallback path).
+                mod.env.wasm.simd = true;
+                return mod;
+            }
+            catch (e) {
+                cached = undefined;
+                throw new Error("onnxruntime-web is required for ML inference in the browser. Install with: npm install onnxruntime-web", { cause: e });
+            }
+        })();
+    }
+    return cached;
+}
+class WebInferenceSession {
+    session;
+    ort;
+    inputNames;
+    outputNames;
+    constructor(session, ort) {
+        this.session = session;
+        this.ort = ort;
+        this.inputNames = session.inputNames;
+        this.outputNames = session.outputNames;
+    }
+    static async create(modelData, opts = {}) {
+        const ort = await loadOrt();
+        // Execution provider preference — onnxruntime-web picks the first
+        // available; WebGPU silently falls back to WASM when unavailable.
+        const executionProviders = opts.webgpu === false ? ["wasm"] : ["webgpu", "wasm"];
+        const session = await ort.InferenceSession.create(modelData, {
+            executionProviders,
+        });
+        return new WebInferenceSession(session, ort);
+    }
+    async run(inputs) {
+        const feeds = {};
+        for (const [name, tensor] of Object.entries(inputs)) {
+            feeds[name] = new this.ort.Tensor(tensor.type, tensor.data, tensor.dims);
+        }
+        const outputs = await this.session.run(feeds);
+        const out = {};
+        for (const [name, value] of Object.entries(outputs)) {
+            const v = value;
+            out[name] = {
+                name,
+                type: v.type,
+                data: v.data,
+                dims: v.dims,
+            };
+        }
+        return out;
+    }
+    async dispose() {
+        await this.session.release();
+    }
+}
+export async function createWebSession(modelData, opts = {}) {
+    return WebInferenceSession.create(modelData, opts);
+}
+//# sourceMappingURL=onnx-web.js.map

package/dist/ml/session/onnx-web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnx-web.js","sourceRoot":"","sources":["../../../src/ml/session/onnx-web.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkDH,IAAI,MAAyC,CAAA;AAE7C,KAAK,UAAU,OAAO;IACpB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,GAAG,CAAC,KAAK,IAAI,EAAE;YACnB,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,CAAC,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAA4B,CAAA;gBACxE,+DAA+D;gBAC/D,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;gBACxB,OAAO,GAAG,CAAA;YACZ,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,MAAM,GAAG,SAAS,CAAA;gBAClB,MAAM,IAAI,KAAK,CACb,wGAAwG,EACxG,EAAE,KAAK,EAAE,CAAC,EAAE,CACb,CAAA;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CAAA;IACN,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED,MAAM,mBAAmB;IACN,OAAO,CAAe;IACtB,GAAG,CAAc;IACzB,UAAU,CAAmB;IAC7B,WAAW,CAAmB;IAEvC,YAAoB,OAAsB,EAAE,GAAiB;QAC3D,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QACd,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAA;QACpC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;IACxC,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,MAAM,CACjB,SAAmC,EACnC,OAA0B,EAAE;QAE5B,MAAM,GAAG,GAAG,MAAM,OAAO,EAAE,CAAA;QAC3B,kEAAkE;QAClE,kEAAkE;QAClE,MAAM,kBAAkB,GAAa,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;QAC1F,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,EAAE;YAC3D,kBAAkB;SACnB,CAAC,CAAA;QACF,OAAO,IAAI,mBAAmB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;IAC9C,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,MAAuB;QAC/B,MAAM,KAAK,GAA4B,EAAE,CAAA;QACzC,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACpD,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;QAC1E,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAC7C,MAAM,GAAG,GAA2B,EAAE,CAAA;QACtC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACpD,MAAM,CAAC,GAAG,KAA2D,CAAA;YACrE,GAAG,CAAC,IAAI,CAAC,GAAG;gBACV,IAAI;gBACJ,IAAI,EAAE,CAAC,CAAC,IAAsB;gBAC9B,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAA;QACH,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;IAC9B,CAAC;CACF;AAED,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,SAAmC,EACnC,OAA0B,EAAE;IAE5B,OAAO,mBAAmB,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;AACpD,CAAC"}

package/dist/ml/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * ML types — used by the model registry, sessions, and individual model
+ * implementations. Discriminated unions throughout so adding a new
+ * model kind or backend is purely additive (OCP).
+ */
+/**
+ * Discriminated union of every supported model kind. Add a new variant
+ * here + register a factory; nothing else changes.
+ */
+export type ModelKind = "rababa" | "secryst";
+/**
+ * Reference to a model the runtime can provision. Discriminated by
+ * `kind` so the registry can dispatch to the right factory.
+ */
+export interface ModelRef {
+    readonly kind: ModelKind;
+    /** Model-specific identifier (e.g. "200" for rababa max-len-200). */
+    readonly id: string;
+    /** Optional override URL for the model file (otherwise from manifest). */
+    readonly url?: string;
+}
+/**
+ * Input to an ONNX inference call. The runtime hands the model a
+ * Record of named tensors.
+ */
+export type TensorData = Int8Array | Uint8Array | Int16Array | Int32Array | Float32Array | Float64Array | BigInt64Array;
+export interface Tensor {
+    readonly name: string;
+    readonly data: TensorData;
+    readonly dims: readonly number[];
+    readonly type: "int8" | "uint8" | "int16" | "int32" | "int64" | "float32" | "float64";
+}
+export interface InferenceInputs {
+    readonly [name: string]: Tensor;
+}
+export interface InferenceOutputs {
+    readonly [name: string]: Tensor;
+}
+/**
+ * An inference session wraps an ONNX model. Both Node and browser
+ * backends implement this interface; callers don't know which.
+ */
+export interface SessionInputMetadata {
+    readonly name: string;
+    readonly type: string;
+    readonly shape: ReadonlyArray<string | number>;
+}
+export interface InferenceSession {
+    /** Run inference with named inputs. Returns named outputs. */
+    run(inputs: InferenceInputs): Promise<InferenceOutputs>;
+    /** Input names the model accepts. */
+    inputNames: readonly string[];
+    /** Input shapes/types when the backend exposes them (used for
+     *  zero-length KV pasts whose static dims must match the graph). */
+    readonly inputMetadata?: readonly SessionInputMetadata[] | undefined;
+    /** Output names the model produces. */
+    outputNames: readonly string[];
+    /** Free native resources held by the session. */
+    dispose(): Promise<void>;
+}
+/**
+ * A loaded model — has a session plus any auxiliary artifacts
+ * (vocabularies, configs). Each ModelKind has its own subclass
+ * extending this; the registry returns Model implementations
+ * generically.
+ */
+export interface Model {
+    readonly kind: ModelKind;
+    /** Free native resources. */
+    dispose(): Promise<void>;
+}
+/**
+ * Universal text-transform interface. Every ML model — rababa,
+ * secryst, ByT5, or future kinds — implements this single method.
+ *
+ * The interpreter calls `transform(input)` for ANY async funcall,
+ * regardless of model kind. No per-model branching in the interpreter
+ * (OCP: adding a new model kind doesn't change the interpreter).
+ *
+ * MECE: the interface knows about text transformation. It does NOT
+ * know about Arabic diacritization, Thai transliteration, or any
+ * domain-specific concept.
+ */
+export interface MLModel extends Model {
+    /**
+     * Transform input text into output text.
+     *
+     * Rababa: undiacritized Arabic → diacritized Arabic
+     * Secryst: source script → target script
+     * Future models: any text-to-text transformation
+     */
+    transform(input: string): Promise<string>;
+}
+/**
+ * Factory for a model. Given a provisioned bundle (session + auxiliary
+ * data), return a Model implementation.
+ *
+ * Each kind registers exactly one factory (MECE).
+ */
+export type ModelFactory = (params: ModelLoadParams) => Promise<MLModel>;
+export interface ModelLoadParams {
+    readonly session: InferenceSession;
+    readonly artifacts: ModelArtifacts;
+}
+/**
+ * Auxiliary files that ship alongside the model ONNX file:
+ * vocabularies, configs, metadata. Loaded by the provisioner before
+ * the factory is called.
+ */
+export interface ModelArtifacts {
+    readonly [filename: string]: Uint8Array | string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/ml/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ml/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE5C;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,0EAA0E;IAC1E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GACpB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,GAAG,aAAa,CAAA;AAEhG,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAA;CACtF;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;CAC/C;AAED,MAAM,WAAW,gBAAgB;IAC/B,8DAA8D;IAC9D,GAAG,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACvD,qCAAqC;IACrC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B;wEACoE;IACpE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,CAAA;IACpE,uCAAuC;IACvC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,iDAAiD;IACjD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,6BAA6B;IAC7B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,OAAQ,SAAQ,KAAK;IACpC;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CAC1C;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAExE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAA;CACnC;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAAA;CACjD"}

package/dist/ml/types.js

@@ -0,0 +1,7 @@
+/**
+ * ML types — used by the model registry, sessions, and individual model
+ * implementations. Discriminated unions throughout so adding a new
+ * model kind or backend is purely additive (OCP).
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/ml/types.js.map

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

package/dist/runtime/compile-item.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Item compilation — convert AST Items into RegExp source or literal string.
+ *
+ * Items are decomposed into their compiled form ONCE per stage, then
+ * reused across many string inputs. This avoids redundant work and
+ * keeps the interpreter's inner loop tight (DRY + performance).
+ */
+import type { Item } from "../types.js";
+import type { ExecutionContext } from "./context.js";
+/** Compiled form of a pattern Item. */
+export interface CompiledItem {
+    /** RegExp source. */
+    readonly re: string;
+    /** Literal value (for replacement strings). */
+    readonly literal: string;
+}
+/**
+ * Compile an Item into a RegExp source string + literal value.
+ * Visitor-free dispatch — adding a new Item kind = adding a case here.
+ *
+ * Note: this is intentionally a single switch with exhaustive type
+ * coverage. New Item kinds force this switch to be updated, which is
+ * good — it surfaces the change rather than hiding it.
+ */
+export declare function compileItem(item: Item, ctx: ExecutionContext): CompiledItem;
+/**
+ * Compile an Item to a literal string only (no regex semantics).
+ * Used by the parallel-replace executor which needs exact strings.
+ *
+ * Returns `null` if the Item cannot be represented as a literal
+ * (captures, regex-only constructs). The caller decides whether to
+ * fall back to sequential execution.
+ */
+export declare function compileToLiteral(item: Item, ctx: ExecutionContext): string | null;
+/**
+ * Expand a `from` item into ALL possible literal strings for parallel
+ * replace. `any` items produce one entry per alternative. Other items
+ * produce a single entry (or null if not literal).
+ *
+ * This is the multi-valued counterpart of `compileToLiteral`.
+ */
+export declare function expandFromLiterals(item: Item, ctx: ExecutionContext): string[] | null;
+/**
+ * Compute the max-length estimate for an Item. Mirrors Ruby's
+ * `Node::Item#max_length`, which is used to sort parallel rules
+ * (longest first) before building the megaregexp fallback.
+ *
+ * The estimate need not be exact — it only governs sort order within
+ * a parallel block. Stdlib aliases count as length 1 (matching Ruby),
+ * `none` is 0.
+ */
+export declare function maxLengthOfItem(item: Item, ctx: ExecutionContext): number;
+//# sourceMappingURL=compile-item.d.ts.map

package/dist/runtime/compile-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-item.d.ts","sourceRoot":"","sources":["../../src/runtime/compile-item.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAGpD,uCAAuC;AACvC,MAAM,WAAW,YAAY;IAC3B,qBAAqB;IACrB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,GAAG,YAAY,CAqE3E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CA4CjF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,GAAG,MAAM,EAAE,GAAG,IAAI,CA2DrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAyBzE"}

package/dist/runtime/compile-item.js

@@ -0,0 +1,278 @@
+/**
+ * Item compilation — convert AST Items into RegExp source or literal string.
+ *
+ * Items are decomposed into their compiled form ONCE per stage, then
+ * reused across many string inputs. This avoids redundant work and
+ * keeps the interpreter's inner loop tight (DRY + performance).
+ */
+import { regexpEscape } from "../stdlib.js";
+/**
+ * Compile an Item into a RegExp source string + literal value.
+ * Visitor-free dispatch — adding a new Item kind = adding a case here.
+ *
+ * Note: this is intentionally a single switch with exhaustive type
+ * coverage. New Item kinds force this switch to be updated, which is
+ * good — it surfaces the change rather than hiding it.
+ */
+export function compileItem(item, ctx) {
+    switch (item.kind) {
+        case "string":
+            return { re: regexpEscape(item.value), literal: item.value };
+        case "capture_group": {
+            const inner = compileItem(item.data, ctx);
+            return { re: `(${inner.re})`, literal: inner.literal };
+        }
+        case "capture_ref": {
+            const id = item.id;
+            return { re: `\\${id}`, literal: `$${id}` };
+        }
+        case "alias": {
+            // Stdlib aliases (single characters like \w, \b, etc.)
+            const stdlib = STDLIB_ALIASES[item.name];
+            if (stdlib)
+                return stdlib;
+            const resolved = ctx.resolveAlias(item.name);
+            if (!resolved)
+                return { re: "", literal: "" };
+            return compileItem(resolved, ctx);
+        }
+        case "any": {
+            const parts = item.of.map((i) => compileItem(i, ctx).re);
+            // Mirror Ruby's Any#nth_string: the literal form picks the first
+            // alternative. Sub rules with `to: any("ie")` use this for the
+            // canonical replacement.
+            const firstLit = item.of.length > 0 ? compileItem(item.of[0], ctx).literal : "";
+            return { re: `(?:${parts.join("|")})`, literal: firstLit };
+        }
+        case "any_char_class": {
+            // Build a JS char class. Range → [first-last], chars → [abc].
+            // Both forms are escaped so a literal `]` or `-` survives.
+            if (item.range) {
+                const [first, last] = item.range;
+                return {
+                    re: `[${regexpEscape(first)}-${regexpEscape(last)}]`,
+                    literal: first ?? "",
+                };
+            }
+            if (item.chars && item.chars.length > 0) {
+                const escaped = item.chars.map((c) => regexpEscape(c)).join("");
+                return { re: `[${escaped}]`, literal: item.chars[0] };
+            }
+            return { re: "[^]", literal: "" };
+        }
+        case "group": {
+            const compiled = item.items.map((i) => compileItem(i, ctx));
+            const re = compiled.map((c) => c.re).join("");
+            const literal = compiled.map((c) => c.literal).join("");
+            return { re: `(?:${re})`, literal };
+        }
+        case "repeat": {
+            const inner = compileItem(item.item, ctx).re;
+            const { min, max } = item;
+            const maxVal = max === null ? Infinity : max;
+            const quant = maxVal === Infinity ? (min === 0 ? "*" : "+") : `{${min},${maxVal}}`;
+            return { re: `(?:${inner})${quant}`, literal: "" };
+        }
+        case "stage_ref":
+            // Stage references are handled by the executor, not by item compilation.
+            return { re: "", literal: "" };
+    }
+}
+/**
+ * Compile an Item to a literal string only (no regex semantics).
+ * Used by the parallel-replace executor which needs exact strings.
+ *
+ * Returns `null` if the Item cannot be represented as a literal
+ * (captures, regex-only constructs). The caller decides whether to
+ * fall back to sequential execution.
+ */
+export function compileToLiteral(item, ctx) {
+    switch (item.kind) {
+        case "string":
+            return item.value;
+        case "alias": {
+            const stdlib = STDLIB_ALIASES[item.name];
+            if (stdlib)
+                return stdlib.literal === "" ? null : stdlib.literal;
+            const resolved = ctx.resolveAlias(item.name);
+            if (!resolved)
+                return null;
+            return compileToLiteral(resolved, ctx);
+        }
+        case "capture_group":
+        case "capture_ref":
+        case "repeat":
+        case "stage_ref":
+            return null;
+        case "any_char_class": {
+            // Mirror Ruby's Any#nth_string: first char of the class.
+            if (item.chars && item.chars.length > 0)
+                return item.chars[0];
+            if (item.range)
+                return item.range[0];
+            return null;
+        }
+        case "any": {
+            // `any` represents alternative spellings (e.g. "te" vs "t" for the
+            // same source char). Ruby picks the first option in non-iterating
+            // mode; we match that.
+            if (item.of.length === 0)
+                return null;
+            return compileToLiteral(item.of[0], ctx);
+        }
+        case "group": {
+            let out = "";
+            for (const child of item.items) {
+                const lit = compileToLiteral(child, ctx);
+                if (lit === null)
+                    return null;
+                out += lit;
+            }
+            return out;
+        }
+    }
+}
+/**
+ * Expand a `from` item into ALL possible literal strings for parallel
+ * replace. `any` items produce one entry per alternative. Other items
+ * produce a single entry (or null if not literal).
+ *
+ * This is the multi-valued counterpart of `compileToLiteral`.
+ */
+export function expandFromLiterals(item, ctx) {
+    switch (item.kind) {
+        case "string":
+            return [item.value];
+        case "alias": {
+            const stdlib = STDLIB_ALIASES[item.name];
+            if (stdlib)
+                return null;
+            const resolved = ctx.resolveAlias(item.name);
+            if (!resolved)
+                return null;
+            return expandFromLiterals(resolved, ctx);
+        }
+        case "any_char_class": {
+            // Mirror Ruby's parallel-tree expansion: one entry per char.
+            // For ranges, expand every code point — same as Ruby's Any#data
+            // when value is a Range.
+            if (item.chars)
+                return [...item.chars];
+            if (item.range) {
+                const [first, last] = item.range;
+                const start = first.codePointAt(0);
+                const end = last.codePointAt(0);
+                const out = [];
+                for (let cp = start; cp <= end; cp++)
+                    out.push(String.fromCodePoint(cp));
+                return out;
+            }
+            return null;
+        }
+        case "any": {
+            const out = [];
+            for (const child of item.of) {
+                const lit = expandFromLiterals(child, ctx);
+                if (lit === null)
+                    return null;
+                out.push(...lit);
+            }
+            return out;
+        }
+        case "group": {
+            // Cartesian product of all children's alternatives.
+            let combos = [""];
+            for (const child of item.items) {
+                const childAlts = expandFromLiterals(child, ctx);
+                if (childAlts === null)
+                    return null;
+                const next = [];
+                for (const prefix of combos) {
+                    for (const suffix of childAlts) {
+                        next.push(prefix + suffix);
+                    }
+                }
+                combos = next;
+            }
+            return combos;
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Compute the max-length estimate for an Item. Mirrors Ruby's
+ * `Node::Item#max_length`, which is used to sort parallel rules
+ * (longest first) before building the megaregexp fallback.
+ *
+ * The estimate need not be exact — it only governs sort order within
+ * a parallel block. Stdlib aliases count as length 1 (matching Ruby),
+ * `none` is 0.
+ */
+export function maxLengthOfItem(item, ctx) {
+    switch (item.kind) {
+        case "string":
+            return item.value.length;
+        case "capture_group":
+            return maxLengthOfItem(item.data, ctx);
+        case "capture_ref":
+            return 1;
+        case "alias": {
+            if (item.name === "none")
+                return 0;
+            if (STDLIB_ALIASES[item.name])
+                return 1;
+            const resolved = ctx.resolveAlias(item.name);
+            return resolved ? maxLengthOfItem(resolved, ctx) : 1;
+        }
+        case "any":
+            return item.of.reduce((m, i) => Math.max(m, maxLengthOfItem(i, ctx)), 0);
+        case "any_char_class":
+            return 1;
+        case "group":
+            return item.items.reduce((sum, i) => sum + maxLengthOfItem(i, ctx), 0);
+        case "repeat":
+            return maxLengthOfItem(item.item, ctx);
+        case "stage_ref":
+            return 1;
+    }
+}
+/**
+ * Stdlib alias table — single-character aliases like `:word`, `:boundary`.
+ * Mirrors Interscript::Stdlib::ALIASES in Ruby.
+ */
+const STDLIB_ALIASES = Object.freeze({
+    any_character: { re: ".", literal: "" },
+    none: { re: "", literal: "" },
+    space: { re: " ", literal: " " },
+    whitespace: { re: "\\s+", literal: " " },
+    // Boundary is implemented as Unicode-aware lookarounds so that
+    // Cyrillic, Arabic, Devanagari etc. get correct word boundaries
+    // (66 maps rely on this). Ruby's \b is ASCII-only by default, but
+    // most maps work because their boundary usage is at start-of-string
+    // or after whitespace — cases where ASCII \b happens to coincide
+    // with the Unicode form.
+    boundary: {
+        re: "(?:(?<![\\p{L}\\p{M}])(?=[\\p{L}\\p{M}])|(?<=[\\p{L}\\p{M}])(?![\\p{L}\\p{M}]))",
+        literal: "",
+    },
+    non_word_boundary: {
+        re: "(?:(?<=[\\p{L}\\p{M}])(?=[\\p{L}\\p{M}])|(?<![\\p{L}\\p{M}])(?![\\p{L}\\p{M}]))",
+        literal: "",
+    },
+    // word / not_word mirror Ruby's default ASCII-only \w / \W. Only one
+    // map (odni-che-Cyrl-Latn-2015) uses these aliases — its palochka
+    // rule depends on Cyrillic being treated as non-word. ASCII-only
+    // here is harmless to the 65+ maps that use boundary instead.
+    word: { re: "[A-Za-z0-9_]", literal: "" },
+    not_word: { re: "[^A-Za-z0-9_]", literal: "" },
+    alpha: { re: "[a-zA-Z]", literal: "" },
+    not_alpha: { re: "[^a-zA-Z]", literal: "" },
+    digit: { re: "[0-9]", literal: "" },
+    not_digit: { re: "[^0-9]", literal: "" },
+    line_start: { re: "^", literal: "" },
+    line_end: { re: "(?=\\n|$)", literal: "" },
+    string_start: { re: "^", literal: "" },
+    string_end: { re: "$", literal: "" },
+});
+//# sourceMappingURL=compile-item.js.map