pi-mega-compact 0.4.23 → 0.4.25

package/dist/extensions/dashboard-server.js

@@ -11,11 +11,32 @@
  * @module
  */
 import { createServer } from "node:http";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, watch, writeFileSync, appendFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
+// ---------------------------------------------------------------------------
+// Local runtime log
+//
+// The dashboard server is spawned as a DETACHED child. When it is launched with
+// `stdio: "ignore"` (the old default) any crash before the first console.log is
+// invisible — there is no log to "check". We therefore mirror every lifecycle
+// line to a file in the state dir so a failed start is always diagnosable. The
+// launcher also captures stderr, so this doubles as defense-in-depth.
+// ---------------------------------------------------------------------------
+let LOG_PATH = null;
+function log(...parts) {
+    const line = `[mega-compact][dashboard] ${parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")}`;
+    // eslint-disable-next-line no-console
+    console.error(line); // stderr — captured by the launcher pipe
+    if (LOG_PATH) {
+        try {
+            appendFileSync(LOG_PATH, new Date().toISOString() + " " + line + "\n");
+        }
+        catch { /* non-fatal */ }
+    }
+}
 // --- Multi-repo index (Phase 5b) ------------------------------------------------
 // The extension writes a machine-wide repo registry into a single SQLite DB
 // (<indexDir>/index.sqlite) as the concurrency-safe write path; the dashboard
@@ -651,7 +672,7 @@ function dashboardHtml(tierName) {
 // ---------------------------------------------------------------------------
 // Server
 // ---------------------------------------------------------------------------
-export function launchDashboardServer(stateDir) {
+export async function launchDashboardServer(stateDir) {
     // Our own package version — exposed at /api/version so the launcher can
     // detect a stale server (started by an older build) and replace it on
     // upgrade instead of reuse it.
@@ -675,17 +696,41 @@ export function launchDashboardServer(stateDir) {
     const portFile = join(stateDir, "port.pid");
     const snapshotPath = join(stateDir, "dashboard.json");
     const eventsPath = join(stateDir, "events.log");
-    // ── Existing server? ──────────────────────────────────────────────────────
+    LOG_PATH = join(stateDir, "dashboard.log");
+    log("launch invoked", { stateDir });
+    // ── Existing server? ───────────────────────────────────────────────────────
+    // A stale port.pid pointing at a dead/competing process is the classic cause
+    // of "dashboard failed to start" — we return a port that is NOT actually
+    // serving. Probe for a live server on that port first; only reuse the marker
+    // when something real answers /api/version. Otherwise drop it and start fresh.
     if (existsSync(portFile)) {
         try {
             const info = JSON.parse(readFileSync(portFile, "utf-8"));
             if (info && info.port) {
-                return Promise.resolve({ port: info.port, url: `http://localhost:${info.port}` });
+                let live = false;
+                try {
+                    const probe = await fetch(`http://localhost:${info.port}/api/version`, { signal: AbortSignal.timeout(800) });
+                    live = probe.ok;
+                }
+                catch {
+                    live = false;
+                }
+                if (live) {
+                    log("reusing live server from port.pid", { port: info.port });
+                    return { port: info.port, url: `http://localhost:${info.port}` };
+                }
+                log("port.pid present but no live server — treating as stale", { port: info.port });
             }
         }
         catch {
-            // stale file, overwrite
+            log("port.pid unparseable — treating as stale");
         }
+        // stale file, remove so the fresh bind does not collide with a lingering
+        // process that still holds the port
+        try {
+            unlinkSync(portFile);
+        }
+        catch { /* ignore */ }
     }
     // ── New server ────────────────────────────────────────────────────────────
     mkdirSync(stateDir, { recursive: true });
@@ -799,20 +844,26 @@ export function launchDashboardServer(stateDir) {
         function tryPort(port) {
             server.once("error", (err) => {
                 if (err.code === "EADDRINUSE" && port < TARGET_PORT + PORT_RANGE - 1) {
+                    log("port in use, trying next", { port });
                     tryPort(port + 1);
                 }
                 else {
+                    log("listen failed", { port, code: err.code, message: err.message });
                     reject(err);
                 }
             });
             server.listen(port, "127.0.0.1", () => {
                 const url = `http://localhost:${port}`;
+                log("server running", { url });
+                // eslint-disable-next-line no-console
                 console.log(`[mega-compact] dashboard server running: ${url}`);
                 // Write port.pid
                 try {
                     writeFileSync(portFile, JSON.stringify({ port, pid: process.pid }));
                 }
-                catch { /* non-fatal */ }
+                catch (e) {
+                    log("could not write port.pid", { error: String(e) });
+                }
                 // Graceful cleanup
                 const cleanup = () => {
                     try {

package/dist/extensions/dashboard-server.test.js

@@ -9,6 +9,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { spawn } from "node:child_process";
 // ---------------------------------------------------------------------------
 // helpers
 // ---------------------------------------------------------------------------
@@ -109,3 +110,79 @@ describe("port.pid file", () => {
         rmSync(dir, { recursive: true });
     });
 });
+// ---------------------------------------------------------------------------
+// Lifecycle integration — launch the compiled server as a real subprocess
+// (the same way the /dashboard command spawns it) and assert the two failure
+// modes that historically produced a silent "failed to start":
+//   1. a stale port.pid pointing at a dead port is dropped, and the server
+//      binds fresh (instead of returning the dead port);
+//   2. a module-load crash is captured to the launch log instead of going
+//      silent under stdio:"ignore".
+// ---------------------------------------------------------------------------
+const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
+function waitFor(cond, timeoutMs = 6000) {
+    const start = Date.now();
+    return new Promise((resolve, reject) => {
+        const tick = async () => {
+            if (await cond())
+                return resolve();
+            if (Date.now() - start > timeoutMs)
+                return reject(new Error("timeout"));
+            setTimeout(tick, 50);
+        };
+        tick();
+    });
+}
+describe("server lifecycle", () => {
+    test("drops a stale port.pid and binds a fresh port", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "dash-stale-"));
+        // A marker claiming a port where nothing is listening.
+        writeFileSync(join(dir, "port.pid"), JSON.stringify({ port: 9325, pid: 999999 }));
+        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+        try {
+            // Wait for the server to actually be live (not just any port.pid — the
+            // stale marker already exists at t=0 and would pass a naive check).
+            await waitFor(async () => {
+                try {
+                    const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+                    const res = await fetch(`http://localhost:${raw.port}/api/version`);
+                    return res.ok;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+            assert.equal(typeof raw.port, "number");
+            assert.notEqual(raw.port, 9325, "should not reuse the dead port from the stale marker");
+            // And a real server must answer on it.
+            const res = await fetch(`http://localhost:${raw.port}/api/version`);
+            assert.equal(res.ok, true);
+        }
+        finally {
+            child.kill("SIGTERM");
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    test("writes a dashboard.log with startup lines", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "dash-log-"));
+        const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+        try {
+            await waitFor(() => {
+                try {
+                    return /server running/.test(readFileSync(join(dir, "dashboard.log"), "utf-8"));
+                }
+                catch {
+                    return false;
+                }
+            });
+            const log = readFileSync(join(dir, "dashboard.log"), "utf-8");
+            assert.match(log, /\[mega-compact\]\[dashboard\]/);
+            assert.match(log, /server running/);
+        }
+        finally {
+            child.kill("SIGTERM");
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/extensions/mega-dashboard-cmds.js

@@ -7,7 +7,7 @@
  */
 import { join, dirname, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, writeFileSync, readFileSync, unlinkSync, openSync, closeSync } from "node:fs";
 import { spawn } from "node:child_process"; // guardrails-allow PREVENT-PI-004: spawns the optional, user-triggered localhost dashboard server only
 /** Register the dashboard server lifecycle commands. */
 export function registerDashboardCommands(pi, runtime) {
@@ -213,11 +213,41 @@ export function registerDashboardCommands(pi, runtime) {
                 ctx.ui.notify("[mega-compact] dashboard entry not found — check logs.");
                 return;
             }
+            // Clear any stale marker so a fresh bind never collides with a lingering
+            // orphan, and truncate the launch log so the next error report shows only
+            // this attempt's output.
+            try {
+                unlinkSync(portFile);
+            }
+            catch { /* ignore */ }
+            try {
+                writeFileSync(launchLog, "");
+            }
+            catch { /* ignore */ }
             const args = dashboardNeedsStrip ? ["--experimental-strip-types", runnerFile] : [runnerFile];
+            // Redirect the child's stderr to the launch log so that a CRASH BEFORE the
+            // runner's own __fail handler runs (e.g. an ESM module-load / parse error,
+            // or a missing entry) is still captured. With the old `stdio: "ignore"`
+            // these failures were completely silent and the "check logs" message
+            // pointed at an empty file. We open the fd in the parent and pass it to the
+            // child; once spawned we close our copy (the child keeps its own dup).
+            let stderrFd;
+            try {
+                stderrFd = openSync(launchLog, "a");
+            }
+            catch {
+                stderrFd = -1; // fall back to ignored stderr
+            }
             const child = spawn(process.execPath, args, {
                 detached: true,
-                stdio: "ignore",
+                stdio: ["ignore", "ignore", stderrFd >= 0 ? stderrFd : "ignore"],
             });
+            if (stderrFd >= 0) {
+                try {
+                    closeSync(stderrFd);
+                }
+                catch { /* ignore */ }
+            }
             child.unref();
             // Poll for a live server (port 9320–9329) instead of relying solely on the
             // port.pid marker, which can land in a different state dir than the one we

package/dist/extensions/openclaw-mega-compact.js

@@ -0,0 +1,291 @@
+/**
+ * openclaw-mega-compact — OpenClaw plugin adapter for the pi-mega-compact engine.
+ *
+ * Wires the pi-agnostic Trident engine (src/) into OpenClaw's plugin lifecycle:
+ *  - Registers a CompactionProvider that replaces the built-in summarizeInStages.
+ *  - Exposes `mega_status` and `mega_recall` tools for on-demand inspection.
+ *  - Hooks into `before_compaction` / `after_compaction` for diagnostics.
+ *
+ * Design constraints:
+ *  - NO imports from `@earendil-works/pi-coding-agent` or pi-agent-core.
+ *  - The engine core (src/) is pi-agnostic; this file is the sole OpenClaw boundary.
+ *  - No network at runtime — everything is local (stores + extractive summarizer).
+ */
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { compactSession, setDefaultStore, } from "../src/engine.js";
+import { recallAndInline } from "../src/recall.js";
+import { VectorStore } from "../src/vectorStore.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const PLUGIN_ID = "mega-compact";
+const PLUGIN_LABEL = "Mega Compact (Trident)";
+/** Default state directory for vector store persistence. */
+const STATE_DIR = process.env.MEGA_COMPACT_STATE_DIR ?? undefined;
+/** Minimum messages before we bother compacting. */
+const MIN_MESSAGES_FOR_COMPACT = 6;
+// ---------------------------------------------------------------------------
+// Message conversion — OpenClaw unknown[] → EngineMessage[]
+// ---------------------------------------------------------------------------
+/**
+ * Best-effort conversion from OpenClaw's opaque message array to our
+ * EngineMessage shape. OpenClaw messages are typed as `unknown[]` so we
+ * handle whatever shape comes through gracefully.
+ */
+function toEngineMessages(messages) {
+    return messages.map((msg) => {
+        if (!msg || typeof msg !== "object") {
+            // Primitive fallback — treat as custom text.
+            return {
+                role: "custom",
+                text: String(msg ?? ""),
+            };
+        }
+        const m = msg;
+        const role = typeof m.role === "string" ? m.role : "custom";
+        // Normalize role to one of our four engine roles.
+        let engineRole;
+        switch (role) {
+            case "user":
+                engineRole = "user";
+                break;
+            case "assistant":
+                engineRole = "assistant";
+                break;
+            case "tool":
+            case "function":
+                engineRole = "tool";
+                break;
+            default:
+                engineRole = "custom";
+                break;
+        }
+        // Extract text content from common message shapes.
+        const text = typeof m.content === "string"
+            ? m.content
+            : typeof m.text === "string"
+                ? m.text
+                : Array.isArray(m.content)
+                    ? m.content
+                        .filter((part) => part.type === "text" && typeof part.text === "string")
+                        .map((part) => part.text)
+                        .join("\n")
+                    : "";
+        // Preserve tool metadata when present.
+        const toolName = typeof m.name === "string"
+            ? m.name
+            : typeof m.toolName === "string"
+                ? m.toolName
+                : undefined;
+        const input = typeof m.input === "string"
+            ? m.input
+            : typeof m.arguments === "string"
+                ? m.arguments
+                : m.arguments !== undefined
+                    ? JSON.stringify(m.arguments)
+                    : undefined;
+        const output = typeof m.output === "string"
+            ? m.output
+            : engineRole === "tool" && typeof m.content === "string"
+                ? m.content
+                : undefined;
+        return { role: engineRole, text, toolName, input, output };
+    });
+}
+// ---------------------------------------------------------------------------
+// Compaction provider
+// ---------------------------------------------------------------------------
+function createCompactionProvider(store) {
+    return {
+        id: PLUGIN_ID,
+        label: PLUGIN_LABEL,
+        async summarize({ messages, signal, compressionRatio, }) {
+            // Abort check — bail early if the caller cancelled.
+            if (signal?.aborted) {
+                throw new DOMException("Aborted", "AbortError");
+            }
+            const engineMessages = toEngineMessages(messages);
+            // Nothing meaningful to compact.
+            if (engineMessages.length < MIN_MESSAGES_FOR_COMPACT) {
+                return "";
+            }
+            // Map compression ratio → keepFrom boundary.
+            // compressionRatio=0.5 means "compact the oldest 50%".
+            // Default to compacting the oldest half if not specified.
+            const ratio = compressionRatio ?? 0.5;
+            const keepFrom = Math.max(MIN_MESSAGES_FOR_COMPACT, Math.floor(engineMessages.length * (1 - ratio)));
+            // Abort check after conversion (conversion is cheap but check anyway).
+            if (signal?.aborted) {
+                throw new DOMException("Aborted", "AbortError");
+            }
+            const sessionId = `openclaw-${Date.now()}`;
+            const input = {
+                sessionId,
+                messages: engineMessages,
+                keepFrom,
+            };
+            const result = compactSession(input, store);
+            if (result.skipped) {
+                return "";
+            }
+            return result.summary;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Plugin entry
+// ---------------------------------------------------------------------------
+export default definePluginEntry({
+    id: PLUGIN_ID,
+    name: "Mega Compact",
+    description: "Layered, local, vector-backed context compressor (Trident engine) for OpenClaw compaction.",
+    register(api) {
+        const logger = api.logger;
+        // Resolve state directory — prefer plugin config override.
+        const pluginCfg = (api.pluginConfig ?? {});
+        const stateDir = typeof pluginCfg.stateDir === "string" && pluginCfg.stateDir.length > 0
+            ? pluginCfg.stateDir
+            : STATE_DIR;
+        // Initialize vector store.
+        let store;
+        try {
+            store = new VectorStore({ stateDir });
+            setDefaultStore(store);
+            logger.info?.(`${PLUGIN_ID}: vector store initialized (stateDir=${stateDir ?? "default"})`);
+        }
+        catch (err) {
+            logger.error?.(`${PLUGIN_ID}: failed to init vector store:`, err);
+            return; // Hard bail — no point registering if store is broken.
+        }
+        // -----------------------------------------------------------------------
+        // Register compaction provider
+        // -----------------------------------------------------------------------
+        const provider = createCompactionProvider(store);
+        api.registerCompactionProvider(provider);
+        logger.info?.(`${PLUGIN_ID}: registered compaction provider "${provider.id}"`);
+        // -----------------------------------------------------------------------
+        // Hooks — before / after compaction diagnostics
+        // -----------------------------------------------------------------------
+        api.registerHook({
+            event: "before_compaction",
+            handler: async (ctx) => {
+                const msgCount = Array.isArray(ctx?.messages) ? ctx.messages.length : 0;
+                logger.info?.(`${PLUGIN_ID}: before_compaction — ${msgCount} messages in scope`);
+            },
+        });
+        api.registerHook({
+            event: "after_compaction",
+            handler: async (ctx) => {
+                const summaryLen = typeof ctx?.summary === "string" ? ctx.summary.length : 0;
+                logger.info?.(`${PLUGIN_ID}: after_compaction — summary ${summaryLen} chars`);
+            },
+        });
+        // -----------------------------------------------------------------------
+        // Tool: mega_status
+        // -----------------------------------------------------------------------
+        api.registerTool({
+            name: "mega_status",
+            description: "Show the current status of the mega-compact engine: vector store stats, checkpoint count, and recent compaction activity.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Optional session ID to scope stats to.",
+                    },
+                },
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const sessionId = args?.sessionId ?? "global";
+                try {
+                    const stats = store.stats(sessionId);
+                    const parts = [
+                        `**Mega Compact Status**`,
+                        `Session: ${sessionId}`,
+                        `Checkpoints: ${stats.checkpointCount}`,
+                        `Total tokens saved: ${stats.totalTokenEstimate}`,
+                        `Last checkpoint: ${stats.lastCheckpointId ?? "—"}`,
+                        `Injected count: ${stats.injectedCount}`,
+                        `Dedup hit rate: ${(stats.dedupHitRate * 100).toFixed(0)}%`,
+                    ];
+                    if (stats.lastSummary) {
+                        parts.push(`\nLast summary (truncated):\n  ${stats.lastSummary.slice(0, 120).replace(/\n/g, " ")}…`);
+                    }
+                    return { content: [{ type: "text", text: parts.join("\n") }] };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: "text", text: `Error reading mega-compact status: ${err}` }],
+                        isError: true,
+                    };
+                }
+            },
+        });
+        // -----------------------------------------------------------------------
+        // Tool: mega_recall
+        // -----------------------------------------------------------------------
+        api.registerTool({
+            name: "mega_recall",
+            description: "Recall and inline relevant context from the mega-compact vector store for the current session.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sessionId: {
+                        type: "string",
+                        description: "Session ID to recall context for.",
+                    },
+                    query: {
+                        type: "string",
+                        description: "Natural language query for relevant context.",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max checkpoints to recall (default 3).",
+                    },
+                },
+                required: ["sessionId", "query"],
+                additionalProperties: false,
+            },
+            handler: async (args) => {
+                const { sessionId, query, limit } = args;
+                if (!sessionId || !query) {
+                    return {
+                        content: [{ type: "text", text: "Both `sessionId` and `query` are required." }],
+                        isError: true,
+                    };
+                }
+                try {
+                    const result = recallAndInline({ sessionId, query, limit: limit ?? 3, source: "command", skipInjected: false }, store);
+                    if (result.toInject.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No relevant context found in the mega-compact store." }],
+                        };
+                    }
+                    const parts = [
+                        `**Recalled ${result.toInject.length} checkpoint(s):**`,
+                        ...result.report,
+                        "",
+                        "---",
+                        result.block,
+                    ];
+                    return { content: [{ type: "text", text: parts.join("\n") }] };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: "text", text: `Error during mega-recall: ${err}` }],
+                        isError: true,
+                    };
+                }
+            },
+        });
+        // -----------------------------------------------------------------------
+        // Cleanup on shutdown
+        // -----------------------------------------------------------------------
+        api.on("shutdown", () => {
+            logger.info?.(`${PLUGIN_ID}: shutting down — clearing default store`);
+            setDefaultStore(undefined);
+        });
+        logger.info?.(`${PLUGIN_ID}: plugin registered (tools: mega_status, mega_recall)`);
+    },
+});

package/dist/src/minilm.js

@@ -0,0 +1,92 @@
+/**
+ * minilm.ts — local MiniLM (all-MiniLM-L6-v2) sentence embedder (Sprint 12).
+ *
+ * Implements the `Embedder` interface so it drops into the existing VectorStore
+ * dedup cascade and search with no call-site changes. Inference is 100% local:
+ * the ONNX model + WordPiece vocab are on-disk artifacts fetched once by
+ * scripts/setup-minilm.mjs. There is NO network call at runtime (PREVENT-PI-004).
+ *
+ * Inputs (dynamic): input_ids, attention_mask, token_type_ids (int64).
+ * Output: last_hidden_state (batch, seq, 384). We mean-pool over non-padded
+ * tokens (attention_mask == 1) and L2-normalize → 384-dim unit vector.
+ *
+ * The ONNX session + tokenizer are loaded LAZILY on first embed() so the default
+ * TrigramEmbedder path (and its zero native-init cost) is untouched unless
+ * MEGACOMPACT_EMBEDDER=minilm is selected.
+ */
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { l2Normalize, awaitSync } from "./embedder.js";
+import { WordPieceTokenizer } from "./wordpiece.js";
+export const MINILM_DIM = 384;
+export const MINILM_MAX_LEN = 256;
+/** Resolve the model directory: MEGACOMPACT_MINILM_DIR > ./models/minilm > ~/.pi … */
+function resolveModelDir() {
+    if (process.env.MEGACOMPACT_MINILM_DIR)
+        return process.env.MEGACOMPACT_MINILM_DIR;
+    // Repo-local vendored path (gitignored).
+    const local = join(process.cwd(), "models", "minilm");
+    if (existsSync(local))
+        return local;
+    return join(homedir(), ".pi", "agent", "extensions", "mega-compact", "models", "minilm");
+}
+export class MiniLMEmbedder {
+    dim = MINILM_DIM;
+    session = null;
+    tokenizer = null;
+    modelDir;
+    loadPromise = null;
+    constructor(modelDir = resolveModelDir()) {
+        this.modelDir = modelDir;
+    }
+    async ensureLoaded() {
+        if (this.session && this.tokenizer)
+            return;
+        if (this.loadPromise)
+            return this.loadPromise;
+        this.loadPromise = (async () => {
+            const ort = await import("onnxruntime-node");
+            const modelPath = join(this.modelDir, "model_quantized.onnx");
+            const vocabPath = join(this.modelDir, "vocab.txt");
+            if (!existsSync(modelPath) || !existsSync(vocabPath)) {
+                throw new Error(`MiniLM artifacts missing in ${this.modelDir}. Run: node scripts/setup-minilm.mjs`);
+            }
+            // 1 thread is plenty for a single short-region embed and bounds CPU.
+            this.session = await ort.InferenceSession.create(modelPath, {
+                executionProviders: ["cpu"],
+                graphOptimizationLevel: "all",
+            });
+            this.tokenizer = WordPieceTokenizer.fromVocabFile(vocabPath);
+        })();
+        return this.loadPromise;
+    }
+    embed(text) {
+        awaitSync(this.ensureLoaded());
+        const enc = this.tokenizer.encode(text, MINILM_MAX_LEN);
+        const n = enc.inputIds.length;
+        const BigInt64 = (arr) => arr.map((x) => BigInt(x));
+        const ort = awaitSync(import("onnxruntime-node"));
+        const tensors = {
+            input_ids: new ort.Tensor("int64", BigInt64(enc.inputIds), [1, n]),
+            attention_mask: new ort.Tensor("int64", BigInt64(enc.attentionMask), [1, n]),
+            token_type_ids: new ort.Tensor("int64", BigInt64(enc.tokenTypeIds), [1, n]),
+        };
+        const out = awaitSync(this.session.run(tensors));
+        const hidden = out.last_hidden_state.data;
+        // hidden shape: [1, n, 384]. Mean-pool over non-padded positions.
+        const pooled = new Array(MINILM_DIM).fill(0);
+        let count = 0;
+        for (let i = 0; i < n; i++) {
+            if (enc.attentionMask[i] === 0)
+                continue;
+            const base = i * MINILM_DIM;
+            for (let d = 0; d < MINILM_DIM; d++)
+                pooled[d] += hidden[base + d];
+            count++;
+        }
+        if (count === 0)
+            return l2Normalize(new Array(MINILM_DIM).fill(0));
+        return l2Normalize(pooled.map((x) => x / count));
+    }
+}