@happyvertical/smrt-web 0.42.6 → 0.43.0

package/dist/chunks/src-CDdW9uYx.js

@@ -0,0 +1,2292 @@
+import { createCollection } from "@tanstack/db";
+import { QueryClient } from "@tanstack/query-core";
+import { queryCollectionOptions } from "@tanstack/query-db-collection";
+//#region src/capability.ts
+async function runWrapMutation(capabilities, envelope, ctx) {
+	for (const capability of capabilities) {
+		if (!capability.wrapMutation) continue;
+		const outcome = await capability.wrapMutation(envelope, ctx);
+		if (outcome?.handled) return {
+			handled: true,
+			result: outcome.result
+		};
+	}
+	return { handled: false };
+}
+//#endregion
+//#region src/internal.ts
+var persistedMutationResults = /* @__PURE__ */ new WeakMap();
+var mutationTargetHydrators = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/data-query.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+var MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES = 1e7;
+var MAX_SMRT_WEB_DATA_QUERY_ROWS = 1e3;
+var MAX_SMRT_WEB_DATA_QUERY_FACETS = 20;
+var MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES = 1e3;
+var MAX_SMRT_WEB_DATA_QUERY_WARNINGS = 100;
+var MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT = 1e3;
+var MAX_SMRT_WEB_DATA_QUERY_OFFSET = 1e6;
+var MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS = 1e3;
+var MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH = 65536;
+function consumeBytes(budget, text, label) {
+	const bytes = new TextEncoder().encode(text).byteLength;
+	if (bytes > budget.remaining) throw new TypeError(`${label} exceeds the maximum byte limit`);
+	budget.remaining -= bytes;
+}
+function plainObject(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be a plain object`);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`${label} must be a plain object`);
+	for (const key of Object.keys(value)) if (FORBIDDEN_KEYS.has(key)) throw new TypeError(`${label} contains a forbidden key`);
+	return value;
+}
+function exactKeys(value, allowed, label) {
+	const keys = new Set(allowed);
+	for (const key of Object.keys(value)) if (!keys.has(key)) throw new TypeError(`${label} contains ${key}`);
+}
+function stringValue(value, label, maxLength = 2048) {
+	if (typeof value !== "string" || value.length === 0 || value.length > maxLength) throw new TypeError(`${label} must be a bounded non-empty string`);
+	return value;
+}
+function nonNegativeInteger(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${label} must be a non-negative safe integer`);
+	return value;
+}
+function scalar(value, label, budget) {
+	if (typeof value === "string") {
+		if (value.length > 65536) throw new TypeError(`${label} exceeds the string limit`);
+		consumeBytes(budget, JSON.stringify(value), label);
+		return value;
+	}
+	if (value === null || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+		consumeBytes(budget, JSON.stringify(value), label);
+		return value;
+	}
+	throw new TypeError(`${label} must be a JSON scalar`);
+}
+function jsonValue(value, label, budget, depth = 0) {
+	if (depth > 16) throw new TypeError(`${label} exceeds JSON depth`);
+	if (typeof value === "string") {
+		if (value.length > 65536) throw new TypeError(`${label} exceeds the string limit`);
+		consumeBytes(budget, JSON.stringify(value), label);
+		return value;
+	}
+	if (value === null || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+		consumeBytes(budget, JSON.stringify(value), label);
+		return value;
+	}
+	if (Array.isArray(value)) {
+		if (value.length > 1e3) throw new TypeError(`${label} exceeds the container-item limit`);
+		consumeBytes(budget, "[", label);
+		const result2 = [];
+		for (const [index, item] of value.entries()) {
+			if (index > 0) consumeBytes(budget, ",", label);
+			result2.push(jsonValue(item, `${label}[${index}]`, budget, depth + 1));
+		}
+		consumeBytes(budget, "]", label);
+		return result2;
+	}
+	const object = plainObject(value, label);
+	if (Object.keys(object).length > 1e3) throw new TypeError(`${label} exceeds the container-item limit`);
+	const result = /* @__PURE__ */ Object.create(null);
+	consumeBytes(budget, "{", label);
+	for (const [index, key] of Object.keys(object).sort().entries()) {
+		if (key.length > 65536) throw new TypeError(`${label}.${key} exceeds the string limit`);
+		if (index > 0) consumeBytes(budget, ",", label);
+		consumeBytes(budget, JSON.stringify(key), `${label}.${key}`);
+		consumeBytes(budget, ":", label);
+		result[key] = jsonValue(object[key], `${label}.${key}`, budget, depth + 1);
+	}
+	consumeBytes(budget, "}", label);
+	return result;
+}
+function normalizeTotal(value) {
+	const total = plainObject(value, "Data query total");
+	const kind = stringValue(total.kind, "Data query total kind");
+	if (kind === "unavailable") {
+		exactKeys(total, ["kind", "reason"], "Data query unavailable total");
+		return {
+			kind,
+			...total.reason === void 0 ? {} : { reason: stringValue(total.reason, "Data query total reason") }
+		};
+	}
+	if (kind !== "exact" && kind !== "estimated") throw new TypeError("Data query total kind is invalid");
+	exactKeys(total, [
+		"kind",
+		"value",
+		"asOf"
+	], "Data query total");
+	return {
+		kind,
+		value: nonNegativeInteger(total.value, "Data query total value"),
+		...total.asOf === void 0 ? {} : { asOf: stringValue(total.asOf, "Data query total asOf", 128) }
+	};
+}
+function normalizeFacets(value, budget) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new TypeError("Data query facets must be an array");
+	if (value.length > 20) throw new TypeError("Data query facets exceed the maximum");
+	const fields = /* @__PURE__ */ new Set();
+	return value.map((candidate, index) => {
+		const facet = plainObject(candidate, `Data query facet ${index}`);
+		exactKeys(facet, [
+			"field",
+			"values",
+			"truncated"
+		], "Data query facet");
+		const field = stringValue(facet.field, "Data query facet field");
+		if (fields.has(field)) throw new TypeError("Data query facet fields must be unique");
+		fields.add(field);
+		if (!Array.isArray(facet.values)) throw new TypeError("Data query facet values must be an array");
+		if (facet.values.length > 1e3) throw new TypeError("Data query facet values exceed the maximum");
+		if (typeof facet.truncated !== "boolean") throw new TypeError("Data query facet truncated must be boolean");
+		return {
+			field,
+			values: facet.values.map((value2, valueIndex) => {
+				const entry = plainObject(value2, `Data query facet ${index} value ${valueIndex}`);
+				exactKeys(entry, ["value", "count"], "Data query facet value");
+				return {
+					value: scalar(entry.value, "Data query facet value", budget),
+					count: nonNegativeInteger(entry.count, "Data query facet count")
+				};
+			}),
+			truncated: facet.truncated
+		};
+	});
+}
+function normalizeSmrtWebDataQueryResult(value) {
+	const result = plainObject(value, "Data query result");
+	exactKeys(result, [
+		"version",
+		"requestId",
+		"queryFingerprint",
+		"identityField",
+		"rows",
+		"page",
+		"total",
+		"facets",
+		"freshness",
+		"warnings",
+		"truncated"
+	], "Data query result");
+	if (result.version !== 1) throw new TypeError("Unsupported data query version");
+	const identityField = stringValue(result.identityField, "Data query identity field");
+	if (!Array.isArray(result.rows)) throw new TypeError("Data query rows must be an array");
+	if (result.rows.length > 1e3) throw new TypeError("Data query rows exceed the maximum");
+	const budget = { remaining: MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES };
+	const rows = result.rows.map((row, index) => {
+		const object = plainObject(jsonValue(row, `Data query row ${index}`, budget), `Data query row ${index}`);
+		const identity = object[identityField];
+		if (typeof identity !== "string" && typeof identity !== "number" || identity === "") throw new TypeError("Data query row is missing its stable identity");
+		return object;
+	});
+	let page;
+	if (result.page !== void 0) {
+		const candidate = plainObject(result.page, "Data query page");
+		exactKeys(candidate, [
+			"kind",
+			"limit",
+			"offset",
+			"nextCursor",
+			"hasMore"
+		], "Data query page");
+		const kind = stringValue(candidate.kind, "Data query page kind");
+		if (kind !== "offset" && kind !== "cursor") throw new TypeError("Data query page kind is invalid");
+		if (typeof candidate.hasMore !== "boolean") throw new TypeError("Data query page hasMore must be boolean");
+		const limit = nonNegativeInteger(candidate.limit, "Data query page limit");
+		if (limit === 0) throw new TypeError("Data query page limit must be positive");
+		if (limit > 1e3) throw new TypeError("Data query page limit exceeds the maximum");
+		if (kind === "offset") {
+			if (candidate.nextCursor !== void 0 || candidate.offset === void 0) throw new TypeError("Offset data query page must carry only an offset");
+			const offset = nonNegativeInteger(candidate.offset, "Data query offset");
+			if (offset > 1e6) throw new TypeError("Data query offset exceeds the maximum");
+			page = {
+				kind,
+				limit,
+				offset,
+				hasMore: candidate.hasMore
+			};
+		} else {
+			if (candidate.offset !== void 0) throw new TypeError("Cursor data query page cannot carry an offset");
+			const nextCursor = candidate.nextCursor === void 0 ? void 0 : stringValue(candidate.nextCursor, "Data query next cursor");
+			if (candidate.hasMore !== Boolean(nextCursor)) throw new TypeError("Cursor data query page hasMore must match nextCursor");
+			page = {
+				kind,
+				limit,
+				hasMore: candidate.hasMore,
+				...nextCursor === void 0 ? {} : { nextCursor }
+			};
+		}
+	}
+	if (page && rows.length > page.limit) throw new TypeError("Data query rows exceed the declared page limit");
+	const freshness = plainObject(result.freshness, "Data query freshness");
+	exactKeys(freshness, ["state", "asOf"], "Data query freshness");
+	const state = stringValue(freshness.state, "Data query freshness state");
+	if (state !== "fresh" && state !== "stale" && state !== "unknown") throw new TypeError("Data query freshness state is invalid");
+	if (!Array.isArray(result.warnings) || result.warnings.length > 100 || result.warnings.some((item) => typeof item !== "string")) throw new TypeError("Data query warnings must be strings");
+	if (typeof result.truncated !== "boolean") throw new TypeError("Data query truncated must be boolean");
+	const facets = normalizeFacets(result.facets, budget);
+	const warnings = result.warnings.map((warning) => stringValue(warning, "Data query warning", 512));
+	const normalized = {
+		version: 1,
+		requestId: stringValue(result.requestId, "Data query request id"),
+		queryFingerprint: stringValue(result.queryFingerprint, "Data query fingerprint"),
+		identityField,
+		rows,
+		...page === void 0 ? {} : { page },
+		total: normalizeTotal(result.total),
+		...facets === void 0 ? {} : { facets },
+		freshness: {
+			state,
+			...freshness.asOf === void 0 ? {} : { asOf: stringValue(freshness.asOf, "Data query freshness asOf", 128) }
+		},
+		warnings: [...new Set(warnings)].sort(),
+		truncated: result.truncated
+	};
+	if (new TextEncoder().encode(JSON.stringify(normalized)).byteLength > 1e7) throw new TypeError("Data query result exceeds the maximum byte limit");
+	return normalized;
+}
+async function executeSmrtWebDataQuery(transport, request, options) {
+	const result = normalizeSmrtWebDataQueryResult(await transport.query(request, options));
+	if (result.requestId !== request.requestId) throw new TypeError("Data query result request id does not match its request");
+	return result;
+}
+//#endregion
+//#region src/durable-store.ts
+function durableStoreNamespace(key) {
+	const optional = (value) => value === void 0 ? "" : `_${encodeURIComponent(value)}`;
+	return `smrt-web:${encodeURIComponent(key.apiBase)}:${optional(key.tenantId)}:${optional(key.identityId)}:${encodeURIComponent(key.manifestHash)}`;
+}
+var registry = /* @__PURE__ */ new Map();
+function registerDurableResource(namespace, resource) {
+	let resources = registry.get(namespace);
+	if (!resources) {
+		resources = /* @__PURE__ */ new Set();
+		registry.set(namespace, resources);
+	}
+	resources.add(resource);
+	return () => {
+		const current = registry.get(namespace);
+		if (!current) return;
+		current.delete(resource);
+		if (current.size === 0) registry.delete(namespace);
+	};
+}
+async function wipeDurableStore(namespace) {
+	const resources = registry.get(namespace);
+	if (!resources || resources.size === 0) {
+		registry.delete(namespace);
+		return;
+	}
+	const snapshot = [...resources];
+	registry.delete(namespace);
+	await Promise.allSettled(snapshot.map((resource) => resource.clear()));
+}
+//#endregion
+//#region src/offline/durable-queue.ts
+var OUTBOX_STORE = "outbox";
+var OUTBOX_STATE_INDEX = "state";
+function promisifyRequest$2(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$2(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$1() {
+	const idb = globalThis.indexedDB;
+	if (!idb) return false;
+	const probeName = "__smrt_web_outbox_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 DurableOutboxQueue = class {
+	db;
+	/** The IndexedDB database name (== the durable-store namespace). */
+	dbName;
+	constructor(db, dbName) {
+		this.db = db;
+		this.dbName = dbName;
+	}
+	/**
+	* Append a mutation to the tail of the queue in state `pending`, due
+	* immediately (`nextAttemptAt = 0`, `attempts = 0`). Resolves with the
+	* assigned `seq` once the write is durably committed.
+	*/
+	async enqueue(input) {
+		const now = Date.now();
+		const row = {
+			itemId: input.itemId,
+			object: input.object,
+			op: input.op,
+			id: input.id,
+			payload: input.payload,
+			baseUpdatedAt: input.baseUpdatedAt,
+			state: "pending",
+			attempts: 0,
+			nextAttemptAt: 0,
+			enqueuedAt: now
+		};
+		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
+		const seq = await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).add(row));
+		await awaitTransaction$2(tx);
+		return seq;
+	}
+	/**
+	* Persist a state transition (and any of attempts/backoff/error) for the row
+	* at `seq`, reading-then-writing inside ONE transaction so a concurrent drain
+	* in the same tab can't lose the update. A no-op if the row is already gone
+	* (removed by a prior terminal transition).
+	*/
+	async markState(seq, patch) {
+		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
+		const store = tx.objectStore(OUTBOX_STORE);
+		const existing = await promisifyRequest$2(store.get(seq));
+		if (!existing) {
+			await awaitTransaction$2(tx);
+			return;
+		}
+		const next = {
+			...existing,
+			...patch,
+			seq
+		};
+		await promisifyRequest$2(store.put(next));
+		await awaitTransaction$2(tx);
+	}
+	/**
+	* All rows that are due to (re)send at `now`: state `pending` AND
+	* `nextAttemptAt <= now`, in ascending `seq` (FIFO). Uses the `state` index to
+	* avoid scanning terminal tombstones. Terminal rows (`synced`/`failed`) are
+	* excluded — they await removal, not replay.
+	*/
+	async listPending(now) {
+		const tx = this.db.transaction(OUTBOX_STORE, "readonly");
+		const rows = await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).index(OUTBOX_STATE_INDEX).getAll(IDBKeyRange.only("pending")));
+		await awaitTransaction$2(tx);
+		return rows.filter((row) => row.nextAttemptAt <= now).sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+	}
+	/** Remove the row at `seq` (a terminal transition drops it). */
+	async remove(seq) {
+		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
+		await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).delete(seq));
+		await awaitTransaction$2(tx);
+	}
+	/** Every row currently in the queue (any state), ascending `seq`. */
+	async all() {
+		const tx = this.db.transaction(OUTBOX_STORE, "readonly");
+		const rows = await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).getAll());
+		await awaitTransaction$2(tx);
+		return rows.sort((a, b) => (a.seq ?? 0) - (b.seq ?? 0));
+	}
+	/**
+	* Drop every row — the durable-store `clear()` for `wipeDurableStore`. Empties
+	* the store but keeps the database (and its `seq` autoincrement counter) so a
+	* subsequent enqueue still gets fresh monotonic ids.
+	*/
+	async clear() {
+		const tx = this.db.transaction(OUTBOX_STORE, "readwrite");
+		await promisifyRequest$2(tx.objectStore(OUTBOX_STORE).clear());
+		await awaitTransaction$2(tx);
+	}
+	/** Close the underlying database handle (called on engine dispose). */
+	close() {
+		this.db.close();
+	}
+};
+function openDurableOutboxQueue(dbName) {
+	const idb = globalThis.indexedDB;
+	if (!idb) return Promise.reject(/* @__PURE__ */ new Error("[smrt-web] IndexedDB is unavailable in this environment"));
+	return new Promise((resolve, reject) => {
+		const request = idb.open(dbName, 1);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains("outbox")) db.createObjectStore(OUTBOX_STORE, {
+				keyPath: "seq",
+				autoIncrement: true
+			}).createIndex(OUTBOX_STATE_INDEX, "state", { unique: false });
+		};
+		request.onsuccess = () => resolve(new DurableOutboxQueue(request.result, dbName));
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error(`[smrt-web] failed to open outbox database "${dbName}"`));
+		request.onblocked = () => reject(/* @__PURE__ */ new Error(`[smrt-web] opening outbox database "${dbName}" was blocked`));
+	});
+}
+//#endregion
+//#region src/offline/leader.ts
+function getLockManager() {
+	const locks = globalThis.navigator?.locks;
+	if (locks && typeof locks.request === "function") return locks;
+}
+var warnedNoLocks = false;
+function acquireLeadership(lockName, onAcquired, onReleased) {
+	const locks = getLockManager();
+	if (!locks) {
+		if (!warnedNoLocks) {
+			warnedNoLocks = true;
+			console.warn("[smrt-web] Web Locks API unavailable — the offline outbox falls back to single-tab leadership; the multi-tab exactly-one-replayer guarantee does not hold across tabs.");
+		}
+		let released2 = false;
+		const release2 = () => {
+			if (released2) return;
+			released2 = true;
+			onReleased();
+		};
+		queueMicrotask(() => {
+			if (!released2) onAcquired();
+		});
+		return release2;
+	}
+	const controller = new AbortController();
+	let releaseHeldLock;
+	let released = false;
+	let acquired = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		if (acquired && releaseHeldLock) releaseHeldLock();
+		else controller.abort();
+		onReleased();
+	};
+	locks.request(lockName, {
+		signal: controller.signal,
+		mode: "exclusive"
+	}, () => {
+		acquired = true;
+		if (released) return Promise.resolve();
+		onAcquired();
+		return new Promise((resolve) => {
+			releaseHeldLock = resolve;
+		});
+	}).catch((error) => {
+		if (error?.name !== "AbortError") console.warn("[smrt-web] outbox leader lock request failed", error);
+		if (!released) {
+			released = true;
+			onReleased();
+		}
+	});
+	return release;
+}
+//#endregion
+//#region src/offline/types.ts
+var MAX_SYNC_APPLY_BATCH_SIZE = 1e3;
+var SYNC_APPLY_ROUTE_SEGMENTS = ["sync", "apply"];
+var DEFAULT_BACKOFF = {
+	initialDelayMs: 1e3,
+	multiplier: 2,
+	maxDelayMs: 6e4
+};
+function computeBackoffDelay(attempts, backoff, random = Math.random) {
+	const exponent = Math.max(0, attempts - 1);
+	const raw = backoff.initialDelayMs * backoff.multiplier ** exponent;
+	const capped = Math.min(backoff.maxDelayMs, raw);
+	const jitter = .5 + random() * .5;
+	return Math.round(capped * jitter);
+}
+//#endregion
+//#region src/offline/engine.ts
+function envelopeKindToOp(kind) {
+	return kind === "insert" ? "create" : kind;
+}
+function newItemId() {
+	const cryptoRef = globalThis.crypto;
+	if (cryptoRef?.randomUUID) return cryptoRef.randomUUID();
+	return `item-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function isDefinitelyOffline() {
+	return globalThis.navigator?.onLine === false;
+}
+var OutboxEngine = class {
+	config;
+	/**
+	* Per-collection callback sets, keyed by the collection route segment
+	* (`object`). Keyed by `object` — NOT by the queue row's `itemId` — precisely
+	* so replayed rows that were REHYDRATED from IndexedDB after a reload (whose
+	* itemIds this session never enqueued) still route their state/conflict events
+	* to the reloaded collection's callbacks. A `Set` per object so N collections
+	* sharing one engine+object each get every event (the common case is one
+	* collection per object, but the shared-engine model does not forbid more).
+	*/
+	listenersByObject = /* @__PURE__ */ new Map();
+	/** Ref count: number of collections currently attached to this engine. */
+	refCount = 0;
+	/** The durable queue, once opened. undefined while opening / if IDB absent. */
+	queue;
+	/** Resolves once the async open settles (success or degraded). */
+	ready;
+	/** True when IndexedDB was unavailable and the engine is a durable no-op. */
+	degraded = false;
+	/** Leadership handle; set once we've requested the leader lock. */
+	leadership;
+	/** True while this tab holds leadership. */
+	isLeader = false;
+	/** Unregister fn from the durable-store registry. */
+	unregisterResource;
+	/** True once dispose() ran — guards late async continuations. */
+	disposed = false;
+	/**
+	* Paused by an auth_required/forbidden result: the loop stops draining until
+	* a later enqueue (the app re-authenticated and is writing again) or an
+	* explicit retry wakes it. Items stay queued.
+	*/
+	paused = false;
+	/** True while a drain pass is running, to coalesce concurrent triggers. */
+	draining = false;
+	/** A drain requested while one was in flight — run one more pass after. */
+	drainQueued = false;
+	/** Timer for the next backoff-scheduled drain, if any. */
+	backoffTimer;
+	/** The `online` event listener, so we can remove it on dispose. */
+	onlineListener;
+	constructor(config) {
+		this.config = config;
+		this.ready = this.open();
+		this.wireOnlineListener();
+		this.requestLeadership();
+		this.ready.then(() => {
+			if (!this.disposed) this.drain();
+		});
+	}
+	/** Open the durable queue (or mark degraded if IndexedDB is unusable). */
+	async open() {
+		if (!await probeIndexedDb$1()) {
+			this.degraded = true;
+			console.warn("[smrt-web] IndexedDB unavailable — the offline outbox is disabled; offline writes will not be durable.");
+			return;
+		}
+		try {
+			this.queue = await openDurableOutboxQueue(this.config.namespace);
+			this.unregisterResource = this.config.registerResource(async () => {
+				await this.queue?.clear();
+			});
+			if (this.disposed) {
+				this.queue.close();
+				this.queue = void 0;
+				this.unregisterResource?.();
+				this.unregisterResource = void 0;
+				return;
+			}
+		} catch (error) {
+			this.degraded = true;
+			console.warn("[smrt-web] failed to open the offline outbox", error);
+		}
+	}
+	/** Wake the drain loop immediately when connectivity returns. */
+	wireOnlineListener() {
+		const target = globalThis;
+		if (typeof target.addEventListener !== "function") return;
+		const listener = () => {
+			this.drain();
+		};
+		target.addEventListener("online", listener);
+		this.onlineListener = listener;
+	}
+	/** Request cross-tab leadership; drain whenever we hold it. */
+	requestLeadership() {
+		const lockName = `smrt-web-outbox-leader:${this.config.namespace}`;
+		this.leadership = acquireLeadership(lockName, () => {
+			this.isLeader = true;
+			this.drain();
+		}, () => {
+			this.isLeader = false;
+		});
+	}
+	/**
+	* Attach a collection: register its per-object callbacks and bump the ref
+	* count. Returns the exact callback record registered so the caller can pass
+	* it back to {@link unregisterCollection} for precise removal (two collections
+	* on the same object must each detach only their own callbacks). Registering
+	* by `object` is what lets rehydrated rows (reloaded from IDB) reach this
+	* collection's callbacks even though this session never enqueued them.
+	*/
+	registerCollection(binding) {
+		this.refCount += 1;
+		const record = {
+			onSyncStateChange: binding.onSyncStateChange,
+			onConflict: binding.onConflict
+		};
+		let set = this.listenersByObject.get(binding.object);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listenersByObject.set(binding.object, set);
+		}
+		set.add(record);
+		return record;
+	}
+	/**
+	* Detach a collection: remove its callback record and decrement the ref count;
+	* when it reaches zero, dispose the engine (release the lock, unregister from
+	* the durable-store registry, close IndexedDB). The durable ROWS are NOT
+	* cleared — they must survive to replay after a reload; only the in-memory
+	* engine is torn down. Returns true if it disposed.
+	*/
+	async unregisterCollection(object, record) {
+		const set = this.listenersByObject.get(object);
+		if (set) {
+			set.delete(record);
+			if (set.size === 0) this.listenersByObject.delete(object);
+		}
+		this.refCount = Math.max(0, this.refCount - 1);
+		if (this.refCount > 0) return false;
+		await this.dispose();
+		return true;
+	}
+	/** Current ref count (test/introspection aid). */
+	get referenceCount() {
+		return this.refCount;
+	}
+	/**
+	* Enqueue an optimistic write into the durable queue and fire the initial
+	* `pending` state, then kick a drain. Resolves once the row is durably
+	* committed (so the caller's `wrapMutation` only reports handled after
+	* persistence). Replay events for this row (and for rows this session did not
+	* enqueue — reloaded from disk) route to the registered per-`object`
+	* callbacks, so a reload does not lose observability.
+	*
+	* In degraded (no-IndexedDB) mode the write is NOT durable, so this returns
+	* `undefined` and the capability falls through to the real fetcher instead
+	* of acknowledging an optimistic-only write.
+	*/
+	async enqueue(request) {
+		await this.ready;
+		if (!this.queue || this.degraded) return void 0;
+		const itemId = newItemId();
+		const op = envelopeKindToOp(request.kind);
+		const payload = op === "delete" ? void 0 : request.data;
+		await this.queue.enqueue({
+			itemId,
+			object: request.object,
+			op,
+			id: request.rowId,
+			payload,
+			baseUpdatedAt: request.baseUpdatedAt
+		});
+		this.emit({
+			itemId,
+			rowId: request.rowId,
+			object: request.object,
+			state: "pending",
+			attempts: 0
+		});
+		this.paused = false;
+		this.drain();
+		return itemId;
+	}
+	/**
+	* Force a retry of a specific queued item now: clears its backoff gate and
+	* wakes the loop. The bridge `OutboxHandle.retry(itemId)` calls this so an app
+	* "retry" button can flush a backed-off or auth-paused item. A no-op for an
+	* item that is not (or no longer) queued.
+	*/
+	async retry(itemId) {
+		await this.ready;
+		if (!this.queue) return;
+		const row = (await this.queue.all()).find((r) => r.itemId === itemId && r.state === "pending");
+		if (!row || row.seq === void 0) return;
+		await this.queue.markState(row.seq, { nextAttemptAt: 0 });
+		this.paused = false;
+		this.drain();
+	}
+	/**
+	* A read-only snapshot of the durable queue — the basis of
+	* `OutboxHandle.snapshot()`. Because the READ cache is NOT rehydrated after a
+	* reload in this slice (that's #1764's warmStart), the snapshot + the raw IDB
+	* store are how a test/app proves durability, not `collection.toArray()`.
+	*/
+	async snapshot() {
+		await this.ready;
+		if (!this.queue) return [];
+		return (await this.queue.all()).map((row) => ({
+			itemId: row.itemId,
+			object: row.object,
+			op: row.op,
+			rowId: row.id,
+			state: row.state,
+			attempts: row.attempts,
+			nextAttemptAt: row.nextAttemptAt,
+			lastError: row.lastError
+		}));
+	}
+	/**
+	* Deliver a state event to every callback registered for the event's
+	* collection `object` (best-effort). Routing by `object` — not `itemId` —
+	* means a row REHYDRATED from IndexedDB after a reload still reaches the
+	* reloaded collection's callback even though this session never enqueued it.
+	*/
+	emit(event) {
+		const set = this.listenersByObject.get(event.object);
+		if (!set) return;
+		for (const listener of set) try {
+			listener.onSyncStateChange?.(event);
+		} catch (error) {
+			console.warn("[smrt-web] onSyncStateChange callback threw", error);
+		}
+	}
+	/** Deliver a conflict to every callback registered for its collection. */
+	emitConflict(conflict) {
+		const set = this.listenersByObject.get(conflict.object);
+		if (!set) return;
+		for (const listener of set) try {
+			listener.onConflict?.(conflict);
+		} catch (error) {
+			console.warn("[smrt-web] onConflict callback threw", error);
+		}
+	}
+	/**
+	* The replay loop. Gated on: (a) holding leadership, (b) not paused by an
+	* auth failure, (c) `navigator.onLine !== false`, (d) IndexedDB usable. Drains
+	* all rows due now (`nextAttemptAt <= now`), oldest-first, chunked into
+	* batches of ≤1000 per POST, one POST at a time to preserve FIFO across
+	* chunks. Concurrency-coalesced: a drain requested while one runs sets a flag
+	* to run exactly one more pass, so overlapping triggers never interleave.
+	*/
+	async drain() {
+		if (this.draining) {
+			this.drainQueued = true;
+			return;
+		}
+		this.draining = true;
+		try {
+			for (;;) {
+				this.drainQueued = false;
+				await this.drainOnce();
+				if (!this.drainQueued) break;
+			}
+		} finally {
+			this.draining = false;
+		}
+	}
+	/** One drain pass: send every currently-due batch, then schedule backoff. */
+	async drainOnce() {
+		if (this.disposed) return;
+		if (!this.isLeader) return;
+		if (this.paused) return;
+		if (this.degraded || !this.queue) return;
+		if (isDefinitelyOffline()) return;
+		const pending = (await this.queue.all()).filter((row) => row.state === "pending");
+		if (pending.length === 0) return;
+		const now = Date.now();
+		const firstBlocked = pending.findIndex((row) => row.nextAttemptAt > now);
+		const due = firstBlocked === -1 ? pending : pending.slice(0, firstBlocked);
+		if (due.length === 0) {
+			await this.scheduleNextBackoff();
+			return;
+		}
+		for (let i = 0; i < due.length; i += MAX_SYNC_APPLY_BATCH_SIZE) {
+			if (this.disposed || this.paused || !this.isLeader) break;
+			const chunk = due.slice(i, i + MAX_SYNC_APPLY_BATCH_SIZE);
+			if (!await this.sendBatch(chunk)) break;
+		}
+		await this.scheduleNextBackoff();
+	}
+	/**
+	* Send one chunk through `POST {basePath}/sync/apply` and map results back
+	* onto durable transitions. On a network reject / non-200 / lost/mismatched
+	* response the WHOLE chunk stays `pending` (blind replay is safe) — every row
+	* goes back to `pending` with an incremented attempt + backoff so the loop
+	* doesn't hot-spin. Returns false when a retryable row remains pending, which
+	* stops this drain pass so newer FIFO chunks do not overtake it.
+	*/
+	async sendBatch(chunk) {
+		for (const row of chunk) this.emit({
+			itemId: row.itemId,
+			rowId: row.id,
+			object: row.object,
+			state: "uploading",
+			attempts: row.attempts
+		});
+		const items = chunk.map((row) => ({
+			itemId: row.itemId,
+			object: row.object,
+			op: row.op,
+			id: row.id,
+			payload: row.payload,
+			baseUpdatedAt: row.baseUpdatedAt
+		}));
+		let results;
+		try {
+			results = await this.postBatch(items);
+		} catch {
+			await this.requeueBatch(chunk, "network error during sync");
+			return false;
+		}
+		if (!results) {
+			await this.requeueBatch(chunk, "unexpected sync response shape");
+			return false;
+		}
+		let drained = true;
+		for (let i = 0; i < chunk.length; i += 1) {
+			const row = chunk[i];
+			const result = results[i];
+			if (!result) {
+				await this.requeueRow(row, "missing result for item");
+				drained = false;
+				continue;
+			}
+			const applied = await this.applyResult(row, result);
+			drained = drained && applied;
+		}
+		return drained;
+	}
+	/**
+	* POST a batch to `{basePath}/sync/apply`. Throws on a non-2xx or a network
+	* error (the caller treats a throw as "response lost → keep pending"). Returns
+	* the positional `results` array, or `undefined` on a malformed 200 body.
+	*/
+	async postBatch(items) {
+		const url = `${this.config.syncApplyBasePath}/${SYNC_APPLY_ROUTE_SEGMENTS.join("/")}`;
+		const response = await this.config.fetchFn(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ items })
+		});
+		if (!response.ok) throw new Error(`[smrt-web] sync/apply returned HTTP ${response.status}`);
+		const body = await response.json().catch(() => null);
+		if (!body || !Array.isArray(body.results)) return void 0;
+		return body.results;
+	}
+	/**
+	* Map one positional apply result onto a durable transition + observable
+	* state, per the contract's consumer notes. See the class doc's mapping table.
+	*/
+	async applyResult(row, result) {
+		if (row.seq === void 0) return true;
+		if (result.status === "applied") {
+			await this.finishSynced(row);
+			return true;
+		}
+		if (result.status === "conflict") {
+			const reason2 = result.reason === "create_conflict" ? "create_conflict" : "stale_write";
+			this.emitConflict({
+				itemId: row.itemId,
+				object: row.object,
+				rowId: row.id,
+				reason: reason2,
+				serverUpdatedAt: result.updatedAt
+			});
+			await this.finishSynced(row);
+			return true;
+		}
+		const reason = result.reason;
+		if (reason === "auth_required" || reason === "forbidden") {
+			this.paused = true;
+			await this.queue?.markState(row.seq, {
+				state: "pending",
+				lastError: `sync ${reason}`
+			});
+			this.emit({
+				itemId: row.itemId,
+				rowId: row.id,
+				object: row.object,
+				state: "pending",
+				attempts: row.attempts,
+				error: `sync ${reason}`
+			});
+			return false;
+		}
+		if (reason === "write_failed") {
+			await this.requeueRow(row, "sync write_failed");
+			return false;
+		}
+		await this.queue?.remove(row.seq);
+		this.emit({
+			itemId: row.itemId,
+			rowId: row.id,
+			object: row.object,
+			state: "failed",
+			attempts: row.attempts,
+			error: reason ? `sync ${reason}` : "sync rejected"
+		});
+		return true;
+	}
+	/** Remove a successfully-applied (or conflict-resolved) row → `synced`. */
+	async finishSynced(row) {
+		if (row.seq !== void 0) await this.queue?.remove(row.seq);
+		this.emit({
+			itemId: row.itemId,
+			rowId: row.id,
+			object: row.object,
+			state: "synced",
+			attempts: row.attempts
+		});
+	}
+	/** Re-queue every row of a failed batch (network path) with backoff. */
+	async requeueBatch(chunk, error) {
+		for (const row of chunk) await this.requeueRow(row, error);
+	}
+	/** Re-queue one row: attempts++, backoff gate, `pending` event. */
+	async requeueRow(row, error) {
+		if (row.seq === void 0) return;
+		const attempts = row.attempts + 1;
+		const delay = computeBackoffDelay(attempts, this.config.backoff, this.config.random);
+		const nextAttemptAt = Date.now() + delay;
+		await this.queue?.markState(row.seq, {
+			state: "pending",
+			attempts,
+			nextAttemptAt,
+			lastError: error
+		});
+		this.emit({
+			itemId: row.itemId,
+			rowId: row.id,
+			object: row.object,
+			state: "pending",
+			attempts,
+			error
+		});
+	}
+	/**
+	* Schedule the next drain for the soonest backed-off row's `nextAttemptAt`.
+	* Only one timer is ever pending; a sooner schedule replaces a later one.
+	*/
+	async scheduleNextBackoff() {
+		if (this.disposed || this.paused || !this.queue) return;
+		const firstPending = (await this.queue.all()).find((r) => r.state === "pending");
+		if (!firstPending) return;
+		const now = Date.now();
+		const delay = Math.max(0, firstPending.nextAttemptAt - now);
+		if (this.backoffTimer) clearTimeout(this.backoffTimer);
+		const timers = globalThis;
+		if (typeof timers.setTimeout !== "function") return;
+		this.backoffTimer = timers.setTimeout(() => {
+			this.backoffTimer = void 0;
+			this.drain();
+		}, delay);
+		this.backoffTimer.unref?.();
+	}
+	/**
+	* Tear down the in-memory engine: release leadership, remove the online
+	* listener, clear timers, unregister from the durable-store registry, and
+	* close IndexedDB. Does NOT clear the durable rows — they must survive to
+	* replay on the next load.
+	*/
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.backoffTimer) {
+			clearTimeout(this.backoffTimer);
+			this.backoffTimer = void 0;
+		}
+		const target = globalThis;
+		if (this.onlineListener && typeof target.removeEventListener === "function") {
+			target.removeEventListener("online", this.onlineListener);
+			this.onlineListener = void 0;
+		}
+		this.leadership?.();
+		this.leadership = void 0;
+		this.unregisterResource?.();
+		this.unregisterResource = void 0;
+		await this.ready.catch(() => void 0);
+		this.queue?.close();
+		this.queue = void 0;
+		this.listenersByObject.clear();
+	}
+};
+var engines = /* @__PURE__ */ new Map();
+function getOrCreateOutboxEngine(config) {
+	let engine = engines.get(config.namespace);
+	if (!engine) {
+		engine = new OutboxEngine(config);
+		engines.set(config.namespace, engine);
+	}
+	return engine;
+}
+function acquireOutboxEngine(config, binding) {
+	const engine = getOrCreateOutboxEngine(config);
+	return {
+		engine,
+		record: engine.registerCollection(binding)
+	};
+}
+async function releaseOutboxEngine(namespace, engine, object, record) {
+	if (await engine.unregisterCollection(object, record) && engines.get(namespace) === engine) engines.delete(namespace);
+}
+//#endregion
+//#region src/offline.ts
+function resolveBackoff(backoff) {
+	return {
+		initialDelayMs: backoff?.initialDelayMs ?? DEFAULT_BACKOFF.initialDelayMs,
+		multiplier: backoff?.multiplier ?? DEFAULT_BACKOFF.multiplier,
+		maxDelayMs: backoff?.maxDelayMs ?? DEFAULT_BACKOFF.maxDelayMs
+	};
+}
+var handlesByNamespace = /* @__PURE__ */ new Map();
+function getPayloadUpdatedAt(data) {
+	const value = data.updatedAt ?? data.updated_at;
+	if (typeof value === "string") return value;
+	if (value instanceof Date) return value.toISOString();
+}
+function offlineOutbox(config) {
+	const namespace = durableStoreNamespace(config.namespace);
+	const syncApplyBasePath = config.syncApplyBasePath ?? "/api/v1";
+	const fetchFn = config.fetchFn ?? ((...args) => globalThis.fetch(...args));
+	const backoff = resolveBackoff(config.backoff);
+	const object = config.object.name;
+	let engine;
+	let record;
+	return {
+		name: "offline-outbox",
+		onAttach() {
+			const acquired = acquireOutboxEngine({
+				namespace,
+				syncApplyBasePath,
+				fetchFn,
+				backoff,
+				random: config.random,
+				registerResource: (clear) => registerDurableResource(namespace, {
+					kind: "outbox",
+					clear
+				})
+			}, {
+				object,
+				onSyncStateChange: config.onSyncStateChange,
+				onConflict: config.onConflict
+			});
+			engine = acquired.engine;
+			record = acquired.record;
+			handlesByNamespace.set(namespace, engine);
+		},
+		async wrapMutation(envelope) {
+			if (!engine) return { handled: false };
+			if (!await engine.enqueue({
+				kind: envelope.kind,
+				object,
+				rowId: envelope.key,
+				data: envelope.data,
+				baseUpdatedAt: envelope.baseUpdatedAt ?? getPayloadUpdatedAt(envelope.data)
+			})) return { handled: false };
+			return {
+				handled: true,
+				result: envelope.data
+			};
+		},
+		async teardown() {
+			if (!engine || !record) return;
+			const current = engine;
+			const currentRecord = record;
+			engine = void 0;
+			record = void 0;
+			const before = current.referenceCount;
+			await releaseOutboxEngine(namespace, current, object, currentRecord);
+			if (before <= 1 && handlesByNamespace.get(namespace) === current) handlesByNamespace.delete(namespace);
+		}
+	};
+}
+function getOutboxHandle(namespace) {
+	const engine = handlesByNamespace.get(namespace);
+	if (!engine) return void 0;
+	return {
+		snapshot: () => engine.snapshot(),
+		retry: (itemId) => engine.retry(itemId)
+	};
+}
+//#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;
+var enginesByNamespace = /* @__PURE__ */ new Map();
+var warnedNoIndexedDb = false;
+function warnNoIndexedDbOnce() {
+	if (warnedNoIndexedDb) return;
+	warnedNoIndexedDb = true;
+	console.warn("[smrt-web] IndexedDB is unavailable; persistence is disabled (collections behave as non-persistent).");
+}
+function acquireSnapshotEngine(namespace) {
+	const existing = enginesByNamespace.get(namespace);
+	if (existing) {
+		existing.refCount += 1;
+		return existing;
+	}
+	const engine = {
+		store: void 0,
+		refCount: 1,
+		unregister: void 0,
+		ready: Promise.resolve(void 0)
+	};
+	engine.ready = (async () => {
+		if (!await probeIndexedDb()) {
+			warnNoIndexedDbOnce();
+			return;
+		}
+		try {
+			const store = await openSnapshotStore(namespace);
+			engine.store = store;
+			engine.unregister = registerDurableResource(namespace, {
+				kind: "persisted-collection",
+				clear: () => store.clear()
+			});
+			return store;
+		} catch {
+			warnNoIndexedDbOnce();
+			return;
+		}
+	})();
+	enginesByNamespace.set(namespace, engine);
+	return engine;
+}
+async function releaseSnapshotEngine(namespace) {
+	const engine = enginesByNamespace.get(namespace);
+	if (!engine) return;
+	engine.refCount -= 1;
+	if (engine.refCount > 0) return;
+	enginesByNamespace.delete(namespace);
+	await engine.ready;
+	engine.unregister?.();
+	engine.unregister = void 0;
+	engine.store?.close();
+	engine.store = void 0;
+}
+function persistCollection(config) {
+	const namespace = durableStoreNamespace(config.namespace);
+	const collectionName = config.collection;
+	const debounceMs = config.debounceMs ?? 250;
+	let engine;
+	let subscription;
+	let debounceTimer;
+	let readSnapshot;
+	let detached = false;
+	let flushing;
+	let dirty = false;
+	const doFlush = async () => {
+		while (dirty && !detached) {
+			dirty = false;
+			if (!engine || !readSnapshot) return;
+			const store = await engine.ready;
+			if (detached || !store) return;
+			const rows = readSnapshot().map((row) => ({ ...row }));
+			try {
+				await store.save(collectionName, rows);
+			} catch {}
+		}
+	};
+	const runFlush = () => {
+		dirty = true;
+		if (flushing) return;
+		flushing = doFlush().finally(() => {
+			flushing = void 0;
+			if (dirty && !detached) runFlush();
+		});
+	};
+	const scheduleFlush = () => {
+		if (detached) return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = void 0;
+			runFlush();
+		}, Math.max(0, debounceMs));
+		debounceTimer.unref?.();
+	};
+	return {
+		name: "persistence",
+		async warmStart(ctx) {
+			const acquired = acquireSnapshotEngine(namespace);
+			engine = acquired;
+			readSnapshot = ctx.snapshot ? () => ctx.snapshot?.() ?? [] : void 0;
+			const store = await acquired.ready;
+			if (!store) return void 0;
+			const rows = await store.load(collectionName);
+			if (!rows || rows.length === 0) return void 0;
+			return rows;
+		},
+		onAttach(ctx) {
+			if (!engine) engine = acquireSnapshotEngine(namespace);
+			if (!readSnapshot && ctx.snapshot) readSnapshot = () => ctx.snapshot?.() ?? [];
+			if (!ctx.snapshot || !ctx.subscribe || !readSnapshot) return;
+			subscription = ctx.subscribe(() => scheduleFlush());
+			scheduleFlush();
+		},
+		async teardown() {
+			detached = true;
+			if (debounceTimer) {
+				clearTimeout(debounceTimer);
+				debounceTimer = void 0;
+			}
+			subscription?.unsubscribe();
+			subscription = void 0;
+			readSnapshot = void 0;
+			if (flushing) await flushing;
+			const current = engine;
+			engine = void 0;
+			if (current) await releaseSnapshotEngine(namespace);
+		}
+	};
+}
+//#endregion
+//#region src/sse-client.ts
+var EVENT_SOURCE_CLOSED = 2;
+function defaultEventSourceFactory(url, init) {
+	const EventSourceCtor = globalThis.EventSource;
+	if (typeof EventSourceCtor !== "function") return void 0;
+	return new EventSourceCtor(url, init);
+}
+function createSmrtWebEventSubscriber(config) {
+	const { eventsUrl, changesUrl, fetchFn = (...args) => globalThis.fetch(...args), eventSourceFactory = defaultEventSourceFactory, pollIntervalMs = 5e3, withCredentials = true, manifestHash, updateState } = config;
+	const tableInvalidators = /* @__PURE__ */ new Map();
+	let lastSeq = null;
+	let transport = "idle";
+	let eventSource = null;
+	let pollTimer = null;
+	let closed = false;
+	const registeredTables = () => [...tableInvalidators.keys()].sort((a, b) => a.localeCompare(b));
+	const buildChangesUrl = (since, tables) => {
+		const url = new URL(changesUrl, "http://smrt.local/");
+		url.searchParams.set("since", String(since));
+		url.searchParams.set("tables", tables.join(","));
+		if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(changesUrl)) return url.href;
+		const pathQueryHash = `${url.pathname}${url.search}${url.hash}`;
+		if (changesUrl.startsWith("//")) return `//${url.host}${pathQueryHash}`;
+		if (changesUrl.startsWith("/")) return pathQueryHash;
+		return pathQueryHash.startsWith("/") ? pathQueryHash.slice(1) : pathQueryHash;
+	};
+	const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+	const warn = (message, error) => {
+		console.warn(`[smrt-web] live subscriber: ${message}`, error);
+	};
+	const fireAll = (invalidators) => {
+		if (!invalidators || invalidators.size === 0) return;
+		for (const invalidate of [...invalidators]) try {
+			invalidate();
+		} catch (error) {
+			warn("an invalidator threw; ignoring", error);
+		}
+	};
+	const invalidateTable = (table) => {
+		fireAll(tableInvalidators.get(table));
+	};
+	const invalidateAll = () => {
+		for (const invalidators of tableInvalidators.values()) fireAll(invalidators);
+	};
+	const advanceLastSeqFromEventId = (lastEventId) => {
+		const seq = Number(lastEventId);
+		if (Number.isFinite(seq)) lastSeq = seq;
+	};
+	const onChange = (ev) => {
+		if (closed) return;
+		let table;
+		try {
+			const parsed = JSON.parse(ev.data);
+			if (typeof parsed.table === "string") table = parsed.table;
+		} catch (error) {
+			warn("dropping malformed change frame", error);
+			return;
+		}
+		if (table === void 0) {
+			warn("dropping change frame with no table", ev.data);
+			return;
+		}
+		advanceLastSeqFromEventId(ev.lastEventId);
+		invalidateTable(table);
+	};
+	const onResync = (ev) => {
+		if (closed) return;
+		advanceLastSeqFromEventId(ev.lastEventId);
+		invalidateAll();
+	};
+	const onManifest = (ev) => {
+		if (closed || manifestHash === void 0 || !updateState) return;
+		try {
+			const serverHash = JSON.parse(ev.data).manifestHash;
+			if (typeof serverHash !== "string" || serverHash.length === 0) {
+				warn("dropping manifest frame with no manifestHash", ev.data);
+				return;
+			}
+			if (serverHash !== manifestHash) updateState.notifyContractUpdated();
+		} catch (error) {
+			warn("dropping malformed manifest frame", error);
+		}
+	};
+	const poll = async () => {
+		if (closed) return;
+		const tables = registeredTables();
+		if (tables.length === 0) return;
+		try {
+			const since = lastSeq ?? 0;
+			const url = buildChangesUrl(since, tables);
+			const response = await fetchFn(url, { credentials: "include" });
+			if (closed) return;
+			const page = await response.json();
+			if (closed) return;
+			if (page.resyncRequired) {
+				invalidateAll();
+				if (isFiniteNumber(page.resyncCursor)) lastSeq = page.resyncCursor;
+				else if (isFiniteNumber(page.cursor) && page.cursor > since) lastSeq = page.cursor;
+				else lastSeq = null;
+				return;
+			}
+			for (const change of page.changes ?? []) if (typeof change.table === "string") invalidateTable(change.table);
+			if (typeof page.cursor === "number") lastSeq = page.cursor;
+		} catch (error) {
+			warn("poll failed; will retry on the next interval", error);
+		}
+	};
+	const startPolling = () => {
+		if (closed || transport === "polling") return;
+		transport = "polling";
+		pollTimer = setInterval(() => {
+			poll();
+		}, pollIntervalMs);
+		pollTimer.unref?.();
+	};
+	const connectSse = (source) => {
+		transport = "sse";
+		eventSource = source;
+		source.addEventListener("change", onChange);
+		source.addEventListener("resync", onResync);
+		source.addEventListener("manifest", onManifest);
+		source.onerror = () => {
+			if (closed) return;
+			if (source.readyState === EVENT_SOURCE_CLOSED) {
+				try {
+					source.close();
+				} catch {}
+				eventSource = null;
+				startPolling();
+			}
+		};
+	};
+	const initialSource = eventSourceFactory(eventsUrl, { withCredentials });
+	if (initialSource) connectSse(initialSource);
+	else startPolling();
+	return {
+		get transport() {
+			return transport;
+		},
+		registerTable(table, invalidate) {
+			let set = tableInvalidators.get(table);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				tableInvalidators.set(table, set);
+			}
+			set.add(invalidate);
+			return () => {
+				const current = tableInvalidators.get(table);
+				if (!current) return;
+				current.delete(invalidate);
+				if (current.size === 0) tableInvalidators.delete(table);
+			};
+		},
+		invalidateAll,
+		close() {
+			if (closed) return;
+			closed = true;
+			if (eventSource) {
+				try {
+					eventSource.close();
+				} catch {}
+				eventSource = null;
+			}
+			if (pollTimer) {
+				clearInterval(pollTimer);
+				pollTimer = null;
+			}
+			tableInvalidators.clear();
+			transport = "idle";
+		}
+	};
+}
+function liveInvalidation(config) {
+	const { subscriber, tableName } = config;
+	let unregister;
+	return {
+		name: "live-invalidation",
+		onAttach(ctx) {
+			unregister = subscriber.registerTable(tableName, () => ctx.invalidate());
+		},
+		teardown() {
+			unregister?.();
+			unregister = void 0;
+		}
+	};
+}
+//#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);
+	let bundle = false;
+	let contract = false;
+	const subscribers = /* @__PURE__ */ new Set();
+	let metaStore;
+	let unregister;
+	let disposed = false;
+	const snapshot = () => ({
+		bundle,
+		contract,
+		updateAvailable: bundle || contract
+	});
+	const notify = () => {
+		const state = snapshot();
+		for (const callback of [...subscribers]) try {
+			callback(state);
+		} catch (error) {
+			console.warn("[smrt-web] updateAvailable subscriber threw", error);
+		}
+	};
+	const setBundle = () => {
+		if (bundle) return;
+		bundle = true;
+		notify();
+	};
+	const setContract = () => {
+		if (contract) return;
+		contract = true;
+		notify();
+	};
+	return {
+		get: snapshot,
+		subscribe(callback) {
+			subscribers.add(callback);
+			try {
+				callback(snapshot());
+			} catch (error) {
+				console.warn("[smrt-web] updateAvailable subscriber threw", error);
+			}
+			return () => {
+				subscribers.delete(callback);
+			};
+		},
+		notifyBundleUpdated: setBundle,
+		notifyContractUpdated: setContract,
+		ready: (async () => {
+			const runningHash = config.manifestHash;
+			if (runningHash === void 0) return;
+			let store;
+			try {
+				store = await openVersionMetaStore(namespace);
+			} catch {
+				return;
+			}
+			if (disposed) {
+				store.close();
+				return;
+			}
+			metaStore = store;
+			unregister = registerDurableResource(namespace, {
+				kind: "persisted-collection",
+				clear: () => store.clear()
+			});
+			let lastSeen;
+			try {
+				lastSeen = await store.get(LAST_SEEN_MANIFEST_HASH_KEY);
+			} catch {
+				lastSeen = void 0;
+			}
+			if (disposed) return;
+			if (lastSeen !== void 0 && lastSeen !== runningHash) setContract();
+			if (lastSeen !== runningHash) try {
+				await store.set(LAST_SEEN_MANIFEST_HASH_KEY, runningHash);
+			} catch {}
+		})(),
+		dispose() {
+			disposed = true;
+			unregister?.();
+			unregister = void 0;
+			metaStore?.close();
+			metaStore = void 0;
+			subscribers.clear();
+		}
+	};
+}
+//#endregion
+//#region src/webmcp.ts
+function getModelContext() {
+	const mc = globalThis.document?.modelContext;
+	if (mc && typeof mc.registerTool === "function") return mc;
+}
+function registerWebMcpTools(definitions, options = {}) {
+	const ctx = getModelContext();
+	if (!ctx) return () => {};
+	const basePath = options.basePath ?? "/api/v1";
+	const controller = new AbortController();
+	const collections = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		const descriptors = definition.toolDescriptors;
+		if (!descriptors || descriptors.length === 0) continue;
+		const fetchers = options.resolveFetchers ? options.resolveFetchers(definition) : createDefinitionFetchers(definition, basePath, options.fetchFn);
+		const collection = createSmrtCollection(definition, {
+			fetchers,
+			basePath,
+			fetchFn: options.fetchFn,
+			...options.client ? { client: options.client } : {},
+			...options.scope ? { scope: options.scope } : {}
+		});
+		collections.set(definition, collection);
+		for (const descriptor of descriptors) {
+			if (options.filter && !options.filter(definition, descriptor)) continue;
+			ctx.registerTool({
+				name: descriptor.name,
+				description: descriptor.description,
+				inputSchema: descriptor.inputSchema,
+				annotations: { readOnlyHint: descriptor.readOnly },
+				execute: (args) => dispatch(fetchers, collection, definition, descriptor.action, descriptor.route, args ?? {})
+			}, { signal: controller.signal });
+		}
+	}
+	return () => {
+		controller.abort();
+		for (const collection of collections.values()) collection.cleanup().catch(() => void 0);
+	};
+}
+function requireId(args, action) {
+	const id = args.id;
+	if (typeof id !== "string" || id.length === 0) throw new Error(`WebMCP ${action} requires a string 'id' argument`);
+	return id;
+}
+function requireIdentifier(args) {
+	const value = args.id ?? args.slug;
+	if (typeof value !== "string" || value.length === 0) throw new Error("WebMCP get requires a string 'id' or 'slug' argument");
+	return value;
+}
+function listParams(args) {
+	const params = {};
+	if (args.limit !== void 0) params.limit = args.limit;
+	if (args.offset !== void 0) params.offset = args.offset;
+	if (args.orderBy !== void 0) params.orderBy = args.orderBy;
+	if (args.where !== void 0) params.where = args.where;
+	return params;
+}
+async function dispatch(fetchers, collection, definition, action, route, args) {
+	switch (action) {
+		case "list": {
+			const rows = unwrapListResult(await fetchers.list(listParams(args)), definition.name);
+			return JSON.stringify(rows);
+		}
+		case "get": {
+			if (!fetchers.get) throw new Error(`${definition.name} has no get action`);
+			const row = unwrapItemResult(await fetchers.get(requireIdentifier(args)), `get(${definition.name})`);
+			return JSON.stringify(row);
+		}
+		case "create": {
+			const localId = newLocalId();
+			const row = unwrapItemResult(await settleTransaction(collection.insert({
+				...args,
+				id: localId
+			}), collection, localId, args), `create(${definition.name})`);
+			return JSON.stringify(row);
+		}
+		case "update": {
+			if (!fetchers.update) throw new Error(`${definition.name} has no update action`);
+			const { id: _id, ...body } = args;
+			await hydrateMutationTarget(fetchers, collection, definition, requireId(args, "update"));
+			const row = unwrapItemResult(await settleTransaction(collection.update(requireId(args, "update"), body), collection, requireId(args, "update"), body), `update(${definition.name})`);
+			return JSON.stringify(row);
+		}
+		case "delete": {
+			if (!fetchers.delete) throw new Error(`${definition.name} has no delete action`);
+			const id = requireId(args, "delete");
+			await hydrateMutationTarget(fetchers, collection, definition, id);
+			await settleTransaction(collection.delete(id), collection, id, {});
+			return JSON.stringify({
+				success: true,
+				id
+			});
+		}
+		default:
+			if (!fetchers.custom) throw new Error(`${definition.name} has no custom action fetcher`);
+			return JSON.stringify(await collection.action(action, args, route));
+	}
+}
+async function settleTransaction(transaction, collection, key, fallback) {
+	await transaction.isPersisted.promise;
+	const persisted = persistedMutationResults.get(collection)?.get(key);
+	if (persisted !== void 0) return persisted;
+	return collection.get(key) ?? {
+		...fallback,
+		id: key
+	};
+}
+async function hydrateMutationTarget(fetchers, collection, definition, id) {
+	if (!fetchers.get) throw new Error(`${definition.name} has no get action; cannot hydrate mutation target '${id}'`);
+	const row = unwrapItemResult(await fetchers.get(id), `get(${definition.name})`);
+	const hydrate = mutationTargetHydrators.get(collection);
+	if (!hydrate) throw new Error(`${definition.name} cannot hydrate mutation target '${id}'`);
+	await hydrate(row);
+}
+//#endregion
+//#region src/index.ts
+var CUSTOM_OPTIONS_QUERY_MARKER = "__smrt_options";
+var SmrtWebRequestError = class extends Error {
+	payload;
+	status;
+	code;
+	constructor(message, payload, status, code) {
+		super(message);
+		this.name = "SmrtWebRequestError";
+		this.payload = payload;
+		if (status !== void 0) this.status = status;
+		if (code !== void 0) this.code = code;
+	}
+};
+function getWebErrorDetail(payload) {
+	if (!payload || typeof payload !== "object") return {};
+	const error = payload.error;
+	if (typeof error === "string") return { message: error };
+	if (!error || typeof error !== "object" || Array.isArray(error)) return {};
+	const failure = error;
+	return {
+		message: typeof failure.message === "string" ? failure.message : void 0,
+		code: typeof failure.code === "string" ? failure.code : void 0
+	};
+}
+function createHttpRequestError(collectionName, status, payload) {
+	if (status >= 500) return new SmrtWebRequestError(`[smrt-web] ${collectionName} request failed: server error`, void 0, status);
+	const detail = getWebErrorDetail(payload);
+	return new SmrtWebRequestError(`[smrt-web] ${collectionName} request failed: ${detail.message ?? `HTTP ${status}`}`, payload, status, detail.code);
+}
+function unwrapListResult(result, collectionName) {
+	if (Array.isArray(result)) return result;
+	if (result && typeof result === "object") {
+		const record = result;
+		if (typeof record.error === "string") throw new SmrtWebRequestError(`[smrt-web] list(${collectionName}) failed: ${record.error}`, result);
+		if (Array.isArray(record.data)) return record.data;
+	}
+	throw new SmrtWebRequestError(`[smrt-web] list(${collectionName}) returned an unexpected payload shape`, result);
+}
+function unwrapItemResult(result, context) {
+	if (result && typeof result === "object" && !Array.isArray(result)) {
+		const record = result;
+		if (typeof record.error === "string") throw new SmrtWebRequestError(`[smrt-web] ${context} failed: ${record.error}`, result);
+		if (record.data && typeof record.data === "object" && !Array.isArray(record.data)) return record.data;
+		return record;
+	}
+	throw new SmrtWebRequestError(`[smrt-web] ${context} returned an unexpected payload shape`, result);
+}
+var SMRT_TO_REST_OPERATOR = {
+	">": "gt",
+	">=": "gte",
+	"<": "lt",
+	"<=": "lte",
+	"!=": "ne",
+	in: "in",
+	like: "like"
+};
+function buildListQuery(params) {
+	if (!params) return "";
+	const search = new URLSearchParams();
+	const { limit, offset, orderBy, where } = params;
+	if (limit !== void 0) search.set("limit", String(limit));
+	if (offset !== void 0) search.set("offset", String(offset));
+	if (orderBy !== void 0) search.set("orderBy", Array.isArray(orderBy) ? orderBy.join(", ") : String(orderBy));
+	if (where && typeof where === "object") {
+		for (const [field, condition] of Object.entries(where)) if (condition && typeof condition === "object" && !Array.isArray(condition) && "op" in condition && "value" in condition) {
+			const { op, value } = condition;
+			const restOp = SMRT_TO_REST_OPERATOR[op];
+			const token = Array.isArray(value) ? value.join(",") : String(value);
+			search.set(restOp ? `${field}[${restOp}]` : field, token);
+		} else if (condition !== void 0 && condition !== null) search.set(field, String(condition));
+	}
+	const qs = search.toString();
+	return qs ? `?${qs}` : "";
+}
+function createDefinitionFetchers(definition, basePath = "/api/v1", fetchFn = (...args) => globalThis.fetch(...args)) {
+	const collectionUrl = `${basePath}${definition.endpoint}`;
+	const headers = { "Content-Type": "application/json" };
+	const parse = async (response) => {
+		if (!response.ok) {
+			if (response.status >= 500) throw createHttpRequestError(definition.name, response.status);
+			const payload = await response.json().catch(() => null);
+			throw createHttpRequestError(definition.name, response.status, payload);
+		}
+		return response.json().catch(() => null);
+	};
+	return {
+		list: async (params) => parse(await fetchFn(`${collectionUrl}${buildListQuery(params)}`, { headers })),
+		get: async (id) => parse(await fetchFn(`${collectionUrl}/${id}`, { headers })),
+		create: async (data) => parse(await fetchFn(collectionUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(data)
+		})),
+		update: async (id, data) => parse(await fetchFn(`${collectionUrl}/${id}`, {
+			method: "PUT",
+			headers,
+			body: JSON.stringify(data)
+		})),
+		delete: async (id) => {
+			const response = await fetchFn(`${collectionUrl}/${id}`, {
+				method: "DELETE",
+				headers
+			});
+			if (!response.ok) {
+				if (response.status >= 500) throw createHttpRequestError(definition.name, response.status);
+				const payload = await response.json().catch(() => null);
+				throw createHttpRequestError(definition.name, response.status, payload);
+			}
+			return true;
+		},
+		custom: async (action, args, route) => {
+			const customRoute = route ?? {
+				method: "POST",
+				scope: typeof args.id === "string" ? "item" : "collection",
+				path: [action]
+			};
+			const optionsBag = customRoute.optionsBag === true;
+			const optionsValue = optionsBag ? args.options : void 0;
+			const transportArgs = optionsBag && optionsValue !== null && typeof optionsValue === "object" ? optionsValue : args;
+			const pathArgs = new Set(customRoute.path.filter((segment) => /^\[[^\]]+\]$/.test(segment)).map((segment) => segment.slice(1, -1)));
+			const parameterAliases = customRoute.parameterAliases ?? {};
+			const inputNameFor = (parameterName) => Object.entries(parameterAliases).find(([, originalName]) => originalName === parameterName)?.[0] ?? parameterName;
+			const valueForPath = (parameterName) => {
+				return args[inputNameFor(parameterName)] ?? args[parameterName];
+			};
+			const id = customRoute.scope === "item" ? args.id : void 0;
+			if (customRoute.scope === "item" && typeof id !== "string") throw new Error(`${definition.name} custom action '${action}' requires an id`);
+			for (const name of pathArgs) if (valueForPath(name) === void 0 || valueForPath(name) === null) throw new Error(`${definition.name} custom action '${action}' requires '${name}'`);
+			const consumedInputs = new Set([...pathArgs].map((name) => inputNameFor(name)));
+			const aliasedInputs = new Set(Object.keys(parameterAliases));
+			const body = optionsBag ? optionsValue : Object.fromEntries(Object.entries(transportArgs).filter(([key]) => key !== "id" && !pathArgs.has(key) && !consumedInputs.has(key) && !aliasedInputs.has(key)));
+			if (!optionsBag) {
+				for (const [inputName, originalName] of Object.entries(parameterAliases)) if (!consumedInputs.has(inputName) && transportArgs[inputName] !== void 0 && originalName !== "id") body[originalName] = transportArgs[inputName];
+			}
+			const idAlias = Object.entries(parameterAliases).find(([, originalName]) => originalName === "id")?.[0];
+			if (!optionsBag && idAlias && !consumedInputs.has(idAlias) && transportArgs[idAlias] !== void 0) body.id = transportArgs[idAlias];
+			const requestPath = `${[
+				collectionUrl,
+				...customRoute.scope === "item" ? [encodeURIComponent(String(id))] : [],
+				...customRoute.path.map((segment) => /^\[[^\]]+\]$/.test(segment) ? encodeURIComponent(String(valueForPath(segment.slice(1, -1)) ?? "")) : segment)
+			].join("/")}`;
+			const init = {
+				method: customRoute.method,
+				headers
+			};
+			if (customRoute.method !== "GET") init.body = JSON.stringify(body);
+			else {
+				const queryParams = new URLSearchParams();
+				if (optionsBag) if (optionsValue === void 0) queryParams.set(CUSTOM_OPTIONS_QUERY_MARKER, "undefined");
+				else if (optionsValue === null) queryParams.set(CUSTOM_OPTIONS_QUERY_MARKER, "null");
+				else {
+					const entries = Object.entries(typeof optionsValue === "object" && !Array.isArray(optionsValue) ? optionsValue : {}).filter(([, value]) => value !== void 0 && value !== null);
+					for (const [key, value] of entries) queryParams.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+					if (entries.length === 0) queryParams.set(CUSTOM_OPTIONS_QUERY_MARKER, "object");
+				}
+				else {
+					const queryBody = body !== null && typeof body === "object" && !Array.isArray(body) ? body : {};
+					for (const [key, value] of Object.entries(queryBody)) {
+						if (value === void 0 || value === null) continue;
+						queryParams.set(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+					}
+				}
+				const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
+				return parse(await fetchFn(`${requestPath}${query}`, { ...init }));
+			}
+			return parse(await fetchFn(requestPath, init));
+		}
+	};
+}
+function newLocalId() {
+	const cryptoRef = globalThis.crypto;
+	if (cryptoRef?.randomUUID) return cryptoRef.randomUUID();
+	return `local-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function createSmrtWebClient() {
+	return {
+		__smrtWebClient: "SmrtWebClient",
+		queryClient: new QueryClient()
+	};
+}
+function resolveQueryClient(client) {
+	if (!client) return new QueryClient();
+	const engine = client;
+	if (engine.__smrtWebClient !== "SmrtWebClient" || !engine.queryClient) throw new SmrtWebRequestError("[smrt-web] options.client must be a handle from createSmrtWebClient()");
+	return engine.queryClient;
+}
+function toPlainRow(row) {
+	const plain = {};
+	for (const [key, value] of Object.entries(row)) if (key.charCodeAt(0) !== 36) plain[key] = value;
+	return plain;
+}
+function projectChanges(changes) {
+	if (!Array.isArray(changes)) return changes;
+	return changes.map((change) => {
+		if (!change || typeof change !== "object") return change;
+		const record = change;
+		const projected = { ...record };
+		if (record.value && typeof record.value === "object") projected.value = toPlainRow(record.value);
+		if (record.previousValue && typeof record.previousValue === "object") projected.previousValue = toPlainRow(record.previousValue);
+		return projected;
+	});
+}
+function getBaseUpdatedAt(row) {
+	if (!row || typeof row !== "object") return void 0;
+	const record = row;
+	const value = record.updatedAt ?? record.updated_at;
+	if (typeof value === "string") return value;
+	if (value instanceof Date) return value.toISOString();
+}
+var engineCollections = /* @__PURE__ */ new WeakMap();
+function getEngineCollection(handle) {
+	const engine = engineCollections.get(handle);
+	if (engine === void 0) throw new SmrtWebRequestError("[smrt-web] getEngineCollection: not a smrt-web collection handle");
+	return engine;
+}
+function warnCapability(capability, hook, error) {
+	console.warn(`[smrt-web] capability "${capability.name}" ${hook} threw; ignoring`, error);
+}
+function createSmrtCollection(definition, options) {
+	const { staleTimeMs = 3e4, retry = false, scope, initialData } = options;
+	const capabilities = options.capabilities ?? [];
+	const fetchers = options.fetchers ?? createDefinitionFetchers(definition, options.basePath, options.fetchFn);
+	const queryClient = resolveQueryClient(options.client);
+	const idField = definition.idField || "id";
+	const mutationResults = /* @__PURE__ */ new Map();
+	let cacheId = scope ? `smrt:${scope}:${definition.name}` : `smrt:${definition.name}`;
+	let queryKey = scope ? [
+		"smrt",
+		scope,
+		definition.name
+	] : ["smrt", definition.name];
+	const invalidationTargets = /* @__PURE__ */ new Set([definition.name]);
+	for (const relationship of definition.relationships ?? []) invalidationTargets.add(relationship.relatedCollection);
+	const invalidateRelated = () => {
+		queryClient.invalidateQueries({ predicate: (query) => {
+			const key = query.queryKey;
+			if (!Array.isArray(key) || key.length === 0) return false;
+			const collectionSegment = key[key.length - 1];
+			return typeof collectionSegment === "string" && invalidationTargets.has(collectionSegment);
+		} });
+	};
+	const ctx = {
+		definition,
+		fetchers,
+		get cacheKey() {
+			return queryKey;
+		},
+		get cacheId() {
+			return cacheId;
+		},
+		invalidate: () => invalidateRelated(),
+		snapshot: () => collection.toArray.map((row) => toPlainRow(row)),
+		subscribe: (callback) => {
+			const subscription = collection.subscribeChanges((changes) => callback(projectChanges(changes)));
+			return { unsubscribe: () => subscription.unsubscribe() };
+		}
+	};
+	for (const capability of capabilities) {
+		let extra;
+		try {
+			extra = capability.contributeCacheKey?.(ctx);
+		} catch (error) {
+			warnCapability(capability, "contributeCacheKey", error);
+		}
+		if (extra && extra.length > 0) {
+			const name = queryKey[queryKey.length - 1];
+			queryKey = [
+				...queryKey.slice(0, -1),
+				...extra,
+				name
+			];
+			cacheId = `${cacheId}:${extra.join(":")}`;
+		}
+	}
+	const seedCache = (rows) => {
+		queryClient.setQueryData(queryKey, (existing) => existing ?? rows);
+	};
+	let disposed = false;
+	const warmRowsFrom = async (capability, warm) => {
+		try {
+			return await warm;
+		} catch (error) {
+			warnCapability(capability, "warmStart", error);
+			return;
+		}
+	};
+	let warmStartPending;
+	if (initialData !== void 0) seedCache(initialData);
+	else for (let i = 0; i < capabilities.length; i += 1) {
+		const capability = capabilities[i];
+		let warm;
+		try {
+			warm = capability.warmStart?.(ctx);
+		} catch (error) {
+			warnCapability(capability, "warmStart", error);
+			continue;
+		}
+		if (warm === void 0) continue;
+		if (warm instanceof Promise) {
+			const firstPromise = warm;
+			warmStartPending = (async () => {
+				let rows = await warmRowsFrom(capability, firstPromise);
+				for (let j = i + 1; rows === void 0 && j < capabilities.length; j += 1) {
+					const later = capabilities[j];
+					let laterWarm;
+					try {
+						laterWarm = later.warmStart?.(ctx);
+					} catch (error) {
+						warnCapability(later, "warmStart", error);
+						continue;
+					}
+					if (laterWarm === void 0) continue;
+					rows = await warmRowsFrom(later, laterWarm);
+				}
+				if (rows !== void 0 && !disposed) seedCache(rows);
+			})();
+			break;
+		}
+		seedCache(warm);
+		break;
+	}
+	const notifySettled = (envelope, outcome) => {
+		for (const capability of capabilities) try {
+			capability.onSettled?.(envelope, outcome, ctx);
+		} catch (error) {
+			warnCapability(capability, "onSettled", error);
+		}
+	};
+	const persistMutation = async (envelope, runFetcher) => {
+		try {
+			const wrapped = await runWrapMutation(capabilities, envelope, ctx);
+			const result = wrapped.handled ? wrapped.result : await runFetcher();
+			notifySettled(envelope, {
+				ok: true,
+				result
+			});
+			return {
+				handled: wrapped.handled,
+				result
+			};
+		} catch (error) {
+			notifySettled(envelope, {
+				ok: false,
+				error
+			});
+			throw error;
+		}
+	};
+	const collection = createCollection(queryCollectionOptions({
+		id: cacheId,
+		queryKey,
+		queryClient,
+		staleTime: staleTimeMs,
+		retry,
+		queryFn: async () => unwrapListResult(await fetchers.list(), definition.name),
+		getKey: (row) => String(row[idField]),
+		onInsert: async ({ transaction }) => {
+			let anyHandled = false;
+			for (const mutation of transaction.mutations) {
+				const modified = mutation.modified;
+				const envelope = {
+					kind: "insert",
+					key: String(modified[idField]),
+					data: modified
+				};
+				const outcome = await persistMutation(envelope, async () => {
+					const { [idField]: _localId, ...data } = modified;
+					return unwrapItemResult(await fetchers.create(data), `create(${definition.name})`);
+				});
+				mutationResults.set(envelope.key, outcome.result);
+				anyHandled = anyHandled || outcome.handled;
+			}
+			if (anyHandled) return { refetch: false };
+			invalidateRelated();
+		},
+		onUpdate: fetchers.update ? async ({ transaction }) => {
+			let anyHandled = false;
+			for (const mutation of transaction.mutations) {
+				const key = String(mutation.key);
+				const changes = mutation.changes;
+				const envelope = {
+					kind: "update",
+					key,
+					data: changes,
+					baseUpdatedAt: getBaseUpdatedAt(mutation.original)
+				};
+				const outcome = await persistMutation(envelope, async () => unwrapItemResult(await fetchers.update(key, changes), `update(${definition.name})`));
+				mutationResults.set(envelope.key, outcome.result);
+				anyHandled = anyHandled || outcome.handled;
+			}
+			if (anyHandled) return { refetch: false };
+			invalidateRelated();
+		} : void 0,
+		onDelete: fetchers.delete ? async ({ transaction }) => {
+			let anyHandled = false;
+			for (const mutation of transaction.mutations) {
+				const key = String(mutation.key);
+				const envelope = {
+					kind: "delete",
+					key,
+					data: {},
+					baseUpdatedAt: getBaseUpdatedAt(mutation.original)
+				};
+				const outcome = await persistMutation(envelope, async () => fetchers.delete(key));
+				mutationResults.set(envelope.key, outcome.result);
+				anyHandled = anyHandled || outcome.handled;
+			}
+			if (anyHandled) return { refetch: false };
+			invalidateRelated();
+		} : void 0
+	}));
+	const handle = {
+		get toArray() {
+			return collection.toArray.map((row) => toPlainRow(row));
+		},
+		get size() {
+			return collection.size;
+		},
+		has(key) {
+			return collection.has(key);
+		},
+		get(key) {
+			const row = collection.get(key);
+			return row === void 0 ? void 0 : toPlainRow(row);
+		},
+		preload() {
+			if (!warmStartPending) return collection.preload();
+			return warmStartPending.then(() => {
+				if (disposed) return;
+				return collection.preload();
+			});
+		},
+		async cleanup() {
+			disposed = true;
+			await collection.cleanup();
+			for (const capability of capabilities) try {
+				await capability.teardown?.(ctx);
+			} catch (error) {
+				warnCapability(capability, "teardown", error);
+			}
+		},
+		subscribeChanges(callback) {
+			const subscription = collection.subscribeChanges((changes) => callback(projectChanges(changes)));
+			return { unsubscribe: () => subscription.unsubscribe() };
+		},
+		insert(row) {
+			return collection.insert(row);
+		},
+		update(key, changes) {
+			if (!fetchers.update) throw new Error(`${definition.name} has no update action`);
+			const { id: _id, ...safeChanges } = changes;
+			return collection.update(key, (draft) => {
+				Object.assign(draft, safeChanges);
+			});
+		},
+		delete(key) {
+			if (!fetchers.delete) throw new Error(`${definition.name} has no delete action`);
+			return collection.delete(key);
+		},
+		async action(action, args, route) {
+			if (!fetchers.custom) throw new Error(`${definition.name} has no custom action fetcher`);
+			const result = route === void 0 ? await fetchers.custom(action, args) : await fetchers.custom(action, args, route);
+			invalidateRelated();
+			return result;
+		}
+	};
+	persistedMutationResults.set(handle, mutationResults);
+	mutationTargetHydrators.set(handle, async (row) => {
+		await collection.preload();
+		collection.utils.writeUpsert(row);
+	});
+	engineCollections.set(handle, collection);
+	for (const capability of capabilities) try {
+		capability.onAttach?.(ctx);
+	} catch (error) {
+		warnCapability(capability, "onAttach", error);
+	}
+	return handle;
+}
+//#endregion
+export { executeSmrtWebDataQuery as A, MAX_SMRT_WEB_DATA_QUERY_FACET_VALUES as C, MAX_SMRT_WEB_DATA_QUERY_ROWS as D, MAX_SMRT_WEB_DATA_QUERY_RESULT_BYTES as E, runWrapMutation as M, MAX_SMRT_WEB_DATA_QUERY_STRING_LENGTH as O, MAX_SMRT_WEB_DATA_QUERY_FACETS as S, MAX_SMRT_WEB_DATA_QUERY_PAGE_LIMIT as T, offlineOutbox as _, createSmrtWebClient as a, wipeDurableStore as b, unwrapItemResult as c, createUpdateState as d, createSmrtWebEventSubscriber as f, getOutboxHandle as g, persistCollection as h, createSmrtCollection as i, normalizeSmrtWebDataQueryResult as j, MAX_SMRT_WEB_DATA_QUERY_WARNINGS as k, unwrapListResult as l, DEFAULT_PERSIST_DEBOUNCE_MS as m, buildListQuery as n, getEngineCollection as o, liveInvalidation as p, createDefinitionFetchers as r, newLocalId as s, SmrtWebRequestError as t, registerWebMcpTools as u, durableStoreNamespace as v, MAX_SMRT_WEB_DATA_QUERY_OFFSET as w, MAX_SMRT_WEB_DATA_QUERY_CONTAINER_ITEMS as x, registerDurableResource as y };
+
+//# sourceMappingURL=src-CDdW9uYx.js.map