@xyo-network/event-kit-node 0.0.1

package/README.md

@@ -0,0 +1,51 @@
+# `@xyo-network/event-kit-node`
+
+Node.js durability adapters for Event Kit:
+
+- `createFilesystemCursorStore` — publisher cursor for the wake publisher actor
+- `createFilesystemPublisherOutbox` — durable pending-wake slot for retry stability
+- `createFilesystemWakeQueue` — crash-safe at-least-once `WakeQueue`
+- `createSqliteWakeQueue` — `WakeQueue` over `node:sqlite`, no new dependencies
+- `createFilesystemWakeInbox` — durable `AtomicWakeInbox` over that queue
+
+## Durability model
+
+`createFilesystemWakeInbox` commits in one order and that order is the
+correctness property: the wake reaches the durable queue **before** either
+identity record is written.
+
+- A crash in the gap redelivers the wake, which the idempotent consumer absorbs.
+- The reverse order could claim `wakeId` for a wake that was never queued and
+  wedge it permanently, which D-002 §6 forbids.
+
+Records and queue entries are published with `link`, never `rename`. `rename` is
+unsound as a claim: when two callers race the same source, both can observe
+success once the paths resolve to one inode, and the entry is handed out twice.
+`link` fails with `EEXIST`, so exactly one caller wins and the loser re-reads the
+winner's receipt.
+
+A claim is `link(pending -> inflight)` then `unlink(pending)`. A consumer that
+dies mid-handler leaves its entry in `inflight/`; `recoverInflight()` returns it
+to `pending/` at startup. A crash between the link and the unlink leaves one
+inode in both sets, and recovery keeps the pending copy.
+
+## Queue providers
+
+Both queues implement the shared lease-based `WakeQueue` port and pass the
+conformance suite in `@xyo-network/event-kit-testing`, so they are swappable
+with each other and with the in-process memory provider.
+
+SQLite makes the lease a single statement: `UPDATE … WHERE state = 'pending'`,
+where the affected-row count decides the winner. That is the transactional form
+of what the filesystem provider approximates with `link`. WAL lets several
+processes on one host share the file; it does not coordinate across hosts.
+
+`node:sqlite` is built in, so this adds no dependency. It does emit an
+ExperimentalWarning.
+
+## Boundary
+
+This survives process death, not host loss, and does not coordinate across
+machines. Gate 5's durable-adapter clause is satisfied for a single node only; a
+multi-node deployment needs a transactional store or a cloud queue with native
+deduplication, which remains Phase 5b.

package/dist/node/filesystemCursorStore.d.ts

@@ -0,0 +1,10 @@
+import type { PublisherCursorStore } from '@xyo-network/event-kit-actor';
+export interface FilesystemCursorStoreOptions {
+    /** Absolute or relative path to the cursor JSON file. */
+    readonly path: string;
+}
+/**
+ * Persists the publisher cursor as `{ "lastProcessedBlock": number }` on disk.
+ */
+export declare function createFilesystemCursorStore(options: FilesystemCursorStoreOptions): PublisherCursorStore;
+//# sourceMappingURL=filesystemCursorStore.d.ts.map

package/dist/node/filesystemCursorStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystemCursorStore.d.ts","sourceRoot":"","sources":["../../src/filesystemCursorStore.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAExE,MAAM,WAAW,4BAA4B;IAC3C,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAMD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,4BAA4B,GACpC,oBAAoB,CAsBtB"}

package/dist/node/filesystemPublisherOutbox.d.ts

@@ -0,0 +1,16 @@
+import type { PublisherOutbox } from '@xyo-network/event-kit-actor';
+export interface FilesystemPublisherOutboxOptions {
+    /** Absolute or relative path to the pending-wake JSON file. */
+    readonly path: string;
+}
+/**
+ * Durable single-slot publisher outbox.
+ *
+ * The publisher emits at most one wake per pass, so one slot is enough: the
+ * entry is written before the first delivery attempt and cleared only after the
+ * cursor advances. A crash in between leaves it on disk, and the next pass
+ * retries the same `wakeId`/`issuedAt` — and therefore the same `eventHash` —
+ * under a freshly minted JWT.
+ */
+export declare function createFilesystemPublisherOutbox(options: FilesystemPublisherOutboxOptions): PublisherOutbox;
+//# sourceMappingURL=filesystemPublisherOutbox.d.ts.map

package/dist/node/filesystemPublisherOutbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystemPublisherOutbox.d.ts","sourceRoot":"","sources":["../../src/filesystemPublisherOutbox.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,8BAA8B,CAAA;AAIhF,MAAM,WAAW,gCAAgC;IAC/C,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,eAAe,CAkCjB"}

package/dist/node/filesystemWakeInbox.d.ts

@@ -0,0 +1,30 @@
+import type { AtomicWakeInbox } from '@xyo-network/event-kit-protocol';
+import type { FilesystemWakeQueue } from './filesystemWakeQueue.ts';
+export interface FilesystemWakeInboxOptions {
+    /** Directory owning the `tokens/` and `wakes/` record sets. */
+    readonly path: string;
+    /** Durable sink receiving each newly admitted wake inside the commit. */
+    readonly queue: FilesystemWakeQueue;
+}
+export interface FilesystemWakeInbox extends AtomicWakeInbox {
+    /** Deletes token records past `retainJwtUntil`. Returns how many were removed. */
+    pruneExpiredTokens: (nowSeconds: number) => Promise<number>;
+}
+/**
+ * Crash-safe single-node `AtomicWakeInbox`.
+ *
+ * Commit order is the correctness property: the wake reaches the durable queue
+ * **before** either identity record is written. A crash in the gap redelivers
+ * the wake, which the idempotent consumer absorbs; the reverse order could
+ * claim `wakeId` for a wake that was never queued and wedge it permanently.
+ * D-002 §6 forbids burning a valid `jti` ahead of a fallible enqueue.
+ *
+ * Identity records are published by `link`, which fails rather than overwrites,
+ * so a concurrent writer loses the race and re-reads the winner's receipt.
+ *
+ * This survives process death, not host loss, and does not coordinate across
+ * machines. A multi-node deployment needs a transactional store or a cloud
+ * queue with native deduplication.
+ */
+export declare function createFilesystemWakeInbox(options: FilesystemWakeInboxOptions): FilesystemWakeInbox;
+//# sourceMappingURL=filesystemWakeInbox.d.ts.map

package/dist/node/filesystemWakeInbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystemWakeInbox.d.ts","sourceRoot":"","sources":["../../src/filesystemWakeInbox.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,eAAe,EAKhB,MAAM,iCAAiC,CAAA;AAExC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAGnE,MAAM,WAAW,0BAA0B;IACzC,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAA;CACpC;AAED,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,kFAAkF;IAClF,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CAC5D;AAkBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,0BAA0B,GAClC,mBAAmB,CAwHrB"}

package/dist/node/filesystemWakeQueue.d.ts

@@ -0,0 +1,34 @@
+import type { WakeQueue } from '@xyo-network/event-kit-protocol';
+export interface FilesystemWakeQueueOptions {
+    /** Directory owning the `pending/` and `inflight/` entry sets. */
+    readonly path: string;
+}
+export type FilesystemWakeQueue = WakeQueue;
+/**
+ * Directory-backed at-least-once wake queue.
+ *
+ * Entries are published by `link`, never `rename`. `rename` is unsound as a
+ * claim: when two callers race the same source, both can observe success once
+ * the paths resolve to one inode, and the entry is then handed out twice. `link`
+ * fails with `EEXIST`, so exactly one claimer wins.
+ *
+ * A claim is `link(pending -> inflight)` followed by `unlink(pending)`. A crash
+ * between the two leaves the entry in both sets as one inode; recovery drops the
+ * inflight copy and the entry stays pending. A consumer that dies mid-handler
+ * leaves its entry inflight for `recoverInflight` rather than dropping it.
+ *
+ * Ordering is approximate FIFO by entry name. Single-node only: this survives
+ * process death, not host loss, and does not coordinate across machines.
+ */
+export declare function createFilesystemWakeQueue(options: FilesystemWakeQueueOptions): FilesystemWakeQueue;
+/** Writes and fsyncs `body` so the bytes survive a crash before the caller publishes it. */
+export declare function writeDurableFile(path: string, body: string): Promise<void>;
+/**
+ * Best-effort directory fsync so a publish survives power loss. Some platforms
+ * and filesystems reject opening a directory for sync; the link itself is still
+ * atomic, so a rejection is not fatal.
+ */
+export declare function syncDirectory(path: string): Promise<void>;
+/** Reads and parses a JSON file, treating an absent or unreadable file as empty. */
+export declare function readJsonFile<T>(path: string): Promise<T | undefined>;
+//# sourceMappingURL=filesystemWakeQueue.d.ts.map

package/dist/node/filesystemWakeQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filesystemWakeQueue.d.ts","sourceRoot":"","sources":["../../src/filesystemWakeQueue.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGV,SAAS,EACV,MAAM,iCAAiC,CAAA;AAExC,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,MAAM,mBAAmB,GAAG,SAAS,CAAA;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,0BAA0B,GAClC,mBAAmB,CAwFrB;AAED,4FAA4F;AAC5F,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhF;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU/D;AAED,oFAAoF;AACpF,wBAAsB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAY1E"}

package/dist/node/index.d.ts

@@ -0,0 +1,11 @@
+export type { FilesystemCursorStoreOptions } from './filesystemCursorStore.ts';
+export { createFilesystemCursorStore } from './filesystemCursorStore.ts';
+export type { FilesystemPublisherOutboxOptions } from './filesystemPublisherOutbox.ts';
+export { createFilesystemPublisherOutbox } from './filesystemPublisherOutbox.ts';
+export type { FilesystemWakeInbox, FilesystemWakeInboxOptions, } from './filesystemWakeInbox.ts';
+export { createFilesystemWakeInbox } from './filesystemWakeInbox.ts';
+export type { FilesystemWakeQueue, FilesystemWakeQueueOptions, } from './filesystemWakeQueue.ts';
+export { createFilesystemWakeQueue } from './filesystemWakeQueue.ts';
+export type { SqliteWakeQueue, SqliteWakeQueueOptions, } from './sqliteWakeQueue.ts';
+export { createSqliteWakeQueue } from './sqliteWakeQueue.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AACxE,YAAY,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAA;AACtF,OAAO,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAA;AAChF,YAAY,EACV,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAA;AACpE,YAAY,EACV,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAA;AACpE,YAAY,EACV,eAAe,EACf,sBAAsB,GACvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/node/index.mjs

@@ -0,0 +1,446 @@
+// src/filesystemCursorStore.ts
+import {
+  mkdir,
+  readFile,
+  writeFile
+} from "node:fs/promises";
+import PATH from "node:path";
+function createFilesystemCursorStore(options) {
+  const filePath = PATH.resolve(options.path);
+  return {
+    async load() {
+      try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.lastProcessedBlock !== "number" || !Number.isFinite(parsed.lastProcessedBlock)) {
+          return void 0;
+        }
+        return parsed.lastProcessedBlock;
+      } catch (error) {
+        if (isNotFound(error)) return void 0;
+        throw error;
+      }
+    },
+    async save(lastProcessedBlock) {
+      await mkdir(PATH.dirname(filePath), { recursive: true });
+      const body = { lastProcessedBlock };
+      await writeFile(filePath, `${JSON.stringify(body)}
+`, "utf8");
+    }
+  };
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/filesystemPublisherOutbox.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  mkdir as mkdir3,
+  rename,
+  unlink as unlink2
+} from "node:fs/promises";
+import PATH3 from "node:path";
+
+// src/filesystemWakeQueue.ts
+import { randomBytes } from "node:crypto";
+import {
+  link,
+  mkdir as mkdir2,
+  open,
+  readdir,
+  unlink
+} from "node:fs/promises";
+import PATH2 from "node:path";
+function createFilesystemWakeQueue(options) {
+  const root = PATH2.resolve(options.path);
+  const pendingDir = PATH2.join(root, "pending");
+  const inflightDir = PATH2.join(root, "inflight");
+  const tempDir = PATH2.join(root, "tmp");
+  let sequence = 0;
+  async function ensureDirs() {
+    await mkdir2(pendingDir, { recursive: true });
+    await mkdir2(inflightDir, { recursive: true });
+    await mkdir2(tempDir, { recursive: true });
+  }
+  async function returnToPending(name) {
+    try {
+      await link(PATH2.join(inflightDir, name), PATH2.join(pendingDir, name));
+    } catch (error) {
+      if (!isAlreadyExists(error) && !isNotFound2(error)) throw error;
+    }
+    await unlink(PATH2.join(inflightDir, name)).catch(ignoreNotFound);
+  }
+  return {
+    async append(wake) {
+      await ensureDirs();
+      const name = entryName(wake, sequence += 1);
+      const tempPath = PATH2.join(tempDir, name);
+      await writeDurableFile(tempPath, `${JSON.stringify(wake)}
+`);
+      try {
+        await link(tempPath, PATH2.join(pendingDir, name));
+        await syncDirectory(pendingDir);
+      } finally {
+        await unlink(tempPath).catch(ignoreNotFound);
+      }
+    },
+    async claim() {
+      await ensureDirs();
+      const names = (await readdir(pendingDir)).sort();
+      for (const name of names) {
+        const inflightPath = PATH2.join(inflightDir, name);
+        const pendingPath = PATH2.join(pendingDir, name);
+        try {
+          await link(pendingPath, inflightPath);
+        } catch (error) {
+          if (isAlreadyExists(error) || isNotFound2(error)) continue;
+          throw error;
+        }
+        await unlink(pendingPath).catch(ignoreNotFound);
+        const wake = await readJsonFile(inflightPath);
+        if (wake === void 0) {
+          await unlink(inflightPath).catch(ignoreNotFound);
+          continue;
+        }
+        return {
+          wake,
+          async ack() {
+            await unlink(inflightPath).catch(ignoreNotFound);
+          },
+          async release() {
+            await returnToPending(name);
+          }
+        };
+      }
+      return void 0;
+    },
+    async pendingCount() {
+      await ensureDirs();
+      return (await readdir(pendingDir)).length;
+    },
+    async recoverInflight() {
+      await ensureDirs();
+      const names = await readdir(inflightDir);
+      let recovered = 0;
+      for (const name of names) {
+        await returnToPending(name);
+        recovered += 1;
+      }
+      return recovered;
+    }
+  };
+}
+async function writeDurableFile(path, body) {
+  const handle = await open(path, "w");
+  try {
+    await handle.writeFile(body, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function syncDirectory(path) {
+  let handle;
+  try {
+    handle = await open(path, "r");
+    await handle.sync();
+  } catch {
+    return;
+  } finally {
+    await handle?.close();
+  }
+}
+async function readJsonFile(path) {
+  try {
+    const handle = await open(path, "r");
+    try {
+      const raw = await handle.readFile("utf8");
+      return JSON.parse(raw);
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return void 0;
+  }
+}
+function entryName(wake, sequence) {
+  const stamp = String(Date.now()).padStart(15, "0");
+  const ordinal = String(sequence).padStart(6, "0");
+  return `${stamp}-${ordinal}-${randomBytes(6).toString("hex")}-${wake.wakeId}.json`;
+}
+function ignoreNotFound(error) {
+  if (!isNotFound2(error)) throw error;
+}
+function isNotFound2(error) {
+  return errorCode(error) === "ENOENT";
+}
+function isAlreadyExists(error) {
+  return errorCode(error) === "EEXIST";
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+
+// src/filesystemPublisherOutbox.ts
+function createFilesystemPublisherOutbox(options) {
+  const filePath = PATH3.resolve(options.path);
+  return {
+    async clear() {
+      try {
+        await unlink2(filePath);
+      } catch (error) {
+        if (!isNotFound3(error)) throw error;
+      }
+    },
+    async load() {
+      return await readJsonFile(filePath);
+    },
+    async save(pending) {
+      await mkdir3(PATH3.dirname(filePath), { recursive: true });
+      const tempPath = `${filePath}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+      await writeDurableFile(tempPath, `${JSON.stringify(pending)}
+`);
+      try {
+        await rename(tempPath, filePath);
+      } catch (error) {
+        try {
+          await unlink2(tempPath);
+        } catch {
+        }
+        throw error;
+      }
+    }
+  };
+}
+function isNotFound3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/filesystemWakeInbox.ts
+import { createHash, randomBytes as randomBytes3 } from "node:crypto";
+import {
+  link as link2,
+  mkdir as mkdir4,
+  open as open2,
+  readdir as readdir2,
+  unlink as unlink3
+} from "node:fs/promises";
+import PATH4 from "node:path";
+function createFilesystemWakeInbox(options) {
+  const root = PATH4.resolve(options.path);
+  const tokensDir = PATH4.join(root, "tokens");
+  const wakesDir = PATH4.join(root, "wakes");
+  const tempDir = PATH4.join(root, "tmp");
+  let tail = Promise.resolve();
+  function exclusive(work) {
+    const run = tail.then(work, work);
+    tail = Promise.allSettled([run]);
+    return run;
+  }
+  async function ensureDirs() {
+    await mkdir4(tokensDir, { recursive: true });
+    await mkdir4(wakesDir, { recursive: true });
+    await mkdir4(tempDir, { recursive: true });
+  }
+  function tokenPath(attempt) {
+    return PATH4.join(tokensDir, `${digest([attempt.audience, attempt.publisher, attempt.jwtId])}.json`);
+  }
+  function wakePath(attempt) {
+    return PATH4.join(wakesDir, `${digest([attempt.audience, attempt.publisher, attempt.wakeId])}.json`);
+  }
+  async function bindToken(attempt, wake) {
+    const record = {
+      ...wake,
+      jwtId: attempt.jwtId,
+      retainJwtUntil: attempt.retainJwtUntil
+    };
+    await writeRecordExclusive(tempDir, tokenPath(attempt), record);
+  }
+  async function matchRecorded(attempt) {
+    const token = await readRecord(tokenPath(attempt));
+    if (token !== void 0) {
+      return token.eventHash === attempt.eventHash && token.wakeId === attempt.wakeId ? { kind: "duplicate", receipt: token.receipt } : { kind: "jwt-id-collision" };
+    }
+    const wake = await readRecord(wakePath(attempt));
+    if (wake === void 0) return void 0;
+    if (wake.eventHash !== attempt.eventHash) return { kind: "wake-id-collision" };
+    await bindToken(attempt, wake);
+    return { kind: "duplicate", receipt: wake.receipt };
+  }
+  return {
+    async resolveAttempt(attempt) {
+      return await exclusive(async () => {
+        await ensureDirs();
+        return await matchRecorded(attempt) ?? { kind: "new" };
+      });
+    },
+    async commitAuthorized({ attempt, wake }) {
+      return await exclusive(async () => {
+        await ensureDirs();
+        const recorded = await matchRecorded(attempt);
+        if (recorded !== void 0) return recorded;
+        const receipt = Object.freeze({
+          audience: attempt.audience,
+          eventHash: attempt.eventHash,
+          id: digest([attempt.audience, attempt.publisher, attempt.wakeId]),
+          publisher: attempt.publisher,
+          wakeId: attempt.wakeId
+        });
+        const record = {
+          audience: attempt.audience,
+          eventHash: attempt.eventHash,
+          publisher: attempt.publisher,
+          receipt,
+          wakeId: attempt.wakeId
+        };
+        await options.queue.append(wake);
+        const claimed = await writeRecordExclusive(tempDir, wakePath(attempt), record);
+        if (!claimed) {
+          const winner = await readRecord(wakePath(attempt));
+          if (winner === void 0) throw new Error("wake record vanished during commit");
+          if (winner.eventHash !== attempt.eventHash) return { kind: "wake-id-collision" };
+          await bindToken(attempt, winner);
+          return { kind: "duplicate", receipt: winner.receipt };
+        }
+        await bindToken(attempt, record);
+        return { kind: "enqueued", receipt };
+      });
+    },
+    async pruneExpiredTokens(nowSeconds) {
+      await ensureDirs();
+      let removed = 0;
+      for (const name of await readdir2(tokensDir)) {
+        const path = PATH4.join(tokensDir, name);
+        const token = await readRecord(path);
+        if (token === void 0 || token.retainJwtUntil > nowSeconds) continue;
+        await unlink3(path).catch(ignoreNotFound2);
+        removed += 1;
+      }
+      return removed;
+    }
+  };
+}
+async function writeRecordExclusive(tempDir, path, record) {
+  const tempPath = PATH4.join(tempDir, `${PATH4.basename(path)}.${process.pid}.${randomSuffix()}`);
+  await writeDurableFile(tempPath, `${JSON.stringify(record)}
+`);
+  try {
+    await link2(tempPath, path);
+    await syncDirectory(PATH4.dirname(path));
+    return true;
+  } catch (error) {
+    if (isAlreadyExists2(error)) return false;
+    throw error;
+  } finally {
+    await unlink3(tempPath).catch(ignoreNotFound2);
+  }
+}
+async function readRecord(path) {
+  try {
+    const handle = await open2(path, "r");
+    try {
+      const raw = await handle.readFile("utf8");
+      return JSON.parse(raw);
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    if (isNotFound4(error)) return void 0;
+    throw error;
+  }
+}
+function digest(parts) {
+  return createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+}
+function randomSuffix() {
+  return randomBytes3(8).toString("hex");
+}
+function ignoreNotFound2(error) {
+  if (!isNotFound4(error)) throw error;
+}
+function isNotFound4(error) {
+  return errorCode2(error) === "ENOENT";
+}
+function isAlreadyExists2(error) {
+  return errorCode2(error) === "EEXIST";
+}
+function errorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+
+// src/sqliteWakeQueue.ts
+import { mkdir as mkdir5 } from "node:fs/promises";
+import PATH5 from "node:path";
+import { DatabaseSync } from "node:sqlite";
+async function createSqliteWakeQueue(options) {
+  const inMemory = options.path === ":memory:";
+  const file = inMemory ? options.path : PATH5.resolve(options.path);
+  if (!inMemory) await mkdir5(PATH5.dirname(file), { recursive: true });
+  const database = new DatabaseSync(file);
+  database.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = FULL;
+    CREATE TABLE IF NOT EXISTS wake_queue (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      body TEXT NOT NULL,
+      state TEXT NOT NULL DEFAULT 'pending'
+    );
+    CREATE INDEX IF NOT EXISTS wake_queue_state ON wake_queue (state, id);
+  `);
+  const insert = database.prepare("INSERT INTO wake_queue (body) VALUES (?)");
+  const nextPending = database.prepare(
+    "SELECT id, body FROM wake_queue WHERE state = 'pending' ORDER BY id LIMIT 1"
+  );
+  const lease = database.prepare(
+    "UPDATE wake_queue SET state = 'inflight' WHERE id = ? AND state = 'pending'"
+  );
+  const remove = database.prepare("DELETE FROM wake_queue WHERE id = ?");
+  const restore = database.prepare(
+    "UPDATE wake_queue SET state = 'pending' WHERE id = ? AND state = 'inflight'"
+  );
+  const countPending = database.prepare(
+    "SELECT COUNT(*) AS total FROM wake_queue WHERE state = 'pending'"
+  );
+  const recoverAll = database.prepare(
+    "UPDATE wake_queue SET state = 'pending' WHERE state = 'inflight'"
+  );
+  return {
+    async append(wake) {
+      insert.run(JSON.stringify(wake));
+    },
+    async claim() {
+      for (; ; ) {
+        const row = nextPending.get();
+        if (row === void 0) return void 0;
+        if (lease.run(row.id).changes !== 1) continue;
+        return {
+          wake: JSON.parse(row.body),
+          async ack() {
+            remove.run(row.id);
+          },
+          async release() {
+            restore.run(row.id);
+          }
+        };
+      }
+    },
+    close() {
+      database.close();
+    },
+    async pendingCount() {
+      return Number(countPending.get().total);
+    },
+    async recoverInflight() {
+      return Number(recoverAll.run().changes);
+    }
+  };
+}
+export {
+  createFilesystemCursorStore,
+  createFilesystemPublisherOutbox,
+  createFilesystemWakeInbox,
+  createFilesystemWakeQueue,
+  createSqliteWakeQueue
+};
+//# sourceMappingURL=index.mjs.map

package/dist/node/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/filesystemCursorStore.ts", "../../src/filesystemPublisherOutbox.ts", "../../src/filesystemWakeQueue.ts", "../../src/filesystemWakeInbox.ts", "../../src/sqliteWakeQueue.ts"],
+  "sourcesContent": ["import {\n  mkdir, readFile, writeFile,\n} from 'node:fs/promises'\nimport PATH from 'node:path'\n\nimport type { PublisherCursorStore } from '@xyo-network/event-kit-actor'\n\nexport interface FilesystemCursorStoreOptions {\n  /** Absolute or relative path to the cursor JSON file. */\n  readonly path: string\n}\n\ninterface CursorFile {\n  readonly lastProcessedBlock: number\n}\n\n/**\n * Persists the publisher cursor as `{ \"lastProcessedBlock\": number }` on disk.\n */\nexport function createFilesystemCursorStore(\n  options: FilesystemCursorStoreOptions,\n): PublisherCursorStore {\n  const filePath = PATH.resolve(options.path)\n  return {\n    async load(): Promise<number | undefined> {\n      try {\n        const raw = await readFile(filePath, 'utf8')\n        const parsed = JSON.parse(raw) as CursorFile\n        if (typeof parsed.lastProcessedBlock !== 'number' || !Number.isFinite(parsed.lastProcessedBlock)) {\n          return undefined\n        }\n        return parsed.lastProcessedBlock\n      } catch (error) {\n        if (isNotFound(error)) return undefined\n        throw error\n      }\n    },\n    async save(lastProcessedBlock: number): Promise<void> {\n      await mkdir(PATH.dirname(filePath), { recursive: true })\n      const body: CursorFile = { lastProcessedBlock }\n      await writeFile(filePath, `${JSON.stringify(body)}\\n`, 'utf8')\n    },\n  }\n}\n\nfunction isNotFound(error: unknown): boolean {\n  return typeof error === 'object'\n    && error !== null\n    && 'code' in error\n    && (error as { code?: unknown }).code === 'ENOENT'\n}\n", "import { randomBytes } from 'node:crypto'\nimport {\n  mkdir, rename, unlink,\n} from 'node:fs/promises'\nimport PATH from 'node:path'\n\nimport type { PendingWake, PublisherOutbox } from '@xyo-network/event-kit-actor'\n\nimport { readJsonFile, writeDurableFile } from './filesystemWakeQueue.ts'\n\nexport interface FilesystemPublisherOutboxOptions {\n  /** Absolute or relative path to the pending-wake JSON file. */\n  readonly path: string\n}\n\n/**\n * Durable single-slot publisher outbox.\n *\n * The publisher emits at most one wake per pass, so one slot is enough: the\n * entry is written before the first delivery attempt and cleared only after the\n * cursor advances. A crash in between leaves it on disk, and the next pass\n * retries the same `wakeId`/`issuedAt` \u2014 and therefore the same `eventHash` \u2014\n * under a freshly minted JWT.\n */\nexport function createFilesystemPublisherOutbox(\n  options: FilesystemPublisherOutboxOptions,\n): PublisherOutbox {\n  const filePath = PATH.resolve(options.path)\n\n  return {\n    async clear(): Promise<void> {\n      try {\n        await unlink(filePath)\n      } catch (error) {\n        if (!isNotFound(error)) throw error\n      }\n    },\n\n    async load(): Promise<PendingWake | undefined> {\n      return await readJsonFile<PendingWake>(filePath)\n    },\n\n    async save(pending: PendingWake): Promise<void> {\n      await mkdir(PATH.dirname(filePath), { recursive: true })\n      // Write-then-rename so a crash mid-write cannot leave a partial entry.\n      // `rename` is sound here: one writer, and replacing the slot is intended.\n      const tempPath = `${filePath}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`\n      await writeDurableFile(tempPath, `${JSON.stringify(pending)}\\n`)\n      try {\n        await rename(tempPath, filePath)\n      } catch (error) {\n        try {\n          await unlink(tempPath)\n        } catch {\n          // A leftover temp file is harmless; the rename failure is what matters.\n        }\n        throw error\n      }\n    },\n  }\n}\n\nfunction isNotFound(error: unknown): boolean {\n  return typeof error === 'object'\n    && error !== null\n    && 'code' in error\n    && (error as { code?: unknown }).code === 'ENOENT'\n}\n", "import { randomBytes } from 'node:crypto'\nimport {\n  link, mkdir, open, readdir, unlink,\n} from 'node:fs/promises'\nimport PATH from 'node:path'\n\nimport type {\n  AdmittedWake,\n  LeasedWake,\n  WakeQueue,\n} from '@xyo-network/event-kit-protocol'\n\nexport interface FilesystemWakeQueueOptions {\n  /** Directory owning the `pending/` and `inflight/` entry sets. */\n  readonly path: string\n}\n\nexport type FilesystemWakeQueue = WakeQueue\n\n/**\n * Directory-backed at-least-once wake queue.\n *\n * Entries are published by `link`, never `rename`. `rename` is unsound as a\n * claim: when two callers race the same source, both can observe success once\n * the paths resolve to one inode, and the entry is then handed out twice. `link`\n * fails with `EEXIST`, so exactly one claimer wins.\n *\n * A claim is `link(pending -> inflight)` followed by `unlink(pending)`. A crash\n * between the two leaves the entry in both sets as one inode; recovery drops the\n * inflight copy and the entry stays pending. A consumer that dies mid-handler\n * leaves its entry inflight for `recoverInflight` rather than dropping it.\n *\n * Ordering is approximate FIFO by entry name. Single-node only: this survives\n * process death, not host loss, and does not coordinate across machines.\n */\nexport function createFilesystemWakeQueue(\n  options: FilesystemWakeQueueOptions,\n): FilesystemWakeQueue {\n  const root = PATH.resolve(options.path)\n  const pendingDir = PATH.join(root, 'pending')\n  const inflightDir = PATH.join(root, 'inflight')\n  const tempDir = PATH.join(root, 'tmp')\n  let sequence = 0\n\n  async function ensureDirs(): Promise<void> {\n    await mkdir(pendingDir, { recursive: true })\n    await mkdir(inflightDir, { recursive: true })\n    await mkdir(tempDir, { recursive: true })\n  }\n\n  /** Moves one entry back to `pending/`, tolerating an existing half-claimed copy. */\n  async function returnToPending(name: string): Promise<void> {\n    try {\n      await link(PATH.join(inflightDir, name), PATH.join(pendingDir, name))\n    } catch (error) {\n      // EEXIST means a crash left both links to the same entry; the pending copy wins.\n      if (!isAlreadyExists(error) && !isNotFound(error)) throw error\n    }\n    await unlink(PATH.join(inflightDir, name)).catch(ignoreNotFound)\n  }\n\n  return {\n    async append(wake: AdmittedWake): Promise<void> {\n      await ensureDirs()\n      const name = entryName(wake, sequence += 1)\n      const tempPath = PATH.join(tempDir, name)\n      await writeDurableFile(tempPath, `${JSON.stringify(wake)}\\n`)\n      try {\n        await link(tempPath, PATH.join(pendingDir, name))\n        await syncDirectory(pendingDir)\n      } finally {\n        await unlink(tempPath).catch(ignoreNotFound)\n      }\n    },\n\n    async claim(): Promise<LeasedWake | undefined> {\n      await ensureDirs()\n      const names = (await readdir(pendingDir)).sort()\n      for (const name of names) {\n        const inflightPath = PATH.join(inflightDir, name)\n        const pendingPath = PATH.join(pendingDir, name)\n        try {\n          // The link is the claim: a second claimer gets EEXIST and moves on.\n          await link(pendingPath, inflightPath)\n        } catch (error) {\n          if (isAlreadyExists(error) || isNotFound(error)) continue\n          throw error\n        }\n        await unlink(pendingPath).catch(ignoreNotFound)\n\n        const wake = await readJsonFile<AdmittedWake>(inflightPath)\n        if (wake === undefined) {\n          await unlink(inflightPath).catch(ignoreNotFound)\n          continue\n        }\n\n        return {\n          wake,\n          async ack(): Promise<void> {\n            await unlink(inflightPath).catch(ignoreNotFound)\n          },\n          async release(): Promise<void> {\n            await returnToPending(name)\n          },\n        }\n      }\n      return undefined\n    },\n\n    async pendingCount(): Promise<number> {\n      await ensureDirs()\n      return (await readdir(pendingDir)).length\n    },\n\n    async recoverInflight(): Promise<number> {\n      await ensureDirs()\n      const names = await readdir(inflightDir)\n      let recovered = 0\n      for (const name of names) {\n        await returnToPending(name)\n        recovered += 1\n      }\n      return recovered\n    },\n  }\n}\n\n/** Writes and fsyncs `body` so the bytes survive a crash before the caller publishes it. */\nexport async function writeDurableFile(path: string, body: string): Promise<void> {\n  const handle = await open(path, 'w')\n  try {\n    await handle.writeFile(body, 'utf8')\n    await handle.sync()\n  } finally {\n    await handle.close()\n  }\n}\n\n/**\n * Best-effort directory fsync so a publish survives power loss. Some platforms\n * and filesystems reject opening a directory for sync; the link itself is still\n * atomic, so a rejection is not fatal.\n */\nexport async function syncDirectory(path: string): Promise<void> {\n  let handle\n  try {\n    handle = await open(path, 'r')\n    await handle.sync()\n  } catch {\n    return\n  } finally {\n    await handle?.close()\n  }\n}\n\n/** Reads and parses a JSON file, treating an absent or unreadable file as empty. */\nexport async function readJsonFile<T>(path: string): Promise<T | undefined> {\n  try {\n    const handle = await open(path, 'r')\n    try {\n      const raw = await handle.readFile('utf8')\n      return JSON.parse(raw) as T\n    } finally {\n      await handle.close()\n    }\n  } catch {\n    return undefined\n  }\n}\n\n/** Sorts approximately FIFO; the random suffix keeps concurrent writers from colliding. */\nfunction entryName(wake: AdmittedWake, sequence: number): string {\n  const stamp = String(Date.now()).padStart(15, '0')\n  const ordinal = String(sequence).padStart(6, '0')\n  return `${stamp}-${ordinal}-${randomBytes(6).toString('hex')}-${wake.wakeId}.json`\n}\n\nfunction ignoreNotFound(error: unknown): void {\n  if (!isNotFound(error)) throw error\n}\n\nfunction isNotFound(error: unknown): boolean {\n  return errorCode(error) === 'ENOENT'\n}\n\nfunction isAlreadyExists(error: unknown): boolean {\n  return errorCode(error) === 'EEXIST'\n}\n\nfunction errorCode(error: unknown): unknown {\n  return typeof error === 'object' && error !== null && 'code' in error\n    ? (error as { code?: unknown }).code\n    : undefined\n}\n", "import { createHash, randomBytes } from 'node:crypto'\nimport {\n  link, mkdir, open, readdir, unlink,\n} from 'node:fs/promises'\nimport PATH from 'node:path'\n\nimport type {\n  AdmittedWake,\n  AtomicWakeInbox,\n  WakeAdmissionAttempt,\n  WakeAdmissionReceipt,\n  WakeAttemptResolution,\n  WakeCommitResult,\n} from '@xyo-network/event-kit-protocol'\n\nimport type { FilesystemWakeQueue } from './filesystemWakeQueue.ts'\nimport { syncDirectory, writeDurableFile } from './filesystemWakeQueue.ts'\n\nexport interface FilesystemWakeInboxOptions {\n  /** Directory owning the `tokens/` and `wakes/` record sets. */\n  readonly path: string\n  /** Durable sink receiving each newly admitted wake inside the commit. */\n  readonly queue: FilesystemWakeQueue\n}\n\nexport interface FilesystemWakeInbox extends AtomicWakeInbox {\n  /** Deletes token records past `retainJwtUntil`. Returns how many were removed. */\n  pruneExpiredTokens: (nowSeconds: number) => Promise<number>\n}\n\ninterface WakeRecord {\n  readonly audience: string\n  readonly eventHash: string\n  readonly publisher: string\n  readonly receipt: WakeAdmissionReceipt\n  readonly wakeId: string\n}\n\ninterface TokenRecord extends WakeRecord {\n  readonly jwtId: string\n  readonly retainJwtUntil: number\n}\n\n/** The already-recorded outcomes, common to both the resolve and commit unions. */\ntype RecordedResolution = Exclude<WakeAttemptResolution, { readonly kind: 'new' }>\n\n/**\n * Crash-safe single-node `AtomicWakeInbox`.\n *\n * Commit order is the correctness property: the wake reaches the durable queue\n * **before** either identity record is written. A crash in the gap redelivers\n * the wake, which the idempotent consumer absorbs; the reverse order could\n * claim `wakeId` for a wake that was never queued and wedge it permanently.\n * D-002 \u00A76 forbids burning a valid `jti` ahead of a fallible enqueue.\n *\n * Identity records are published by `link`, which fails rather than overwrites,\n * so a concurrent writer loses the race and re-reads the winner's receipt.\n *\n * This survives process death, not host loss, and does not coordinate across\n * machines. A multi-node deployment needs a transactional store or a cloud\n * queue with native deduplication.\n */\nexport function createFilesystemWakeInbox(\n  options: FilesystemWakeInboxOptions,\n): FilesystemWakeInbox {\n  const root = PATH.resolve(options.path)\n  const tokensDir = PATH.join(root, 'tokens')\n  const wakesDir = PATH.join(root, 'wakes')\n  const tempDir = PATH.join(root, 'tmp')\n  let tail: Promise<unknown> = Promise.resolve()\n\n  /**\n   * Serializes this process's critical section. Cross-process safety comes from\n   * the exclusive record creates; this keeps one process from racing itself.\n   */\n  function exclusive<T>(work: () => Promise<T>): Promise<T> {\n    const run = tail.then(work, work)\n    tail = Promise.allSettled([run])\n    return run\n  }\n\n  async function ensureDirs(): Promise<void> {\n    await mkdir(tokensDir, { recursive: true })\n    await mkdir(wakesDir, { recursive: true })\n    await mkdir(tempDir, { recursive: true })\n  }\n\n  function tokenPath(attempt: WakeAdmissionAttempt): string {\n    return PATH.join(tokensDir, `${digest([attempt.audience, attempt.publisher, attempt.jwtId])}.json`)\n  }\n\n  function wakePath(attempt: WakeAdmissionAttempt): string {\n    return PATH.join(wakesDir, `${digest([attempt.audience, attempt.publisher, attempt.wakeId])}.json`)\n  }\n\n  /** Binds `attempt`'s token to an already-committed wake receipt. */\n  async function bindToken(attempt: WakeAdmissionAttempt, wake: WakeRecord): Promise<void> {\n    const record: TokenRecord = {\n      ...wake,\n      jwtId: attempt.jwtId,\n      retainJwtUntil: attempt.retainJwtUntil,\n    }\n    await writeRecordExclusive(tempDir, tokenPath(attempt), record)\n  }\n\n  async function matchRecorded(attempt: WakeAdmissionAttempt): Promise<RecordedResolution | undefined> {\n    const token = await readRecord<TokenRecord>(tokenPath(attempt))\n    if (token !== undefined) {\n      return token.eventHash === attempt.eventHash && token.wakeId === attempt.wakeId\n        ? { kind: 'duplicate', receipt: token.receipt }\n        : { kind: 'jwt-id-collision' }\n    }\n\n    const wake = await readRecord<WakeRecord>(wakePath(attempt))\n    if (wake === undefined) return undefined\n    if (wake.eventHash !== attempt.eventHash) return { kind: 'wake-id-collision' }\n    await bindToken(attempt, wake)\n    return { kind: 'duplicate', receipt: wake.receipt }\n  }\n\n  return {\n    async resolveAttempt(attempt: WakeAdmissionAttempt): Promise<WakeAttemptResolution> {\n      return await exclusive(async () => {\n        await ensureDirs()\n        return await matchRecorded(attempt) ?? { kind: 'new' }\n      })\n    },\n\n    async commitAuthorized({ attempt, wake }: {\n      readonly attempt: WakeAdmissionAttempt\n      readonly wake: AdmittedWake\n    }): Promise<WakeCommitResult> {\n      return await exclusive(async () => {\n        await ensureDirs()\n        const recorded = await matchRecorded(attempt)\n        if (recorded !== undefined) return recorded\n\n        const receipt: WakeAdmissionReceipt = Object.freeze({\n          audience: attempt.audience,\n          eventHash: attempt.eventHash,\n          id: digest([attempt.audience, attempt.publisher, attempt.wakeId]),\n          publisher: attempt.publisher,\n          wakeId: attempt.wakeId,\n        })\n        const record: WakeRecord = {\n          audience: attempt.audience,\n          eventHash: attempt.eventHash,\n          publisher: attempt.publisher,\n          receipt,\n          wakeId: attempt.wakeId,\n        }\n\n        // Durable queue first: a crash after this point redelivers, which the\n        // consumer deduplicates. Claiming the identity first could wedge the wake.\n        await options.queue.append(wake)\n\n        const claimed = await writeRecordExclusive(tempDir, wakePath(attempt), record)\n        if (!claimed) {\n          // Another writer committed this wakeId between our check and our write.\n          const winner = await readRecord<WakeRecord>(wakePath(attempt))\n          if (winner === undefined) throw new Error('wake record vanished during commit')\n          if (winner.eventHash !== attempt.eventHash) return { kind: 'wake-id-collision' }\n          await bindToken(attempt, winner)\n          return { kind: 'duplicate', receipt: winner.receipt }\n        }\n\n        await bindToken(attempt, record)\n        return { kind: 'enqueued', receipt }\n      })\n    },\n\n    async pruneExpiredTokens(nowSeconds: number): Promise<number> {\n      await ensureDirs()\n      let removed = 0\n      for (const name of await readdir(tokensDir)) {\n        const path = PATH.join(tokensDir, name)\n        const token = await readRecord<TokenRecord>(path)\n        if (token === undefined || token.retainJwtUntil > nowSeconds) continue\n        await unlink(path).catch(ignoreNotFound)\n        removed += 1\n      }\n      return removed\n    },\n  }\n}\n\n/**\n * Atomically publishes a record. Returns `false` when another writer already\n * claimed the path, which is how a cross-process race is detected.\n *\n * The content is written and fsynced to a temp file first, then `link`ed into\n * place: `link` fails when the destination exists (unlike `rename`, which would\n * overwrite the winner) and publishes only complete bytes, so a concurrent\n * reader can never observe a half-written record.\n */\nasync function writeRecordExclusive(tempDir: string, path: string, record: unknown): Promise<boolean> {\n  const tempPath = PATH.join(tempDir, `${PATH.basename(path)}.${process.pid}.${randomSuffix()}`)\n  await writeDurableFile(tempPath, `${JSON.stringify(record)}\\n`)\n  try {\n    await link(tempPath, path)\n    await syncDirectory(PATH.dirname(path))\n    return true\n  } catch (error) {\n    if (isAlreadyExists(error)) return false\n    throw error\n  } finally {\n    await unlink(tempPath).catch(ignoreNotFound)\n  }\n}\n\nasync function readRecord<T>(path: string): Promise<T | undefined> {\n  try {\n    const handle = await open(path, 'r')\n    try {\n      const raw = await handle.readFile('utf8')\n      return JSON.parse(raw) as T\n    } finally {\n      await handle.close()\n    }\n  } catch (error) {\n    if (isNotFound(error)) return undefined\n    throw error\n  }\n}\n\nfunction digest(parts: readonly string[]): string {\n  return createHash('sha256').update(JSON.stringify(parts)).digest('hex')\n}\n\nfunction randomSuffix(): string {\n  return randomBytes(8).toString('hex')\n}\n\nfunction ignoreNotFound(error: unknown): void {\n  if (!isNotFound(error)) throw error\n}\n\nfunction isNotFound(error: unknown): boolean {\n  return errorCode(error) === 'ENOENT'\n}\n\nfunction isAlreadyExists(error: unknown): boolean {\n  return errorCode(error) === 'EEXIST'\n}\n\nfunction errorCode(error: unknown): unknown {\n  return typeof error === 'object' && error !== null && 'code' in error\n    ? (error as { code?: unknown }).code\n    : undefined\n}\n", "import { mkdir } from 'node:fs/promises'\nimport PATH from 'node:path'\nimport { DatabaseSync } from 'node:sqlite'\n\nimport type {\n  AdmittedWake,\n  LeasedWake,\n  WakeQueue,\n} from '@xyo-network/event-kit-protocol'\n\nexport interface SqliteWakeQueueOptions {\n  /** Database file path, or `:memory:` for a throwaway store. */\n  readonly path: string\n}\n\nexport interface SqliteWakeQueue extends WakeQueue {\n  /** Releases the underlying handle. */\n  close: () => void\n}\n\ninterface QueueRow {\n  readonly body: string\n  readonly id: number\n}\n\n/**\n * SQLite-backed `WakeQueue`.\n *\n * Every state change is a single statement under WAL, so a claim cannot be\n * observed half-applied and two callers cannot lease one row: the claim is an\n * `UPDATE \u2026 WHERE state = 'pending'` whose affected-row count decides the\n * winner. That is the transactional form of the lease the filesystem provider\n * approximates with `link`.\n *\n * WAL also permits concurrent readers with one writer, so several processes on\n * one host can share the file. It does not coordinate across hosts.\n *\n * Uses Node's built-in `node:sqlite`, which still emits an ExperimentalWarning.\n */\nexport async function createSqliteWakeQueue(\n  options: SqliteWakeQueueOptions,\n): Promise<SqliteWakeQueue> {\n  const inMemory = options.path === ':memory:'\n  const file = inMemory ? options.path : PATH.resolve(options.path)\n  if (!inMemory) await mkdir(PATH.dirname(file), { recursive: true })\n\n  const database = new DatabaseSync(file)\n  database.exec(`\n    PRAGMA journal_mode = WAL;\n    PRAGMA synchronous = FULL;\n    CREATE TABLE IF NOT EXISTS wake_queue (\n      id INTEGER PRIMARY KEY AUTOINCREMENT,\n      body TEXT NOT NULL,\n      state TEXT NOT NULL DEFAULT 'pending'\n    );\n    CREATE INDEX IF NOT EXISTS wake_queue_state ON wake_queue (state, id);\n  `)\n\n  const insert = database.prepare('INSERT INTO wake_queue (body) VALUES (?)')\n  const nextPending = database.prepare(\n    'SELECT id, body FROM wake_queue WHERE state = \\'pending\\' ORDER BY id LIMIT 1',\n  )\n  // The affected-row count is the lease: a loser updates zero rows and retries.\n  const lease = database.prepare(\n    'UPDATE wake_queue SET state = \\'inflight\\' WHERE id = ? AND state = \\'pending\\'',\n  )\n  const remove = database.prepare('DELETE FROM wake_queue WHERE id = ?')\n  const restore = database.prepare(\n    'UPDATE wake_queue SET state = \\'pending\\' WHERE id = ? AND state = \\'inflight\\'',\n  )\n  const countPending = database.prepare(\n    'SELECT COUNT(*) AS total FROM wake_queue WHERE state = \\'pending\\'',\n  )\n  const recoverAll = database.prepare(\n    'UPDATE wake_queue SET state = \\'pending\\' WHERE state = \\'inflight\\'',\n  )\n\n  return {\n    async append(wake: AdmittedWake): Promise<void> {\n      insert.run(JSON.stringify(wake))\n    },\n\n    async claim(): Promise<LeasedWake | undefined> {\n      for (;;) {\n        const row = nextPending.get() as QueueRow | undefined\n        if (row === undefined) return undefined\n        if (lease.run(row.id).changes !== 1) continue // another claimer won it\n\n        return {\n          wake: JSON.parse(row.body) as AdmittedWake,\n          async ack(): Promise<void> {\n            remove.run(row.id)\n          },\n          async release(): Promise<void> {\n            restore.run(row.id)\n          },\n        }\n      }\n    },\n\n    close(): void {\n      database.close()\n    },\n\n    async pendingCount(): Promise<number> {\n      return Number((countPending.get() as { total: number }).total)\n    },\n\n    async recoverInflight(): Promise<number> {\n      return Number(recoverAll.run().changes)\n    },\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["randomBytes", "mkdir", "unlink", "PATH", "mkdir", "PATH", "isNotFound", "PATH", "unlink", "isNotFound", "mkdir", "randomBytes", "randomBytes", "link", "mkdir", "open", "readdir", "unlink", "PATH", "PATH", "mkdir", "readdir", "unlink", "ignoreNotFound", "link", "isAlreadyExists", "open", "isNotFound", "randomBytes", "errorCode", "mkdir", "PATH"]
+}

package/dist/node/sqliteWakeQueue.d.ts

@@ -0,0 +1,25 @@
+import type { WakeQueue } from '@xyo-network/event-kit-protocol';
+export interface SqliteWakeQueueOptions {
+    /** Database file path, or `:memory:` for a throwaway store. */
+    readonly path: string;
+}
+export interface SqliteWakeQueue extends WakeQueue {
+    /** Releases the underlying handle. */
+    close: () => void;
+}
+/**
+ * SQLite-backed `WakeQueue`.
+ *
+ * Every state change is a single statement under WAL, so a claim cannot be
+ * observed half-applied and two callers cannot lease one row: the claim is an
+ * `UPDATE … WHERE state = 'pending'` whose affected-row count decides the
+ * winner. That is the transactional form of the lease the filesystem provider
+ * approximates with `link`.
+ *
+ * WAL also permits concurrent readers with one writer, so several processes on
+ * one host can share the file. It does not coordinate across hosts.
+ *
+ * Uses Node's built-in `node:sqlite`, which still emits an ExperimentalWarning.
+ */
+export declare function createSqliteWakeQueue(options: SqliteWakeQueueOptions): Promise<SqliteWakeQueue>;
+//# sourceMappingURL=sqliteWakeQueue.d.ts.map

package/dist/node/sqliteWakeQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqliteWakeQueue.d.ts","sourceRoot":"","sources":["../../src/sqliteWakeQueue.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,SAAS,EACV,MAAM,iCAAiC,CAAA;AAExC,MAAM,WAAW,sBAAsB;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,sCAAsC;IACtC,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,eAAe,CAAC,CAuE1B"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@xyo-network/event-kit-node",
+  "version": "0.0.1",
+  "description": "Node adapters for Event Kit (filesystem publisher cursor)",
+  "keywords": [
+    "xyo",
+    "xl1",
+    "event-kit",
+    "node",
+    "typescript"
+  ],
+  "bugs": {
+    "url": "https://github.com/XYOracleNetwork/event-kit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XYOracleNetwork/event-kit.git",
+    "directory": "packages/node"
+  },
+  "license": "UNLICENSED",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.mjs"
+    },
+    "./package.json": "./package.json",
+    "./README.md": "./README.md"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@xyo-network/event-kit-protocol": "~0.0.1",
+    "@xyo-network/event-kit-actor": "~0.0.1"
+  },
+  "devDependencies": {
+    "@ariestools/actor": "~1.3.0",
+    "@ariestools/lib-neutral": "~9.1.0",
+    "@ariestools/sdk": "~8.1.9",
+    "@ariestools/toolchain": "~9.1.0",
+    "@ariestools/tsconfig": "~9.1.0",
+    "@opentelemetry/api": "~1.9.1",
+    "@types/node": "~26.2.0",
+    "@xyo-network/sdk": "~7.2.3",
+    "@xyo-network/sdk-protocol": "~7.2.4",
+    "@xyo-network/xl1-sdk": "~5.3.1",
+    "async-mutex": "~0.5.0",
+    "eslint": "~10.8.1",
+    "eslint-import-resolver-typescript": "~4.4.5",
+    "ethers": "~6.17.0",
+    "typescript": "~6.0.3",
+    "vite": "~8.2.1",
+    "vitest": "~4.1.11",
+    "zod": "~4.4.3",
+    "@xyo-network/event-kit-http": "~0.0.1",
+    "@xyo-network/event-kit-schemas": "~0.0.1",
+    "@xyo-network/event-kit-testing": "~0.0.1",
+    "@xyo-network/event-kit-xl1": "~0.0.1"
+  },
+  "peerDependencies": {
+    "@ariestools/actor": "^1.3",
+    "@ariestools/sdk": "^8.1",
+    "@opentelemetry/api": "^1.9",
+    "@xyo-network/sdk": "^7.2",
+    "@xyo-network/sdk-protocol": "^7.2",
+    "zod": "^4.4"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "scripts": {
+    "test": "vitest run"
+  }
+}