@voltro/cms 0.86.0 → 0.88.0

package/dist/routeDispositionStore.js

@@ -0,0 +1,288 @@
+import { invalidatePublicationRelease as e, lockPublicationStream as t } from "./changes.js";
+import { copyOutputActivationScope as n, outputActivationHash as r } from "./outputActivation.js";
+import { copyCanonicalPublicRouteUrl as i } from "./publicRouteUrl.js";
+import { copyRouteDispositionDefinition as a, routeDispositionFail as o } from "./routeDispositions.js";
+import { copyRenderReadAuthority as s } from "./renderReadAuthority.js";
+import { and as c, eq as l, generateId as u, gt as d, id as f, inSet as p, integer as m, json as h, table as g, text as _, timestamp as v } from "@voltro/database";
+import { tenant as y } from "@voltro/plugin-multitenancy/mixin";
+import { canonicalJson as b } from "@voltro/runtime";
+// src/routeDispositionStore.ts
+var x = "_voltro_cms_route_disposition_heads", S = "_voltro_cms_route_dispositions", C = "_voltro_cms_route_disposition_revisions", w = g(x, {
+	id: f({ prefix: "crph" }),
+	site: _().maxLength(64),
+	environment: _().maxLength(64),
+	revision: m(),
+	count: m()
+}).with(y()).unique("cms_route_disposition_scope", [
+	"tenantId",
+	"site",
+	"environment"
+]), T = () => ({
+	site: _().maxLength(64),
+	environment: _().maxLength(64),
+	urlKey: _().maxLength(64),
+	revision: m(),
+	revisionId: _().maxLength(64),
+	previousRevisionId: _().maxLength(64).nullable(),
+	definition: h(),
+	authority: h(),
+	approvedAt: v(),
+	integrityDigest: _().maxLength(64)
+}), E = g(S, {
+	id: f({ prefix: "crpd" }),
+	...T()
+}).with(y()).unique("cms_route_disposition_source", [
+	"tenantId",
+	"site",
+	"environment",
+	"urlKey"
+]), D = g(C, {
+	id: f({ prefix: "crpv" }),
+	...T()
+}).with(y()).unique("cms_route_disposition_revision", [
+	"tenantId",
+	"site",
+	"environment",
+	"revision"
+]), O = [
+	w,
+	E,
+	D
+], k = 2147483647, A = 1e5, j = (e) => Number.isSafeInteger(e) && Number(e) >= 0 && Number(e) <= k, M = (e) => typeof e == "string" && /^[A-Za-z0-9_-]{1,64}$/.test(e), N = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), P = (e) => {
+	try {
+		return n(e);
+	} catch {
+		return o("scope");
+	}
+}, F = (e) => c(l("tenantId", e.tenantId), l("site", e.site), l("environment", e.environment)), I = (e, t) => u({
+	kind: "typeid",
+	prefix: e
+}, t) ?? o("state"), L = async (e, t, n) => {
+	let r = () => e.query({
+		table: x,
+		predicate: F(t),
+		lock: "update",
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	}), i = await r();
+	if (i.length === 0) {
+		for (let n of [S, C]) if ((await e.query({
+			table: n,
+			predicate: F(t),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["id"]
+		})).length > 0) return o("state");
+		if (!n) return null;
+		await e.insertIgnore(x, {
+			id: I("crph", x),
+			...t,
+			revision: 0,
+			count: 0
+		}, { conflictColumns: [
+			"tenantId",
+			"site",
+			"environment"
+		] }), i = await r();
+	}
+	let a = i[0];
+	return i.length !== 1 || a === void 0 || !M(a.id) || !j(a.revision) || !j(a.count) || a.count > A || a.count > a.revision || a.count === 0 != (a.revision === 0) ? o("state") : {
+		id: a.id,
+		revision: a.revision,
+		count: a.count
+	};
+}, R = (e, t, n) => {
+	let i;
+	try {
+		i = a(e.definition);
+	} catch {
+		return o("state");
+	}
+	let c = s(e.authority), l = e.approvedAt instanceof Date ? e.approvedAt.getTime() : NaN;
+	if (!M(e.revisionId) || !j(e.revision) || e.revision < 1 || e.revision > n.revision || !(e.previousRevisionId === null || M(e.previousRevisionId)) || e.previousRevisionId === e.revisionId || c === null || !Number.isSafeInteger(l) || l < 0 || !N(e.urlKey) || e.urlKey !== r(i.source.url)) return o("state");
+	let u = {
+		revision: e.revision,
+		revisionId: e.revisionId,
+		previousRevisionId: e.previousRevisionId,
+		definition: i,
+		authority: c,
+		approvedAt: l
+	}, d = r({
+		scope: t,
+		...u
+	});
+	return e.integrityDigest === d ? {
+		...u,
+		urlKey: e.urlKey,
+		integrityDigest: d
+	} : o("state");
+}, z = async (e, t, n, r) => {
+	let i = r.map((e) => R(e, t, n)), a = i.map((e) => e.revisionId);
+	if (new Set(a).size !== a.length) return o("state");
+	let s = a.length === 0 ? [] : await e.query({
+		table: C,
+		predicate: c(F(t), p("id", a)),
+		lock: "update",
+		order: [],
+		take: a.length + 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s.length !== a.length) return o("state");
+	let l = new Map(s.map((e) => [String(e.id), e]));
+	if (l.size !== s.length) return o("state");
+	for (let e of i) {
+		let r = l.get(e.revisionId);
+		if (r === void 0 || r.id !== r.revisionId || b(R(r, t, n)) !== b(e)) return o("state");
+	}
+	return i.map(({ integrityDigest: e, ...t }) => t);
+}, B = async (e, t, n) => {
+	let a = P(t);
+	try {
+		i(n);
+	} catch {
+		return o("input");
+	}
+	let s = await L(e, a, !1);
+	if (s === null) return null;
+	let u = await e.query({
+		table: S,
+		predicate: c(F(a), l("urlKey", r(n))),
+		lock: "update",
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	if (u.length > 1) return o("state");
+	let d = (await z(e, a, s, u))[0];
+	if (d === void 0) return null;
+	if (d.definition.source.url !== n) return o("state");
+	let { urlKey: f, ...p } = d;
+	return p;
+}, V = async (e, t, n = {}) => {
+	let r = P(t), { expectedRevision: i, after: a, take: s = 500 } = n;
+	if (!Number.isInteger(s) || s < 1 || s > 1e3 || i !== void 0 && !j(i) || a !== void 0 && (!N(a) || i === void 0)) return o("input");
+	let l = await L(e, r, !1);
+	if (i !== void 0 && i !== (l?.revision ?? 0)) return o("revision");
+	if (l === null) return {
+		revision: 0,
+		count: 0,
+		entries: [],
+		next: null
+	};
+	let u = await z(e, r, l, await e.query({
+		table: S,
+		predicate: c(F(r), ...a === void 0 ? [] : [d("urlKey", a)]),
+		lock: "update",
+		order: [{
+			column: "urlKey",
+			direction: "asc"
+		}],
+		take: s + 1,
+		skip: void 0,
+		projection: void 0
+	}));
+	if (u.length > l.count) return o("state");
+	let f = a ?? "";
+	for (let e of u) {
+		if (e.urlKey <= f) return o("state");
+		f = e.urlKey;
+	}
+	return {
+		revision: l.revision,
+		count: l.count,
+		entries: u.slice(0, s),
+		next: u.length > s ? u[s - 1].urlKey : null
+	};
+}, H = async (n, i, u) => {
+	let d = P(i), f = u.expectedRevision, p = a(u.definition), m = s(u.authority), h = u.now;
+	if (!j(f) || m === null || !Number.isSafeInteger(h) || h < 0 || h > 864e13) return o("input");
+	await t(n, d);
+	let g = await L(n, d, !0);
+	if (g === null) return o("state");
+	let _ = r(p.source.url), v = await n.query({
+		table: S,
+		predicate: c(F(d), l("urlKey", _)),
+		lock: "update",
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	if (v.length > 1) return o("state");
+	let y = (await z(n, d, g, v))[0], x = y !== void 0 && b(y.definition) === b(p) && b(y.authority) === b(m);
+	if (g.revision !== f) {
+		if (g.revision === f + 1 && y?.revision === g.revision && x) {
+			let { urlKey: e, ...t } = y;
+			return {
+				...t,
+				count: g.count
+			};
+		}
+		return o("revision");
+	}
+	if (x && y !== void 0) {
+		let { urlKey: e, ...t } = y;
+		return {
+			...t,
+			count: g.count
+		};
+	}
+	if (g.revision === k || y === void 0 && g.count === A) return o("bounds");
+	let w = {
+		revision: g.revision + 1,
+		revisionId: I("crpv", C),
+		previousRevisionId: y?.revisionId ?? null,
+		definition: p,
+		authority: m,
+		approvedAt: h
+	}, T = {
+		...d,
+		urlKey: _,
+		...w,
+		approvedAt: new Date(h),
+		integrityDigest: r({
+			scope: d,
+			...w
+		})
+	};
+	if (await n.insert(C, {
+		id: w.revisionId,
+		...T
+	}), y === void 0) await n.insert(S, {
+		id: I("crpd", S),
+		...T
+	});
+	else {
+		let e = v[0];
+		if (!M(e.id)) return o("state");
+		await n.update(S, e.id, T);
+	}
+	let E = g.count + +(y === void 0);
+	return await n.updateMany("_voltro_cms_route_disposition_heads", {
+		revision: w.revision,
+		count: E
+	}, { where: c(F(d), l("id", g.id), l("revision", g.revision)) }) === 1 ? (await e(n, d), {
+		...w,
+		count: E
+	}) : o("revision");
+};
+async function* U(e, t) {
+	let n, r, i = 0, a = 0;
+	do {
+		let o = await V(e, t, {
+			...r === void 0 ? {} : { expectedRevision: r },
+			...n === void 0 ? {} : { after: n }
+		});
+		r = o.revision, a = o.count;
+		for (let { urlKey: e, ...t } of o.entries) i++, yield t;
+		n = o.next ?? void 0;
+	} while (n !== void 0);
+	if (i !== a) return o("state");
+}
+export { S as ROUTE_DISPOSITIONS, x as ROUTE_DISPOSITION_HEADS, C as ROUTE_DISPOSITION_REVISIONS, U as iterateApprovedRouteDispositions, V as readApprovedRouteDispositionPage, B as readApprovedRouteDispositionUrl, w as routeDispositionHeadsTable, D as routeDispositionRevisionsTable, O as routeDispositionTables, E as routeDispositionsTable, H as writeApprovedRouteDisposition };

package/dist/routeDispositionTables.js

@@ -0,0 +1,4 @@
+import { routeDispositionTables as e } from "./routeDispositionStore.js";
+// src/routeDispositionTables.ts
+var t = Object.freeze([...e]);
+export { t as cmsRouteDispositionTables };

package/dist/routeDispositions.js

@@ -0,0 +1,90 @@
+import { copyCanonicalPublicRouteUrl as e } from "./publicRouteUrl.js";
+import { Schema as t } from "effect";
+// src/routeDispositions.ts
+var n = class extends t.TaggedError()("RouteDispositionUnavailable", { reason: t.Literals([
+	"input",
+	"bounds",
+	"scope",
+	"state",
+	"revision",
+	"credential",
+	"graph",
+	"hold"
+]) }) {}, r = (e) => {
+	throw new n({ reason: e });
+}, i = (e, t) => {
+	if (typeof e != "object" || !e || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e)) || Object.getOwnPropertySymbols(e).length > 0) return r("input");
+	let n = Object.getOwnPropertyDescriptors(e);
+	return Object.values(n).some((e) => !e.enumerable || !("value" in e)) || t !== void 0 && Object.keys(n).sort().join(",") !== t ? r("input") : Object.fromEntries(Object.entries(n).map(([e, t]) => [e, t.value]));
+}, a = (t) => {
+	let n = i(t, "routeId,url");
+	if (typeof n.routeId != "string" || !/^(route|native)_[a-f0-9]{64}$/.test(n.routeId)) return r("input");
+	try {
+		return {
+			url: e(n.url),
+			routeId: n.routeId
+		};
+	} catch {
+		return r("input");
+	}
+}, o = (e) => e === null ? null : Number.isSafeInteger(e) && Number(e) >= 0 && Number(e) <= 864e13 ? Number(e) : r("input"), s = (e) => {
+	let t = i(e);
+	if (t.kind === "hold") return i(e, "kind"), { kind: "hold" };
+	if (t.kind === "gone") return i(e, "kind,status"), t.status === 404 || t.status === 410 ? {
+		kind: "gone",
+		status: t.status
+	} : r("input");
+	if (t.kind !== "redirect") return r("input");
+	i(e, "kind,method,status,target");
+	let n = a(t.target);
+	return (t.status === 301 || t.status === 302) && t.method === "allow-post-to-get" ? {
+		kind: "redirect",
+		status: t.status,
+		method: "allow-post-to-get",
+		target: n
+	} : (t.status === 307 || t.status === 308) && t.method === "preserve" ? {
+		kind: "redirect",
+		status: t.status,
+		method: "preserve",
+		target: n
+	} : r("input");
+}, c = (e) => {
+	let t = i(e, "action,activeFrom,activeUntil,source,version");
+	if (t.version !== 1) return r("input");
+	let n = a(t.source), c = s(t.action), l = o(t.activeFrom), u = o(t.activeUntil);
+	return l !== null && u !== null && l >= u || c.kind === "redirect" && c.target.url === n.url ? r("input") : {
+		version: 1,
+		source: n,
+		action: c,
+		activeFrom: l,
+		activeUntil: u
+	};
+}, l = t.Struct({
+	url: t.String,
+	routeId: t.String
+}), u = t.Struct({
+	version: t.Literal(1),
+	source: l,
+	action: t.Union([
+		t.Struct({
+			kind: t.Literal("redirect"),
+			status: t.Literals([301, 302]),
+			method: t.Literal("allow-post-to-get"),
+			target: l
+		}),
+		t.Struct({
+			kind: t.Literal("redirect"),
+			status: t.Literals([307, 308]),
+			method: t.Literal("preserve"),
+			target: l
+		}),
+		t.Struct({
+			kind: t.Literal("gone"),
+			status: t.Literals([404, 410])
+		}),
+		t.Struct({ kind: t.Literal("hold") })
+	]),
+	activeFrom: t.NullOr(t.Int),
+	activeUntil: t.NullOr(t.Int)
+});
+export { u as RouteDispositionDefinitionSchema, n as RouteDispositionUnavailable, c as copyRouteDispositionDefinition, r as routeDispositionFail };

package/dist/routeHistoryStorage.js

@@ -0,0 +1,319 @@
+import { copyOutputActivationScope as e, outputActivationHash as t } from "./outputActivation.js";
+import { copyCanonicalPublicRouteUrl as n } from "./publicRouteUrl.js";
+import { Schema as r } from "effect";
+import { and as i, boolean as a, eq as o, generateId as s, gt as c, id as l, integer as u, table as d, text as f } from "@voltro/database";
+import { tenant as p } from "@voltro/plugin-multitenancy/mixin";
+import { canonicalJson as m } from "@voltro/runtime";
+// src/routeHistoryStorage.ts
+var h = class extends r.TaggedError()("RouteHistoryUnavailable", { reason: r.Literals([
+	"scope",
+	"input",
+	"state",
+	"revision",
+	"bounds"
+]) }) {}, g = 2147483647, _ = 1e5, v = 67108864, y = (e) => {
+	throw new h({ reason: e });
+}, b = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), x = (e) => Number.isSafeInteger(e) && Number(e) >= 0 && Number(e) <= g, S = (t) => {
+	try {
+		return e(t);
+	} catch {
+		return y("scope");
+	}
+}, C = (e) => i(o("tenantId", e.tenantId), o("site", e.site), o("environment", e.environment)), w = (e, t) => {
+	let n = s({
+		kind: "typeid",
+		prefix: e
+	}, t);
+	return n === null ? y("state") : n;
+}, T = (e) => {
+	if (typeof e != "object" || !e || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e)) || Object.getOwnPropertySymbols(e).length > 0) return y("input");
+	let t = Object.getOwnPropertyDescriptors(e);
+	if (Object.keys(t).sort().join(",") !== "routeId,url" || Object.values(t).some((e) => !e.enumerable || !("value" in e))) return y("input");
+	let r = t.url.value, i = t.routeId.value;
+	if (typeof r != "string" || r.length > 4400 || typeof i != "string" || !/^(route|native)_[a-f0-9]{64}$/.test(i)) return y("input");
+	try {
+		n(r);
+	} catch {
+		return y("input");
+	}
+	return {
+		url: r,
+		routeId: i
+	};
+}, E = (e) => {
+	if (!Array.isArray(e) || e.length > _ || Object.getOwnPropertySymbols(e).length > 0 || Object.keys(e).length !== e.length) return y("bounds");
+	let t = 2, n = Array.from({ length: e.length }, (n, r) => {
+		let i = Object.getOwnPropertyDescriptor(e, String(r));
+		if (i === void 0 || !("value" in i)) return y("input");
+		let a = T(i.value);
+		return t += Buffer.byteLength(m(a)) + (r === 0 ? 0 : 1), t > v ? y("bounds") : a;
+	}).sort((e, t) => e.url < t.url ? -1 : +(e.url > t.url));
+	return n.some((e, t) => t > 0 && n[t - 1].url === e.url) ? y("input") : n;
+}, D = (e) => {
+	let { heads: r, entries: s, headPrefix: m, entryPrefix: h, headIndex: v, entryIndex: D } = e, O = d(r, {
+		id: l({ prefix: m }),
+		site: f().maxLength(64),
+		environment: f().maxLength(64),
+		revision: u(),
+		sourceDigest: f().maxLength(64).nullable(),
+		currentDigest: f().maxLength(64).nullable(),
+		currentCount: u(),
+		historyCount: u()
+	}).with(p()).unique(v, [
+		"tenantId",
+		"site",
+		"environment"
+	]), k = d(s, {
+		id: l({ prefix: h }),
+		site: f().maxLength(64),
+		environment: f().maxLength(64),
+		urlKey: f().maxLength(64),
+		url: f(),
+		routeId: f().maxLength(71),
+		active: a(),
+		firstRevision: u(),
+		lastRevision: u(),
+		firstSourceDigest: f().maxLength(64),
+		lastSourceDigest: f().maxLength(64)
+	}).with(p()).unique(D, [
+		"tenantId",
+		"site",
+		"environment",
+		"urlKey"
+	]), A = [O, k], j = async (e, t, n) => {
+		let i = () => e.query({
+			table: r,
+			predicate: C(t),
+			lock: "update",
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0
+		}), a = await i();
+		if (a.length === 0) {
+			if ((await e.query({
+				table: s,
+				predicate: C(t),
+				lock: "update",
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["id"]
+			})).length > 0) return y("state");
+			if (!n) return null;
+			await e.insertIgnore(r, {
+				id: w(m, r),
+				...t,
+				revision: 0,
+				sourceDigest: null,
+				currentDigest: null,
+				currentCount: 0,
+				historyCount: 0
+			}, { conflictColumns: [
+				"tenantId",
+				"site",
+				"environment"
+			] }), a = await i();
+		}
+		let o = a[0];
+		if (a.length !== 1 || o === void 0 || typeof o.id != "string" || !x(o.revision) || !x(o.currentCount) || Number(o.currentCount) > _ || !x(o.historyCount) || Number(o.historyCount) < Number(o.currentCount)) return y("state");
+		let c = Number(o.revision), l = o.sourceDigest, u = o.currentDigest;
+		return (c === 0 ? l !== null || u !== null || o.historyCount !== 0 : !b(l) || !b(u)) ? y("state") : {
+			id: o.id,
+			revision: c,
+			sourceDigest: l,
+			currentDigest: u,
+			currentCount: Number(o.currentCount),
+			historyCount: Number(o.historyCount)
+		};
+	}, M = ({ revision: e, sourceDigest: t, currentDigest: n, currentCount: r, historyCount: i }) => ({
+		revision: e,
+		sourceDigest: t,
+		currentDigest: n,
+		currentCount: r,
+		historyCount: i
+	}), N = (e, n) => {
+		let r;
+		try {
+			r = T({
+				url: e.url,
+				routeId: e.routeId
+			});
+		} catch {
+			return y("state");
+		}
+		return typeof e.id != "string" || e.urlKey !== t(r.url) || typeof e.active != "boolean" || !x(e.firstRevision) || Number(e.firstRevision) < 1 || !x(e.lastRevision) || Number(e.lastRevision) < Number(e.firstRevision) || Number(e.lastRevision) > n.revision || !b(e.firstSourceDigest) || !b(e.lastSourceDigest) ? y("state") : {
+			id: e.id,
+			...r,
+			urlKey: String(e.urlKey),
+			active: e.active,
+			firstRevision: Number(e.firstRevision),
+			lastRevision: Number(e.lastRevision),
+			firstSourceDigest: e.firstSourceDigest,
+			lastSourceDigest: e.lastSourceDigest
+		};
+	}, P = async (e, t, n = {}) => {
+		let r = S(t), a = n.take ?? 500, o = n.after, l = n.expectedRevision;
+		if (!Number.isInteger(a) || a < 1 || a > 1e3 || o !== void 0 && (!b(o) || l === void 0) || l !== void 0 && !x(l)) return y("input");
+		let u = await j(e, r, !1);
+		if (l !== void 0 && l !== (u?.revision ?? 0)) return y("revision");
+		if (u === null) return {
+			revision: 0,
+			sourceDigest: null,
+			currentDigest: null,
+			currentCount: 0,
+			historyCount: 0,
+			entries: [],
+			next: null
+		};
+		let d = (await e.query({
+			table: s,
+			predicate: i(C(r), ...o === void 0 ? [] : [c("urlKey", o)]),
+			lock: "update",
+			order: [{
+				column: "urlKey",
+				direction: "asc"
+			}],
+			take: a + 1,
+			skip: void 0,
+			projection: void 0
+		})).map((e) => {
+			let { id: t, ...n } = N(e, u);
+			return n;
+		});
+		return o === void 0 && d.length === 0 && u.historyCount !== 0 || d.length > u.historyCount ? y("state") : {
+			...M(u),
+			entries: d.slice(0, a),
+			next: d.length > a ? d[a - 1].urlKey : null
+		};
+	}, F = async (e, r, a) => {
+		let c = S(r), l;
+		try {
+			l = n(a);
+		} catch {
+			return y("input");
+		}
+		let u = await j(e, c, !1);
+		if (u === null) return null;
+		let d = await e.query({
+			table: s,
+			predicate: i(C(c), o("urlKey", t(l))),
+			lock: "update",
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0
+		});
+		if (d.length > 1) return y("state");
+		if (d.length === 0) return null;
+		let { id: f, ...p } = N(d[0], u);
+		return p.url === l ? p : y("state");
+	}, I = async (e, n, a) => {
+		let l = S(n), u = a.expectedRevision, d = a.sourceDigest, f = E(a.routes);
+		if (!x(u) || !b(d)) return y("input");
+		let p = await j(e, l, u === 0);
+		if (p === null) return y("revision");
+		let m = t(f), v = /* @__PURE__ */ new Map(), T;
+		for (;;) {
+			let t = await e.query({
+				table: s,
+				predicate: i(C(l), o("active", !0), ...T === void 0 ? [] : [c("urlKey", T)]),
+				lock: "update",
+				order: [{
+					column: "urlKey",
+					direction: "asc"
+				}],
+				take: 500,
+				skip: void 0,
+				projection: void 0
+			});
+			if (t.length === 0) break;
+			for (let e of t) {
+				let t = N(e, p);
+				if (v.has(t.url) || v.size >= _) return y("state");
+				v.set(t.url, t);
+			}
+			T = String(t[t.length - 1].urlKey);
+		}
+		let D = E([...v.values()].map(({ url: e, routeId: t }) => ({
+			url: e,
+			routeId: t
+		})));
+		if (v.size !== p.currentCount || p.revision > 0 && t(D) !== p.currentDigest) return y("state");
+		let O = p.sourceDigest === d && p.currentDigest === m;
+		if (p.revision !== u) return p.revision === u + 1 && O ? M(p) : y("revision");
+		if (O) return M(p);
+		if (p.revision === g) return y("bounds");
+		let k = p.revision + 1, A = new Set(f.map((e) => e.url)), P = p.historyCount;
+		for (let n of f) {
+			let r = v.get(n.url), a = t(n.url);
+			if (r === void 0) {
+				let t = await e.query({
+					table: s,
+					predicate: i(C(l), o("urlKey", a)),
+					lock: "update",
+					order: [],
+					take: 2,
+					skip: void 0,
+					projection: void 0
+				});
+				if (t.length > 1 || (r = t[0] === void 0 ? void 0 : N(t[0], p), r !== void 0 && r.url !== n.url)) return y("state");
+			}
+			if (r === void 0) {
+				if (P === g) return y("bounds");
+				await e.insert(s, {
+					id: w(h, s),
+					...l,
+					...n,
+					urlKey: a,
+					active: !0,
+					firstRevision: k,
+					lastRevision: k,
+					firstSourceDigest: d,
+					lastSourceDigest: d
+				}), P++;
+			} else r.active && r.routeId === n.routeId || await e.update(s, r.id, {
+				routeId: n.routeId,
+				active: !0,
+				lastRevision: k,
+				lastSourceDigest: d
+			});
+		}
+		for (let t of v.values()) A.has(t.url) || await e.update(s, t.id, {
+			active: !1,
+			lastRevision: k,
+			lastSourceDigest: d
+		});
+		let F = {
+			revision: k,
+			sourceDigest: d,
+			currentDigest: m,
+			currentCount: f.length,
+			historyCount: P
+		};
+		return await e.updateMany(r, F, { where: i(C(l), o("id", p.id), o("revision", p.revision)) }) === 1 ? F : y("revision");
+	};
+	async function* L(e, t, n) {
+		let r, i = n, a = 0, o = 0;
+		do {
+			let n = await P(e, t, {
+				...r === void 0 ? {} : { after: r },
+				...i === void 0 ? {} : { expectedRevision: i }
+			});
+			i = n.revision, o = n.historyCount;
+			for (let e of n.entries) a++, yield e;
+			r = n.next ?? void 0;
+		} while (r !== void 0);
+		if (a !== o) return y("state");
+	}
+	return {
+		routeHistoryTables: A,
+		routeHistoryHeadsTable: O,
+		routeHistoryEntriesTable: k,
+		readRouteHistoryPage: P,
+		readRouteHistoryUrl: F,
+		replaceRouteHistory: I,
+		iterateRouteHistory: L
+	};
+};
+export { h as RouteHistoryUnavailable, E as copyObservedRoutes, D as createRouteHistoryStore };