@moxt-ai/mobius 0.0.153 → 0.0.154

package/dist/index.js

@@ -43477,7 +43477,7 @@ async function runRelayConnection({
             return;
           }
           if (kind === SESSION_EVENT_REJECTED_KIND) {
-            publisher.quarantine(message);
+            publisher.reject(message);
             return;
           }
           commands.handle(message);
@@ -43504,250 +43504,84 @@ async function runRelayConnection({
   }
 }
 
-// src/relay-connection/session-event-outbox.ts
+// src/relay-connection/session-event-publisher.ts
+import { WebSocket as WebSocket9 } from "undici";
+
+// src/relay-connection/session-event-queue.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-var DEFAULT_STANDARD_EVENT_BYTES = 96 * 1024 * 1024;
-var DEFAULT_CRITICAL_EVENT_BYTES = 128 * 1024 * 1024;
-var MAX_DEAD_LETTERS = 1024;
-var DEFAULT_LIMITS = {
-  criticalEventBytes: DEFAULT_CRITICAL_EVENT_BYTES,
-  standardEventBytes: DEFAULT_STANDARD_EVENT_BYTES
-};
-var SessionEventOutboxCapacityError = class extends Error {
-  code = "session_event_outbox_full";
+var STANDARD_EVENT_BYTES = 96 * 1024 * 1024;
+var CRITICAL_EVENT_BYTES = 128 * 1024 * 1024;
+var SessionEventQueueCapacityError = class extends Error {
+  code = "session_event_queue_full";
   constructor() {
-    super("The persistent Session event outbox is full");
-    this.name = "SessionEventOutboxCapacityError";
+    super("The in-memory Session event queue is full");
+    this.name = "SessionEventQueueCapacityError";
   }
 };
-function rowNumber(row, field) {
-  const value = typeof row === "object" && row !== null ? Reflect.get(row, field) : void 0;
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`SQLite returned an invalid ${field} value`);
-  }
-  return value;
-}
-function rowString(row, field) {
-  const value = typeof row === "object" && row !== null ? Reflect.get(row, field) : void 0;
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`SQLite returned an invalid ${field} value`);
-  }
-  return value;
-}
-function validateLimits(limits) {
-  if (!Number.isSafeInteger(limits.standardEventBytes) || limits.standardEventBytes < 1 || !Number.isSafeInteger(limits.criticalEventBytes) || limits.criticalEventBytes < limits.standardEventBytes) {
-    throw new Error("Session event outbox limits are invalid");
-  }
-}
-var SessionEventOutbox = class {
-  #database;
-  #limits;
-  constructor(path2, limits = DEFAULT_LIMITS) {
-    validateLimits(limits);
-    mkdirSync3(dirname6(path2), { mode: 448, recursive: true });
-    this.#limits = limits;
-    this.#database = new DatabaseSync(path2);
-    this.#database.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL; PRAGMA busy_timeout = 5000;");
-    this.#database.exec(`
-            CREATE TABLE IF NOT EXISTS relay_session_event_outbox (
-                ordinal INTEGER PRIMARY KEY AUTOINCREMENT,
-                event_id TEXT NOT NULL UNIQUE,
-                session_id TEXT NOT NULL,
-                source_seq INTEGER NOT NULL UNIQUE,
-                byte_length INTEGER NOT NULL,
-                envelope_json TEXT NOT NULL
-            ) STRICT;
-            CREATE INDEX IF NOT EXISTS relay_session_event_outbox_order
-                ON relay_session_event_outbox(source_seq);
-            CREATE TABLE IF NOT EXISTS relay_session_event_outbox_state (
-                singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-                stream_id TEXT NOT NULL,
-                next_source_seq INTEGER NOT NULL,
-                total_bytes INTEGER NOT NULL
-            ) STRICT;
-            CREATE TABLE IF NOT EXISTS relay_session_event_dead_letters (
-                ordinal INTEGER PRIMARY KEY AUTOINCREMENT,
-                event_id TEXT NOT NULL UNIQUE,
-                session_id TEXT NOT NULL,
-                rejection_code TEXT NOT NULL,
-                envelope_json TEXT NOT NULL
-            ) STRICT;
-        `);
-    this.#database.prepare(
-      `INSERT OR IGNORE INTO relay_session_event_outbox_state (
-                    singleton, stream_id, next_source_seq, total_bytes
-                ) VALUES (1, ?, 1, 0)`
-    ).run(randomUUID7());
-  }
-  acknowledge = (acknowledgement) => this.#remove(acknowledgement.eventId, acknowledgement.sessionId);
-  close = () => {
-    this.#database.close();
-  };
-  enqueue = (sessionId, payload, critical) => {
-    const envelope2 = this.enqueueBatch(sessionId, [payload], critical)[0];
-    if (envelope2 === void 0) {
-      throw new Error("The Session event outbox did not enqueue the event");
-    }
-    return envelope2;
-  };
+var SessionEventQueue = class {
+  #streamId = randomUUID7();
+  #events = /* @__PURE__ */ new Map();
+  #nextSourceSeq = 1;
+  #totalBytes = 0;
   enqueueBatch = (sessionId, payloads, critical) => {
     if (payloads.length < 1 || payloads.length > 32) {
       throw new Error("A Session event batch must contain between 1 and 32 events");
     }
-    this.#database.exec("BEGIN IMMEDIATE");
-    try {
-      const state = this.#database.prepare(
-        `SELECT stream_id, next_source_seq, total_bytes
-                     FROM relay_session_event_outbox_state
-                     WHERE singleton = 1`
-      ).get();
-      const sourceSeq = rowNumber(state, "next_source_seq");
-      if (sourceSeq < 1 || !Number.isSafeInteger(sourceSeq + payloads.length)) {
-        throw new Error("The Session event source sequence is exhausted");
-      }
-      const streamId = rowString(state, "stream_id");
-      const stored = payloads.map((payload, index) => {
-        const envelope2 = {
-          delivery: {
-            eventId: randomUUID7(),
-            kind: "reliable",
-            sourceSeq: (sourceSeq + index).toString(),
-            streamId
-          },
-          kind: SESSION_EVENT_KIND,
-          payload,
-          sessionId
-        };
-        const encoded = encodeSessionEventEnvelope(envelope2);
-        return { byteLength: Buffer.byteLength(encoded, "utf8"), encoded, envelope: envelope2 };
-      });
-      const byteLength = stored.reduce((total, entry) => total + entry.byteLength, 0);
-      const maximumBytes = critical ? this.#limits.criticalEventBytes : this.#limits.standardEventBytes;
-      if (rowNumber(state, "total_bytes") + byteLength > maximumBytes) {
-        throw new SessionEventOutboxCapacityError();
-      }
-      const insert = this.#database.prepare(
-        `INSERT INTO relay_session_event_outbox (
-                    event_id, session_id, source_seq, byte_length, envelope_json
-                ) VALUES (?, ?, ?, ?, ?)`
-      );
-      for (const entry of stored) {
-        insert.run(
-          entry.envelope.delivery.eventId,
-          sessionId,
-          Number(entry.envelope.delivery.sourceSeq),
-          entry.byteLength,
-          entry.encoded
-        );
-      }
-      this.#database.prepare(
-        `UPDATE relay_session_event_outbox_state
-                     SET next_source_seq = next_source_seq + ?,
-                         total_bytes = total_bytes + ?
-                     WHERE singleton = 1`
-      ).run(stored.length, byteLength);
-      this.#database.exec("COMMIT");
-      return stored.map((entry) => entry.envelope);
-    } catch (error62) {
-      this.#database.exec("ROLLBACK");
-      throw error62;
+    if (!Number.isSafeInteger(this.#nextSourceSeq + payloads.length)) {
+      throw new Error("The Session event source sequence is exhausted");
     }
-  };
-  pending = (limit, excludedEventIds) => {
-    if (!Number.isSafeInteger(limit) || limit < 1) {
-      throw new Error("Session event replay limit must be a positive integer");
-    }
-    const exclusion = excludedEventIds.length === 0 ? "" : `WHERE event_id NOT IN (${excludedEventIds.map(() => "?").join(", ")})`;
-    return this.#database.prepare(
-      `SELECT envelope_json
-                 FROM relay_session_event_outbox
-                 ${exclusion}
-                 ORDER BY source_seq
-                 LIMIT ?`
-    ).all(...excludedEventIds, limit).map((row) => {
-      const envelope2 = decodeSessionEventEnvelope(rowString(row, "envelope_json"));
-      if (!("delivery" in envelope2)) {
-        throw new Error("SQLite returned an invalid reliable Session event envelope");
-      }
-      return envelope2;
+    const entries = payloads.map((payload, index) => {
+      const envelope2 = {
+        delivery: {
+          eventId: randomUUID7(),
+          kind: "reliable",
+          sourceSeq: (this.#nextSourceSeq + index).toString(),
+          streamId: this.#streamId
+        },
+        kind: SESSION_EVENT_KIND,
+        payload,
+        sessionId
+      };
+      return { envelope: envelope2, byteLength: Buffer.byteLength(encodeSessionEventEnvelope(envelope2), "utf8") };
     });
+    const byteLength = entries.reduce((total, entry) => total + entry.byteLength, 0);
+    if (this.#totalBytes + byteLength > (critical ? CRITICAL_EVENT_BYTES : STANDARD_EVENT_BYTES)) {
+      throw new SessionEventQueueCapacityError();
+    }
+    for (const entry of entries) {
+      this.#events.set(entry.envelope.delivery.eventId, entry);
+    }
+    this.#nextSourceSeq += entries.length;
+    this.#totalBytes += byteLength;
   };
-  quarantine = (rejection) => {
-    this.#database.exec("BEGIN IMMEDIATE");
-    try {
-      const stored = this.#database.prepare(
-        `SELECT byte_length, envelope_json
-                     FROM relay_session_event_outbox
-                     WHERE event_id = ? AND session_id = ?`
-      ).get(rejection.eventId, rejection.sessionId);
-      if (stored === void 0) {
-        this.#database.exec("COMMIT");
-        return false;
+  pending = (limit, excludedEventIds) => {
+    const result = [];
+    for (const [eventId, entry] of this.#events) {
+      if (!excludedEventIds.has(eventId)) {
+        result.push(entry.envelope);
+        if (result.length === limit) {
+          break;
+        }
       }
-      this.#database.prepare(
-        `INSERT INTO relay_session_event_dead_letters (
-                        event_id, session_id, rejection_code, envelope_json
-                    ) VALUES (?, ?, ?, ?)`
-      ).run(rejection.eventId, rejection.sessionId, rejection.code, rowString(stored, "envelope_json"));
-      this.#deleteStored(rejection.eventId, rejection.sessionId, rowNumber(stored, "byte_length"));
-      this.#database.prepare(
-        `DELETE FROM relay_session_event_dead_letters
-                     WHERE ordinal NOT IN (
-                         SELECT ordinal FROM relay_session_event_dead_letters
-                         ORDER BY ordinal DESC LIMIT ?
-                     )`
-      ).run(MAX_DEAD_LETTERS);
-      this.#database.exec("COMMIT");
-      return true;
-    } catch (error62) {
-      this.#database.exec("ROLLBACK");
-      throw error62;
     }
+    return result;
   };
-  #deleteStored = (eventId, sessionId, byteLength) => {
-    const deletion = this.#database.prepare(
-      `DELETE FROM relay_session_event_outbox
-                 WHERE event_id = ? AND session_id = ?`
-    ).run(eventId, sessionId);
-    if (deletion.changes !== 1) {
-      throw new Error("The Session event could not be removed from the outbox");
-    }
-    const state = this.#database.prepare(
-      `UPDATE relay_session_event_outbox_state
-                 SET total_bytes = total_bytes - ?
-                 WHERE singleton = 1 AND total_bytes >= ?`
-    ).run(byteLength, byteLength);
-    if (state.changes !== 1) {
-      throw new Error("The Session event outbox capacity state is inconsistent");
+  remove = (eventId, sessionId) => {
+    const entry = this.#events.get(eventId);
+    if (entry === void 0 || entry.envelope.sessionId !== sessionId) {
+      return false;
     }
+    this.#events.delete(eventId);
+    this.#totalBytes -= entry.byteLength;
+    return true;
   };
-  #remove = (eventId, sessionId) => {
-    this.#database.exec("BEGIN IMMEDIATE");
-    try {
-      const stored = this.#database.prepare(
-        `SELECT byte_length
-                     FROM relay_session_event_outbox
-                     WHERE event_id = ? AND session_id = ?`
-      ).get(eventId, sessionId);
-      if (stored === void 0) {
-        this.#database.exec("COMMIT");
-        return false;
-      }
-      this.#deleteStored(eventId, sessionId, rowNumber(stored, "byte_length"));
-      this.#database.exec("COMMIT");
-      return true;
-    } catch (error62) {
-      this.#database.exec("ROLLBACK");
-      throw error62;
-    }
+  clear = () => {
+    this.#events.clear();
+    this.#totalBytes = 0;
   };
 };
 
 // src/relay-connection/session-event-publisher.ts
-import { WebSocket as WebSocket9 } from "undici";
 var SESSION_EVENT_REPLAY_WINDOW = 16;
 var SESSION_EVENT_REPLAY_BYTE_LIMIT = 32 * 1024 * 1024;
 function reservesSessionEventCapacity(event) {
@@ -43758,18 +43592,17 @@ function reservesSessionEventCapacity(event) {
 }
 var DaemonSessionEventPublisher = class {
   #inFlight = /* @__PURE__ */ new Map();
-  #outbox;
+  #queue = new SessionEventQueue();
   #reportedCapacityKinds = /* @__PURE__ */ new Set();
   #timer;
   #connection = { kind: "disconnected" };
   #deferredReplay = null;
   #inFlightBytes = 0;
-  constructor(outbox, timer) {
-    this.#outbox = outbox;
+  constructor(timer) {
     this.#timer = timer;
   }
   acknowledge = (acknowledgement) => {
-    if (!this.#outbox.acknowledge(acknowledgement)) {
+    if (!this.#queue.remove(acknowledgement.eventId, acknowledgement.sessionId)) {
       return;
     }
     this.#removeInFlight(acknowledgement.eventId);
@@ -43780,7 +43613,7 @@ var DaemonSessionEventPublisher = class {
     this.#deferredReplay = null;
     this.#connection = { kind: "disconnected" };
     this.#clearInFlight();
-    this.#outbox.close();
+    this.#queue.clear();
   };
   connect = (socket, delivery) => {
     this.#connection = { delivery, kind: "connected", socket };
@@ -43809,16 +43642,18 @@ var DaemonSessionEventPublisher = class {
   };
   publish = (sessionId, event) => {
     try {
-      this.#outbox.enqueue(sessionId, encodeRecordedSessionEvent(event), reservesSessionEventCapacity(event));
+      this.#queue.enqueueBatch(
+        sessionId,
+        [encodeRecordedSessionEvent(event)],
+        reservesSessionEventCapacity(event)
+      );
     } catch (error62) {
-      if (!(error62 instanceof SessionEventOutboxCapacityError)) {
+      if (!(error62 instanceof SessionEventQueueCapacityError)) {
         throw error62;
       }
       if (!this.#reportedCapacityKinds.has(event.kind)) {
         this.#reportedCapacityKinds.add(event.kind);
-        console.warn(
-          `Mobius daemon could not persist "${event.kind}" because the Session event outbox is full`
-        );
+        console.warn(`Mobius daemon could not buffer "${event.kind}" because the Session event queue is full`);
       }
       return;
     }
@@ -43826,11 +43661,11 @@ var DaemonSessionEventPublisher = class {
   };
   publishBatch = (sessionId, events) => {
     const critical = events.some(reservesSessionEventCapacity);
-    this.#outbox.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
+    this.#queue.enqueueBatch(sessionId, events.map(encodeRecordedSessionEvent), critical);
     this.#publishNextBatch();
   };
-  quarantine = (rejection) => {
-    if (!this.#outbox.quarantine(rejection)) {
+  reject = (rejection) => {
+    if (!this.#queue.remove(rejection.eventId, rejection.sessionId)) {
       return;
     }
     this.#removeInFlight(rejection.eventId);
@@ -43846,9 +43681,10 @@ var DaemonSessionEventPublisher = class {
       return;
     }
     while (this.#inFlight.size < SESSION_EVENT_REPLAY_WINDOW) {
-      const batch = this.#outbox.pending(SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size, [
-        ...this.#inFlight.keys()
-      ]);
+      const batch = this.#queue.pending(
+        SESSION_EVENT_REPLAY_WINDOW - this.#inFlight.size,
+        new Set(this.#inFlight.keys())
+      );
       let sent = 0;
       for (const envelope2 of batch) {
         const encoded = encodeDaemonToServiceMessage(
@@ -43867,12 +43703,7 @@ var DaemonSessionEventPublisher = class {
           return;
         }
         if (this.#connection.delivery === "ephemeral") {
-          this.#outbox.acknowledge({
-            eventId: envelope2.delivery.eventId,
-            kind: "session.event.ack",
-            outcome: { kind: "relayed" },
-            sessionId: envelope2.sessionId
-          });
+          this.#queue.remove(envelope2.delivery.eventId, envelope2.sessionId);
           sent += 1;
           continue;
         }
@@ -43985,11 +43816,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     join18(stateDirectory, "sessions", `${createHash6("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
   const operations = new DaemonOperationState();
-  const channelHash = createHash6("sha256").update(config2.channelId).digest("hex");
-  const publisher = new DaemonSessionEventPublisher(
-    new SessionEventOutbox(join18(stateDirectory, "events", `${channelHash}.sqlite`)),
-    timer
-  );
+  const publisher = new DaemonSessionEventPublisher(timer);
   const activeTurns = new DaemonTurnRegistry(operations);
   const recordSessionEvent = (sessionId, event) => {
     publisher.publish(sessionId, activeTurns.recordEvent(event));