@happyvertical/smrt-web 0.55.23 → 0.56.0

package/AGENTS.md

@@ -35,7 +35,7 @@ module you are editing. This file keeps what holds in every module.
 
 | Module | Scope | Module doc |
 |---|---|---|
-| `index.ts` hooks + `durable-store.ts` | the six capability hook points, hook error isolation, the no-op guarantee, and the shared durable-store namespacing/wipe registry | [agents/capability-seam.md](agents/capability-seam.md) |
+| `index.ts` hooks + `durable-store.ts` + `durable-store-sweep.ts` | the six capability hook points, hook error isolation, the no-op guarantee, the shared durable-store namespacing/wipe registry, and the shared-device namespace list/prune sweep | [agents/capability-seam.md](agents/capability-seam.md) |
 | `offline/` | durable offline writes — config, sync-apply or consumer-declared transport replay (#3021), idempotency, the shared namespace-keyed engine, and Web Locks leader election | [agents/offline-outbox.md](agents/offline-outbox.md) |
 | `sse-client.ts` | the client half of live cache invalidation — the app-wide subscriber, the wire contract it consumes, and SSE-vs-polling behaviour | [agents/live-invalidation.md](agents/live-invalidation.md) |
 | `webmcp.ts` | framework-agnostic WebMCP registrar; validates an optionally bounded/namespaced, effect-filtered prospective set atomically, keeps legacy list-backed tools on collection state, and executes canonical tool-only definitions directly through REST fetchers. `registerWebMcpBespokeTool` is the single-tool sibling a UI layer's hand-written component tool routes through (`useWebMcpTool` in smrt-svelte, #2586): same fail-closed effect classification and `effects` policy, no `namespace`/`maxTools` | — |

package/README.md

@@ -138,6 +138,24 @@ leader, with the same backoff and `pending → uploading → synced | failed` st
 machine. A reloaded write waits until a queue with its name attaches; it is
 never re-routed to `sync/apply`.
 
+### Sweeping stale data on shared devices
+
+`listDurableNamespaces()` returns the durable-store namespaces this browser
+holds (names only, no contents). `pruneDurableNamespace(namespace, { olderThan })`
+removes that namespace's queued offline writes enqueued before `olderThan` (a
+`Date` or epoch ms) without mounting its queue: nothing replays, no transport
+attaches, and only `{ removed, skipped }` counts come back. Items on a route a
+live queue (in any tab) is replaying are skipped. Use it to age out another
+person's queued work on shared hardware; persisted read snapshots carry no age
+and are left to `wipeDurableStore`.
+
+```ts
+const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+for (const namespace of await listDurableNamespaces()) {
+  await pruneDurableNamespace(namespace, { olderThan: cutoff });
+}
+```
+
 ### Persisted read cache
 
 `persistCollection()` warm-starts from an IndexedDB snapshot, then revalidates
@@ -179,7 +197,7 @@ core.
 | Remote queries | `createSmrtWebQuery`, `SmrtWebQueryTransport` |
 | Data-surface actions | `executeSmrtWebDataSurfaceAction`, `SmrtWebDataSurfaceActionTransport`, `dataSurfaceActionCommandTransport` |
 | HTTP | `createDefinitionFetchers`, `unwrapListResult`, `unwrapItemResult` |
-| Offline | `offlineOutbox`, `offlineCommandQueue`, `getOutboxHandle` |
+| Offline | `offlineOutbox`, `offlineCommandQueue`, `getOutboxHandle`, `listDurableNamespaces`, `pruneDurableNamespace` |
 | Persistence | `persistCollection`, `persistDataSurface`, `wipeDurableStore` |
 | Live updates | `createSmrtWebEventSubscriber`, `liveInvalidation` |
 | Version awareness | `createUpdateState` |

package/agents/capability-seam.md

@@ -90,6 +90,18 @@ bookkeeping, ZERO `@tanstack/*` imports.
   clears every registered `DurableResource` under a namespace (best-effort — a
   rejected `clear()` doesn't abort the sweep) then drops it; a safe no-op on an
   unknown/empty namespace.
+- Shared-device sweep (#3234, `durable-store-sweep.ts`): the registry above
+  only reaches resources registered in THIS page load.
+  `listDurableNamespaces()` adds every namespace with an smrt-web IndexedDB
+  database (outbox = bare namespace; `::snapshots` / `::meta` suffixes
+  stripped) by NAME via `indexedDB.databases()`, never opening one.
+  `pruneDurableNamespace(ns, { olderThan })` deletes outbox rows with
+  `enqueuedAt < olderThan` straight from IndexedDB — no `OutboxEngine`, no
+  binding, no transport, no `fetch`; counts only. It must never create a
+  database (opens versionless and aborts `upgradeneeded`), and per route it
+  takes the replayer's own leader lock (`outboxLeaderLockName`) with
+  `ifAvailable`, skipping a held route; without Web Locks it skips a namespace
+  whose outbox this page has registered.
 
 Rationale: the persistence slice's storage (SQLite-WASM/OPFS) and the outbox's
 IndexedDB queue are **separate storage engines**, so the shared foundation lives

package/dist/chunks/{src-BFQJky1a.js → src-ClpJxx94.js}

@@ -480,6 +480,15 @@ async function wipeDurableStore(namespace) {
 	registry.delete(namespace);
 	await Promise.allSettled(snapshot.map((resource) => resource.clear()));
 }
+function hasDurableResource(namespace, kind) {
+	const resources = registry.get(namespace);
+	if (!resources) return false;
+	for (const resource of resources) if (resource.kind === kind) return true;
+	return false;
+}
+function registeredDurableNamespaces() {
+	return [...registry.keys()];
+}
 //#endregion
 //#region src/offline/durable-queue.ts
 var OUTBOX_STORE = "outbox";
@@ -630,13 +639,13 @@ function openDurableOutboxQueue(dbName) {
 }
 //#endregion
 //#region src/offline/leader.ts
-function getLockManager() {
+function getLockManager$1() {
 	const locks = globalThis.navigator?.locks;
 	if (locks && typeof locks.request === "function") return locks;
 }
 var warnedNoLocks = false;
 function acquireLeadership(lockName, onAcquired, onReleased) {
-	const locks = getLockManager();
+	const locks = getLockManager$1();
 	if (!locks) {
 		if (!warnedNoLocks) {
 			warnedNoLocks = true;
@@ -708,6 +717,10 @@ var SYNC_APPLY_ROUTE = "sync-apply";
 function routeOf(row) {
 	return row.transport === void 0 ? SYNC_APPLY_ROUTE : `transport:${row.transport}`;
 }
+function outboxLeaderLockName(namespace, route) {
+	const root = `smrt-web-outbox-leader:${namespace}`;
+	return route === SYNC_APPLY_ROUTE ? root : `${root}:${route}`;
+}
 function newItemId() {
 	const cryptoRef = globalThis.crypto;
 	if (cryptoRef?.randomUUID) return cryptoRef.randomUUID();
@@ -845,8 +858,7 @@ var OutboxEngine = class {
 			existing.refs += 1;
 			return;
 		}
-		const root = `smrt-web-outbox-leader:${this.config.namespace}`;
-		const lockName = route === SYNC_APPLY_ROUTE ? root : `${root}:${route}`;
+		const lockName = outboxLeaderLockName(this.config.namespace, route);
 		const entry = {
 			release: () => {},
 			isLeader: false,
@@ -1405,6 +1417,328 @@ async function releaseOutboxEngine(namespace, engine, object, record) {
 	if (await engine.unregisterCollection(object, record) && engines.get(namespace) === engine) engines.delete(namespace);
 }
 //#endregion
+//#region src/persistence/snapshot-store.ts
+var SNAPSHOT_STORE = "snapshots";
+var SNAPSHOT_DB_SUFFIX = "::snapshots";
+function promisifyRequest$1(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
+	});
+}
+function awaitTransaction$1(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
+		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
+	});
+}
+async function probeIndexedDb() {
+	const idb = globalThis.indexedDB;
+	if (!idb) return false;
+	const probeName = "__smrt_web_snapshot_probe__";
+	try {
+		(await new Promise((resolve, reject) => {
+			const request = idb.open(probeName, 1);
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("probe failed"));
+			request.onblocked = () => reject(/* @__PURE__ */ new Error("probe blocked"));
+		})).close();
+		try {
+			idb.deleteDatabase(probeName);
+		} catch {}
+		return true;
+	} catch {
+		return false;
+	}
+}
+var SnapshotStore = class {
+	db;
+	/** The IndexedDB database name (== the durable-store namespace). */
+	dbName;
+	constructor(db, dbName) {
+		this.db = db;
+		this.dbName = dbName;
+	}
+	/**
+	* Read the persisted rows for `collection`, or `undefined` if none were ever
+	* saved (or the record is malformed). `undefined` is the warm-start "nothing
+	* on disk" signal — the engine then fetches fresh.
+	*/
+	async load(collection) {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readonly");
+		const record = await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).get(collection));
+		await awaitTransaction$1(tx);
+		if (!record || !Array.isArray(record.rows)) return void 0;
+		return record.rows;
+	}
+	/**
+	* Write (replacing) the snapshot for `collection`. Resolves once the write is
+	* durably committed. A single blob per collection — the whole current row set,
+	* not a delta — so a restore is one read with no reconciliation.
+	*/
+	async save(collection, rows) {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
+		const store = tx.objectStore(SNAPSHOT_STORE);
+		const record = {
+			collection,
+			rows
+		};
+		await promisifyRequest$1(store.put(record));
+		await awaitTransaction$1(tx);
+	}
+	/**
+	* Drop the snapshot for a single `collection` (its capability's own teardown
+	* does NOT clear — the persisted rows must survive for the next load; this is
+	* only for an explicit targeted purge). Kept for completeness / tests.
+	*/
+	async remove(collection) {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
+		await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).delete(collection));
+		await awaitTransaction$1(tx);
+	}
+	/**
+	* Drop EVERY snapshot — the durable-store `clear()` for `wipeDurableStore`.
+	* Empties the store but keeps the database so a subsequent save still works.
+	*/
+	async clear() {
+		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
+		await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).clear());
+		await awaitTransaction$1(tx);
+	}
+	/** Close the underlying database handle (called on the last detach). */
+	close() {
+		this.db.close();
+	}
+};
+function openSnapshotStore(namespace) {
+	const idb = globalThis.indexedDB;
+	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
+	const dbName = `${namespace}${SNAPSHOT_DB_SUFFIX}`;
+	return new Promise((resolve, reject) => {
+		const request = idb.open(dbName, 1);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("snapshots")) db.createObjectStore(SNAPSHOT_STORE, { keyPath: "collection" });
+		};
+		request.onsuccess = () => resolve(new SnapshotStore(request.result, dbName));
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open snapshot database "${dbName}"`));
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening snapshot database "${dbName}" was blocked`));
+	});
+}
+//#endregion
+//#region src/update-state/meta-store.ts
+var META_STORE = "meta";
+var META_DB_SUFFIX = "::meta";
+var LAST_SEEN_MANIFEST_HASH_KEY = "lastSeenManifestHash";
+function promisifyRequest(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
+	});
+}
+function awaitTransaction(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
+		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
+	});
+}
+var VersionMetaStore = class {
+	db;
+	/** The IndexedDB database name (== the durable-store namespace). */
+	dbName;
+	constructor(db, dbName) {
+		this.db = db;
+		this.dbName = dbName;
+	}
+	/** Read the value for `key`, or `undefined` if unset / malformed. */
+	async get(key) {
+		const tx = this.db.transaction(META_STORE, "readonly");
+		const record = await promisifyRequest(tx.objectStore(META_STORE).get(key));
+		await awaitTransaction(tx);
+		return record && typeof record.value === "string" ? record.value : void 0;
+	}
+	/** Write (replacing) the value for `key`; resolves once durably committed. */
+	async set(key, value) {
+		const tx = this.db.transaction(META_STORE, "readwrite");
+		const record = {
+			key,
+			value
+		};
+		await promisifyRequest(tx.objectStore(META_STORE).put(record));
+		await awaitTransaction(tx);
+	}
+	/**
+	* Drop EVERY meta record — the durable-store `clear()` for
+	* {@link wipeDurableStore}, so a logout also clears the last-seen manifest
+	* hash (the AC "wipe clears the last-seen-hash record").
+	*/
+	async clear() {
+		const tx = this.db.transaction(META_STORE, "readwrite");
+		await promisifyRequest(tx.objectStore(META_STORE).clear());
+		await awaitTransaction(tx);
+	}
+	/** Close the underlying database handle. */
+	close() {
+		this.db.close();
+	}
+};
+function openVersionMetaStore(namespace) {
+	const idb = globalThis.indexedDB;
+	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
+	const dbName = `${namespace}${META_DB_SUFFIX}`;
+	return new Promise((resolve, reject) => {
+		const request = idb.open(dbName, 1);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("meta")) db.createObjectStore(META_STORE, { keyPath: "key" });
+		};
+		request.onsuccess = () => resolve(new VersionMetaStore(request.result, dbName));
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open meta database "${dbName}"`));
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening meta database "${dbName}" was blocked`));
+	});
+}
+//#endregion
+//#region src/durable-store-sweep.ts
+var NAMESPACE_PATTERN$1 = /^smrt-web:[^:]*:(?:_[^:]*)?:(?:_[^:]*)?:[^:]*$/;
+function isDurableStoreNamespace(value) {
+	return typeof value === "string" && NAMESPACE_PATTERN$1.test(value);
+}
+function namespaceOfDatabase(name) {
+	if (name === void 0) return void 0;
+	for (const suffix of [SNAPSHOT_DB_SUFFIX, META_DB_SUFFIX]) if (name.endsWith(suffix)) {
+		const base = name.slice(0, -suffix.length);
+		return isDurableStoreNamespace(base) ? base : void 0;
+	}
+	return isDurableStoreNamespace(name) ? name : void 0;
+}
+function getIndexedDb() {
+	return globalThis.indexedDB;
+}
+async function listDurableNamespaces() {
+	const names = new Set(registeredDurableNamespaces());
+	const idb = getIndexedDb();
+	if (idb && typeof idb.databases === "function") for (const info of await idb.databases()) {
+		const namespace = namespaceOfDatabase(info.name);
+		if (namespace !== void 0) names.add(namespace);
+	}
+	return [...names].sort();
+}
+function resolveCutoff(olderThan) {
+	const cutoff = olderThan instanceof Date ? olderThan.getTime() : typeof olderThan === "number" ? olderThan : NaN;
+	if (!Number.isFinite(cutoff)) throw new TypeError("pruneDurableNamespace requires olderThan as a valid Date or epoch milliseconds");
+	return cutoff;
+}
+function openExistingDatabase(idb, name) {
+	return new Promise((resolve, reject) => {
+		let created = false;
+		const request = idb.open(name);
+		request.onupgradeneeded = () => {
+			created = true;
+			request.transaction?.abort();
+		};
+		request.onsuccess = () => {
+			const db = request.result;
+			if (created) {
+				db.close();
+				resolve(void 0);
+				return;
+			}
+			db.onversionchange = () => db.close();
+			resolve(db);
+		};
+		request.onerror = (event) => {
+			if (created) {
+				event.preventDefault();
+				resolve(void 0);
+				return;
+			}
+			reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open durable database "${name}"`));
+		};
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening durable database "${name}" was blocked`));
+	});
+}
+function isStale(row, cutoff) {
+	return typeof row.enqueuedAt === "number" && row.enqueuedAt < cutoff;
+}
+function countStaleByRoute(db, cutoff) {
+	return new Promise((resolve, reject) => {
+		const counts = /* @__PURE__ */ new Map();
+		const tx = db.transaction(OUTBOX_STORE, "readonly");
+		const request = tx.objectStore(OUTBOX_STORE).openCursor();
+		request.onsuccess = () => {
+			const cursor = request.result;
+			if (!cursor) return;
+			const row = cursor.value;
+			if (isStale(row, cutoff)) {
+				const route = routeOf(row);
+				counts.set(route, (counts.get(route) ?? 0) + 1);
+			}
+			cursor.continue();
+		};
+		tx.oncomplete = () => resolve(counts);
+		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
+		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
+	});
+}
+function deleteStaleRows(db, cutoff, route) {
+	return new Promise((resolve, reject) => {
+		let removed = 0;
+		const tx = db.transaction(OUTBOX_STORE, "readwrite");
+		const request = tx.objectStore(OUTBOX_STORE).openCursor();
+		request.onsuccess = () => {
+			const cursor = request.result;
+			if (!cursor) return;
+			const row = cursor.value;
+			if (routeOf(row) === route && isStale(row, cutoff)) {
+				cursor.delete();
+				removed += 1;
+			}
+			cursor.continue();
+		};
+		tx.oncomplete = () => resolve(removed);
+		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
+		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
+	});
+}
+function getLockManager() {
+	const locks = globalThis.navigator?.locks;
+	return locks && typeof locks.request === "function" ? locks : void 0;
+}
+async function whileRouteIdle(namespace, route, work) {
+	const locks = getLockManager();
+	if (!locks) return hasDurableResource(namespace, "outbox") ? void 0 : work();
+	return locks.request(outboxLeaderLockName(namespace, route), {
+		mode: "exclusive",
+		ifAvailable: true
+	}, async (lock) => lock === null ? void 0 : work());
+}
+async function pruneDurableNamespace(namespace, options) {
+	if (!isDurableStoreNamespace(namespace)) throw new TypeError("pruneDurableNamespace requires a durableStoreNamespace() string");
+	const cutoff = resolveCutoff(options?.olderThan);
+	const result = {
+		removed: 0,
+		skipped: 0
+	};
+	const idb = getIndexedDb();
+	if (!idb) return result;
+	const db = await openExistingDatabase(idb, namespace);
+	if (!db) return result;
+	try {
+		if (!db.objectStoreNames.contains("outbox")) return result;
+		const staleByRoute = await countStaleByRoute(db, cutoff);
+		for (const [route, count] of staleByRoute) {
+			const removed = await whileRouteIdle(namespace, route, () => deleteStaleRows(db, cutoff, route));
+			if (removed === void 0) result.skipped += count;
+			else result.removed += removed;
+		}
+		return result;
+	} finally {
+		db.close();
+	}
+}
+//#endregion
 //#region src/offline.ts
 function resolveBackoff(backoff) {
 	return {
@@ -1537,116 +1871,6 @@ function getOutboxHandle(namespace) {
 	};
 }
 //#endregion
-//#region src/persistence/snapshot-store.ts
-var SNAPSHOT_STORE = "snapshots";
-var SNAPSHOT_DB_SUFFIX = "::snapshots";
-function promisifyRequest$1(request) {
-	return new Promise((resolve, reject) => {
-		request.onsuccess = () => resolve(request.result);
-		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
-	});
-}
-function awaitTransaction$1(tx) {
-	return new Promise((resolve, reject) => {
-		tx.oncomplete = () => resolve();
-		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
-		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
-	});
-}
-async function probeIndexedDb() {
-	const idb = globalThis.indexedDB;
-	if (!idb) return false;
-	const probeName = "__smrt_web_snapshot_probe__";
-	try {
-		(await new Promise((resolve, reject) => {
-			const request = idb.open(probeName, 1);
-			request.onsuccess = () => resolve(request.result);
-			request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("probe failed"));
-			request.onblocked = () => reject(/* @__PURE__ */ new Error("probe blocked"));
-		})).close();
-		try {
-			idb.deleteDatabase(probeName);
-		} catch {}
-		return true;
-	} catch {
-		return false;
-	}
-}
-var SnapshotStore = class {
-	db;
-	/** The IndexedDB database name (== the durable-store namespace). */
-	dbName;
-	constructor(db, dbName) {
-		this.db = db;
-		this.dbName = dbName;
-	}
-	/**
-	* Read the persisted rows for `collection`, or `undefined` if none were ever
-	* saved (or the record is malformed). `undefined` is the warm-start "nothing
-	* on disk" signal — the engine then fetches fresh.
-	*/
-	async load(collection) {
-		const tx = this.db.transaction(SNAPSHOT_STORE, "readonly");
-		const record = await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).get(collection));
-		await awaitTransaction$1(tx);
-		if (!record || !Array.isArray(record.rows)) return void 0;
-		return record.rows;
-	}
-	/**
-	* Write (replacing) the snapshot for `collection`. Resolves once the write is
-	* durably committed. A single blob per collection — the whole current row set,
-	* not a delta — so a restore is one read with no reconciliation.
-	*/
-	async save(collection, rows) {
-		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
-		const store = tx.objectStore(SNAPSHOT_STORE);
-		const record = {
-			collection,
-			rows
-		};
-		await promisifyRequest$1(store.put(record));
-		await awaitTransaction$1(tx);
-	}
-	/**
-	* Drop the snapshot for a single `collection` (its capability's own teardown
-	* does NOT clear — the persisted rows must survive for the next load; this is
-	* only for an explicit targeted purge). Kept for completeness / tests.
-	*/
-	async remove(collection) {
-		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
-		await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).delete(collection));
-		await awaitTransaction$1(tx);
-	}
-	/**
-	* Drop EVERY snapshot — the durable-store `clear()` for `wipeDurableStore`.
-	* Empties the store but keeps the database so a subsequent save still works.
-	*/
-	async clear() {
-		const tx = this.db.transaction(SNAPSHOT_STORE, "readwrite");
-		await promisifyRequest$1(tx.objectStore(SNAPSHOT_STORE).clear());
-		await awaitTransaction$1(tx);
-	}
-	/** Close the underlying database handle (called on the last detach). */
-	close() {
-		this.db.close();
-	}
-};
-function openSnapshotStore(namespace) {
-	const idb = globalThis.indexedDB;
-	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
-	const dbName = `${namespace}${SNAPSHOT_DB_SUFFIX}`;
-	return new Promise((resolve, reject) => {
-		const request = idb.open(dbName, 1);
-		request.onupgradeneeded = () => {
-			const db = request.result;
-			if (!db.objectStoreNames.contains("snapshots")) db.createObjectStore(SNAPSHOT_STORE, { keyPath: "collection" });
-		};
-		request.onsuccess = () => resolve(new SnapshotStore(request.result, dbName));
-		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open snapshot database "${dbName}"`));
-		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening snapshot database "${dbName}" was blocked`));
-	});
-}
-//#endregion
 //#region src/persistence.ts
 var DEFAULT_PERSIST_DEBOUNCE_MS = 250;
 function registerForWipe(engine, namespace) {
@@ -2461,79 +2685,6 @@ function liveInvalidation(config) {
 	};
 }
 //#endregion
-//#region src/update-state/meta-store.ts
-var META_STORE = "meta";
-var META_DB_SUFFIX = "::meta";
-var LAST_SEEN_MANIFEST_HASH_KEY = "lastSeenManifestHash";
-function promisifyRequest(request) {
-	return new Promise((resolve, reject) => {
-		request.onsuccess = () => resolve(request.result);
-		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB request failed"));
-	});
-}
-function awaitTransaction(tx) {
-	return new Promise((resolve, reject) => {
-		tx.oncomplete = () => resolve();
-		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction failed"));
-		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("[smrt-web] IndexedDB transaction aborted"));
-	});
-}
-var VersionMetaStore = class {
-	db;
-	/** The IndexedDB database name (== the durable-store namespace). */
-	dbName;
-	constructor(db, dbName) {
-		this.db = db;
-		this.dbName = dbName;
-	}
-	/** Read the value for `key`, or `undefined` if unset / malformed. */
-	async get(key) {
-		const tx = this.db.transaction(META_STORE, "readonly");
-		const record = await promisifyRequest(tx.objectStore(META_STORE).get(key));
-		await awaitTransaction(tx);
-		return record && typeof record.value === "string" ? record.value : void 0;
-	}
-	/** Write (replacing) the value for `key`; resolves once durably committed. */
-	async set(key, value) {
-		const tx = this.db.transaction(META_STORE, "readwrite");
-		const record = {
-			key,
-			value
-		};
-		await promisifyRequest(tx.objectStore(META_STORE).put(record));
-		await awaitTransaction(tx);
-	}
-	/**
-	* Drop EVERY meta record — the durable-store `clear()` for
-	* {@link wipeDurableStore}, so a logout also clears the last-seen manifest
-	* hash (the AC "wipe clears the last-seen-hash record").
-	*/
-	async clear() {
-		const tx = this.db.transaction(META_STORE, "readwrite");
-		await promisifyRequest(tx.objectStore(META_STORE).clear());
-		await awaitTransaction(tx);
-	}
-	/** Close the underlying database handle. */
-	close() {
-		this.db.close();
-	}
-};
-function openVersionMetaStore(namespace) {
-	const idb = globalThis.indexedDB;
-	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
-	const dbName = `${namespace}${META_DB_SUFFIX}`;
-	return new Promise((resolve, reject) => {
-		const request = idb.open(dbName, 1);
-		request.onupgradeneeded = () => {
-			const db = request.result;
-			if (!db.objectStoreNames.contains("meta")) db.createObjectStore(META_STORE, { keyPath: "key" });
-		};
-		request.onsuccess = () => resolve(new VersionMetaStore(request.result, dbName));
-		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open meta database "${dbName}"`));
-		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening meta database "${dbName}" was blocked`));
-	});
-}
-//#endregion
 //#region src/update-state.ts
 function createUpdateState(config) {
 	const namespace = durableStoreNamespace(config.namespace);
@@ -3554,6 +3705,6 @@ function createSmrtCollection(definition, options) {
 	return handle;
 }
 //#endregion
-export { MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH as A, MAX_SMRT_WEB_DATA_QUERY_OFFSET as B, getOutboxHandle as C, registerDurableResource as D, durableStoreNamespace as E, executeSmrtWebDataSurfaceAction as F, MAX_SMRT_WEB_DATA_QUERY_WARNINGS as G, MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES as H, normalizeSmrtWebDataSurfaceActionResult as I, runWrapMutation as J, executeSmrtWebDataQuery as K, MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS as L, MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES as M, classifySmrtWebDataSurfaceActionResult as N, wipeDurableStore as O, dataSurfaceActionCommandTransport as P, MAX_SMRT_WEB_DATA_QUERY_FACETS as R, persistDataSurface as S, offlineOutbox as T, MAX_SMRT_WEB_DATA_QUERY_ROWS as U, MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT as V, MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH as W, createSmrtWebEventSubscriber as _, createSmrtWebClient as a, DEFAULT_PERSIST_DEBOUNCE_MS as b, newLocalId as c, unwrapListResult as d, validateSmrtWebClient as f, createUpdateState as g, registerWebMcpTools as h, createSmrtCollection as i, MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH as j, MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS as k, throwIfSmrtWebError as l, registerWebMcpBespokeTool as m, buildListQuery as n, getEngineCollection as o, registerViewIntent as p, normalizeSmrtWebDataQueryResult as q, createDefinitionFetchers as r, invalidateSmrtWebCollections as s, SmrtWebRequestError as t, unwrapItemResult as u, liveInvalidation as v, offlineCommandQueue as w, persistCollection as x, createSmrtWebQuery as y, MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES as z };
+export { wipeDurableStore as A, MAX_SMRT_WEB_DATA_QUERY_FACETS as B, getOutboxHandle as C, pruneDurableNamespace as D, listDurableNamespaces as E, classifySmrtWebDataSurfaceActionResult as F, MAX_SMRT_WEB_DATA_QUERY_ROWS as G, MAX_SMRT_WEB_DATA_QUERY_OFFSET as H, dataSurfaceActionCommandTransport as I, executeSmrtWebDataQuery as J, MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH as K, executeSmrtWebDataSurfaceAction as L, MAX_SMRT_WEB_DATA_SURFACE_ACTION_IDENTIFIER_LENGTH as M, MAX_SMRT_WEB_DATA_SURFACE_ACTION_JSON_DEPTH as N, durableStoreNamespace as O, MAX_SMRT_WEB_DATA_SURFACE_ACTION_RESULT_BYTES as P, normalizeSmrtWebDataSurfaceActionResult as R, persistDataSurface as S, offlineOutbox as T, MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT as U, MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES as V, MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES as W, runWrapMutation as X, normalizeSmrtWebDataQueryResult as Y, createSmrtWebEventSubscriber as _, createSmrtWebClient as a, DEFAULT_PERSIST_DEBOUNCE_MS as b, newLocalId as c, unwrapListResult as d, validateSmrtWebClient as f, createUpdateState as g, registerWebMcpTools as h, createSmrtCollection as i, MAX_SMRT_WEB_DATA_SURFACE_ACTION_CONTAINER_ITEMS as j, registerDurableResource as k, throwIfSmrtWebError as l, registerWebMcpBespokeTool as m, buildListQuery as n, getEngineCollection as o, registerViewIntent as p, MAX_SMRT_WEB_DATA_QUERY_WARNINGS as q, createDefinitionFetchers as r, invalidateSmrtWebCollections as s, SmrtWebRequestError as t, unwrapItemResult as u, liveInvalidation as v, offlineCommandQueue as w, persistCollection as x, createSmrtWebQuery as y, MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS as z };
 
-//# sourceMappingURL=src-BFQJky1a.js.map
+//# sourceMappingURL=src-ClpJxx94.js.map