trellis 3.1.35 → 3.2.0

package/dist/{index-h9e2efx4.js → chunk-LNUIGRDZ.js}

@@ -1,7 +1,6 @@
-// @bun
 import {
   __require
-} from "./index-a76rekgs.js";
+} from "./chunk-KFQGP6VL.js";
 
 // src/core/persist/sqljs-backend.ts
 var SCHEMA_SQL = `
@@ -29,20 +28,23 @@ CREATE INDEX IF NOT EXISTS idx_ops_agent ON ops(agent_id);
 CREATE INDEX IF NOT EXISTS idx_ops_previous ON ops(previous_hash);
 CREATE INDEX IF NOT EXISTS idx_snapshots_op ON snapshots(last_op_hash);
 `;
-
-class SqlJsKernelBackend {
-  opts;
+var SqlJsKernelBackend = class _SqlJsKernelBackend {
+  constructor(opts) {
+    this.opts = opts;
+    this.flushEvery = opts.autoFlushEvery ?? 50;
+  }
   db;
   stmts;
   writes = 0;
   flushEvery;
   initialized = false;
-  constructor(opts) {
-    this.opts = opts;
-    this.flushEvery = opts.autoFlushEvery ?? 50;
-  }
+  /**
+   * Async factory — sql.js WASM init is async, but the resulting backend
+   * exposes the synchronous KernelBackend surface, so it slots into the
+   * existing kernel without interface changes.
+   */
   static async create(opts) {
-    const backend = new SqlJsKernelBackend(opts);
+    const backend = new _SqlJsKernelBackend(opts);
     await backend.bootstrap();
     return backend;
   }
@@ -52,7 +54,9 @@ class SqlJsKernelBackend {
       const mod = await import("sql.js");
       initSqlJs = mod.default ?? mod;
     } catch (e) {
-      throw new Error('SqlJsKernelBackend requires the optional dependency "sql.js". Install it: npm install sql.js');
+      throw new Error(
+        'SqlJsKernelBackend requires the optional dependency "sql.js". Install it: npm install sql.js'
+      );
     }
     let sqljsDistDir = null;
     if (typeof window === "undefined") {
@@ -68,31 +72,26 @@ class SqlJsKernelBackend {
     }
     const SQL = await initSqlJs({
       locateFile: (file) => {
-        if (typeof window !== "undefined")
-          return `/sql-wasm/${file}`;
-        if (sqljsDistDir)
-          return `${sqljsDistDir}/${file}`;
+        if (typeof window !== "undefined") return `/sql-wasm/${file}`;
+        if (sqljsDistDir) return `${sqljsDistDir}/${file}`;
         return file;
       }
     });
     const existing = this.loadFromDisk();
-    this.db = existing ? new SQL.Database(existing) : new SQL.Database;
+    this.db = existing ? new SQL.Database(existing) : new SQL.Database();
   }
   loadFromDisk() {
-    if (this.opts.dbPath === ":memory:")
-      return null;
+    if (this.opts.dbPath === ":memory:") return null;
     try {
       const fs = __require("fs");
-      if (!fs.existsSync(this.opts.dbPath))
-        return null;
+      if (!fs.existsSync(this.opts.dbPath)) return null;
       return new Uint8Array(fs.readFileSync(this.opts.dbPath));
     } catch {
       return null;
     }
   }
   flushToDisk() {
-    if (this.opts.dbPath === ":memory:")
-      return;
+    if (this.opts.dbPath === ":memory:") return;
     try {
       const fs = __require("fs");
       const path = __require("path");
@@ -101,34 +100,50 @@ class SqlJsKernelBackend {
       const tmp = `${this.opts.dbPath}.tmp`;
       fs.writeFileSync(tmp, Buffer.from(data));
       fs.renameSync(tmp, this.opts.dbPath);
-    } catch {}
+    } catch {
+    }
   }
   init() {
-    if (this.initialized)
-      return;
+    if (this.initialized) return;
     this.db.exec(SCHEMA_SQL);
     this.prepareStatements();
     this.initialized = true;
   }
   prepareStatements() {
     this.stmts = {
-      insert: this.db.prepare(`INSERT OR IGNORE INTO ops (hash, kind, timestamp, agent_id, previous_hash, payload)
-         VALUES ($hash, $kind, $timestamp, $agentId, $previousHash, $payload)`),
-      readAll: this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops ORDER BY rowid ASC`),
-      readUntil: this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+      insert: this.db.prepare(
+        `INSERT OR IGNORE INTO ops (hash, kind, timestamp, agent_id, previous_hash, payload)
+         VALUES ($hash, $kind, $timestamp, $agentId, $previousHash, $payload)`
+      ),
+      readAll: this.db.prepare(
+        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+         FROM ops ORDER BY rowid ASC`
+      ),
+      readUntil: this.db.prepare(
+        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
          FROM ops WHERE rowid <= (SELECT rowid FROM ops WHERE hash = $hash)
-         ORDER BY rowid ASC`),
-      readAfter: this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+         ORDER BY rowid ASC`
+      ),
+      readAfter: this.db.prepare(
+        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
          FROM ops WHERE rowid > (SELECT rowid FROM ops WHERE hash = $hash)
-         ORDER BY rowid ASC`),
-      getByHash: this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops WHERE hash = $hash`),
-      getLast: this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-         FROM ops ORDER BY rowid DESC LIMIT 1`),
+         ORDER BY rowid ASC`
+      ),
+      getByHash: this.db.prepare(
+        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+         FROM ops WHERE hash = $hash`
+      ),
+      getLast: this.db.prepare(
+        `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+         FROM ops ORDER BY rowid DESC LIMIT 1`
+      ),
       count: this.db.prepare(`SELECT COUNT(*) AS cnt FROM ops`),
-      saveSnapshot: this.db.prepare(`INSERT INTO snapshots (last_op_hash, data) VALUES ($lastOpHash, $data)`),
-      loadSnapshot: this.db.prepare(`SELECT last_op_hash, data FROM snapshots ORDER BY id DESC LIMIT 1`)
+      saveSnapshot: this.db.prepare(
+        `INSERT INTO snapshots (last_op_hash, data) VALUES ($lastOpHash, $data)`
+      ),
+      loadSnapshot: this.db.prepare(
+        `SELECT last_op_hash, data FROM snapshots ORDER BY id DESC LIMIT 1`
+      )
     };
   }
   append(op) {
@@ -161,8 +176,10 @@ class SqlJsKernelBackend {
     return this.runAll(this.stmts.readAfter, { $hash: hash });
   }
   readUntilTimestamp(iso) {
-    const stmt = this.db.prepare(`SELECT hash, kind, timestamp, agent_id, previous_hash, payload
-       FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`);
+    const stmt = this.db.prepare(
+      `SELECT hash, kind, timestamp, agent_id, previous_hash, payload
+       FROM ops WHERE timestamp <= $ts ORDER BY rowid ASC`
+    );
     const rows = this.runAll(stmt, { $ts: iso });
     stmt.free();
     return rows;
@@ -193,7 +210,7 @@ class SqlJsKernelBackend {
     const has = this.stmts.loadSnapshot.step();
     if (!has) {
       this.stmts.loadSnapshot.reset();
-      return;
+      return void 0;
     }
     const row = this.stmts.loadSnapshot.getAsObject();
     this.stmts.loadSnapshot.reset();
@@ -203,36 +220,33 @@ class SqlJsKernelBackend {
     try {
       this.flushToDisk();
     } finally {
-      for (const s of Object.values(this.stmts ?? {}))
-        s?.free?.();
+      for (const s of Object.values(this.stmts ?? {})) s?.free?.();
       this.db?.close?.();
     }
   }
+  /** Force a write of the in-memory DB image to disk. */
   flush() {
     this.flushToDisk();
   }
   runAll(stmt, params = {}) {
     stmt.bind(params);
     const rows = [];
-    while (stmt.step())
-      rows.push(rowToOp(stmt.getAsObject()));
+    while (stmt.step()) rows.push(rowToOp(stmt.getAsObject()));
     stmt.reset();
     return rows;
   }
   runOne(stmt, params = {}) {
     stmt.bind(params);
     const has = stmt.step();
-    const row = has ? stmt.getAsObject() : undefined;
+    const row = has ? stmt.getAsObject() : void 0;
     stmt.reset();
-    return row ? rowToOp(row) : undefined;
+    return row ? rowToOp(row) : void 0;
   }
   tickFlush() {
-    if (this.flushEvery === 0)
-      return;
-    if (++this.writes % this.flushEvery === 0)
-      this.flushToDisk();
+    if (this.flushEvery === 0) return;
+    if (++this.writes % this.flushEvery === 0) this.flushToDisk();
   }
-}
+};
 function rowToOp(row) {
   const payload = JSON.parse(row.payload);
   return {
@@ -240,7 +254,7 @@ function rowToOp(row) {
     kind: row.kind,
     timestamp: row.timestamp,
     agentId: row.agent_id,
-    previousHash: row.previous_hash ?? undefined,
+    previousHash: row.previous_hash ?? void 0,
     facts: payload.facts,
     links: payload.links,
     deleteFacts: payload.deleteFacts,
@@ -248,4 +262,6 @@ function rowToOp(row) {
   };
 }
 
-export { SqlJsKernelBackend };
+export {
+  SqlJsKernelBackend
+};

package/dist/chunk-LOPXTPF3.js

@@ -0,0 +1,120 @@
+import {
+  __esm
+} from "./chunk-2ESYSVXG.js";
+
+// src/server/node-adapter.ts
+async function startNodeServer(opts) {
+  const http = await import("http");
+  let WebSocketServer;
+  try {
+    ({ WebSocketServer } = await import("ws"));
+  } catch {
+    throw new Error(
+      'Running the Trellis server outside Bun requires the optional dependency "ws". Install it: npm install ws'
+    );
+  }
+  const httpServer = http.createServer(
+    async (req, res) => {
+      try {
+        const fetchReq = await toFetchRequest(req);
+        const fetchRes = await opts.fetch(fetchReq);
+        await writeFetchResponse(res, fetchRes);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Internal Server Error", message: msg }));
+      }
+    }
+  );
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+  });
+  wss.on("connection", (ws) => {
+    Promise.resolve(opts.websocket.open(ws)).catch(() => {
+    });
+    ws.on("message", (raw) => {
+      const data = Array.isArray(raw) ? Buffer.concat(raw).toString() : raw instanceof ArrayBuffer ? Buffer.from(raw).toString() : raw.toString();
+      Promise.resolve(opts.websocket.message(ws, data)).catch(() => {
+      });
+    });
+    ws.on("close", () => opts.websocket.close(ws));
+  });
+  await new Promise(
+    (resolve) => httpServer.listen(opts.port, opts.hostname, resolve)
+  );
+  const addr = httpServer.address();
+  const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
+  const boundHost = typeof addr === "object" && addr ? addr.address : opts.hostname;
+  return wrapNodeServer(httpServer, wss, boundPort, boundHost);
+}
+async function toFetchRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const protocol = req.socket?.encrypted ? "https" : "http";
+  const url = `${protocol}://${host}${req.url ?? "/"}`;
+  const method = req.method ?? "GET";
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else if (value != null) {
+      headers.set(key, value);
+    }
+  }
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? new Uint8Array(await readBody(req)) : void 0;
+  return new Request(url, { method, headers, body });
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function writeFetchResponse(res, fetchRes) {
+  res.statusCode = fetchRes.status;
+  fetchRes.headers.forEach((value, key) => res.setHeader(key, value));
+  if (!fetchRes.body) {
+    res.end();
+    return;
+  }
+  const reader = fetchRes.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    res.write(value);
+  }
+  res.end();
+}
+function wrapNodeServer(httpServer, wss, port, hostname) {
+  return {
+    port,
+    hostname: hostname ?? "localhost",
+    stop(closeActiveConnections) {
+      return new Promise((resolve, reject) => {
+        if (closeActiveConnections) {
+          for (const client of wss.clients) client.terminate();
+        }
+        wss.close(() => {
+          httpServer.close(
+            (err) => err ? reject(err) : resolve()
+          );
+        });
+      });
+    }
+  };
+}
+var init_node_adapter = __esm({
+  "src/server/node-adapter.ts"() {
+  }
+});
+
+export {
+  startNodeServer,
+  init_node_adapter
+};