@voltro/cms 0.86.0 → 0.87.0

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 };

package/dist/snapshotRouting.js

@@ -0,0 +1,113 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+import { Schema as t } from "effect";
+import { createHash as n } from "node:crypto";
+import { canonicalJson as r } from "@voltro/runtime";
+//#region src/snapshotRouting.ts
+var i = class extends t.TaggedError()("SnapshotRoutingUnavailable", { reason: t.Literals([
+	"definition",
+	"discovery",
+	"claim",
+	"missing",
+	"collision",
+	"ownership"
+]) }) {}, a = (e) => {
+	throw new i({ reason: e });
+}, o = (e) => n("sha256").update(r(e)).digest("hex"), s = (e) => typeof e != "object" || !e || Array.isArray(e) ? a("definition") : e, c = (e) => typeof e == "string" && e.length > 0 && e.length <= 1024 && !/[\\\x00-\x1f\x7f:]/.test(e) && e.split("/").every((e) => e !== "" && e !== "." && e !== ".." && e.toLowerCase() !== ".git"), l = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), u = (t) => e({
+	key: "routing",
+	value: { data: t }
+}).value.data, d = (e) => {
+	if (e === null) return null;
+	let t = s(u(e)), n = s(t.claims);
+	if (Object.keys(t).length !== 2 || !c(t.pagesDirectory) || Object.keys(n).length > 4096) return a("definition");
+	let r = Object.fromEntries(Object.keys(n).sort().map((e) => {
+		if (!c(e)) return a("definition");
+		let t = s(n[e]);
+		return t.kind === "cms" && Object.keys(t).length === 1 ? [e, { kind: "cms" }] : t.kind === "code" && ["collision,kind", "collision,kind,public"].includes(Object.keys(t).sort().join(",")) && [
+			"reject",
+			"cms",
+			"code"
+		].includes(String(t.collision)) && (t.public === void 0 || typeof t.public == "boolean") ? [e, {
+			kind: "code",
+			collision: t.collision,
+			...t.public === void 0 ? {} : { public: t.public }
+		}] : a("definition");
+	}));
+	return {
+		pagesDirectory: t.pagesDirectory,
+		claims: r
+	};
+}, f = (e, t, n) => {
+	let i = d(e);
+	if (i === null) return t === null ? {
+		definition: null,
+		discovery: null
+	} : a("discovery");
+	let f = s(u(t)), { digest: p, ...m } = f, h = s(f.inputs);
+	if (f.version !== 2 || !l(p) || o(m) !== p || f.pagesDirectory !== i.pagesDirectory || !l(h.id) || r(h) !== r({
+		id: h.id,
+		...n
+	}) || !Array.isArray(f.pages) || f.pages.length === 0 || f.pages.length > 4096) return a("discovery");
+	let g = /* @__PURE__ */ new Set();
+	for (let e of f.pages) {
+		let t = s(e), n = s(t.source), r = s(t.matcher);
+		if (!c(t.file) || g.has(t.file) || n.path !== `${i.pagesDirectory}/${t.file}` || !l(n.digest) || typeof t.pattern != "string" || !t.pattern.startsWith("/") || t.pattern.length > 4096 || typeof r.source != "string" || r.source.length > 8192 || r.flags !== "" || !Number.isSafeInteger(r.priority) || Number(r.priority) < 0) return a("discovery");
+		try {
+			new RegExp(r.source);
+		} catch {
+			return a("discovery");
+		}
+		g.add(t.file);
+	}
+	return Object.keys(i.claims).some((e) => !g.has(e)) ? a("claim") : {
+		definition: i,
+		discovery: f
+	};
+}, p = (e, t, n) => {
+	if (e.definition === null || e.discovery === null) return n ? {
+		owner: "cms",
+		code: null
+	} : null;
+	let r = e.discovery.pages.filter((e) => new RegExp(e.matcher.source, e.matcher.flags).test(t)).sort((e, t) => e.matcher.priority - t.matcher.priority), i = r[0];
+	if (i === void 0) return n ? a("missing") : null;
+	if (r[1]?.matcher.priority === i.matcher.priority) return a("collision");
+	let o = e.definition.claims[i.file] ?? {
+		kind: "code",
+		collision: "reject"
+	}, s = {
+		file: i.file,
+		pattern: i.pattern,
+		sourceDigest: i.source.digest
+	};
+	return n ? o.kind === "code" && o.collision === "reject" ? a("collision") : {
+		owner: o.kind === "cms" ? "cms" : o.collision,
+		code: s
+	} : o.kind === "cms" ? null : {
+		owner: "code",
+		code: s
+	};
+}, m = (e, t) => p(e, t, !0), h = (e, t) => {
+	if (e.definition === null || e.discovery === null) return a("missing");
+	let n = e.discovery.pages.filter((n) => e.definition.claims[n.file]?.kind === "cms" && new RegExp(n.matcher.source, n.matcher.flags).test(t)).sort((e, t) => e.matcher.priority - t.matcher.priority), r = n[0];
+	return r === void 0 ? a("missing") : n[1]?.matcher.priority === r.matcher.priority ? a("collision") : {
+		file: r.file,
+		pattern: r.pattern,
+		sourceDigest: r.source.digest
+	};
+}, g = (e) => {
+	let t = s(e.routing), n = f(t.definition, t.discovery, e.app);
+	return r(t) === r(n) ? n : a("discovery");
+}, _ = (e, t) => {
+	let n = m(g(e), String(t.path));
+	return r(t.ownership) === r(n) ? n : a("ownership");
+}, v = (e, t, n, r) => `native_${o([
+	{
+		tenantId: e.tenantId,
+		site: e.site,
+		environment: e.environment
+	},
+	t,
+	n,
+	r
+])}`;
+//#endregion
+export { i as SnapshotRoutingUnavailable, f as compileSnapshotRouting, d as copySnapshotRoutingDefinition, v as nativeSnapshotRouteId, g as readSnapshotRouting, h as snapshotCmsPage, p as snapshotRouteDispatch, m as snapshotRouteOwnership, c as snapshotRoutingPath, _ as verifySnapshotRouteOwnership };

package/dist/snapshotSeo.js

@@ -0,0 +1,179 @@
+import { compileSiteDelivery as e } from "./siteDelivery.js";
+import { normalizeHost as t } from "./domainHost.js";
+import { copySnapshotResource as n, findVerifiedSnapshotResource as r, pinnedSnapshotPartSource as i, readVerifiedSnapshotResource as a, verifyBuildSnapshot as o } from "./buildSnapshot.js";
+import { verifySnapshotRouteOwnership as s } from "./snapshotRouting.js";
+import { contentRouteId as c } from "./contentRouteIdentity.js";
+import { Schema as l } from "effect";
+import { createHash as u } from "node:crypto";
+import { canonicalJson as d } from "@voltro/runtime";
+//#region src/snapshotSeo.ts
+var f = class extends l.TaggedError()("SnapshotSeoUnavailable", { reason: l.Literals([
+	"scope",
+	"format",
+	"configuration",
+	"domain",
+	"route",
+	"publication"
+]) }) {}, 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 = async (l, u, f, g) => {
+	let _ = {
+		tenantId: u.tenantId,
+		site: u.site,
+		environment: u.environment
+	}, v = {
+		id: f.id,
+		digest: f.digest
+	}, y = g.now ?? Date.now(), b = g.xDefault, x = g.routeKey;
+	if (x !== void 0 && !/^path:[a-f0-9]{64}$/.test(x)) return p("route");
+	if (!Object.values(_).every(h) || typeof b != "boolean") return p("scope");
+	let S = await o(l, _, v, y), C = (e, t) => {
+		let n = i(l, _, S, e, y);
+		return n.format === t ? n : p("format");
+	}, w = C("routes", "voltro.cms.content-routes/v4"), T = C("domains", "voltro.cms.domains/v1");
+	C("locales", "voltro.cms.locales/v1");
+	let E = (await a(l, _, S, "routes", "configuration")).value, D = (await a(l, _, S, "locales", "policy")).value, O = e(E.site);
+	if (O.definition.id !== _.site || !O.definition.environments.includes(_.environment) || [E, D].some((e) => e.tenantId !== _.tenantId || e.environment !== _.environment) || D.site !== _.site || d(E.app) !== d(D.app) || E.resolution !== "per-node" || D.resolution !== "per-node" || !Array.isArray(E.types) || E.types.some((e) => typeof e != "object" || !e || !Array.isArray(e.locations))) return p("configuration");
+	let k = {
+		version: O.definition.version,
+		defaultLocale: O.definition.defaultLocale,
+		sourceLocale: O.definition.sourceLocale,
+		locales: O.definition.locales
+	}, A = {
+		contentLocales: O.contentLocales,
+		defaultLocale: O.defaultLocale,
+		sourceLocale: O.sourceLocale,
+		fallback: O.fallback,
+		prefixes: O.prefixes,
+		tags: O.tags,
+		directions: O.directions
+	};
+	if (d(D.definition) !== d(k) || d(D.compiled) !== d(A)) return p("configuration");
+	let j;
+	for await (let e of T.entries(S.manifest.publication)) {
+		let n = e.value;
+		if (n.version !== 1 || n.tenantId !== _.tenantId || n.site !== _.site || typeof n.host != "string" || t(n.host) !== n.host || e.key !== n.host || typeof n.primary != "boolean") return p("domain");
+		if (n.primary) {
+			if (j !== void 0) return p("domain");
+			j = n.host;
+		}
+	}
+	if (j === void 0) return p("domain");
+	let M = `https://${j}`, N = O.definition.locales.filter((e) => e.enabled), P = (e) => {
+		let t = e.value;
+		if (t.version !== 1 || t.tenantId !== _.tenantId || t.site !== _.site || t.environment !== _.environment || ![
+			t.contentType,
+			t.documentId,
+			t.mappingId,
+			t.localeId,
+			t.requestedLocale,
+			t.sourceLocale,
+			t.variantId,
+			t.revisionId
+		].every(h) || !Number.isSafeInteger(t.revision) || Number(t.revision) < 1 || typeof t.fallback != "boolean" || t.definitionDigest !== E.definitionDigest) return p("route");
+		let n = t.lastModified;
+		if (n !== null && (typeof n != "string" || !Number.isFinite(Date.parse(n)) || new Date(n).toISOString() !== n)) return p("route");
+		let r = N.find((e) => e.id === t.localeId), i = E.types.find((e) => e.name === t.contentType);
+		if (r === void 0 || r.contentLocale !== t.requestedLocale || i === void 0 || !i.locations.some((e) => e.id === t.mappingId) || ![r.contentLocale, ...O.fallback[r.contentLocale]].includes(String(t.sourceLocale)) || t.fallback !== (t.sourceLocale !== t.requestedLocale) || t.routeId !== c(_, r.id, String(t.contentType), String(t.documentId), String(t.mappingId))) return p("route");
+		if (t.state === "unroutable") {
+			if (e.key !== `unroutable:${t.routeId}` || t.reason !== "orphan") return p("route");
+		} else if (t.state !== "resolved" || typeof t.path != "string" || !t.path.startsWith("/") || t.path.startsWith("//") || /[?#\\]/.test(t.path) || e.key !== `path:${m(t.path)}`) return p("route");
+		return t.state === "resolved" && s(E, t), t;
+	}, F = async (e, t) => {
+		let n = c(_, t, String(e.contentType), String(e.documentId), String(e.mappingId)), i = await r(l, _, S, "routes", `identity:${n}`);
+		if (i === null) return null;
+		if (i.value.version !== 1 || i.value.kind !== "route-index" || !h(i.value.target)) return p("route");
+		let o = await a(l, _, S, "routes", i.value.target), s = P(o);
+		return s.routeId === n ? s : p("route");
+	}, I = n({
+		key: "configuration",
+		value: {
+			version: 1,
+			..._,
+			origin: M,
+			xDefault: b,
+			sourceSnapshot: {
+				id: S.id,
+				digest: S.digest
+			},
+			inputs: S.manifest.parts.filter((e) => [
+				"routes",
+				"domains",
+				"locales"
+			].includes(e.part)),
+			addressPolicy: "published-own-variants/v1",
+			publicAdmission: "required"
+		}
+	});
+	return {
+		format: "voltro.cms.seo-addresses/v2",
+		entries: async function* (e) {
+			if (d(e) !== d(S.manifest.publication)) return p("publication");
+			yield n(I);
+			let t = x === void 0 ? w.entries(e) : (async function* () {
+				yield await a(l, _, S, "routes", x);
+			})();
+			for await (let e of t) {
+				if (e.key === "configuration" || e.key.startsWith("identity:")) continue;
+				let t = P(e), r = await F(t, String(t.localeId));
+				if (r === null || d(r) !== d(t)) return p("route");
+				if (t.state === "unroutable") {
+					yield {
+						key: String(t.routeId),
+						value: {
+							version: 1,
+							routeKey: e.key,
+							state: "excluded",
+							reason: "unroutable"
+						}
+					};
+					continue;
+				}
+				if (s(E, t).owner === "code") {
+					yield {
+						key: String(t.routeId),
+						value: {
+							version: 1,
+							routeKey: e.key,
+							state: "excluded",
+							reason: "code-owned"
+						}
+					};
+					continue;
+				}
+				let i = [];
+				for (let e of N) {
+					let n = await F(t, e.id);
+					n !== null && n.state === "resolved" && n.fallback === !1 && s(E, n).owner === "cms" && i.push({
+						localeId: e.id,
+						locale: e.tag,
+						routeId: String(n.routeId),
+						href: M + String(n.path)
+					});
+				}
+				let a = N.find((e) => e.contentLocale === t.sourceLocale), o = a === void 0 ? void 0 : i.find((e) => e.localeId === a.id);
+				if (o === void 0) return p("route");
+				yield n({
+					key: String(t.routeId),
+					value: {
+						version: 1,
+						state: "resolved",
+						routeKey: e.key,
+						routeId: t.routeId,
+						revisionId: t.revisionId,
+						lastModified: t.lastModified,
+						requestedLocale: t.requestedLocale,
+						sourceLocale: t.sourceLocale,
+						fallback: t.fallback,
+						canonical: o.href,
+						canonicalRouteId: o.routeId,
+						alternates: i,
+						xDefault: b ? i.find((e) => e.localeId === O.definition.defaultLocale)?.href ?? null : null
+					}
+				});
+			}
+		}
+	};
+};
+//#endregion
+export { f as SnapshotSeoUnavailable, g as snapshotSeoAddressSource };