@voltro/cms 0.85.0 → 0.87.0

package/dist/snapshotRoleTransfer.js

@@ -0,0 +1,106 @@
+import { SnapshotSeoReadUnavailable as e } from "./snapshotSeoRead.js";
+import { copySnapshotSeoDocumentsSelection as t } from "./snapshotSeoPathSets.js";
+import { readSnapshotSeoDocuments as n, snapshotOutputSafetyBinding as r } from "./snapshotSeoDocuments.js";
+import { readCurrentOutputSafetyArtifact as i } from "./outputSafetyArtifact.js";
+import { readSnapshotSeoOutputArtifact as a } from "./snapshotSeoOutput.js";
+import { readSnapshotRedirectOutputArtifact as o } from "./snapshotRedirectOutput.js";
+import { createSnapshotOutputBatch as s, createSnapshotOutputTransfer as c } from "./snapshotOutputTransfer.js";
+import { canonicalJson as l } from "@voltro/protocol";
+//#region src/snapshotRoleTransfer.ts
+var u = () => {
+	throw new e({ reason: "binding" });
+}, d = (e) => {
+	let { store: d, provider: f, declaration: p, maxBytes: m } = e, h = { ...e.scope }, g = { ...e.use }, _ = e.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), v = e.now ?? Date.now;
+	if (!Number.isSafeInteger(m) || m < 1) return u();
+	let y = f.readAssets?.bind(f), b = async (e, s) => {
+		let c = structuredClone(e), { role: b, id: x } = c;
+		if (![
+			"assets",
+			"deny",
+			"redirects",
+			"sitemap",
+			"robots"
+		].includes(b) || !/^[a-f0-9]{64}$/.test(x) || !Array.isArray(c.targets) || b !== "redirects" && c.targets.length !== 0 || (["assets", "deny"].includes(b) ? c.safety !== null : c.safety === null)) return u();
+		let S = {
+			snapshot: { ...c.snapshot },
+			token: c.token,
+			consumerId: c.consumerId,
+			buildId: c.buildId,
+			host: c.host
+		}, C = t(c.documents), w = (e) => n(e, h, S, C, {
+			provider: f,
+			use: g,
+			keys: _,
+			now: v
+		}), T = async () => {
+			if (b === "assets") {
+				if (y === void 0) return u();
+				let e = await d.transactional(w), t = e.paths.admission.app, n = e.inventory;
+				if (t.web === void 0) return u();
+				let r = await y({
+					id: x,
+					snapshotDigest: S.snapshot.digest,
+					inputsId: t.inputsId,
+					executionId: t.executionId,
+					web: { ...t.web },
+					consentPurposes: n.consentPurposes,
+					presentations: n.presentations,
+					documents: n.records.map((e) => ({
+						url: e.url,
+						path: e.path,
+						routeId: e.routeId,
+						artifactId: e.artifactId,
+						presentation: e.presentation
+					}))
+				}), i = await d.transactional(w);
+				return l(e.inventory) !== l(i.inventory) || l(e.paths.selection) !== l(i.paths.selection) || l(e.paths.admission.context) !== l(i.paths.admission.context) ? u() : r;
+			}
+			if (b === "deny") return (await i(d, h, x, {
+				provider: f,
+				maxBytes: m,
+				admit: async (e) => r(await w(e))
+			})).artifact;
+			if (c.safety === null) return u();
+			let e = {
+				...S,
+				documents: C,
+				safety: { ...c.safety }
+			};
+			return b === "redirects" ? p === void 0 ? u() : o(d, h, S.snapshot, {
+				...e,
+				id: x,
+				targets: c.targets
+			}, {
+				declaration: p,
+				provider: f,
+				use: g,
+				keys: _,
+				maxBytes: m,
+				now: v
+			}) : a(d, h, S.snapshot, {
+				...e,
+				id: x,
+				kind: b
+			}, {
+				provider: f,
+				use: g,
+				keys: _,
+				maxBytes: m,
+				now: v
+			});
+		}, E = await T(), D = 0;
+		for (let e of E.manifest.files) if (!Number.isSafeInteger(e.size) || e.size < 0 || (D += e.size, !Number.isSafeInteger(D) || D > m)) return u();
+		if (E.id !== x) return u();
+		let O = await s(E), k = await T();
+		return l(k) === l(E) ? O : u();
+	};
+	return {
+		...c(f, b),
+		readBatch: s(f, b)
+	};
+};
+//#endregion
+export { d as createSnapshotRoleTransfer };

package/dist/snapshotRoleTransferRest.js

@@ -0,0 +1,99 @@
+import { cmsCredential as e, privateCmsHttpRoutes as t, privateCmsOperation as n } from "./privateCmsTransport.js";
+import { CmsBuildSnapshotUnavailable as r } from "./buildSnapshotService.js";
+import { Effect as i, Schema as a } from "effect";
+import { strictInput as o } from "@voltro/protocol";
+//#region src/snapshotRoleTransferRest.ts
+var s = (s) => {
+	let c = {
+		namespace: "cms.roleTransfer",
+		path: "/v1/cms/role-transfer",
+		operationPrefix: "cmsRoleTransfer",
+		tags: ["CMS private output role transfer"],
+		error: r,
+		errorStatus: { CmsBuildSnapshotUnavailable: 409 },
+		credentialError: "CmsBuildSnapshotUnavailable"
+	}, l = a.Struct({
+		path: a.String,
+		digest: a.String,
+		size: a.Int,
+		contentType: a.String
+	}), u = a.Struct({
+		offset: a.Int,
+		size: a.Int,
+		digest: a.String
+	}), d = a.Struct({
+		artifactId: a.String,
+		pathSets: a.Array(a.Struct({
+			id: a.String,
+			digest: a.String
+		}))
+	}), f = a.Struct({
+		snapshot: a.Struct({
+			id: a.String,
+			digest: a.String
+		}),
+		consumerId: a.String,
+		buildId: a.String,
+		host: a.String,
+		id: a.String,
+		documents: d,
+		role: a.Literals([
+			"assets",
+			"deny",
+			"redirects",
+			"sitemap",
+			"robots"
+		]),
+		safety: a.NullOr(a.Struct({ artifactId: a.String })),
+		targets: a.Array(a.Struct({
+			host: a.String,
+			documents: d
+		}))
+	}), p = "Render-read bearer; complete signed paths, original document receipts, current media rights and grant are admitted before and after every provider read. The exact role is independently reconstructed from original retained assets or current safety, route history and SEO controls. Metadata and bytes are private; they grant no activation or serving authority. No hidden renewal or retry.", m = (e) => i.tryPromise({
+		try: e,
+		catch: () => new r({ reason: "render" })
+	}), h = [
+		n(c, "manifest", "Read a private admitted output role manifest", p, o(f, c.namespace + ".manifest", !0), a.Struct({
+			id: a.String,
+			manifest: a.Struct({
+				version: a.Literal(1),
+				subject: a.Record(a.String, a.Unknown),
+				files: a.Array(l)
+			})
+		}), (t, n) => m(() => s.read({
+			...t,
+			token: e(n, c.credentialError)
+		}))),
+		n(c, "file", "Plan bounded private output role chunks", p, o(a.Struct({
+			...f.fields,
+			path: a.String
+		}), c.namespace + ".file", !0), a.Struct({
+			file: l,
+			chunks: a.Array(u)
+		}), (t, n) => m(() => s.planFile({
+			...t,
+			token: e(n, c.credentialError)
+		}))),
+		n(c, "chunk", "Read a verified private output role chunk", p, o(a.Struct({
+			...f.fields,
+			file: l,
+			chunk: u
+		}), c.namespace + ".chunk", !0), a.Struct({ base64: a.String }), (t, n) => m(async () => ({ base64: Buffer.from(await s.readChunk({
+			...t,
+			token: e(n, c.credentialError)
+		})).toString("base64") }))),
+		n(c, "batch", "Read one bounded batch of complete private output files", p, o(a.Struct({
+			...f.fields,
+			files: a.Array(l).check(a.isMinLength(1), a.isMaxLength(200))
+		}), c.namespace + ".batch", !0), a.Struct({ base64: a.String }), (t, n) => m(async () => ({ base64: Buffer.from(await s.readBatch({
+			...t,
+			token: e(n, c.credentialError)
+		})).toString("base64") })))
+	];
+	return {
+		routes: h,
+		httpRoutes: t(h)
+	};
+};
+//#endregion
+export { s as cmsSnapshotRoleTransferRest };

package/dist/snapshotRouteAdmission.js

@@ -0,0 +1,71 @@
+import { normalizeHost as e } from "./domainHost.js";
+import { findVerifiedSnapshotResource as t, readVerifiedSnapshotResource as n } from "./buildSnapshot.js";
+import { contentRouteId as r } from "./contentRouteIdentity.js";
+import { admitSnapshotPresentation as i, copySnapshotPresentationValue as a } from "./snapshotPresentation.js";
+import { readCapturedSnapshotConsentPurposes as o } from "./snapshotPresentationPolicy.js";
+import { resolveSnapshotReadBinding as s } from "./snapshotReadAdmission.js";
+import { verifyRenderReadGrant as c } from "./renderReadGrant.js";
+import { Schema as l } from "effect";
+import { createHash as u } from "node:crypto";
+import { canonicalJson as d } from "@voltro/runtime";
+//#region src/snapshotRouteAdmission.ts
+var f = class extends l.TaggedError()("SnapshotRouteReadUnavailable", { reason: l.Literals([
+	"binding",
+	"host",
+	"path",
+	"route",
+	"definition",
+	"publication",
+	"bounds",
+	"projection",
+	"owner"
+]) }) {}, p = (e) => {
+	throw new f({ reason: e });
+}, m = (e) => u("sha256").update(d(e)).digest("hex"), h = (e) => typeof e == "string" && e.length > 0, g = (e, t, n) => {
+	let { contentType: i, documentId: a, localeId: o, mappingId: s } = n;
+	if (![
+		i,
+		a,
+		o,
+		s
+	].every(h) || n.version !== 1 || n.state !== "resolved" || n.path !== t || n.tenantId !== e.tenantId || n.site !== e.site || n.environment !== e.environment || n.routeId !== r(e, String(o), String(i), String(a), String(s))) return p("route");
+}, _ = async (r, l, u, d, f) => {
+	let h = f.now ?? Date.now(), _ = {
+		tenantId: l.tenantId,
+		site: l.site,
+		environment: l.environment
+	}, v = {
+		...d,
+		presentation: a(d.presentation)
+	}, y = f.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), b = {
+		id: u.id,
+		digest: u.digest
+	}, { snapshot: x, binding: S } = await s(r, _, b, v, h);
+	await c(r, v.token, S, {
+		keys: y,
+		now: h
+	});
+	let C = typeof v.host == "string" ? e(v.host) : null;
+	if (C === null) return p("host");
+	let w = (await t(r, _, x, "domains", C))?.value;
+	if (w === void 0 || w.version !== 1 || w.host !== C || w.tenantId !== _.tenantId || w.site !== _.site) return p("host");
+	if (typeof v.path != "string" || !v.path.startsWith("/") || v.path.startsWith("//") || v.path.length > 4096 || /[\x00-\x20\x7f\\?#]/.test(v.path) || new URL(v.path, `https://${C}`).pathname !== v.path) return p("path");
+	let T = (await t(r, _, x, "routes", `path:${m(v.path)}`))?.value;
+	T !== void 0 && g(_, v.path, T);
+	let E = (await n(r, _, x, "routes", "configuration")).value, D = await o(r, _, x, E.app);
+	return {
+		snapshot: x,
+		binding: S,
+		place: _,
+		input: v,
+		route: T,
+		configuration: E,
+		presentation: i(D, v.presentation),
+		now: h
+	};
+};
+//#endregion
+export { f as SnapshotRouteReadUnavailable, _ as readSnapshotRouteAdmission, g as verifySnapshotContentRoute };

package/dist/snapshotRouteDispatch.js

@@ -0,0 +1,111 @@
+import { defineSiteDelivery as e } from "./siteDelivery.js";
+import { nativeSnapshotRouteId as t, readSnapshotRouting as n, snapshotCmsPage as r, snapshotRouteDispatch as i, verifySnapshotRouteOwnership as a } from "./snapshotRouting.js";
+import { coversSnapshotComponents as o } from "./snapshotFrontend.js";
+import { readSnapshotAppExecution as s } from "./snapshotAppExecution.js";
+import { SnapshotRouteReadUnavailable as c, readSnapshotRouteAdmission as l } from "./snapshotRouteAdmission.js";
+import { readAdmittedSnapshotContentRoute as u } from "./snapshotRouteRead.js";
+import { readAdmittedSnapshotBindingContext as d } from "./snapshotBindingRead.js";
+import { snapshotPathLocale as f } from "./snapshotPathLocale.js";
+import { readAdmittedSnapshotTrees as p } from "./snapshotTreeRead.js";
+import { readAdmittedSnapshotFieldPlan as m } from "./snapshotFieldPlan.js";
+import { readAdmittedSnapshotSeo as h } from "./snapshotSeoRead.js";
+import { readAdmittedSnapshotAddressGraph as g } from "./snapshotAddressGraph.js";
+import { readAdmittedSnapshotReferenceGraph as _ } from "./snapshotReferenceGraph.js";
+//#region src/snapshotRouteDispatch.ts
+var v = async (...v) => {
+	let [y] = v, b = await l(...v), { snapshot: x, place: S, input: C, route: w, configuration: T } = b, E = n(T);
+	if (w !== void 0 && T.definitionDigest !== w.definitionDigest) throw new c({ reason: "binding" });
+	let D = w === void 0 ? i(E, C.path, !1) : a(T, w);
+	if (D === null) return null;
+	if (D.owner === "cms") {
+		let e = await u(y, b);
+		if (e === null) return null;
+		let t = await s(y, S, x, e.output.contentType, e.components, {
+			id: e.output.localeId,
+			contentLocale: e.output.requestedLocale
+		}), n = t.nativePages ? r(E, C.path) : null, i = n === null ? null : await h(y, S, e, b.now), a = n === null ? null : await m(y, S, e, b.now), l = a ?? {
+			references: [],
+			media: [],
+			dependencies: [],
+			content: null
+		}, f = a === null ? [] : [{
+			source: null,
+			context: {
+				...e,
+				routeId: e.output.routeId
+			},
+			fields: a
+		}], v = t.definitions.value, w = n === null ? [] : Object.keys(v.site.bindings).sort();
+		if (w.length > 64) throw new c({ reason: "binding" });
+		let T = Object.create(null);
+		for (let n of w) {
+			let r = await d(y, S, e, n, b.now);
+			if (r === null) {
+				T[n] = null;
+				continue;
+			}
+			if (!o(v.frontend, r.components, t.context)) throw new c({ reason: "binding" });
+			let i = await m(y, S, r, b.now);
+			T[n] = {
+				output: r.output,
+				...i
+			}, f.push({
+				source: n,
+				context: r,
+				fields: i
+			});
+		}
+		if (l.media.length + Object.values(T).reduce((e, t) => e + (t?.media.length ?? 0), 0) > 1024) throw new c({ reason: "binding" });
+		let D = {
+			nodes: {},
+			edges: []
+		};
+		if (a !== null) {
+			if (t.context === void 0) throw new c({ reason: "binding" });
+			D = await _(y, S, f, v.frontend, t.context, b.now);
+		}
+		let O = n === null ? {} : await p(y, S, x, e.output.localeId, {
+			contentType: e.output.contentType,
+			documentId: e.document.documentId
+		}, b.now);
+		return {
+			owner: "cms",
+			presentation: b.presentation,
+			capturedAt: x.manifest.capturedAt,
+			route: e.output,
+			page: n,
+			...l,
+			trees: O,
+			bindings: T,
+			referenceGraph: D,
+			addressGraph: a === null ? [] : await g(y, S, f, D, b.now),
+			seo: i?.seo ?? null,
+			image: i?.image ?? null,
+			...t
+		};
+	}
+	if (D.code === null) throw new c({ reason: "owner" });
+	let O = e(T.site), k = f(O, C.path), A = await s(y, S, x, void 0, [], {
+		id: k.id,
+		contentLocale: k.contentLocale
+	});
+	if (!A.nativePages) throw new c({ reason: "owner" });
+	let j = E.definition?.claims[D.code.file];
+	return {
+		owner: "code",
+		publicCode: j?.kind === "code" && j.public === !0,
+		presentation: b.presentation,
+		capturedAt: x.manifest.capturedAt,
+		route: {
+			routeId: t(S, k.id, D.code.file, C.path),
+			path: C.path,
+			code: D.code,
+			localeId: k.id,
+			languageTag: k.tag
+		},
+		trees: await p(y, S, x, k.id, null, b.now),
+		...A
+	};
+};
+//#endregion
+export { v as readSnapshotRenderRoute };

package/dist/snapshotRouteDispositionPlan.js

@@ -0,0 +1,73 @@
+import { copyObservedRoutes as e } from "./routeHistoryStorage.js";
+import { findVerifiedSnapshotResources as t } from "./buildSnapshot.js";
+import { copyRouteDispositionDefinition as n, routeDispositionFail as r } from "./routeDispositions.js";
+import { compileCmsPublicRouteDeclaration as i } from "./initializePublicRoutes.js";
+import { snapshotRedirectSource as a } from "./snapshotRedirects.js";
+import { isPrivateNativeRouteReservation as o } from "./privateNativeRouteReservation.js";
+import { planExactRouteDispositions as s } from "./routeDispositionGraph.js";
+import { canonicalJson as c } from "@voltro/runtime";
+//#region src/snapshotRouteDispositionPlan.ts
+var l = async (l, u, d, f, p, m) => {
+	let h = i(f).routing, { snapshot: g, input: _ } = d.admission, v = g.manifest.parts.find((e) => e.part === "redirects");
+	if (v?.format !== "voltro.cms.redirect-history/v4") return r("state");
+	let y = new Set(d.contexts.map((e) => e.host));
+	if (!y.has(_.host) || y.size > 256 || d.entries.length > 1e5 || d.entries.some((e) => !y.has(e.host))) return r("graph");
+	for (let e of y) for (let t of d.site.locales.filter((e) => e.enabled)) for (let n of ["cms", "code"]) if (!d.contexts.some((r) => r.host === e && r.localeIds.includes(t.id) && r.owners.includes(n))) return r("graph");
+	let b = [], x = [], S = [], C = [], w = 0, T = /* @__PURE__ */ new Map(), E = (t) => {
+		let i = t.value;
+		if ([
+			"configuration",
+			"source:configuration",
+			"disposition:configuration"
+		].includes(t.key) && T.set(t.key, i), t.key.startsWith("source:url:") || t.key.startsWith("observed:url:")) {
+			let [n] = e([{
+				url: i.url,
+				routeId: i.routeId
+			}]);
+			if (n === void 0) return r("state");
+			if (new URL(n.url).hostname !== _.host) return;
+			let a = t.key.startsWith("source:") ? b : x;
+			if (a.length >= 1e5) return r("bounds");
+			a.push(n), t.key.startsWith("source:") && i.active === !0 && S.push(n);
+		} else if (t.key.startsWith("disposition:url:")) {
+			let e = n(i.definition);
+			if (new URL(e.source.url).hostname !== _.host) return;
+			if (C.length >= 1e5) return r("bounds");
+			C.push(e);
+		}
+	}, D = async (e) => {
+		let n = await t(l, u, g, "redirects", e.map((e) => e.key));
+		for (let t of e) {
+			if (++w > v.entries || c(n.get(t.key)) !== c(t)) return r("state");
+			E(t);
+		}
+	}, O = [], k = a(l, u, p, f, m);
+	for await (let e of k.entries(g.manifest.publication)) O.push(e), O.length === 200 && (await D(O), O = []);
+	if (O.length > 0 && await D(O), w !== v.entries) return r("state");
+	let A = T.get("source:configuration"), j = T.get("configuration"), M = T.get("disposition:configuration");
+	if (A === void 0 || j === void 0 || M === void 0 || typeof A.revision != "number" || typeof A.sourceDigest != "string" || typeof j.revision != "number" || j.sourceDigest !== null && typeof j.sourceDigest != "string" || typeof M.revision != "number") return r("state");
+	let N = new Map([...x, ...b].map((e) => [e.url, e])), P = new Set(S.map((e) => e.url)), F = [...N.values()].filter((e) => o(h, new URL(e.url).pathname, P.has(e.url)));
+	return {
+		definitions: s({
+			observed: x,
+			sourceObserved: b,
+			currentOwned: S,
+			reserved: F,
+			current: d.entries.map((e) => ({
+				url: "https://" + e.host + e.path,
+				routeId: e.routeId
+			})),
+			decisions: C,
+			now: m
+		}),
+		routeState: {
+			sourceRevision: A.revision,
+			sourceDigest: A.sourceDigest,
+			outputRevision: j.revision,
+			outputSourceDigest: j.sourceDigest,
+			approvalRevision: M.revision
+		}
+	};
+};
+//#endregion
+export { l as readSnapshotRouteDispositionPlan };

package/dist/snapshotRouteRead.js

@@ -0,0 +1,43 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { verifySnapshotRouteOwnership as t } from "./snapshotRouting.js";
+import { admitSnapshotPublicDocument as n, admitVerifiedSnapshotPublicDocument as r } from "./snapshotPublicAccess.js";
+import { SnapshotRouteReadUnavailable as i, readSnapshotRouteAdmission as a } from "./snapshotRouteAdmission.js";
+import { projectSnapshotDocument as o } from "./snapshotDocumentProjection.js";
+import { canonicalJson as s } from "@voltro/runtime";
+//#region src/snapshotRouteRead.ts
+var c = (e) => {
+	throw new i({ reason: e });
+}, l = async (e, t, n, r, i) => u(e, await a(e, t, n, r, i)), u = async (i, a, l) => {
+	let { snapshot: u, binding: d, place: f, input: p, route: m, configuration: h, presentation: g, now: _ } = a;
+	if (m === void 0) return null;
+	let { contentType: v, documentId: y, localeId: b } = m, x = l === void 0 ? await n(i, f, u, String(v), String(b), String(y), _) : await r(i, f, u, l, String(v), String(b), String(y), _);
+	if (x === null) return null;
+	let S = x.chain[0];
+	if (S.variantId !== m.variantId || S.revisionId !== m.revisionId || S.revision !== m.revision || S.locale !== m.sourceLocale || x.requestedLocale !== m.requestedLocale || m.fallback !== (S.locale !== x.requestedLocale)) return c("route");
+	let C = (await e(i, f, u, "schema", `type:${String(v)}`)).value;
+	if (h.definitionDigest !== m.definitionDigest || s(h.app) !== s(C.app)) return c("binding");
+	if (t(h, m).owner !== "cms") return c("owner");
+	let { values: w, components: T } = await o(i, f, u, String(v), S, C, _, g);
+	return {
+		snapshot: u,
+		binding: d,
+		route: m,
+		document: S,
+		components: T,
+		output: {
+			snapshotId: u.id,
+			snapshotDigest: u.digest,
+			routeId: String(m.routeId),
+			path: p.path,
+			contentType: String(v),
+			localeId: String(b),
+			requestedLocale: x.requestedLocale,
+			sourceLocale: S.locale,
+			fallback: S.locale !== x.requestedLocale,
+			values: w,
+			presentation: g
+		}
+	};
+}, d = async (...e) => (await l(...e))?.output ?? null;
+//#endregion
+export { i as SnapshotRouteReadUnavailable, u as readAdmittedSnapshotContentRoute, d as readSnapshotRoute, l as readSnapshotRouteContext };

package/dist/snapshotRoutes.js

@@ -0,0 +1,79 @@
+import { compileSiteDelivery as e } from "./siteDelivery.js";
+import { compileContentRouteTypes as t } from "./contentRouteTypes.js";
+import { pageCapturedPublications as n, readCapturedDocumentEntry as r, verifyPublicationState as i } from "./publicationState.js";
+import { copySnapshotResource as a } from "./buildSnapshot.js";
+import { compileSnapshotRouting as o } from "./snapshotRouting.js";
+import { copySnapshotAppCodePin as s } from "./snapshotDefinitions.js";
+import { ContentRouteMaterializationUnavailable as c, materializeContentRoutes as l } from "./contentRouteMaterializer.js";
+import { Schema as u } from "effect";
+import { createHash as d } from "node:crypto";
+import { canonicalJson as f } from "@voltro/runtime";
+//#region src/snapshotRoutes.ts
+var p = class extends u.TaggedError()("SnapshotRouteUnavailable", { reason: u.Literals([
+	"scope",
+	"types",
+	"mapping",
+	"publication",
+	"bounds"
+]) }) {}, m = (e) => {
+	throw new p({ reason: e });
+}, h = (e) => d("sha256").update(f(e)).digest("hex"), g = (e) => typeof e == "string" && e.length > 0, _ = (u, d, f, p, _, v = Date.now(), y = {
+	definition: null,
+	discovery: null
+}) => {
+	let b = {
+		tenantId: d.tenantId,
+		site: d.site,
+		environment: d.environment
+	}, x = e(p), S = s(_), C = o(y.definition, y.discovery, S);
+	if (!Object.values(b).every(g) || x.definition.id !== b.site || !x.definition.environments.includes(b.environment)) return m("scope");
+	let w = t(f);
+	if (!w.ok) return m(w.reason);
+	let T = w.types, E = h({
+		site: x.definition,
+		types: T,
+		routing: C
+	}), D = a({
+		key: "configuration",
+		value: {
+			version: 1,
+			...b,
+			app: S,
+			definitionDigest: E,
+			types: T,
+			site: x.definition,
+			routing: C,
+			resolution: "per-node",
+			addressScope: "site"
+		}
+	});
+	return {
+		format: "voltro.cms.content-routes/v4",
+		entries: async function* (e) {
+			let t = await i(u, b, e, v);
+			if (t.types.length !== T.length || t.types.some((e) => !T.some((t) => t.name === e)) || t.locales.length !== x.contentLocales.length || t.locales.some((e) => !x.contentLocales.includes(e))) return m("scope");
+			yield a(D);
+			try {
+				yield* l({
+					scope: b,
+					site: x,
+					types: T,
+					routing: C,
+					definitionDigest: E
+				}, {
+					read: (t, n, i) => r(u, b, e.id, t, n, i, v),
+					page: (t, r, i) => n(u, b, e.id, t, r, {
+						limit: 200,
+						now: v,
+						...i === void 0 ? {} : { after: i }
+					})
+				});
+			} catch (e) {
+				if (e instanceof c) return m(e.reason);
+				throw e;
+			}
+		}
+	};
+};
+//#endregion
+export { p as SnapshotRouteUnavailable, _ as snapshotContentRoutesSource };