@voltro/cms 0.85.0 → 0.87.0

package/dist/buildSnapshot.js

@@ -0,0 +1,401 @@
+import { capturePublicationState as e, verifyPublicationState as t } from "./publicationState.js";
+import { Schema as n } from "effect";
+import { and as r, eq as i, gt as a, id as o, inSet 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";
+//#region src/buildSnapshot.ts
+var _ = [
+	"release",
+	"environment",
+	"site",
+	"domains",
+	"locales",
+	"routes",
+	"schema",
+	"components",
+	"assets",
+	"redirects",
+	"seo",
+	"policies",
+	"projection",
+	"app"
+], v = /* @__PURE__ */ new Set([
+	"release",
+	"environment",
+	"site",
+	"locales",
+	"schema",
+	"components",
+	"seo",
+	"policies",
+	"projection",
+	"app"
+]), y = class extends n.TaggedError()("BuildSnapshotUnavailable", { reason: n.Literals([
+	"scope",
+	"parts",
+	"resource",
+	"duplicate",
+	"bounds",
+	"snapshot",
+	"expired",
+	"cursor"
+]) }) {}, b = "_voltro_cms_build_snapshots", x = "_voltro_cms_snapshot_resources", S = d(b, {
+	id: o({ prefix: "bsnap" }),
+	site: f().maxLength(64),
+	environment: f().maxLength(64),
+	state: f().oneOf(["capturing", "sealed"]),
+	publicationStateId: f().maxLength(64),
+	manifest: l().nullable(),
+	digest: f().maxLength(64).nullable(),
+	capturedAt: p(),
+	expiresAt: p()
+}).with(m()), C = d(x, {
+	id: o({ prefix: "bsres" }),
+	snapshotId: f().maxLength(64),
+	site: f().maxLength(64),
+	environment: f().maxLength(64),
+	part: f().maxLength(32),
+	ordinal: c(),
+	key: f().maxLength(256),
+	keyDigest: f().maxLength(64),
+	value: l(),
+	digest: f().maxLength(64)
+}).with(m()).index("cms_snapshot_resources_page", [
+	"tenantId",
+	"snapshotId",
+	"part",
+	"ordinal"
+]).unique("cms_snapshot_resources_key", [
+	"tenantId",
+	"snapshotId",
+	"part",
+	"keyDigest"
+]), w = (e) => {
+	throw new y({ reason: e });
+}, T = (e) => typeof e == "string" && e.trim().length > 0, E = (e) => h("sha256").update(g(e)).digest("hex"), D = (e, t, n) => E({
+	part: e,
+	ordinal: t,
+	...n
+}), O = (e, t) => {
+	let n = h("sha256"), r = 0;
+	for (let i of t.entries()) n.update(D(e, ++r, M(i)) + "\n");
+	return {
+		part: e,
+		format: t.format,
+		entries: r,
+		digest: n.digest("hex")
+	};
+}, k = (e) => typeof e == "string" && /^[0-9a-f]{64}$/.test(e), A = (e) => [
+	e.tenantId,
+	e.site,
+	e.environment
+].every(T) ? r(i("tenantId", e.tenantId), i("site", e.site), i("environment", e.environment)) : w("scope"), j = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, M = (e) => {
+	if (!T(e.key) || e.key.length > 256 || e.value === null || typeof e.value != "object" || Array.isArray(e.value)) return w("resource");
+	let t = /* @__PURE__ */ new Set(), n = (e, r) => {
+		if (r > 64) return w("bounds");
+		if (e !== null && typeof e != "string" && typeof e != "boolean" && !(typeof e == "number" && Number.isFinite(e))) {
+			if (typeof e != "object" || t.has(e) || Object.getOwnPropertySymbols(e).length > 0 || !Array.isArray(e) && Object.getPrototypeOf(e) !== Object.prototype && Object.getPrototypeOf(e) !== null || Array.isArray(e) && (Object.keys(e).length !== e.length || Object.keys(e).some((e, t) => e !== String(t)))) return w("resource");
+			t.add(e);
+			for (let [t, i] of Object.entries(Object.getOwnPropertyDescriptors(e))) if (!(Array.isArray(e) && t === "length")) {
+				if (!i.enumerable || !("value" in i)) return w("resource");
+				n(i.value, r + 1);
+			}
+			t.delete(e);
+		}
+	};
+	n(e.value, 0);
+	let r = JSON.stringify(e.value);
+	return Buffer.byteLength(r, "utf8") > 524288 ? w("bounds") : {
+		key: e.key,
+		value: JSON.parse(r)
+	};
+}, N = async (t, n, r, i) => {
+	if (A(r), Object.keys(i.sources).length !== _.length || _.some((e) => {
+		let t = i.sources[e];
+		return t === void 0 || !T(t.format) || t.format.length > 128 || typeof t.entries != "function";
+	})) return w("parts");
+	let a = {
+		tenantId: r.tenantId,
+		site: r.site,
+		environment: r.environment
+	}, o = Object.fromEntries(_.map((e) => [e, {
+		format: i.sources[e].format,
+		entries: i.sources[e].entries
+	}])), s = i.now ?? Date.now();
+	return P(t, a, await e(t, n, a, {
+		locales: i.locales,
+		expiresAt: i.expiresAt,
+		now: s
+	}), {
+		sources: o,
+		now: s,
+		expiresAt: i.expiresAt
+	});
+}, P = async (e, t, n, a) => {
+	let { now: o, sources: c } = a, l = await e.insert(b, {
+		tenantId: t.tenantId,
+		site: t.site,
+		environment: t.environment,
+		state: "capturing",
+		publicationStateId: n.id,
+		manifest: null,
+		digest: null,
+		capturedAt: new Date(o),
+		expiresAt: new Date(a.expiresAt)
+	}), u = String(l.id), d = [];
+	for (let a of _) {
+		let o = c[a], l = h("sha256"), f = 0, p = [], m = 0, g = async () => {
+			if (p.length === 0) return;
+			let n = p.map((e) => String(e.keyDigest));
+			if (new Set(n).size !== n.length || (await e.query({
+				table: "_voltro_cms_snapshot_resources",
+				predicate: r(A(t), i("snapshotId", u), i("part", a), s("keyDigest", n)),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: ["id"]
+			})).length > 0) return w("duplicate");
+			await e.insertMany(x, p, { returning: "none" }), p = [], m = 0;
+		};
+		for await (let e of o.entries(structuredClone(n))) {
+			let n = M(e), r = Buffer.byteLength(JSON.stringify(n.value), "utf8");
+			if ((p.length >= 64 || m + r > 2097152) && await g(), f === 2147483647) return w("bounds");
+			let i = ++f, o = D(a, i, n);
+			l.update(o + "\n"), p.push({
+				tenantId: t.tenantId,
+				site: t.site,
+				environment: t.environment,
+				snapshotId: u,
+				part: a,
+				ordinal: i,
+				key: n.key,
+				keyDigest: E(n.key),
+				value: n.value,
+				digest: o
+			}), m += r;
+		}
+		if (await g(), f === 0 && v.has(a)) return w("parts");
+		d.push({
+			part: a,
+			format: o.format,
+			entries: f,
+			digest: l.digest("hex")
+		});
+	}
+	let f = {
+		version: 1,
+		capturedAt: o,
+		expiresAt: a.expiresAt,
+		scope: {
+			tenantId: t.tenantId,
+			site: t.site,
+			environment: t.environment
+		},
+		publication: n,
+		parts: d
+	}, p = E(f);
+	return await e.update(b, u, {
+		state: "sealed",
+		manifest: f,
+		digest: p
+	}), {
+		id: u,
+		digest: p,
+		expiresAt: a.expiresAt,
+		manifest: structuredClone(f)
+	};
+}, F = async (e, t, n, a = Date.now()) => {
+	let [o] = await e.query({
+		table: b,
+		predicate: r(A(t), i("id", n)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (o === void 0 || o.state !== "sealed" || !k(o.digest) || o.manifest === null || typeof o.manifest != "object") return w("snapshot");
+	let s = o.manifest;
+	if (s.version !== 1 || !Array.isArray(s.parts) || s.parts.length !== _.length || g(s.scope) !== g({
+		tenantId: t.tenantId,
+		site: t.site,
+		environment: t.environment
+	}) || s.publication?.id !== o.publicationStateId || !k(s.publication?.digest) || s.parts.some((e, t) => typeof e != "object" || !e || e.part !== _[t] || !T(e.format) || !Number.isSafeInteger(e.entries) || e.entries < 0 || !k(e.digest)) || E(s) !== o.digest) return w("snapshot");
+	let c = j(o.expiresAt);
+	return !Number.isSafeInteger(a) || !Number.isFinite(c) || !Number.isSafeInteger(s.capturedAt) || !Number.isSafeInteger(s.expiresAt) || s.expiresAt <= s.capturedAt || j(o.capturedAt) !== s.capturedAt || c !== s.expiresAt || a < s.capturedAt ? w("snapshot") : c <= a ? w("expired") : {
+		id: n,
+		digest: o.digest,
+		expiresAt: c,
+		manifest: structuredClone(s)
+	};
+}, I = async (e, t, n, o, s = {}) => {
+	let c = (await F(e, t, n, s.now)).manifest.parts.find((e) => e.part === o), l = 0, u = s.limit ?? 64;
+	if (c === void 0) return w("parts");
+	if (s.after !== void 0) {
+		if (!T(s.after) || s.after.length > 64) return w("cursor");
+		let [a] = await e.query({
+			table: x,
+			predicate: r(A(t), i("snapshotId", n), i("part", o), i("id", s.after)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (a === void 0 || typeof a.ordinal != "number" || !Number.isSafeInteger(a.ordinal) || a.ordinal < 1 || a.ordinal > c.entries || a.keyDigest !== E(a.key) || a.digest !== E({
+			part: o,
+			ordinal: a.ordinal,
+			key: a.key,
+			value: a.value
+		})) return w("cursor");
+		l = a.ordinal;
+	}
+	if (!Number.isSafeInteger(u) || u < 1 || u > 200) return w("bounds");
+	let d = await e.query({
+		table: x,
+		predicate: r(A(t), i("snapshotId", n), i("part", o), a("ordinal", l)),
+		order: [{
+			column: "ordinal",
+			direction: "asc"
+		}],
+		take: Math.min(u, c.entries - l) + 1,
+		skip: void 0,
+		projection: void 0
+	}), f = Math.min(u + 1, c.entries - l);
+	return d.length === f ? {
+		items: d.map((e, t) => {
+			let n = l + t + 1;
+			return e.ordinal !== n || e.keyDigest !== E(e.key) || e.digest !== E({
+				part: o,
+				ordinal: n,
+				key: e.key,
+				value: e.value
+			}) ? w("resource") : M({
+				key: String(e.key),
+				value: e.value
+			});
+		}).slice(0, u),
+		next: l + u < c.entries ? String(d[u - 1].id) : null
+	} : w("resource");
+}, L = async (e, t, n, r, i) => (await R(e, t, n, r, [i])).get(i) ?? null, R = async (e, t, n, a, o) => {
+	let c = n.manifest.parts.find((e) => e.part === a);
+	if (c === void 0 || o.some((e) => !T(e) || e.length > 256) || g(n.manifest.scope) !== g({
+		tenantId: t.tenantId,
+		site: t.site,
+		environment: t.environment
+	})) return w("scope");
+	if (o.length > 200) return w("bounds");
+	let l = new Set(o), u = /* @__PURE__ */ new Map();
+	if (l.size === 0) return u;
+	let d = await e.query({
+		table: x,
+		predicate: r(A(t), i("snapshotId", n.id), i("part", a), s("keyDigest", [...l].map(E))),
+		lock: "update",
+		order: [],
+		take: l.size,
+		skip: void 0,
+		projection: void 0
+	});
+	for (let e of d) {
+		let t = e.key;
+		if (typeof t != "string" || !l.has(t) || u.has(t) || e.keyDigest !== E(t) || !Number.isSafeInteger(e.ordinal) || Number(e.ordinal) < 1 || Number(e.ordinal) > c.entries || e.digest !== E({
+			part: a,
+			ordinal: e.ordinal,
+			key: t,
+			value: e.value
+		})) return w("resource");
+		u.set(t, M({
+			key: t,
+			value: e.value
+		}));
+	}
+	return u;
+}, z = async (e, t, n, r, i) => await L(e, t, n, r, i) ?? w("resource"), B = async (e, n, o, s = Date.now()) => {
+	let c = await F(e, n, o.id, s);
+	if (c.digest !== o.digest) return w("snapshot");
+	await t(e, c.manifest.scope, c.manifest.publication, s);
+	let l = new Map(c.manifest.parts.map((e) => [e.part, {
+		pin: e,
+		count: 0,
+		digest: h("sha256")
+	}])), d;
+	for (;;) {
+		let t = await e.query({
+			table: x,
+			predicate: r(A(n), i("snapshotId", c.id), ...d === void 0 ? [] : [u(a("part", d.part), r(i("part", d.part), a("ordinal", d.ordinal)))]),
+			order: [{
+				column: "part",
+				direction: "asc"
+			}, {
+				column: "ordinal",
+				direction: "asc"
+			}],
+			take: 64,
+			skip: void 0,
+			projection: void 0
+		});
+		for (let e of t) {
+			let t = l.get(e.part);
+			if (t === void 0 || e.ordinal !== ++t.count || t.count > t.pin.entries || e.keyDigest !== E(e.key) || e.digest !== E({
+				part: t.pin.part,
+				ordinal: t.count,
+				key: e.key,
+				value: e.value
+			})) return w("resource");
+			let n = M({
+				key: String(e.key),
+				value: e.value
+			});
+			t.digest.update(D(t.pin.part, t.count, n) + "\n"), d = {
+				part: t.pin.part,
+				ordinal: t.count
+			};
+		}
+		if (t.length < 64) break;
+	}
+	for (let { pin: e, count: t, digest: n } of l.values()) if (t !== e.entries || n.digest("hex") !== e.digest) return w("resource");
+	return c;
+}, V = (e, t, n, r, i = Date.now()) => {
+	let a = structuredClone(n), o = {
+		tenantId: t.tenantId,
+		site: t.site,
+		environment: t.environment
+	}, s = a.manifest.parts.find((e) => e.part === r);
+	return s === void 0 ? w("parts") : {
+		format: s.format,
+		entries: async function* (t) {
+			if (g(t) !== g(a.manifest.publication)) return w("snapshot");
+			let n = h("sha256"), c, l = 0;
+			do {
+				let t = await I(e, o, a.id, r, {
+					now: i,
+					limit: 100,
+					...c === void 0 ? {} : { after: c }
+				});
+				for (let e of t.items) n.update(D(r, ++l, e) + "\n"), yield e;
+				c = t.next ?? void 0;
+			} while (c !== void 0);
+			if (l !== s.entries || n.digest("hex") !== s.digest) return w("resource");
+		}
+	};
+}, H = async (e, t, n, r, i = Date.now()) => {
+	let a = {
+		tenantId: t.tenantId,
+		site: t.site,
+		environment: t.environment
+	}, o = {
+		id: n.id,
+		digest: n.digest
+	}, s = Object.entries(r);
+	if (s.some(([e, t]) => !_.includes(e) || t === void 0 || !T(t.format) || t.format.length > 128 || typeof t.entries != "function")) return w("parts");
+	let c = new Map(s.map(([e, t]) => [e, {
+		format: t.format,
+		entries: t.entries
+	}])), l = await B(e, a, o, i), u = Object.fromEntries(l.manifest.parts.map((t) => [t.part, c.get(t.part) ?? V(e, a, l, t.part, i)])), d = await P(e, a, l.manifest.publication, {
+		sources: u,
+		now: l.manifest.capturedAt,
+		expiresAt: l.expiresAt
+	});
+	return d.manifest.parts.some((e, t) => !c.has(e.part) && g(e) !== g(l.manifest.parts[t])) ? w("resource") : d;
+};
+//#endregion
+export { b as BUILD_SNAPSHOTS_TABLE, y as BuildSnapshotUnavailable, _ as SNAPSHOT_PARTS, x as SNAPSHOT_RESOURCES_TABLE, S as buildSnapshotsTable, N as captureBuildSnapshot, M as copySnapshotResource, H as deriveBuildSnapshot, L as findVerifiedSnapshotResource, R as findVerifiedSnapshotResources, I as pageSnapshotResources, V as pinnedSnapshotPartSource, F as readBuildSnapshot, z as readVerifiedSnapshotResource, D as snapshotResourceDigest, C as snapshotResourcesTable, O as snapshotStaticPartPin, B as verifyBuildSnapshot };

package/dist/buildSnapshotApplicationPin.js

@@ -0,0 +1,32 @@
+import { copySnapshotAppCodePin as e } from "./snapshotDefinitions.js";
+//#region src/buildSnapshotApplicationPin.ts
+var t = (e) => {
+	let t = () => {
+		throw TypeError("Invalid retained application identity");
+	};
+	if (typeof e != "object" || !e || Array.isArray(e) || Object.keys(e).sort().join(",") !== "executionId,inputsId") return t();
+	let { inputsId: n, executionId: r } = e;
+	return typeof n != "string" || !/^[a-f0-9]{64}$/.test(n) || typeof r != "string" || !/^[a-f0-9]{64}$/.test(r) ? t() : {
+		inputsId: n,
+		executionId: r
+	};
+}, n = (t) => {
+	let n = () => {
+		throw TypeError("Invalid retained application pin");
+	};
+	if (typeof t != "object" || !t || Array.isArray(t) || Object.keys(t).sort().join(",") !== "code,executionId,inputsId") return n();
+	let { code: r, inputsId: i, executionId: a } = t;
+	if (typeof i != "string" || !/^[a-f0-9]{64}$/.test(i) || typeof a != "string" || !/^[a-f0-9]{64}$/.test(a) || typeof r != "object" || !r || Array.isArray(r) || Object.keys(r).sort().join(",") !== "artifactDigest,commit,configDigest") return n();
+	let o = r;
+	return typeof o.commit != "string" || typeof o.artifactDigest != "string" || typeof o.configDigest != "string" ? n() : {
+		inputsId: i,
+		executionId: a,
+		code: e({
+			commit: o.commit,
+			artifactDigest: o.artifactDigest,
+			configDigest: o.configDigest
+		})
+	};
+};
+//#endregion
+export { t as copyBuildSnapshotApplicationIdentity, n as copyBuildSnapshotApplicationPin };

package/dist/buildSnapshotRest.js

@@ -0,0 +1,210 @@
+import { cmsCredential as e, privateCmsHttpRoutes as t, privateCmsOperation as n } from "./privateCmsTransport.js";
+import { CmsBuildSnapshotUnavailable as r } from "./buildSnapshotService.js";
+import { Schema as i } from "effect";
+//#region src/buildSnapshotRest.ts
+var a = (t) => e(t, "CmsBuildSnapshotUnavailable"), o = i.Struct({
+	id: i.String,
+	digest: i.String
+}), s = i.Struct({
+	artifactId: i.String,
+	pathSets: i.Array(i.Struct({
+		id: i.String,
+		digest: i.String
+	}))
+}), c = i.Struct({
+	version: i.Literal(1),
+	decided: i.Boolean,
+	granted: i.Array(i.Struct({
+		id: i.String,
+		version: i.Number
+	}))
+}), l = i.Struct({
+	snapshot: o,
+	consumerId: i.String,
+	buildId: i.String,
+	host: i.String,
+	path: i.String,
+	presentation: i.optional(c)
+}), u = (e, t) => ({
+	snapshot: e.snapshot,
+	consumerId: e.consumerId,
+	buildId: e.buildId,
+	host: e.host,
+	path: e.path,
+	token: a(t),
+	...e.presentation === void 0 ? {} : { presentation: e.presentation }
+}), d = i.Struct({
+	snapshotId: i.String,
+	snapshotDigest: i.String,
+	routeId: i.String,
+	path: i.String,
+	contentType: i.String,
+	localeId: i.String,
+	requestedLocale: i.String,
+	sourceLocale: i.String,
+	fallback: i.Boolean,
+	values: i.Record(i.String, i.Unknown),
+	presentation: c
+}), f = i.Struct({
+	documentId: i.String,
+	parent: i.NullOr(i.String),
+	depth: i.Number,
+	path: i.String,
+	sourceLocale: i.String,
+	fallback: i.Boolean,
+	values: i.Record(i.String, i.Unknown)
+}), p = (e, t, i, a, o, s) => n({
+	namespace: "cms.buildSnapshot",
+	path: "/v1/cms/build-snapshots",
+	operationPrefix: "cmsBuildSnapshot",
+	tags: ["CMS build snapshots"],
+	credentialError: "CmsBuildSnapshotUnavailable",
+	error: r,
+	errorStatus: { CmsBuildSnapshotUnavailable: 409 }
+}, e, t, i, a, o, s), m = (e) => {
+	let n = [
+		p("capture", "Capture or resume one immutable build snapshot", "Organization API-key bearer. Scope, app inputs, expiry and storage are selected by the server. Optional expectedApplication compares the retained source, inputs and execution before any capture attempt; it selects no provider or path. Reuse attemptId only with the same authority, release and configuration.", i.Struct({
+			attemptId: i.String,
+			releaseId: i.String,
+			expectedApplication: i.optional(i.Struct({
+				inputsId: i.String,
+				executionId: i.String,
+				code: i.Struct({
+					commit: i.String,
+					artifactDigest: i.String,
+					configDigest: i.String
+				})
+			}))
+		}), i.Struct({
+			id: i.String,
+			digest: i.String,
+			expiresAt: i.Number
+		}), (t, n) => e.capture({
+			attemptId: t.attemptId,
+			releaseId: t.releaseId,
+			apiKey: a(n),
+			...t.expectedApplication === void 0 ? {} : { expectedApplication: t.expectedApplication }
+		})),
+		p("open", "Issue a short-lived read grant for the retained application", "Organization API-key bearer. Optional resume requires the original grant token and buildId plus the same parent credential, even after read expiry; revoked proof refuses. consentPurposes is the bounded catalog from this same independently verified retained application, not personal consent or additional rights. Coordinators can derive finite public presentation classes without executing application code. The response token is private and must never be persisted in a public artifact or a generic HTTP idempotency cache.", i.Struct({
+			snapshot: o,
+			resume: i.optional(i.Struct({
+				token: i.String,
+				buildId: i.String
+			}))
+		}), i.Struct({
+			id: i.String,
+			token: i.String,
+			expiresAt: i.Number,
+			consumerId: i.String,
+			buildId: i.String,
+			snapshotId: i.String,
+			snapshotDigest: i.String,
+			consentPurposes: i.Array(i.Struct({
+				id: i.String,
+				version: i.Int
+			})).check(i.isMaxLength(32))
+		}), (t, n) => e.open({
+			snapshot: t.snapshot,
+			apiKey: a(n),
+			...t.resume === void 0 ? {} : { resume: t.resume }
+		})),
+		p("read", "Read anonymous projected content at one snapshot route", "Render-read token bearer from open. All reads carry the same snapshot pin. Unknown routes return null only after fresh grant, host and snapshot admission; there is no live fallback.", l, i.NullOr(d), (t, n) => e.read(u(t, n))),
+		p("readBinding", "Read a captured site binding at an admitted CMS page", "Render-read token bearer. The server resolves only named site bindings captured in the same snapshot, using its locale fallback, anonymous access, consent and field projection. Nested references grant no media or document access.", i.Struct({
+			...l.fields,
+			binding: i.String
+		}), i.NullOr(i.Struct({
+			snapshotId: i.String,
+			snapshotDigest: i.String,
+			binding: i.String,
+			contentType: i.String,
+			localeId: i.String,
+			requestedLocale: i.String,
+			sourceLocale: i.String,
+			fallback: i.Boolean,
+			values: i.Record(i.String, i.Unknown),
+			presentation: c
+		})), (t, n) => e.readBinding({
+			...u(t, n),
+			binding: t.binding
+		})),
+		p("readTree", "Read a named public tree from the captured publication", "Render-read token bearer. Named scalar projections, tree ordering, ancestor policy and mapped addresses come from this snapshot. Breadcrumbs are independent of navigation inclusion. No live fallback or personal authority; unknown names fail after credential admission.", i.Struct({
+			...l.fields,
+			name: i.String
+		}), i.Struct({
+			version: i.Literals([1]),
+			contentType: i.String,
+			localeId: i.String,
+			requestedLocale: i.String,
+			currentDocumentId: i.NullOr(i.String),
+			nodes: i.Array(f),
+			ancestors: i.Array(f)
+		}), (t, n) => e.readTree({
+			...u(t, n),
+			name: t.name
+		})),
+		p("render", "Render a private candidate using the retained application", "Render-read token bearer from open. This does not activate output or grant permission to serve it. Media requires the server-configured custody/output provider.", l, i.NullOr(i.Struct({
+			html: i.String,
+			head: i.String,
+			document: i.NullOr(i.String),
+			artifactId: i.NullOr(i.String)
+		})), (t, n) => e.render(u(t, n))),
+		p("renderSafety", "Stage one complete current safety generation for captured output", "Render-read token bearer. Requires actual complete documents and stored signed path sets from the same snapshot, application and build. The server stages every current scoped URL/hash denial; a changed generation or withdrawn admission refuses before sealing. Returned private artifact IDs grant no activation or serving authority.", i.Struct({
+			snapshot: o,
+			consumerId: i.String,
+			buildId: i.String,
+			host: i.String,
+			documents: s
+		}), i.Struct({
+			artifactId: i.String,
+			generation: i.Int,
+			entryCount: i.Int
+		}), (t, n) => e.renderSafety({
+			...t,
+			token: a(n)
+		})),
+		p("renderRedirects", "Stage explicitly approved retired routes from captured source and output history", "Render-read token bearer. Requires actual document custody, complete signed path sets for every enabled locale and both owners on this host, current renderSafety output, and the captured server-admitted route declaration. The required sorted targets array supplies {host, documents} for every other selected host; use an empty array for one host. Each target inventory undergoes the same fresh grant, document, rights and complete signed EOF admission. Every retired observed URL needs explicit current intent; conflicting historical owners hold. Current owners suppress old rules, but only admitted public documents may be redirect targets. Intrinsic CMS redirects do not authorize output. Exact 301/302 method permission, 307/308 preservation, 404/410 and active intervals remain distinct. Rechecks authority and current metadata around writes. Returned private artifacts confer no activation or public serving authority.", i.Struct({
+			snapshot: o,
+			consumerId: i.String,
+			buildId: i.String,
+			host: i.String,
+			documents: s,
+			targets: i.Array(i.Struct({
+				host: i.String,
+				documents: s
+			})),
+			safety: i.Struct({ artifactId: i.String })
+		}), i.Struct({
+			artifactId: i.String,
+			count: i.Int
+		}), (t, n) => e.renderRedirects({
+			...t,
+			token: a(n)
+		})),
+		p("renderSeo", "Stage private sitemap and robots artifacts from captured public SEO", "Render-read token bearer. Anonymous own variants, editorial opt-out/index policy, canonical domain and alternates come from this snapshot. Production web controls require the actual document artifact, stored signed path-set IDs and digests, and the current renderSafety artifact; native metadata comes from matched render receipts. Withdrawn URLs and documents using denied media are excluded, including their alternates. Current safety and document admission are checked around output writes. Large sitemaps split by protocol limits. Returned private artifact IDs confer no activation or serving authority; an output provider is required.", i.Struct({
+			snapshot: o,
+			consumerId: i.String,
+			buildId: i.String,
+			host: i.String,
+			documents: i.optional(s),
+			safety: i.optional(i.Struct({ artifactId: i.String }))
+		}), i.Struct({
+			sitemapArtifactId: i.String,
+			robotsArtifactId: i.String,
+			urlCount: i.Number
+		}), (t, n) => e.renderSeo({
+			snapshot: t.snapshot,
+			consumerId: t.consumerId,
+			buildId: t.buildId,
+			host: t.host,
+			token: a(n),
+			...t.documents === void 0 ? {} : { documents: t.documents },
+			...t.safety === void 0 ? {} : { safety: t.safety }
+		}))
+	];
+	return {
+		routes: n,
+		httpRoutes: t(n)
+	};
+};
+//#endregion
+export { m as cmsBuildSnapshotRest };