@rulvar/store-sqlite 1.44.1 → 1.45.0

package/dist/index.d.ts

@@ -19,12 +19,27 @@ interface SqliteStoreOptions {
   now?: () => number;
 }
 declare class SqliteStore implements MetaLookupStore, LeasableStore {
+  /**
+  * The fenced writes promise (fenced run state RFC, phase 2): every
+  * lease-carrying mutation of this store (append, putMeta, delete)
+  * verifies the lease is the current holder FOR THE MUTATED RUN,
+  * atomically with the mutation, and rejects stale or mismatched
+  * holders with the typed LeaseHeldError leaving nothing changed.
+  */
+  readonly fencedWrites = true;
   private readonly db;
   private readonly ttlMs;
   private readonly now;
   constructor(options: SqliteStoreOptions);
   close(): void;
   private liveLease;
+  /**
+  * A lease fences exactly the run it names: guarding a mutation of a
+  * DIFFERENT run with it would pass the holder check while touching
+  * state the lease never protected, so the mismatch rejects typed
+  * before any check runs.
+  */
+  private requireRunMatch;
   /** Rejects unless `lease` is the CURRENT live lease for its run. */
   private assertFencing;
   /**
@@ -40,10 +55,12 @@ declare class SqliteStore implements MetaLookupStore, LeasableStore {
   private insertEntry;
   append(runId: string, e: JournalEntry, lease?: Lease): Promise<void>;
   load(runId: string): Promise<JournalEntry[]>;
-  putMeta(m: RunMeta): Promise<void>;
+  private upsertMeta;
+  putMeta(m: RunMeta, lease?: Lease): Promise<void>;
   getMeta(runId: string): Promise<RunMeta | undefined>;
   listRuns(f?: RunFilter): Promise<RunMeta[]>;
-  delete(runId: string): Promise<void>;
+  private deleteRows;
+  delete(runId: string, lease?: Lease): Promise<void>;
   /**
   * TTL introspection (the LeasableStore optional capability): lets
   * createWorker verify at construction that its renew cadence matches

package/dist/index.js

@@ -21,6 +21,12 @@ import { ConfigError, JournalOrderViolation, LeaseHeldError, metaMatchesFilter }
 *   cross-process window where a takeover landing between them let the
 *   superseded holder append a visible entry, extend the successor's
 *   lease, or delete it outright (the fenced-run-state RFC, finding F3).
+* - Fenced writes (`fencedWrites: true`, the RFC's phase 2): putMeta
+*   and delete accept the same optional lease under the same atomic
+*   rule, and every lease-guarded mutation additionally requires the
+*   lease's runId to BE the mutated run, so a superseded worker can
+*   neither strand a run through a stale terminal meta write (F1) nor
+*   delete live run state (F4).
 * - acquire on a held, unexpired lease rejects with LeaseHeldError; the
 *   holder MUST renew at an interval of at most ttl/3; an unrenewed
 *   lease is reclaimable after ttl and reclaiming advances the epoch.
@@ -31,6 +37,14 @@ import { ConfigError, JournalOrderViolation, LeaseHeldError, metaMatchesFilter }
 const DEFAULT_LEASE_TTL_MS = 6e4;
 const wallClock = Date.now.bind(globalThis);
 var SqliteStore = class {
+	/**
+	* The fenced writes promise (fenced run state RFC, phase 2): every
+	* lease-carrying mutation of this store (append, putMeta, delete)
+	* verifies the lease is the current holder FOR THE MUTATED RUN,
+	* atomically with the mutation, and rejects stale or mismatched
+	* holders with the typed LeaseHeldError leaving nothing changed.
+	*/
+	fencedWrites = true;
 	db;
 	ttlMs;
 	now;
@@ -78,6 +92,15 @@ var SqliteStore = class {
 		if (row === void 0 || row.expires_at <= this.now()) return;
 		return row;
 	}
+	/**
+	* A lease fences exactly the run it names: guarding a mutation of a
+	* DIFFERENT run with it would pass the holder check while touching
+	* state the lease never protected, so the mismatch rejects typed
+	* before any check runs.
+	*/
+	requireRunMatch(lease, runId, mutation) {
+		if (lease.runId !== runId) throw new LeaseHeldError(`lease for run '${lease.runId}' (owner ${lease.owner}, epoch ${lease.epoch}) cannot guard a ${mutation} of run '${runId}'; the mutation is rejected and nothing changed`);
+	}
 	/** Rejects unless `lease` is the CURRENT live lease for its run. */
 	assertFencing(lease) {
 		const live = this.liveLease(lease.runId);
@@ -112,6 +135,7 @@ var SqliteStore = class {
 	}
 	async append(runId, e, lease) {
 		if (lease !== void 0) {
+			this.requireRunMatch(lease, runId, "journal append");
 			this.fenced(lease, () => {
 				this.insertEntry(runId, e);
 			});
@@ -122,9 +146,19 @@ var SqliteStore = class {
 	async load(runId) {
 		return this.db.prepare("SELECT payload FROM entries WHERE run_id = ? ORDER BY id").all(runId).map((row) => JSON.parse(row.payload));
 	}
-	async putMeta(m) {
+	upsertMeta(m) {
 		this.db.prepare("INSERT INTO meta (run_id, payload) VALUES (?, ?) ON CONFLICT(run_id) DO UPDATE SET payload = excluded.payload").run(m.runId, JSON.stringify(m));
 	}
+	async putMeta(m, lease) {
+		if (lease !== void 0) {
+			this.requireRunMatch(lease, m.runId, "meta write");
+			this.fenced(lease, () => {
+				this.upsertMeta(m);
+			});
+			return;
+		}
+		this.upsertMeta(m);
+	}
 	async getMeta(runId) {
 		const row = this.db.prepare("SELECT payload FROM meta WHERE run_id = ?").get(runId);
 		return row === void 0 ? void 0 : JSON.parse(row.payload);
@@ -147,13 +181,23 @@ var SqliteStore = class {
 		const sql = "SELECT payload FROM meta" + (where.length === 0 ? "" : ` WHERE ${where.join(" AND ")}`) + " ORDER BY run_id";
 		return this.db.prepare(sql).all(...params).map((row) => JSON.parse(row.payload)).filter((meta) => metaMatchesFilter(meta, f));
 	}
-	async delete(runId) {
+	deleteRows(runId) {
+		this.db.prepare("DELETE FROM entries WHERE run_id = ?").run(runId);
+		this.db.prepare("DELETE FROM meta WHERE run_id = ?").run(runId);
+		this.db.prepare("DELETE FROM leases WHERE run_id = ?").run(runId);
+		this.db.prepare("DELETE FROM epochs WHERE run_id = ?").run(runId);
+	}
+	async delete(runId, lease) {
+		if (lease !== void 0) {
+			this.requireRunMatch(lease, runId, "run deletion");
+			this.fenced(lease, () => {
+				this.deleteRows(runId);
+			});
+			return;
+		}
 		this.db.exec("BEGIN IMMEDIATE");
 		try {
-			this.db.prepare("DELETE FROM entries WHERE run_id = ?").run(runId);
-			this.db.prepare("DELETE FROM meta WHERE run_id = ?").run(runId);
-			this.db.prepare("DELETE FROM leases WHERE run_id = ?").run(runId);
-			this.db.prepare("DELETE FROM epochs WHERE run_id = ?").run(runId);
+			this.deleteRows(runId);
 			this.db.exec("COMMIT");
 		} catch (thrown) {
 			this.db.exec("ROLLBACK");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/store-sqlite",
-  "version": "1.44.1",
+  "version": "1.45.0",
   "description": "Rulvar SQLite store implementing JournalStore and LeasableStore with a fencing epoch.",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,13 +22,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@rulvar/core": "1.44.1"
+    "@rulvar/core": "1.45.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",
     "tsdown": "^0.22.3",
     "typescript": "~6.0.3",
-    "@rulvar/store-conformance": "1.44.1"
+    "@rulvar/store-conformance": "1.45.0"
   },
   "repository": {
     "type": "git",