@voltro/cms 0.86.0 → 0.88.0

package/dist/publicRouteRegistryBinding.js

@@ -0,0 +1,193 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { CMS_REVISIONS_TABLE as t } from "./contentType.js";
+import { lockSiteState as n } from "./siteState.js";
+import { invalidatePublicationRelease as r, lockPublicationStream as i, readPublicationBoundary as a } from "./changes.js";
+import { CMS_PATHS_TABLE as o, CMS_REDIRECTS_TABLE as s } from "./redirects.js";
+import { queryPublicRouteIntegrity as c } from "./publicRouteIntegrity.js";
+import { copyOutputActivationScope as l, outputActivationHash as u } from "./outputActivation.js";
+import { readPublicRouteHistoryPage as d, replacePublicRouteHistory as f } from "./publicRouteHistoryStore.js";
+import { copyPublicRouteRegistryDefinition as p } from "./publicRouteRegistryDefinition.js";
+import { and as m, eq as h, generateId as g, id as _, integer as v, json as y, table as b, text as x, timestamp as S } from "@voltro/database";
+import { tenant as C } from "@voltro/plugin-multitenancy/mixin";
+import { canonicalJson as w } from "@voltro/runtime";
+// src/publicRouteRegistryBinding.ts
+var T = "_voltro_cms_public_route_registry_heads", E = "_voltro_cms_public_route_registry_bindings", D = b(T, {
+	id: _({ prefix: "crrh" }),
+	site: x().maxLength(64),
+	environment: x().maxLength(64),
+	revision: v(),
+	bindingId: x().maxLength(64)
+}).with(C()).unique("cms_public_route_registry_scope", [
+	"tenantId",
+	"site",
+	"environment"
+]), O = b(E, {
+	id: _({ prefix: "crrb" }),
+	site: x().maxLength(64),
+	environment: x().maxLength(64),
+	revision: v(),
+	definition: y(),
+	definitionDigest: x().maxLength(64),
+	previousBindingId: x().maxLength(64).nullable(),
+	origin: y(),
+	boundAt: S(),
+	integrityDigest: x().maxLength(64)
+}).with(C()).unique("cms_public_route_binding_revision", [
+	"tenantId",
+	"site",
+	"environment",
+	"revision"
+]), k = [D, O], A = (t) => {
+	try {
+		return l(t);
+	} catch {
+		return e("scope");
+	}
+}, j = (e) => m(h("tenantId", e.tenantId), h("site", e.site), h("environment", e.environment)), M = (e) => typeof e == "string" && /^[A-Za-z0-9_-]{1,64}$/.test(e), N = (e) => Number.isInteger(e) && Number(e) >= 1 && Number(e) <= 2147483647, P = (t, n) => g({
+	kind: "typeid",
+	prefix: t
+}, n) ?? e("state"), F = (t) => {
+	if (typeof t != "object" || !t || Array.isArray(t) || Object.getOwnPropertySymbols(t).length !== 0) return e("state");
+	let n = Object.getOwnPropertyDescriptors(t);
+	if (Object.keys(n).sort().join(",") !== "checkpoint,generation,releaseId" || Object.values(n).some((e) => !e.enumerable || !("value" in e))) return e("state");
+	let r = n.generation.value;
+	return typeof r != "string" || !/^0{20}$/.test(r) || n.releaseId.value !== null || n.checkpoint.value !== null ? e("state") : {
+		generation: r,
+		releaseId: null,
+		checkpoint: null
+	};
+}, I = (e, t, n) => e.insert(E, {
+	id: n.id,
+	...t,
+	revision: n.revision,
+	previousBindingId: n.previousBindingId,
+	definition: n.definition,
+	definitionDigest: u(n.definition),
+	origin: n.origin,
+	boundAt: new Date(n.boundAt),
+	integrityDigest: u({
+		scope: t,
+		...n
+	})
+}), L = async (t, n) => {
+	let r = A(n), i = await c(t, {
+		table: T,
+		predicate: j(r),
+		lock: "update",
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	if (i.length === 0) return (await c(t, {
+		table: "_voltro_cms_public_route_registry_bindings",
+		predicate: j(r),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length > 0 ? e("state") : null;
+	let a = i[0];
+	if (i.length !== 1 || !M(a.id) || !M(a.bindingId) || !N(a.revision)) return e("state");
+	let o = await c(t, {
+		table: E,
+		predicate: m(j(r), h("id", a.bindingId)),
+		lock: "update",
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	}), s = o[0];
+	if (o.length !== 1 || s === void 0 || s.revision !== a.revision || !M(s.id) || !(s.previousBindingId === null || M(s.previousBindingId)) || s.previousBindingId === null != (s.revision === 1)) return e("state");
+	let l;
+	try {
+		l = p(s.definition);
+	} catch {
+		return e("state");
+	}
+	let d = s.boundAt instanceof Date ? s.boundAt.getTime() : NaN, f = F(s.origin);
+	if (!Number.isSafeInteger(d) || d < 0 || d > 864e13 || l.site.id !== r.site || !l.site.environments.includes(r.environment) || s.definitionDigest !== u(l)) return e("state");
+	let g = {
+		id: s.id,
+		revision: a.revision,
+		previousBindingId: s.previousBindingId,
+		definition: l,
+		origin: f,
+		boundAt: d
+	};
+	return s.integrityDigest === u({
+		scope: r,
+		...g
+	}) ? g : e("state");
+}, R = async (l, m, h) => {
+	let g = A(m), _ = p(h.definition), v = h.expectedRevision, y = h.now;
+	if (!Number.isSafeInteger(v) || v < 0 || v > 2147483647) return e("revision");
+	if (!Number.isSafeInteger(y) || y < 0 || y > 864e13) return e("bounds");
+	if (_.site.id !== g.site || !_.site.environments.includes(g.environment)) return e("scope");
+	await n(l, g), await i(l, g);
+	let b = await L(l, g);
+	if (b !== null) return v !== 0 && v !== b.revision ? e("revision") : w(b.definition) === w(_) ? (await d(l, g, { take: 1 })).revision === 0 ? e("history") : b : e("configuration");
+	if (v !== 0) return e("revision");
+	let x = await a(l, g);
+	if (BigInt(x.generation) !== 0n || x.releaseId !== null || x.checkpoint !== null) return e("history");
+	for (let n of [
+		t,
+		o,
+		s,
+		..._.types.map((e) => e.name + "_published")
+	]) if ((await c(l, {
+		table: n,
+		predicate: j(g),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	})).length > 0) return e("history");
+	let S = {
+		id: P("crrb", E),
+		revision: 1,
+		previousBindingId: null,
+		definition: _,
+		origin: x,
+		boundAt: y
+	};
+	return await I(l, g, S), await l.insert(T, {
+		id: P("crrh", T),
+		...g,
+		revision: 1,
+		bindingId: S.id
+	}), await r(l, g), await f(l, g, {
+		expectedRevision: 0,
+		sourceDigest: u({
+			scope: g,
+			binding: S,
+			origin: "fresh-source-namespace"
+		}),
+		routes: []
+	}), S;
+}, z = async (t, r, a) => {
+	let o = A(r), s = p(a.definition), c = a.expectedRevision;
+	if (!N(c) || c === 2147483647) return e("revision");
+	if (!Number.isSafeInteger(a.now) || a.now < 0 || a.now > 864e13) return e("bounds");
+	if (s.site.id !== o.site || !s.site.environments.includes(o.environment)) return e("scope");
+	await n(t, o), await i(t, o);
+	let l = await L(t, o);
+	if (l === null) return e("configuration");
+	if (l.revision !== c) return e("revision");
+	if (w(l.definition) === w(s)) return l;
+	let u = {
+		id: P("crrb", E),
+		revision: c + 1,
+		previousBindingId: l.id,
+		definition: s,
+		origin: { ...l.origin },
+		boundAt: a.now
+	};
+	return await I(t, o, u), await t.updateMany("_voltro_cms_public_route_registry_heads", {
+		revision: u.revision,
+		bindingId: u.id
+	}, { where: m(j(o), h("revision", c), h("bindingId", l.id)) }) === 1 ? u : e("revision");
+};
+export { E as PUBLIC_ROUTE_REGISTRY_BINDINGS, T as PUBLIC_ROUTE_REGISTRY_HEADS, z as advancePublicRouteDefinition, R as bindInitialPublicRouteDefinition, k as publicRouteRegistryBindingTables, O as publicRouteRegistryBindingsTable, D as publicRouteRegistryHeadsTable, L as readPublicRouteBinding };

package/dist/publicRouteRegistryDefinition.js

@@ -0,0 +1,75 @@
+import { PublicRouteRegistryUnavailable as e, publicRouteRegistryFail as t } from "./publicRouteRegistry.js";
+import { compileSiteDelivery as n } from "./siteDelivery.js";
+import { defineContentLocations as r } from "./contentLocations.js";
+import { outputActivationHash as i } from "./outputActivation.js";
+import { compileContentRouteTypes as a } from "./contentRouteTypes.js";
+import { copySnapshotResource as o } from "./buildSnapshot.js";
+import { compileSnapshotRouting as s } from "./snapshotRouting.js";
+import { copySnapshotAppCodePin as c } from "./snapshotDefinitions.js";
+import { canonicalJson as l } from "@voltro/runtime";
+// src/publicRouteRegistryDefinition.ts
+var u = (e, n) => typeof e != "object" || !e || Array.isArray(e) || Object.keys(e).sort().join(",") !== n ? t("definition") : e, d = (e) => typeof e == "string" && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(e), f = (e, n, r) => r === null ? e !== null || n !== null ? t("definition") : {
+	definition: null,
+	discovery: null
+} : s(e, n, r), p = (a) => {
+	try {
+		let e = u(o({
+			key: "route-definition",
+			value: a
+		}).value, "app,definitionDigest,routing,site,types,version");
+		if (e.version !== 1 || !Array.isArray(e.types) || e.types.length === 0) return t("definition");
+		let s = e.app === null ? null : c(e.app), p = n(e.site).definition, m = u(e.routing, "definition,discovery"), h = f(m.definition, m.discovery, s), g = [], _ = "";
+		for (let n of e.types) {
+			let e = u(n, "locations,name,tree");
+			if (!d(e.name) || e.name <= _ || !Array.isArray(e.locations)) return t("definition");
+			_ = e.name;
+			let i = r(e.locations), a = null;
+			if (e.tree !== null) {
+				let n = u(e.tree, "parent,segment");
+				if (!d(n.parent) || !d(n.segment)) return t("definition");
+				a = {
+					parent: n.parent,
+					segment: n.segment
+				};
+			}
+			g.push({
+				name: e.name,
+				locations: i,
+				tree: a
+			});
+		}
+		let v = {
+			version: 1,
+			app: s,
+			site: p,
+			types: g,
+			routing: h,
+			definitionDigest: i({
+				site: p,
+				types: g,
+				routing: h
+			})
+		};
+		return l(v) === l(e) ? v : t("definition");
+	} catch (n) {
+		if (n instanceof e) throw n;
+		return t("definition");
+	}
+}, m = (e) => {
+	let r = a(e.types);
+	if (!r.ok) return t("definition");
+	let o = e.app === null ? null : c(e.app), s = n(e.site).definition, l = f(e.routing.definition, e.routing.discovery, o), u = r.types;
+	return p({
+		version: 1,
+		app: o,
+		site: s,
+		types: u,
+		routing: l,
+		definitionDigest: i({
+			site: s,
+			types: u,
+			routing: l
+		})
+	});
+};
+export { m as compilePublicRouteRegistryDefinition, f as compilePublicRouteRouting, p as copyPublicRouteRegistryDefinition };

package/dist/publicRouteSitePublication.js

@@ -0,0 +1,39 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { copySiteScope as t } from "./siteState.js";
+import { invalidatePublicationRelease as n, lockPublicationStream as r } from "./changes.js";
+import { queryPublicRouteIntegrity as i } from "./publicRouteIntegrity.js";
+import { PUBLIC_ROUTE_REGISTRY_HEADS as a } from "./publicRouteRegistryBinding.js";
+import { reconcilePublicRouteNamespace as o } from "./publicRouteNamespace.js";
+import { and as s, eq as c, gt as l } from "@voltro/database";
+// src/publicRouteSitePublication.ts
+var u = async (u, d) => {
+	let f = t(d), p = /* @__PURE__ */ new Set(), m;
+	for (;;) {
+		let t = await i(u, {
+			table: a,
+			predicate: s(c("tenantId", f.tenantId), c("site", f.site), ...m === void 0 ? [] : [l("id", m)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 200,
+			skip: void 0,
+			projection: void 0
+		});
+		if (t.length === 0) break;
+		for (let n of t) {
+			if (typeof n.id != "string" || n.id <= (m ?? "") || typeof n.environment != "string" || !/^[a-z][a-z0-9_-]{0,63}$/.test(n.environment) || p.has(n.environment) || n.tenantId !== f.tenantId || n.site !== f.site) return e("state");
+			if (p.size >= 1e4) return e("bounds");
+			m = n.id, p.add(n.environment);
+		}
+	}
+	for (let e of [...p].sort()) {
+		let t = {
+			...f,
+			environment: e
+		};
+		await r(u, t), await n(u, t), await o(u, t);
+	}
+};
+export { u as reconcileDomainPublication };

package/dist/publicRouteTables.js

@@ -0,0 +1,12 @@
+import { cmsSiteStateHeadsTable as e } from "./siteState.js";
+import { publicRouteHistoryTables as t } from "./publicRouteHistoryStore.js";
+import { publicRouteRegistryBindingTables as n } from "./publicRouteRegistryBinding.js";
+import { cmsSiteDomainsTable as r } from "./domains.js";
+// src/publicRouteTables.ts
+var i = [
+	e,
+	...n,
+	...t,
+	r
+];
+export { i as cmsPublicRouteTables };

package/dist/publicRouteUrl.js

@@ -0,0 +1,17 @@
+import { normalizeHost as e } from "./domainHost.js";
+import { CmsPublicBuildUnavailable as t, canonicalCmsPublicPath as n } from "./publicBuild.js";
+// src/publicRouteUrl.ts
+var r = (r) => {
+	let i = () => {
+		throw new t("request");
+	};
+	if (typeof r != "string" || r.length > 4400) return i();
+	try {
+		let t = new URL(r);
+		if (t.protocol !== "https:" || t.host !== e(t.host) || t.host !== t.hostname || t.origin + t.pathname !== r || n(t.pathname) !== t.pathname) return i();
+	} catch {
+		return i();
+	}
+	return r;
+};
+export { r as copyCanonicalPublicRouteUrl };

package/dist/publicationSeo.js

@@ -0,0 +1,51 @@
+import { ContentSeoUnavailable as e } from "./errors.js";
+import { resolveContentSeo as t } from "./contentSeo.js";
+import { defineSiteDelivery as n } from "./siteDelivery.js";
+// src/publicationSeo.ts
+var r = (t) => {
+	let r = () => {
+		throw new e({ reason: "definition" });
+	};
+	if (!Array.isArray(t) || t.length < 1 || t.length > 128 || Object.getOwnPropertySymbols(t).length || Object.getOwnPropertyNames(t).length !== t.length + 1) return r();
+	let i = Array.from({ length: t.length }, (e, i) => {
+		let a = Object.getOwnPropertyDescriptor(t, String(i));
+		return a === void 0 || !a.enumerable || !("value" in a) ? r() : n(a.value);
+	});
+	return new Set(i.map((e) => e.id)).size === i.length ? Object.freeze(i) : r();
+}, i = (n, i, a) => {
+	if (n.seo === void 0) {
+		if (n.seoSites !== void 0) throw new e({ reason: "definition" });
+		return null;
+	}
+	if (n.seoSites === void 0) return t(n.seo, i);
+	let o = r(n.seoSites).find((e) => e.id === a.site), s = o?.locales.find((e) => e.contentLocale === a.locale);
+	if (o === void 0 || !o.environments.includes(a.environment) || s === void 0) throw new e({ reason: "scope" });
+	let c = o.seo !== void 0 && Object.hasOwn(o.seo, s.id) ? o.seo[s.id] : void 0;
+	return t(n.seo, i, c);
+}, a = (t, n, r) => {
+	let a;
+	try {
+		a = i(t, n, r);
+	} catch (t) {
+		if (!(t instanceof e)) throw t;
+		return [{
+			field: "$seo",
+			rule: `seo.${t.reason}`,
+			message: "SEO metadata could not be resolved for this publication scope."
+		}];
+	}
+	if (a === null || t.seo === void 0) return [];
+	let o = t.seo, s = {
+		title: o.title.fields[0],
+		description: o.description?.fields[0],
+		"social.title": o.social?.title?.fields[0],
+		"social.description": o.social?.description?.fields[0],
+		"structuredData.title": o.structuredData?.title
+	};
+	return a.findings.flatMap((e) => e.kind === "recommendation" ? [] : [{
+		field: e.field ?? s[e.target] ?? "$seo",
+		rule: `seo.${e.rule}`,
+		message: e.kind === "missing" ? `SEO ${e.target} is required for publication.` : `SEO ${e.target} contains an invalid ${e.rule} value.`
+	}]);
+};
+export { r as defineContentSeoSites, i as resolveScopedContentSeo, a as seoPublishViolations };

package/dist/publicationState.js

@@ -0,0 +1,295 @@
+import { readPublicationBoundary as e } from "./changes.js";
+import { pickDeclared as t, readContentModificationTime as n } from "./contentValues.js";
+import { Schema as r } from "effect";
+import { and as i, eq as a, gt as o, id as s, integer as c, json as l, or as u, table as d, text as f, timestamp as p } from "@voltro/database";
+import { tenant as m } from "@voltro/plugin-multitenancy/mixin";
+import { createHash as h } from "node:crypto";
+import { canonicalJson as g } from "@voltro/runtime";
+// src/publicationState.ts
+var _ = class extends r.TaggedError()("PublicationStateUnavailable", { reason: r.Literals([
+	"scope",
+	"types",
+	"locales",
+	"expiry",
+	"state",
+	"expired",
+	"publication",
+	"cursor",
+	"query"
+]) }) {}, v = "_voltro_cms_publication_states", y = "_voltro_cms_publication_state_entries", b = d(v, {
+	id: s({ prefix: "cstate" }),
+	site: f().maxLength(64),
+	environment: f().maxLength(64),
+	state: f().oneOf(["capturing", "sealed"]),
+	checkpoint: f().maxLength(64).nullable(),
+	generation: f().maxLength(20),
+	releaseId: f().maxLength(64).nullable(),
+	types: l(),
+	locales: l(),
+	capturedAt: p(),
+	expiresAt: p(),
+	entries: c().default(0),
+	digest: f().maxLength(64).default("")
+}).with(m()), x = d(y, {
+	id: s({ prefix: "cpub" }),
+	stateId: f().maxLength(64),
+	site: f().maxLength(64),
+	environment: f().maxLength(64),
+	contentType: f().maxLength(64),
+	variantId: f().maxLength(64),
+	documentId: f().maxLength(64),
+	locale: f().maxLength(64),
+	revisionId: f().maxLength(64),
+	revision: c(),
+	values: l(),
+	modifiedAt: f().maxLength(32).nullable(),
+	digest: f().maxLength(64)
+}).with(m()).index("cms_pubstate_entries_page", [
+	"tenantId",
+	"stateId",
+	"contentType",
+	"locale",
+	"variantId"
+]).index("cms_pubstate_entries_document", [
+	"tenantId",
+	"stateId",
+	"contentType",
+	"locale",
+	"documentId"
+]).unique("cms_pubstate_entries_variant", [
+	"tenantId",
+	"stateId",
+	"contentType",
+	"variantId"
+]), S = (e) => {
+	throw new _({ reason: e });
+}, C = (e) => typeof e == "string" && e.trim().length > 0, w = (e) => [
+	e.tenantId,
+	e.site,
+	e.environment
+].every(C) ? i(a("tenantId", e.tenantId), a("site", e.site), a("environment", e.environment)) : S("scope"), T = (e) => Array.isArray(e) && e.every(C), E = (e) => h("sha256").update(g(e)).digest("hex"), D = (e) => {
+	let t = n(e);
+	return t.ok ? t.value : S("publication");
+}, O = (e) => ({
+	contentType: e.contentType,
+	variantId: e.variantId,
+	documentId: e.documentId,
+	locale: e.locale,
+	revisionId: e.revisionId,
+	revision: e.revision,
+	values: e.values,
+	modifiedAt: D(e.modifiedAt)
+}), k = async (n, r, s, c) => {
+	let l = w(s), d = r.map((e) => e.name).sort();
+	if (r.length === 0 || !d.every(C) || new Set(d).size !== d.length) return S("types");
+	if (!T(c.locales) || c.locales.length === 0 || new Set(c.locales).size !== c.locales.length) return S("locales");
+	let f = [...c.locales].sort(), p = c.now ?? Date.now();
+	if (!Number.isSafeInteger(p) || !Number.isFinite(new Date(p).getTime()) || !Number.isSafeInteger(c.expiresAt) || c.expiresAt <= p || !Number.isFinite(new Date(c.expiresAt).getTime())) return S("expiry");
+	let { checkpoint: m, generation: _, releaseId: b } = await e(n, s), x = await n.insert(v, {
+		...s,
+		state: "capturing",
+		checkpoint: m,
+		generation: _,
+		releaseId: b,
+		types: d,
+		locales: f,
+		capturedAt: new Date(p),
+		expiresAt: new Date(c.expiresAt),
+		entries: 0,
+		digest: ""
+	}), O = String(x.id), k = h("sha256").update(g({
+		version: 3,
+		scope: s,
+		types: d,
+		locales: f,
+		checkpoint: m,
+		generation: _,
+		releaseId: b
+	}) + "\n"), A = 0;
+	for (let e of [...r].sort((e, t) => e.name < t.name ? -1 : +(e.name > t.name))) {
+		let r;
+		for (;;) {
+			let c = await n.query({
+				table: `${e.name}_published`,
+				lock: "update",
+				predicate: i(l, a("status", "published"), u(...f.map((e) => a("locale", e))), ...r === void 0 ? [] : [o("id", r)]),
+				order: [{
+					column: "id",
+					direction: "asc"
+				}],
+				take: 500,
+				skip: void 0,
+				projection: void 0
+			});
+			if (c.length === 0) break;
+			let d = c.map((n) => {
+				if (![
+					n.id,
+					n.documentId,
+					n.revisionId,
+					n.locale
+				].every(C) || !Number.isSafeInteger(n.revision) || Number(n.revision) < 1) return S("publication");
+				let r = JSON.parse(JSON.stringify(t(e, n))), i = {
+					contentType: e.name,
+					variantId: n.id,
+					documentId: n.documentId,
+					locale: n.locale,
+					revisionId: n.revisionId,
+					revision: n.revision,
+					values: r,
+					modifiedAt: D(n.updatedAt)
+				}, a = E(i);
+				return k.update(a + "\n"), {
+					...s,
+					stateId: O,
+					...i,
+					digest: a
+				};
+			});
+			await n.insertMany(y, d, { returning: "none" }), A += c.length, r = String(c[c.length - 1].id);
+		}
+	}
+	let j = {
+		entries: A,
+		digest: k.digest("hex")
+	};
+	return await n.update(v, O, {
+		state: "sealed",
+		...j
+	}), {
+		id: O,
+		checkpoint: m,
+		generation: _,
+		releaseId: b,
+		...j
+	};
+}, A = async (e, t, n, r, o, s) => {
+	let [c] = await e.query({
+		table: v,
+		predicate: i(w(t), a("id", n)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (c === void 0 || c.state !== "sealed" || !T(c.types) || !c.types.includes(r) || !T(c.locales) || !c.locales.includes(o) || typeof c.digest != "string" || !/^[0-9a-f]{64}$/.test(c.digest) || !Number.isSafeInteger(c.entries) || Number(c.entries) < 0) return S("state");
+	let l = c.expiresAt instanceof Date ? c.expiresAt.getTime() : new Date(String(c.expiresAt)).getTime();
+	if (!Number.isFinite(s) || !Number.isFinite(l)) return S("state");
+	if (l <= s) return S("expired");
+}, j = (e) => e.digest !== E(O(e)) || e.values === null || typeof e.values != "object" || Array.isArray(e.values) ? S("publication") : structuredClone({
+	...e.values,
+	id: e.variantId,
+	documentId: e.documentId,
+	revisionId: e.revisionId,
+	revision: e.revision,
+	tenantId: e.tenantId,
+	site: e.site,
+	environment: e.environment,
+	locale: e.locale,
+	status: "published"
+}), M = async (e, t, n, r, o, s, c = Date.now()) => {
+	await A(e, t, n, r, o, c);
+	let [l] = await e.query({
+		table: y,
+		predicate: i(w(t), a("stateId", n), a("contentType", r), a("locale", o), a("variantId", s)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return l === void 0 ? null : j(l);
+}, N = async (e, t, n, r, o, s, c = Date.now()) => {
+	if (!C(s)) return S("query");
+	await A(e, t, n, r, o, c);
+	let l = await e.query({
+		table: y,
+		predicate: i(w(t), a("stateId", n), a("contentType", r), a("locale", o), a("documentId", s)),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0
+	});
+	return l.length > 1 ? S("publication") : l[0] === void 0 ? null : {
+		content: j(l[0]),
+		modifiedAt: D(l[0].modifiedAt)
+	};
+}, P = async (e, t, n, r, i, a, o = Date.now()) => (await N(e, t, n, r, i, a, o))?.content ?? null, F = async (e, t, n, r, s, c = {}) => {
+	await A(e, t, n, r, s, c.now ?? Date.now());
+	let l = c.limit ?? 100;
+	if (!Number.isSafeInteger(l) || l < 1 || l > 200) return S("query");
+	let u = i(w(t), a("stateId", n), a("contentType", r), a("locale", s)), d;
+	if (c.after !== void 0) {
+		let [t] = await e.query({
+			table: y,
+			predicate: i(u, a("id", c.after)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["variantId"]
+		});
+		if (t === void 0 || !C(t.variantId)) return S("cursor");
+		d = t.variantId;
+	}
+	let f = await e.query({
+		table: y,
+		predicate: i(u, ...d === void 0 ? [] : [o("variantId", d)]),
+		order: [{
+			column: "variantId",
+			direction: "asc"
+		}],
+		take: l + 1,
+		skip: void 0,
+		projection: void 0
+	}), p = f.slice(0, l);
+	return {
+		items: p.map(j),
+		next: f.length > l ? String(p[p.length - 1].id) : null
+	};
+}, I = async (e, t, n, r = Date.now()) => {
+	let [s] = await e.query({
+		table: v,
+		predicate: i(w(t), a("id", n.id)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s === void 0 || !T(s.types) || !T(s.locales) || s.types.length === 0 || s.locales.length === 0 || s.checkpoint !== n.checkpoint || s.generation !== n.generation || s.releaseId !== n.releaseId || !/^[0-9]{20}$/.test(n.generation) || n.releaseId !== null && !C(n.releaseId) || s.entries !== n.entries || s.digest !== n.digest) return S("state");
+	await A(e, t, n.id, s.types[0], s.locales[0], r);
+	let c = h("sha256").update(g({
+		version: 3,
+		scope: t,
+		types: s.types,
+		locales: s.locales,
+		checkpoint: s.checkpoint,
+		generation: s.generation,
+		releaseId: s.releaseId
+	}) + "\n"), l = 0;
+	for (let r of s.types) {
+		let u;
+		for (;;) {
+			let d = await e.query({
+				table: y,
+				predicate: i(w(t), a("stateId", n.id), a("contentType", r), ...u === void 0 ? [] : [o("variantId", u)]),
+				order: [{
+					column: "variantId",
+					direction: "asc"
+				}],
+				take: 500,
+				skip: void 0,
+				projection: void 0
+			});
+			if (d.length === 0) break;
+			for (let e of d) {
+				if (!C(e.variantId) || !s.locales.includes(String(e.locale))) return S("publication");
+				j(e), c.update(String(e.digest) + "\n"), l++;
+			}
+			u = String(d[d.length - 1].variantId);
+		}
+	}
+	return l !== n.entries || c.digest("hex") !== n.digest ? S("publication") : {
+		types: [...s.types],
+		locales: [...s.locales]
+	};
+};
+export { v as PUBLICATION_STATES_TABLE, y as PUBLICATION_STATE_ENTRIES_TABLE, _ as PublicationStateUnavailable, k as capturePublicationState, F as pageCapturedPublications, x as publicationStateEntriesTable, b as publicationStatesTable, P as readCapturedDocument, N as readCapturedDocumentEntry, M as readCapturedPublication, I as verifyPublicationState };