@craftainer/crud-sdk 0.0.0-stage → 0.1.0

package/dist/cache/index.mjs

@@ -0,0 +1,972 @@
+import { n as cacheScope, t as ANON } from "../auth-DwtNEKrw.mjs";
+import { i as tanstackCachePolicy, n as subscribeEvents, r as cachePolicyFromManifest, t as getEventHub } from "../events-Cqj9Rbon.mjs";
+//#region src/cache/entry.ts
+const statuses = /* @__PURE__ */ new WeakMap();
+/**
+* How the cache answered `response`: `hit` (fresh, no network), `stale`
+* (inside the stale-while-revalidate window, refreshed in the background),
+* `revalidated` (a `304` rebuilt from the stored entry) or `miss`.
+* `undefined` when the cache did not handle the request.
+*/
+function cacheStatus(response) {
+	return statuses.get(response);
+}
+/** Tag `response` with how the cache answered. */
+function tagStatus(response, status) {
+	statuses.set(response, status);
+	return response;
+}
+const TRANSFER_HEADERS = /* @__PURE__ */ new Set([
+	"content-length",
+	"content-encoding",
+	"transfer-encoding",
+	"connection",
+	"keep-alive"
+]);
+const VARY_OK = /* @__PURE__ */ new Set([
+	"authorization",
+	"accept",
+	"accept-encoding"
+]);
+/** The lower-cased directive names of the `Cache-Control` header. */
+function cacheControl(headers) {
+	const names = (headers.get("cache-control") ?? "").split(",").map((part) => part.split("=", 1)[0].trim().toLowerCase()).filter((name) => name !== "");
+	return new Set(names);
+}
+/** Whether the media type is JSON (`application/json` or `+json`). */
+function isJson(response) {
+	const media = (response.headers.get("content-type") ?? "").split(";", 1)[0].trim().toLowerCase();
+	return media === "application/json" || media.endsWith("+json");
+}
+/** `Vary` may only name headers the key already accounts for; `*` never caches. */
+function varyAllowsCaching(response) {
+	return (response.headers.get("vary") ?? "").split(",").map((part) => part.trim().toLowerCase()).filter((name) => name !== "").every((name) => VARY_OK.has(name));
+}
+function storableHeaders(headers) {
+	const items = [];
+	for (const [name, value] of headers) if (!TRANSFER_HEADERS.has(name)) items.push([name, value]);
+	return items;
+}
+/** Snapshot a read response whose body text was already read. */
+function buildEntry(response, body, times, keepEtag) {
+	const etag = keepEtag ? response.headers.get("etag") : null;
+	const base = {
+		status: response.status,
+		headers: storableHeaders(response.headers),
+		body,
+		storedAt: times.now,
+		freshUntil: times.now + times.fresh,
+		staleUntil: times.now + times.fresh + times.stale
+	};
+	return etag === null ? base : {
+		...base,
+		etag
+	};
+}
+/** RFC 9111 4.3.4: headers of a `304` replace the stored ones of the same name. */
+function mergeHeaders(stored, update) {
+	const fresh = storableHeaders(update);
+	const replaced = new Set(fresh.map(([name]) => name));
+	return [...stored.filter(([name]) => !replaced.has(name)), ...fresh];
+}
+/** Rebuild a response from an entry, tagged with how the cache produced it. */
+function toResponse(entry, status) {
+	const headers = new Headers();
+	for (const [name, value] of entry.headers) headers.append(name, value);
+	return tagStatus(new Response(entry.body, {
+		status: entry.status,
+		headers
+	}), status);
+}
+//#endregion
+//#region src/cache/keys.ts
+const KINDS = /* @__PURE__ */ new Set([
+	"list",
+	"record",
+	"stats",
+	"predict",
+	"revisions",
+	"filters"
+]);
+const STATS_KINDS = /* @__PURE__ */ new Set(["stats", "predict"]);
+const COLLECTION_KINDS = [
+	"list",
+	"stats",
+	"predict"
+];
+const PER_RECORD_KINDS = ["record", "revisions"];
+/** `true` when the op is a cacheable read kind. */
+function isCacheKind(op) {
+	return KINDS.has(op);
+}
+/** `true` for `stats` and `predict`, which `stats_ttl` bounds. */
+function isStatsKind(kind) {
+	return STATS_KINDS.has(kind);
+}
+/**
+* Sorts the query pairs the client sent and drops `id` (it is the subject).
+* Values are kept verbatim: the client already emits canonical,
+* percent-encoded text, so nothing is decoded or re-encoded here.
+*/
+function canonicalQuery(query) {
+	const pairs = (query.startsWith("?") ? query.slice(1) : query).split("&").filter((part) => part !== "" && part.split("=", 1)[0] !== "id").map((part) => {
+		const at = part.indexOf("=");
+		return at < 0 ? [part, ""] : [part.slice(0, at), part.slice(at)];
+	});
+	pairs.sort(([an, av], [bn, bv]) => an === bn ? av < bv ? -1 : av > bv ? 1 : 0 : an < bn ? -1 : 1);
+	return pairs.map(([name, rest]) => name + rest).join("&");
+}
+/** The key of one cached response. */
+function buildKey(parts) {
+	const subject = (parts.kind === "record" || parts.kind === "revisions") && parts.recordId !== void 0 ? String(parts.recordId) : "_";
+	const version = parts.apiVersion ?? "_";
+	return `v1/${parts.resource}/${parts.kind}/${subject}/${version}/${parts.scope}/${canonicalQuery(parts.query ?? "")}`;
+}
+/** Key of the manifest document for one caller scope. */
+function manifestKey(scope) {
+	return `v1/_manifest/${scope}`;
+}
+/** Prefix of all entries of one kind for `resource` (every scope and subject). */
+function kindPrefix(resource, kind) {
+	return `v1/${resource}/${kind}/`;
+}
+/** Prefix of the `record` entries of one record (every version, scope, query). */
+function recordPrefix(resource, recordId) {
+	return `v1/${resource}/record/${recordId}/`;
+}
+/** Prefix of the `revisions` entries of one record. */
+function revisionsPrefix(resource, recordId) {
+	return `v1/${resource}/revisions/${recordId}/`;
+}
+/** The list, stats and predict prefixes of `resource`. */
+function collectionPrefixes(resource) {
+	return COLLECTION_KINDS.map((kind) => kindPrefix(resource, kind));
+}
+/** Everything cached for `resource` except `filters` (a reconnect or an unknown change). */
+function resourcePrefixes(resource) {
+	return [...COLLECTION_KINDS, ...PER_RECORD_KINDS].map((kind) => kindPrefix(resource, kind));
+}
+/**
+* Prefixes an SSE event clears, per the spec's table: `create` clears the
+* collection kinds; `update`/`delete`/`restore` also clear the record and its
+* revisions; an unknown action or a missing record id clears the resource.
+*/
+function eventPrefixes(resource, action, recordId) {
+	if (action === "create") return collectionPrefixes(resource);
+	if ((action === "update" || action === "delete" || action === "restore") && recordId !== void 0) return [
+		...collectionPrefixes(resource),
+		recordPrefix(resource, recordId),
+		revisionsPrefix(resource, recordId)
+	];
+	return resourcePrefixes(resource);
+}
+//#endregion
+//#region src/cache/scope.ts
+/**
+* `"anon"` when the request has no Authorization header; otherwise the first
+* 32 hex characters of the SHA-256 of the whole credential, the same digest as
+* the client's `cacheScope(token)` (a `Bearer ` prefix is dropped, any other value is hashed as it is). It is read from the
+* request the cache sees, so it must be the innermost middleware that matters:
+* whatever sets Authorization has to run before the cache. The raw credential
+* never enters a key or a log, and the unverified `sub` claim is never used.
+*/
+async function credentialScope(headers) {
+	const value = headers.get("authorization");
+	if (value === null) return ANON;
+	const credential = /^bearer\s+(.+)$/i.exec(value)?.[1] ?? value;
+	return cacheScope(credential);
+}
+//#endregion
+//#region src/cache/middleware.ts
+const MIN_RETENTION_MS = 36e5;
+const MANIFEST_POLICY = cachePolicyFromManifest({});
+const WRITE_METHODS = /* @__PURE__ */ new Set([
+	"POST",
+	"PATCH",
+	"PUT",
+	"DELETE"
+]);
+const BULK_OPS = /* @__PURE__ */ new Set(["bulk_update", "bulk_delete"]);
+const RECORD_WRITES = /* @__PURE__ */ new Set([
+	"delete",
+	"publish",
+	"restore"
+]);
+const CREATES = /* @__PURE__ */ new Set([
+	"create",
+	"clone",
+	"draft"
+]);
+function isStorable(response) {
+	return isJson(response) && !cacheControl(response.headers).has("no-store") && varyAllowsCaching(response);
+}
+function retentionMs(freshMs, staleMs) {
+	return Math.max(freshMs + staleMs, MIN_RETENTION_MS);
+}
+/** The ids of a bulk response (`{matched, ids}`), or `undefined` if unreadable. */
+function idsFromBody(body) {
+	try {
+		const ids = JSON.parse(body).ids;
+		return Array.isArray(ids) && ids.every((id) => Number.isInteger(id)) ? ids : void 0;
+	} catch {
+		return;
+	}
+}
+/** The resource names in a manifest document, or none if unreadable. */
+function manifestResources(body) {
+	try {
+		const resources = JSON.parse(body).resources;
+		return Array.isArray(resources) ? resources.map((item) => item.name).filter((name) => typeof name === "string") : [];
+	} catch {
+		return [];
+	}
+}
+async function safe(call) {
+	try {
+		return await call();
+	} catch {
+		return;
+	}
+}
+function createCache(options) {
+	const { store } = options;
+	const policies = new Map(Object.entries(options.policies));
+	const policyFor = (resource, apiVersion) => resource === void 0 ? void 0 : policies.get(`${resource}@${apiVersion}`) ?? policies.get(resource);
+	const cacheManifest = options.cacheManifest ?? true;
+	const now = options.now ?? Date.now;
+	const eventsActive = /* @__PURE__ */ new Set();
+	const generations = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Set();
+	const tasks = /* @__PURE__ */ new Set();
+	const background = new AbortController();
+	let globalGeneration = 0;
+	const generation = (resource) => (generations.get(resource ?? "") ?? 0) + globalGeneration;
+	const bump = (resource) => {
+		generations.set(resource, generation(resource) + 1);
+	};
+	/**
+	* Whether an entry of `kind` may be served without the network right now:
+	* only while the stream is up, except `stats`/`predict`, which `stats_ttl`
+	* bounds on its own. Never `filters` (events never clear them) or the manifest.
+	*/
+	const gateOpen = (policy, resource, kind) => !policy.revalidateOnly && kind !== "manifest" && kind !== "filters" && (isStatsKind(kind) || eventsActive.has(resource));
+	/** Stale-while-revalidate needs the stream for every kind, stats and predict included. */
+	const staleOpen = (policy, resource, kind) => gateOpen(policy, resource, kind) && eventsActive.has(resource);
+	/** Milliseconds fresh and of stale-while-revalidate for a new entry; none if the response may predate an invalidation. */
+	const entryTimes = (state, kind) => {
+		const resource = state.ctx.resource;
+		if (generation(resource) !== state.generation || !gateOpen(state.policy, resource, kind)) return {
+			fresh: 0,
+			stale: 0
+		};
+		return {
+			fresh: (isStatsKind(kind) ? state.policy.statsTtl : state.policy.maxAge) * 1e3,
+			stale: staleOpen(state.policy, resource, kind) ? state.policy.staleWhileRevalidate * 1e3 : 0
+		};
+	};
+	const decide = (state, entry) => {
+		if (entry === void 0) return "miss";
+		if (!state.forceRevalidate && gateOpen(state.policy, state.ctx.resource, state.kind)) {
+			const at = now();
+			if (at < entry.freshUntil) return "hit";
+			if (at < entry.staleUntil && staleOpen(state.policy, state.ctx.resource, state.kind)) return "stale";
+		}
+		return entry.etag !== void 0 && state.policy.etag ? "revalidate" : "miss";
+	};
+	const begin = async (ctx) => {
+		const { request, resource } = ctx;
+		const scope = await credentialScope(request.headers);
+		const generationNow = generation(resource);
+		if (request.method !== "GET") {
+			if (!WRITE_METHODS.has(request.method)) return;
+			const policy = policyFor(resource, ctx.apiVersion);
+			return policy?.enabled === true ? {
+				ctx,
+				policy,
+				kind: void 0,
+				key: void 0,
+				generation: generationNow,
+				scope,
+				forceRevalidate: false
+			} : void 0;
+		}
+		let policy;
+		let kind;
+		let key;
+		if (ctx.op === "manifest") {
+			if (!cacheManifest) return;
+			policy = MANIFEST_POLICY;
+			kind = "manifest";
+			key = manifestKey(scope);
+		} else {
+			policy = policyFor(resource, ctx.apiVersion);
+			if (resource === void 0 || policy?.enabled !== true || !isCacheKind(ctx.op)) return;
+			kind = ctx.op;
+			key = buildKey({
+				resource,
+				kind,
+				recordId: ctx.recordId,
+				scope,
+				query: new URL(request.url).search,
+				apiVersion: ctx.apiVersion
+			});
+		}
+		const control = cacheControl(request.headers);
+		if (control.has("no-store") || request.headers.has("if-none-match")) return;
+		return {
+			ctx,
+			policy,
+			kind,
+			key,
+			generation: generationNow,
+			scope,
+			forceRevalidate: control.has("no-cache")
+		};
+	};
+	/** A copy of `ctx` whose request carries our validator (a `GET` has no body to lose). */
+	const withValidator = (ctx, etag) => {
+		const headers = new Headers(ctx.request.headers);
+		headers.set("if-none-match", etag);
+		return {
+			...ctx,
+			request: new Request(ctx.request, { headers })
+		};
+	};
+	const readBody = async (state, response) => {
+		const { status } = response;
+		const { op, recordId } = state.ctx;
+		let wanted;
+		if (state.kind !== void 0) wanted = status === 200 && isStorable(response);
+		else if (op === "update") wanted = status === 200 && recordId !== void 0 && isStorable(response);
+		else wanted = status >= 200 && status < 300 && (BULK_OPS.has(op) || op === "restore" && recordId === void 0);
+		return wanted ? response.clone().text() : void 0;
+	};
+	/** One clear op for all `prefixes`: the store clears them in a single pass. */
+	const clears = (prefixes) => [{
+		type: "clear",
+		prefixes
+	}];
+	const manifestOps = (old, entry) => {
+		if (old === void 0 || old.etag !== void 0 && old.etag === entry.etag) return [];
+		const names = /* @__PURE__ */ new Set([
+			...[...policies.keys()].map((key) => key.replace(/@[^@]*$/, "")),
+			...manifestResources(old.body),
+			...manifestResources(entry.body)
+		]);
+		return clears([...names].sort().map((name) => kindPrefix(name, "filters")));
+	};
+	const readPlan = (state, response, body) => {
+		const key = state.key;
+		const kind = state.kind;
+		const { status } = response;
+		const at = now();
+		const { fresh, stale } = entryTimes(state, kind);
+		const old = state.entry;
+		if (status === 304 && state.validated === true && old !== void 0) {
+			const updated = {
+				...old,
+				headers: mergeHeaders(old.headers, response.headers),
+				storedAt: at,
+				freshUntil: at + fresh,
+				staleUntil: at + fresh + stale,
+				etag: response.headers.get("etag") ?? old.etag
+			};
+			return {
+				result: toResponse(updated, "revalidated"),
+				ops: [{
+					type: "set",
+					key,
+					entry: updated,
+					ttlMs: retentionMs(fresh, stale)
+				}]
+			};
+		}
+		if (status === 200 && body !== void 0) {
+			tagStatus(response, "miss");
+			const entry = buildEntry(response, body, {
+				now: at,
+				fresh,
+				stale
+			}, state.policy.etag);
+			if (entry.etag === void 0 && fresh <= 0) return {
+				result: response,
+				ops: [{
+					type: "delete",
+					key
+				}]
+			};
+			const ops = [{
+				type: "set",
+				key,
+				entry,
+				ttlMs: retentionMs(fresh, stale)
+			}];
+			if (kind === "manifest") ops.push(...manifestOps(old, entry));
+			return {
+				result: response,
+				ops
+			};
+		}
+		if (status === 200 || status === 404 || status === 410) return {
+			result: response,
+			ops: [{
+				type: "delete",
+				key
+			}]
+		};
+		return {
+			result: response,
+			ops: []
+		};
+	};
+	/** Store the PATCH response as the record's entry (it is the read view plus ETag). */
+	const writeThrough = (state, response, body, resource, recordId) => {
+		if (body === void 0) return [];
+		const { fresh, stale } = entryTimes(state, "record");
+		const entry = buildEntry(response, body, {
+			now: now(),
+			fresh,
+			stale
+		}, state.policy.etag);
+		if (entry.etag === void 0 && fresh <= 0) return [];
+		return [{
+			type: "set",
+			key: buildKey({
+				resource,
+				kind: "record",
+				recordId,
+				scope: state.scope,
+				apiVersion: state.ctx.apiVersion
+			}),
+			entry,
+			ttlMs: retentionMs(fresh, stale)
+		}];
+	};
+	const writeOps = (state, response, body) => {
+		const { op, recordId } = state.ctx;
+		const resource = state.ctx.resource;
+		const { status } = response;
+		if (status === 412) return recordId === void 0 ? [] : clears([recordPrefix(resource, recordId)]);
+		if (status < 200 || status >= 300) return [];
+		const collections = collectionPrefixes(resource);
+		if (CREATES.has(op)) return clears(collections);
+		if (recordId !== void 0 && (RECORD_WRITES.has(op) || op === "update")) return [...clears([
+			...collections,
+			revisionsPrefix(resource, recordId),
+			recordPrefix(resource, recordId)
+		]), ...op === "update" ? writeThrough(state, response, body, resource, recordId) : []];
+		if (BULK_OPS.has(op) || op === "restore") {
+			const ids = idsFromBody(body);
+			if (ids !== void 0) return clears([...collections, ...ids.flatMap((id) => [recordPrefix(resource, id), revisionsPrefix(resource, id)])]);
+		}
+		return clears(resourcePrefixes(resource));
+	};
+	/** One pass when the store can, else one `clear` per prefix; a failure is a miss. */
+	const clearPrefixes = async (prefixes) => {
+		if (store.clearMany !== void 0) {
+			await safe(() => store.clearMany?.(prefixes));
+			return;
+		}
+		for (const prefix of prefixes) await safe(() => store.clear(prefix));
+	};
+	const apply = async (op) => {
+		await safe(() => op.type === "clear" ? clearPrefixes(op.prefixes) : op.type === "set" ? store.set(op.key, op.entry, op.ttlMs) : store.delete(op.key));
+	};
+	/** Plan, then apply, the store changes a response calls for. */
+	const finish = async (state, response) => {
+		const body = await readBody(state, response);
+		const { result, ops } = state.kind === void 0 ? {
+			result: response,
+			ops: writeOps(state, response, body)
+		} : readPlan(state, response, body);
+		if (state.kind === void 0 && ops.some((op) => op.type === "clear")) bump(state.ctx.resource);
+		const expected = generation(state.ctx.resource);
+		for (const op of ops) await apply(op);
+		if (generation(state.ctx.resource) !== expected) for (const op of ops.filter((candidate) => candidate.type === "set")) await apply({
+			type: "delete",
+			key: op.key
+		});
+		return result;
+	};
+	const schedule = (state, next) => {
+		const key = state.key;
+		if (background.signal.aborted || inflight.has(key)) return;
+		inflight.add(key);
+		const entry = state.entry;
+		const task = (async () => {
+			try {
+				const signal = background.signal;
+				const headers = new Headers(state.ctx.request.headers);
+				if (entry.etag !== void 0) headers.set("if-none-match", entry.etag);
+				const request = new Request(state.ctx.request.url, {
+					method: "GET",
+					headers,
+					signal
+				});
+				const fresh = {
+					...state,
+					validated: entry.etag !== void 0
+				};
+				const response = await next({
+					...state.ctx,
+					request,
+					signal
+				});
+				await (await finish(fresh, response)).body?.cancel();
+			} catch {} finally {
+				inflight.delete(key);
+			}
+		})();
+		tasks.add(task);
+		task.then(() => tasks.delete(task));
+	};
+	const middleware = async (ctx, next) => {
+		const state = await begin(ctx);
+		if (state === void 0) return next(ctx);
+		if (state.kind === void 0) return finish(state, await next(ctx));
+		state.entry = await safe(() => store.get(state.key));
+		const decision = decide(state, state.entry);
+		const entry = state.entry;
+		if (decision === "hit") return toResponse(entry, "hit");
+		if (decision === "stale") {
+			schedule(state, next);
+			return toResponse(entry, "stale");
+		}
+		let sent = ctx;
+		if (decision === "revalidate") {
+			sent = withValidator(ctx, entry.etag);
+			state.validated = true;
+		}
+		return finish(state, await next(sent));
+	};
+	const autoIfMatch = async (ctx, next) => {
+		const { request, resource, recordId } = ctx;
+		if ((ctx.op === "update" || ctx.op === "delete") && recordId !== void 0 && resource !== void 0 && policyFor(resource, ctx.apiVersion)?.enabled === true && !request.headers.has("if-match")) {
+			const etag = await lookupEtag(resource, recordId, await credentialScope(request.headers), ctx.apiVersion);
+			if (etag !== void 0) {
+				const headers = new Headers(request.headers);
+				headers.set("if-match", etag);
+				return next({
+					...ctx,
+					request: new Request(request, { headers })
+				});
+			}
+		}
+		return next(ctx);
+	};
+	const lookupEtag = async (resource, recordId, scope, apiVersion) => {
+		return (await safe(() => store.get(buildKey({
+			resource,
+			kind: "record",
+			recordId,
+			scope,
+			apiVersion
+		}))))?.etag;
+	};
+	return {
+		middleware,
+		autoIfMatch,
+		setEventsActive(resource, active) {
+			if (active) eventsActive.add(resource);
+			else eventsActive.delete(resource);
+		},
+		eventsActive: (resource) => eventsActive.has(resource),
+		async invalidateEvent(resource, action, recordId) {
+			bump(resource);
+			await clearPrefixes(eventPrefixes(resource, action, recordId));
+		},
+		async clearResource(resource) {
+			bump(resource);
+			await clearPrefixes(resourcePrefixes(resource));
+		},
+		async clear(prefix) {
+			globalGeneration += 1;
+			await safe(() => store.clear(prefix));
+		},
+		cachedEtag: lookupEtag,
+		async close() {
+			background.abort();
+			await Promise.allSettled(tasks);
+		}
+	};
+}
+/** LRU store (default 1024 entries) that also honours each entry's ttl. */
+var MemoryStore = class {
+	data = /* @__PURE__ */ new Map();
+	maxEntries;
+	defaultTtlMs;
+	now;
+	constructor(options = {}) {
+		const maxEntries = options.maxEntries ?? 1024;
+		if (!Number.isInteger(maxEntries) || maxEntries < 1) throw new RangeError("maxEntries must be an integer of at least 1");
+		this.maxEntries = maxEntries;
+		this.defaultTtlMs = options.defaultTtlMs ?? 36e5;
+		this.now = options.now ?? Date.now;
+	}
+	/** Number of stored entries (expired ones included until touched). */
+	get size() {
+		return this.data.size;
+	}
+	get(key) {
+		const item = this.data.get(key);
+		if (item === void 0) return;
+		if (item.expiresAt <= this.now()) {
+			this.data.delete(key);
+			return;
+		}
+		this.data.delete(key);
+		this.data.set(key, item);
+		return item.entry;
+	}
+	set(key, entry, ttlMs) {
+		this.data.delete(key);
+		this.data.set(key, {
+			expiresAt: this.now() + (ttlMs ?? this.defaultTtlMs),
+			entry
+		});
+		while (this.data.size > this.maxEntries) this.data.delete(this.data.keys().next().value);
+	}
+	delete(key) {
+		this.data.delete(key);
+	}
+	/** Remove every key under any of `prefixes` in one walk. */
+	clearMany(prefixes) {
+		for (const key of this.data.keys()) if (prefixes.some((prefix) => key.startsWith(prefix))) this.data.delete(key);
+	}
+	clear(prefix) {
+		for (const key of this.data.keys()) if (prefix === void 0 || key.startsWith(prefix)) this.data.delete(key);
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/idb@8.0.4/node_modules/idb/build/index.js
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+	return idbProxyableTypes || (idbProxyableTypes = [
+		IDBIndex,
+		IDBObjectStore,
+		IDBCursor,
+		IDBDatabase,
+		IDBTransaction
+	]);
+}
+function getCursorAdvanceMethods() {
+	return cursorAdvanceMethods || (cursorAdvanceMethods = [
+		"advance",
+		"continue",
+		"continuePrimaryKey"
+	].map((method) => IDBCursor.prototype[method]));
+}
+const transactionDoneMap = /* @__PURE__ */ new WeakMap();
+const transformCache = /* @__PURE__ */ new WeakMap();
+const reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+	const promise = new Promise((resolve, reject) => {
+		const unlisten = () => {
+			request.removeEventListener("success", success);
+			request.removeEventListener("error", error);
+		};
+		const success = () => {
+			resolve(wrap(request.result));
+			unlisten();
+		};
+		const error = () => {
+			reject(request.error);
+			unlisten();
+		};
+		request.addEventListener("success", success);
+		request.addEventListener("error", error);
+	});
+	reverseTransformCache.set(promise, request);
+	return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+	if (transactionDoneMap.has(tx)) return;
+	const done = new Promise((resolve, reject) => {
+		const unlisten = () => {
+			tx.removeEventListener("complete", complete);
+			tx.removeEventListener("error", error);
+			tx.removeEventListener("abort", error);
+		};
+		const complete = () => {
+			resolve();
+			unlisten();
+		};
+		const error = () => {
+			reject(tx.error || new DOMException("AbortError", "AbortError"));
+			unlisten();
+		};
+		tx.addEventListener("complete", complete);
+		tx.addEventListener("error", error);
+		tx.addEventListener("abort", error);
+	});
+	transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+	get(target, prop, receiver) {
+		if (target instanceof IDBTransaction) {
+			if (prop === "done") return transactionDoneMap.get(target);
+			if (prop === "store") return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+		}
+		return wrap(target[prop]);
+	},
+	set(target, prop, value) {
+		target[prop] = value;
+		return true;
+	},
+	has(target, prop) {
+		if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) return true;
+		return prop in target;
+	}
+};
+function replaceTraps(callback) {
+	idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+	if (getCursorAdvanceMethods().includes(func)) return function(...args) {
+		func.apply(unwrap(this), args);
+		return wrap(this.request);
+	};
+	return function(...args) {
+		return wrap(func.apply(unwrap(this), args));
+	};
+}
+function transformCachableValue(value) {
+	if (typeof value === "function") return wrapFunction(value);
+	if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
+	if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
+	return value;
+}
+function wrap(value) {
+	if (value instanceof IDBRequest) return promisifyRequest(value);
+	if (transformCache.has(value)) return transformCache.get(value);
+	const newValue = transformCachableValue(value);
+	if (!Object.is(newValue, value)) {
+		transformCache.set(value, newValue);
+		reverseTransformCache.set(newValue, value);
+	}
+	return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+/**
+* Open a database.
+*
+* @param name Name of the database.
+* @param version Schema version.
+* @param callbacks Additional callbacks.
+*/
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+	const request = indexedDB.open(name, version);
+	const openPromise = wrap(request);
+	if (upgrade) request.addEventListener("upgradeneeded", (event) => {
+		upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+	});
+	if (blocked) request.addEventListener("blocked", (event) => blocked(event.oldVersion, event.newVersion, event));
+	openPromise.then((db) => {
+		if (terminated) db.addEventListener("close", () => terminated());
+		if (blocking) db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+	}).catch(() => {});
+	return openPromise;
+}
+const readMethods = [
+	"get",
+	"getKey",
+	"getAll",
+	"getAllKeys",
+	"count"
+];
+const writeMethods = [
+	"put",
+	"add",
+	"delete",
+	"clear"
+];
+const cachedMethods = {};
+function getMethod(target, prop) {
+	if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) return;
+	if (cachedMethods[prop]) return cachedMethods[prop];
+	const targetFuncName = prop.replace(/FromIndex$/, "");
+	const useIndex = prop !== targetFuncName;
+	const isWrite = writeMethods.includes(targetFuncName);
+	if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) return;
+	const method = async function(storeName, ...args) {
+		const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+		let target = tx.store;
+		if (useIndex) target = target.index(args.shift());
+		return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
+	};
+	return cachedMethods[prop] = method;
+}
+replaceTraps((oldTraps) => ({
+	...oldTraps,
+	get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+	has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+const advanceMethodProps = [
+	"advance",
+	"continue",
+	"continuePrimaryKey"
+];
+const methodMap = {};
+const advanceResults = /* @__PURE__ */ new WeakMap();
+const ittrProxiedCursorToOriginalProxy = /* @__PURE__ */ new WeakMap();
+const cursorIteratorTraps = { get(target, prop) {
+	if (!advanceMethodProps.includes(prop)) return target[prop];
+	let cachedFunc = methodMap[prop];
+	if (!cachedFunc) cachedFunc = methodMap[prop] = function(...args) {
+		advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+	};
+	return cachedFunc;
+} };
+async function* iterate(...args) {
+	let cursor = this;
+	if (!(cursor instanceof IDBCursor)) cursor = await cursor.openCursor(...args);
+	if (!cursor) return;
+	cursor = cursor;
+	const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+	ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+	reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+	while (cursor) {
+		yield proxiedCursor;
+		cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+		advanceResults.delete(proxiedCursor);
+	}
+}
+function isIteratorProp(target, prop) {
+	return prop === Symbol.asyncIterator && instanceOfAny(target, [
+		IDBIndex,
+		IDBObjectStore,
+		IDBCursor
+	]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps((oldTraps) => ({
+	...oldTraps,
+	get(target, prop, receiver) {
+		if (isIteratorProp(target, prop)) return iterate;
+		return oldTraps.get(target, prop, receiver);
+	},
+	has(target, prop) {
+		return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+	}
+}));
+//#endregion
+//#region src/cache/idb.ts
+/**
+* IndexedDB cache store (one object store, out-of-line string keys).
+*
+* Every call is wrapped: a blocked database, private mode or a missing
+* `indexedDB` is a miss (or a no-op), never a failed request. `clear(prefix)`
+* is one `IDBKeyRange.bound(prefix, prefix + "\uffff")` delete.
+*/
+const STORE = "entries";
+var IndexedDbStore = class {
+	name;
+	defaultTtlMs;
+	now;
+	opening;
+	constructor(options = {}) {
+		this.name = options.name ?? "craftainer-crud-cache";
+		if (this.name === "") throw new RangeError("IndexedDbStore: name must not be empty");
+		this.defaultTtlMs = options.defaultTtlMs ?? 36e5;
+		this.now = options.now ?? Date.now;
+	}
+	open() {
+		this.opening ??= openDB(this.name, 1, { upgrade(db) {
+			db.createObjectStore(STORE);
+		} });
+		return this.opening;
+	}
+	/** Run `work` on the database; a failure drops the handle (so a later call retries) and yields `fallback`. */
+	async run(fallback, work) {
+		try {
+			return await work(await this.open());
+		} catch {
+			const dropped = this.opening;
+			this.opening = void 0;
+			try {
+				(await dropped)?.close();
+			} catch {}
+			return fallback;
+		}
+	}
+	get(key) {
+		return this.run(void 0, async (db) => {
+			const stored = await db.get(STORE, key);
+			if (stored === void 0) return;
+			if (stored.expiresAt <= this.now()) {
+				await db.delete(STORE, key);
+				return;
+			}
+			return stored.entry;
+		});
+	}
+	set(key, entry, ttlMs) {
+		return this.run(void 0, async (db) => {
+			const stored = {
+				expiresAt: this.now() + (ttlMs ?? this.defaultTtlMs),
+				entry
+			};
+			await db.put(STORE, stored, key);
+		});
+	}
+	delete(key) {
+		return this.run(void 0, (db) => db.delete(STORE, key));
+	}
+	clear(prefix) {
+		return this.run(void 0, (db) => prefix === void 0 ? db.clear(STORE) : db.delete(STORE, IDBKeyRange.bound(prefix, `${prefix}\uffff`)));
+	}
+	/** Clear several prefixes in one transaction (one bound range each). */
+	clearMany(prefixes) {
+		return this.run(void 0, async (db) => {
+			const tx = db.transaction(STORE, "readwrite");
+			await Promise.all([...prefixes.map((prefix) => tx.store.delete(IDBKeyRange.bound(prefix, `${prefix}\uffff`))), tx.done]);
+		});
+	}
+	/** Close the database handle; a later call reopens it. */
+	async close() {
+		const opening = this.opening;
+		this.opening = void 0;
+		try {
+			(await opening)?.close();
+		} catch {}
+	}
+};
+//#endregion
+//#region src/cache/wire.ts
+/** The subscriptions that currently see a connected stream, per cache and resource. */
+const connected = /* @__PURE__ */ new WeakMap();
+/**
+* Subscribe `cache` to `hub` for the manifest resource `resource`. Events
+* clear the spec's prefixes, a reconnect clears the resource, and fresh hits
+* are allowed only while the stream is connected. Returns the unsubscribe
+* (it also closes the freshness gate).
+*/
+function invalidateOnEvents(cache, hub, resource) {
+	const byResource = connected.get(cache) ?? /* @__PURE__ */ new Map();
+	connected.set(cache, byResource);
+	const live = byResource.get(resource) ?? /* @__PURE__ */ new Set();
+	byResource.set(resource, live);
+	const self = {};
+	const mark = (up) => {
+		if (up) live.add(self);
+		else live.delete(self);
+		cache.setEventsActive(resource, live.size > 0);
+	};
+	const unsubscribe = hub.subscribe({
+		onEvent: (event) => cache.invalidateEvent(resource, event.action, event.recordId),
+		onReset: () => cache.clearResource(resource),
+		onStatus: mark
+	});
+	return () => {
+		try {
+			unsubscribe();
+		} finally {
+			mark(false);
+		}
+	};
+}
+//#endregion
+export { IndexedDbStore, MemoryStore, buildKey, cachePolicyFromManifest, cacheStatus, canonicalQuery, createCache, credentialScope, eventPrefixes, getEventHub, invalidateOnEvents, manifestKey, recordPrefix, resourcePrefixes, subscribeEvents, tanstackCachePolicy };
+
+//# sourceMappingURL=index.mjs.map