@voltro/cms 0.86.0 → 0.88.0

package/dist/snapshotDocumentAssembly.js

@@ -0,0 +1,192 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+import { admitSnapshotPresentation as t, snapshotPresentations as n } from "./snapshotPresentation.js";
+import { readCapturedSnapshotConsentPurposes as r } from "./snapshotPresentationPolicy.js";
+import { SnapshotSeoReadUnavailable as i } from "./snapshotSeoRead.js";
+import { copySnapshotPathSetSelection as a, readSnapshotPathSets as o } from "./snapshotSeoPathSets.js";
+import { readSnapshotSeoDocuments as s } from "./snapshotSeoDocuments.js";
+import { createHash as c } from "node:crypto";
+import { canonicalJson as l } from "@voltro/runtime";
+// src/snapshotDocumentAssembly.ts
+var u = () => {
+	throw new i({ reason: "binding" });
+}, d = (e) => c("sha256").update(l(e)).digest("hex"), f = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), p = (e, t) => typeof e != "object" || !e || Array.isArray(e) || Object.keys(e).sort().join(",") !== t ? u() : e, m = (e, t) => Number.isSafeInteger(e) && Number(e) >= 0 && Number(e) <= t, h = 1e5, g = 67108864, _ = 8192, v = "voltro.cms-document-assembly/v1", y = (i) => {
+	let { store: c, provider: y } = i, b = {
+		tenantId: i.scope.tenantId,
+		site: i.scope.site,
+		environment: i.scope.environment
+	}, x = { ...i.use }, S = i.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), C = i.now ?? Date.now, w = (e) => ({
+		snapshot: {
+			id: e.snapshot.id,
+			digest: e.snapshot.digest
+		},
+		token: e.token,
+		consumerId: e.consumerId,
+		buildId: e.buildId,
+		host: e.host,
+		...a({ pathSets: e.pathSets })
+	}), T = async (e) => c.transactional(async (t) => {
+		let i = await o(t, b, e, { pathSets: e.pathSets }, {
+			keys: S,
+			now: C
+		}), a = i.admission;
+		if (a.app.web === void 0) return u();
+		let s = await r(t, b, a.admission.snapshot, a.admission.configuration.app), c = [...n(s, 257)].sort((e, t) => d(e) < d(t) ? -1 : +(d(e) > d(t)));
+		return {
+			paths: i,
+			consentPurposes: s,
+			presentations: c,
+			binding: {
+				scope: b,
+				snapshot: e.snapshot,
+				consumerId: e.consumerId,
+				buildId: e.buildId,
+				host: e.host,
+				inputsId: a.app.inputsId,
+				executionId: a.app.executionId,
+				pathSets: [...i.selection.pathSets].sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)),
+				consentPurposes: s,
+				presentations: c
+			}
+		};
+	}), E = (e, t) => {
+		if (l(e.binding) !== l(t.binding) || l(e.paths.entries) !== l(t.paths.entries) || l(e.paths.contexts) !== l(t.paths.contexts)) return u();
+	}, D = async (e) => {
+		if (!f(e) || y.read === void 0) return u();
+		let t = await y.read(e);
+		return t.id !== e || d(t.manifest) !== e || t.manifest.version !== 1 || t.manifest.files.length !== 0 ? u() : t.manifest.subject;
+	}, O = async (e) => {
+		let t = await y.begin();
+		try {
+			let n = await t.seal(e);
+			return !f(n.id) || n.id !== d({
+				version: 1,
+				subject: e,
+				files: []
+			}) ? u() : n.id;
+		} catch (e) {
+			throw await t.abort(), e;
+		}
+	}, k = (e) => !f(e.headerId) || !f(e.tipId) ? u() : {
+		headerId: e.headerId,
+		tipId: e.tipId
+	}, A = async (e, t) => {
+		let n = p(await D(e.headerId), "binding,profile,version");
+		if (n.version !== 1 || n.profile !== v || l(n.binding) !== l(t.binding)) return u();
+	}, j = (n, r) => {
+		let i = e({
+			key: "document-assembly",
+			value: { documents: n }
+		}).value.documents;
+		if (!Array.isArray(i) || i.length === 0 || i.length > h || Buffer.byteLength(l(i)) > _) return u();
+		let a = new Map(r.paths.entries.map((e) => [e.path, e]));
+		return i.map((e) => {
+			let n = p(e, "artifactId,path,presentation,routeId,url"), i = a.get(String(n.path));
+			return !f(n.artifactId) || i === void 0 || n.routeId !== i.routeId || n.url !== "https://" + i.host + i.path ? u() : {
+				url: String(n.url),
+				path: i.path,
+				routeId: i.routeId,
+				artifactId: n.artifactId,
+				presentation: t(r.consentPurposes, n.presentation)
+			};
+		});
+	}, M = async (e, t, n) => {
+		if (e === t.headerId) return {
+			previousId: null,
+			count: 0,
+			bytes: 0,
+			documents: []
+		};
+		let r = p(await D(e), "bytes,count,documents,headerId,previousId,profile,version");
+		return r.version !== 1 || r.profile !== v || r.headerId !== t.headerId || !f(r.previousId) || !m(r.count, h) || !m(r.bytes, g) ? u() : {
+			previousId: r.previousId,
+			count: r.count,
+			bytes: r.bytes,
+			documents: j(r.documents, n)
+		};
+	};
+	return {
+		begin: async (e) => {
+			let t = w(e), n = await T(t), r = await O({
+				version: 1,
+				profile: v,
+				binding: n.binding
+			});
+			return E(n, await T(t)), {
+				headerId: r,
+				tipId: r,
+				count: 0,
+				bytes: 0
+			};
+		},
+		append: async (t) => {
+			let n = w(t), r = k(t), i = e({
+				key: "document-assembly",
+				value: { documents: t.documents }
+			}).value.documents, a = await T(n), o = j(i, a);
+			await A(r, a);
+			let s = await M(r.tipId, r, a), c = s.count + o.length, d = s.bytes + Buffer.byteLength(l(o));
+			if (c > h || d > g) return u();
+			let f = await O({
+				version: 1,
+				profile: v,
+				headerId: r.headerId,
+				previousId: r.tipId,
+				count: c,
+				bytes: d,
+				documents: o
+			});
+			return E(a, await T(n)), {
+				headerId: r.headerId,
+				tipId: f,
+				count: c,
+				bytes: d
+			};
+		},
+		seal: async (e) => {
+			let t = w(e), n = k(e), r = await T(t);
+			if (y.composeDocuments === void 0) return u();
+			await A(n, r);
+			let i = [], a = /* @__PURE__ */ new Set(), o = n.tipId, d, p = 0, _ = 0;
+			for (;;) {
+				if (a.has(o) || a.size > h) return u();
+				a.add(o);
+				let e = await M(o, n, r);
+				if (d !== void 0 && (e.count + d.documents.length !== d.count || e.bytes + Buffer.byteLength(l(d.documents)) !== d.bytes) || (p += e.documents.length, _ += e.documents.length === 0 ? 0 : Buffer.byteLength(l(e.documents)), p > h || _ > g)) return u();
+				if (e.previousId === null) break;
+				i.push(e.documents), d = e, o = e.previousId;
+			}
+			let v = i.reverse().flat(), D = r.paths.admission.app, O = await y.composeDocuments({
+				snapshotDigest: t.snapshot.digest,
+				inputsId: D.inputsId,
+				executionId: D.executionId,
+				selector: [
+					"1",
+					t.snapshot.digest,
+					D.inputsId,
+					D.executionId
+				].join("."),
+				pathSetIds: r.paths.selection.pathSets.map((e) => e.digest).sort(),
+				consentPurposes: r.consentPurposes,
+				presentations: r.presentations,
+				documents: v
+			});
+			return !f(O.id) || O.documents !== p || !m(O.bytes, 1073741824) ? u() : (E(r, await T(t)), await c.transactional((e) => s(e, b, t, {
+				artifactId: O.id,
+				pathSets: t.pathSets
+			}, {
+				provider: y,
+				use: x,
+				keys: S,
+				now: C
+			})), E(r, await T(t)), {
+				artifactId: O.id,
+				documents: O.documents,
+				bytes: O.bytes
+			});
+		}
+	};
+};
+export { y as createSnapshotDocumentAssembly };

package/dist/snapshotDocumentAssemblyRest.js

@@ -0,0 +1,83 @@
+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";
+// src/snapshotDocumentAssemblyRest.ts
+var s = {
+	namespace: "cms.documentAssembly",
+	path: "/v1/cms/document-assemblies",
+	operationPrefix: "cmsDocumentAssembly",
+	tags: ["CMS document assemblies"],
+	error: r,
+	errorStatus: { CmsBuildSnapshotUnavailable: 409 },
+	credentialError: "CmsBuildSnapshotUnavailable"
+}, c = a.Struct({
+	snapshot: a.Struct({
+		id: a.String,
+		digest: a.String
+	}),
+	consumerId: a.String,
+	buildId: a.String,
+	host: a.String,
+	pathSets: a.Array(a.Struct({
+		id: a.String,
+		digest: a.String
+	}))
+}), l = {
+	headerId: a.String,
+	tipId: a.String
+}, u = a.Struct({
+	...l,
+	count: a.Int,
+	bytes: a.Int
+}), d = a.Struct({
+	url: a.String,
+	path: a.String,
+	routeId: a.String,
+	artifactId: a.String,
+	presentation: a.Struct({
+		version: a.Literal(1),
+		decided: a.Boolean,
+		granted: a.Array(a.Struct({
+			id: a.String,
+			version: a.Int
+		}))
+	})
+}), f = (t, a, c, l, u, d) => n(s, t, a, c, o(l, s.namespace + "." + t, !0), u, (t, n) => {
+	let a = e(n, s.credentialError);
+	return i.tryPromise({
+		try: () => d(t, a),
+		catch: () => new r({ reason: "render" })
+	});
+}), p = (e) => {
+	let n = [
+		f("begin", "Begin a private captured document assembly", "Render-read bearer. The server freshly verifies the same snapshot, scope, app, consumer, build, host and stored signed path sets. Creates immutable private metadata only; no credentials are persisted. A journal ID grants no activation or serving authority.", c, u, (t, n) => e.begin({
+			...t,
+			token: n
+		})),
+		f("append", "Append one bounded immutable group of rendered document pins", "Render-read bearer. At most 8 KiB of document pins per part and 100000 documents/64 MiB metadata per branch. Original route identities and captured consent classes must match current admitted signed paths. Repeating the same append is idempotent; immutable branches are independent. No provider path or credential in the body.", a.Struct({
+			...c.fields,
+			...l,
+			documents: a.Array(d)
+		}), u, (t, n) => e.append({
+			...t,
+			token: n
+		})),
+		f("seal", "Compose complete captured documents from actual private renderer output", "Render-read bearer. Reopens the complete immutable chain, verifies actual renderer receipts and all document bytes through EOF in server-selected custody, requires complete signed route and public consent-class coverage, and rechecks current rights and authority after I/O. Partial, mismatched or expired branches refuse. Returned private artifact IDs grant no activation or serving permission.", a.Struct({
+			...c.fields,
+			...l
+		}), a.Struct({
+			artifactId: a.String,
+			documents: a.Int,
+			bytes: a.Int
+		}), (t, n) => e.seal({
+			...t,
+			token: n
+		}))
+	];
+	return {
+		routes: n,
+		httpRoutes: t(n)
+	};
+};
+export { p as cmsDocumentAssemblyRest };

package/dist/snapshotDocumentProjection.js

@@ -0,0 +1,201 @@
+import { richDocumentProblems as e } from "./richDocument.js";
+import { documentHasChanges as t } from "./trackChanges.js";
+import { readCapturedPublication as n } from "./publicationState.js";
+import { readVerifiedSnapshotResource as r } from "./buildSnapshot.js";
+import { admitSnapshotPresentation as i, copySnapshotPresentationValue as a } from "./snapshotPresentation.js";
+import { projectContentValues as o } from "./contentProjection.js";
+import { readCapturedSnapshotConsentPurposes as s } from "./snapshotPresentationPolicy.js";
+import { SnapshotRouteReadUnavailable as c } from "./snapshotRouteAdmission.js";
+import { createHash as l } from "node:crypto";
+import { canonicalJson as u } from "@voltro/runtime";
+// src/snapshotDocumentProjection.ts
+var d = (e) => {
+	throw new c({ reason: e });
+}, f = (e) => l("sha256").update(u(e)).digest("hex"), p = (e) => typeof e != "object" || !e || Array.isArray(e) ? d("definition") : e, m = (e) => typeof e == "string" && e.length > 0, h = (e, t) => Object.fromEntries(t.filter((t) => Object.hasOwn(e, t)).map((t) => [t, e[t]])), g = {
+	paragraph: [
+		"id",
+		"type",
+		"style"
+	],
+	heading: [
+		"id",
+		"type",
+		"style",
+		"level"
+	],
+	list: [
+		"id",
+		"type",
+		"style",
+		"ordered",
+		"levels",
+		"sublists"
+	],
+	table: [
+		"id",
+		"type",
+		"header"
+	],
+	image: [
+		"id",
+		"type",
+		"asset",
+		"caption"
+	],
+	file: [
+		"id",
+		"type",
+		"asset",
+		"label"
+	],
+	component: [
+		"id",
+		"type",
+		"componentId",
+		"fingerprint"
+	]
+}, _ = async (c, l, _, v, y, b, x, S) => {
+	let C = a(S), w = i(await s(c, l, _, b.app), C), T = (await r(c, l, _, "projection", `type:${String(v)}`)).value;
+	if (T.version !== 1 || T.contentType !== v || T.schemaDigest !== f(b) || u(T.app) !== u(b.app)) return d("binding");
+	if (T.definition === null) return d("projection");
+	let E = await n(c, l, _.manifest.publication.id, String(v), y.locale, y.variantId, x);
+	if (E === null || E.status !== "published" || E.revisionId !== y.revisionId) return d("publication");
+	let D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new WeakMap(), k = /* @__PURE__ */ new Map(), A = (e, t, n) => (O.set(e, {
+		id: t,
+		digest: n
+	}), e), j = 0, M = (e) => {
+		if (++j > 1e5 || e > 64) return d("bounds");
+	}, N = async (e, t, n) => {
+		M(n);
+		let r = p(t), i = {};
+		for (let [t, a] of Object.entries(p(e))) Object.hasOwn(r, t) && Object.defineProperty(i, t, {
+			value: await F(p(a), r[t], n + 1),
+			enumerable: !0
+		});
+		return i;
+	}, P = async (e, t, n) => {
+		M(n);
+		let i = p(t);
+		if (!Array.isArray(e) || !m(i.componentId)) return d("definition");
+		let a = e.map(p).find((e) => e.id === i.componentId);
+		if (a === void 0 || !m(a.digest)) return d("definition");
+		let o = D.get(String(a.id));
+		if (o === void 0) {
+			let e = (await r(c, l, _, "components", `component:${String(a.id)}`)).value;
+			if (f(e) !== a.digest || u(e.app) !== u(b.app)) return d("binding");
+			o = {
+				definition: p(e.definition),
+				digest: f(e)
+			}, D.set(String(a.id), o);
+		}
+		let s = o.definition;
+		if (o.digest !== a.digest || s.id !== i.componentId || s.fingerprint !== i.fingerprint) return d("binding");
+		if (s.consent !== void 0) {
+			if (!m(s.consent)) return d("definition");
+			if (!w.granted.some((e) => e.id === s.consent)) return A({
+				...i.type === "component" ? {
+					type: "component",
+					id: i.id
+				} : { instanceId: i.instanceId },
+				componentId: i.componentId,
+				fingerprint: i.fingerprint,
+				consentRequired: s.consent,
+				props: {}
+			}, String(a.id), o.digest);
+		}
+		return A({
+			...h(i, i.type === "component" ? g.component : [
+				"instanceId",
+				"componentId",
+				"fingerprint"
+			]),
+			props: await N(s.props, i.props, n + 1)
+		}, String(a.id), o.digest);
+	}, F = async (n, r, i) => {
+		if (M(i), r == null) return r;
+		switch (n.kind) {
+			case "array": {
+				if (!Array.isArray(r)) return d("publication");
+				let e = [];
+				for (let t of r) e.push(await F(p(n.element), t, i + 1));
+				return e;
+			}
+			case "struct": return N(n.struct, r, i + 1);
+			case "components": {
+				if (!Array.isArray(r)) return d("publication");
+				let e = [];
+				for (let t of r) e.push(await P(n.components, t, i + 1));
+				return e;
+			}
+			case "richText": {
+				let a = p(r);
+				if (a.type !== "doc" || !Array.isArray(a.blocks)) return d("publication");
+				let o = n.richText === void 0 ? {} : p(n.richText), s = o.profile === void 0 ? {} : p(o.profile);
+				if (s.id !== void 0 && a.profile !== s.id) return d("binding");
+				if (e("", a, o).length > 0 || t(a)) return d("publication");
+				let c = (e) => Array.isArray(e) ? e.map((e) => {
+					M(i + 1);
+					let t = p(e);
+					if (t.type === "text") return h(t, [
+						"type",
+						"text",
+						"marks",
+						"style"
+					]);
+					if (t.type === "link") return h(t, [
+						"type",
+						"text",
+						"target"
+					]);
+					if (t.type !== "contact") return d("publication");
+					let n = p(t.contact);
+					return {
+						...h(t, ["type", "text"]),
+						contact: h(n, Object.hasOwn(n, "target") ? ["target"] : ["channel", "value"])
+					};
+				}) : d("publication"), l = [];
+				for (let e of a.blocks) {
+					M(i + 1);
+					let t = p(e), n = t.type;
+					if (!Object.hasOwn(g, n)) return d("publication");
+					if (n === "component") {
+						l.push(await P(s.components, t, i + 1));
+						continue;
+					}
+					let r = h(t, g[n]);
+					if ((n === "paragraph" || n === "heading") && (r.content = c(t.content)), n === "list") {
+						if (!Array.isArray(t.items)) return d("publication");
+						r.items = t.items.map(c);
+					}
+					if (n === "table") {
+						if (!Array.isArray(t.rows)) return d("publication");
+						r.rows = t.rows.map((e) => Array.isArray(e) ? e.map(c) : d("publication"));
+					}
+					l.push(r);
+				}
+				return {
+					...h(a, ["type", "profile"]),
+					blocks: l
+				};
+			}
+			case "string":
+			case "number":
+			case "boolean":
+			case "date":
+			case "datetime":
+			case "literal":
+			case "reference":
+			case "media": return r;
+			default: return d("definition");
+		}
+	};
+	return {
+		values: o(T.definition, await N(p(b.definition).fields, E, 0), (e) => {
+			let t = O.get(e);
+			t !== void 0 && k.set(t.id, t);
+		}),
+		components: [...k.values()].sort((e, t) => e.id < t.id ? -1 : +(e.id > t.id)),
+		presentation: w
+	};
+};
+export { _ as projectSnapshotDocument };

package/dist/snapshotDocumentTransfer.js

@@ -0,0 +1,34 @@
+import { SnapshotSeoReadUnavailable as e } from "./snapshotSeoRead.js";
+import { copySnapshotSeoDocumentsSelection as t } from "./snapshotSeoPathSets.js";
+import { readSnapshotSeoDocuments as n } from "./snapshotSeoDocuments.js";
+import { createSnapshotOutputTransfer as r } from "./snapshotOutputTransfer.js";
+import { canonicalJson as i } from "@voltro/protocol";
+// src/snapshotDocumentTransfer.ts
+var a = () => {
+	throw new e({ reason: "binding" });
+}, o = (e) => {
+	let { store: o, provider: s } = e, c = { ...e.scope }, l = { ...e.use }, u = e.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), d = e.now ?? Date.now, f = s.read?.bind(s);
+	return r(s, async (e, r) => {
+		let p = {
+			snapshot: { ...e.snapshot },
+			token: e.token,
+			consumerId: e.consumerId,
+			buildId: e.buildId,
+			host: e.host
+		}, m = t(e.documents), h = e.id;
+		if (h !== m.artifactId || f === void 0) return a();
+		let g = () => o.transactional((e) => n(e, c, p, m, {
+			provider: s,
+			use: l,
+			keys: u,
+			now: d
+		})), _ = await g(), v = await f(h);
+		if (v.id !== h) return a();
+		let y = await r(structuredClone(v)), b = await g();
+		return i(b.inventory) !== i(_.inventory) || i(b.paths.selection) !== i(_.paths.selection) || i(b.paths.admission.context) !== i(_.paths.admission.context) ? a() : y;
+	});
+};
+export { o as createSnapshotDocumentTransfer };

package/dist/snapshotDocumentTransferRest.js

@@ -0,0 +1,79 @@
+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";
+// src/snapshotDocumentTransferRest.ts
+var s = (s) => {
+	let c = {
+		namespace: "cms.documentTransfer",
+		path: "/v1/cms/document-transfer",
+		operationPrefix: "cmsDocumentTransfer",
+		tags: ["CMS private document 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({
+		snapshot: a.Struct({
+			id: a.String,
+			digest: a.String
+		}),
+		consumerId: a.String,
+		buildId: a.String,
+		host: a.String,
+		id: a.String,
+		documents: a.Struct({
+			artifactId: a.String,
+			pathSets: a.Array(a.Struct({
+				id: a.String,
+				digest: a.String
+			}))
+		})
+	}), f = "Render-read bearer; complete signed paths, original document receipts, current media rights and grant are admitted before and after every provider read. Only the exact selected document role is available. Metadata and bytes are private; they grant no activation or serving authority. No hidden renewal or retry.", p = (e) => i.tryPromise({
+		try: e,
+		catch: () => new r({ reason: "render" })
+	}), m = [
+		n(c, "manifest", "Read private admitted document manifest", f, o(d, 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) => p(() => s.read({
+			...t,
+			token: e(n, c.credentialError)
+		}))),
+		n(c, "file", "Plan bounded private document file chunks", f, o(a.Struct({
+			...d.fields,
+			path: a.String
+		}), c.namespace + ".file", !0), a.Struct({
+			file: l,
+			chunks: a.Array(u)
+		}), (t, n) => p(() => s.planFile({
+			...t,
+			token: e(n, c.credentialError)
+		}))),
+		n(c, "chunk", "Read a verified private document file chunk", f, o(a.Struct({
+			...d.fields,
+			file: l,
+			chunk: u
+		}), c.namespace + ".chunk", !0), a.Struct({ base64: a.String }), (t, n) => p(async () => ({ base64: Buffer.from(await s.readChunk({
+			...t,
+			token: e(n, c.credentialError)
+		})).toString("base64") })))
+	];
+	return {
+		routes: m,
+		httpRoutes: t(m)
+	};
+};
+export { s as cmsSnapshotDocumentTransferRest };

package/dist/snapshotDomains.js

@@ -0,0 +1,55 @@
+import { SiteStateUnavailable as e } from "./errors.js";
+import { copySiteScope as t, lockSiteState as n, siteStatePredicate as r } from "./siteState.js";
+import { normalizeHost as i } from "./domainHost.js";
+import { verifyPublicationState as a } from "./publicationState.js";
+import { copySnapshotResource as o } from "./buildSnapshot.js";
+import { CMS_SITE_DOMAINS_TABLE as s } from "./domains.js";
+import { and as c, eq as l, gt as u } from "@voltro/database";
+// src/snapshotDomains.ts
+var d = async (d, f, p = Date.now()) => {
+	let m = {
+		...t(f),
+		environment: f.environment
+	};
+	return await n(d, m), {
+		format: "voltro.cms.domains/v1",
+		entries: async function* (t) {
+			await a(d, m, t, p);
+			let n, f = !1;
+			for (;;) {
+				let t = await d.query({
+					table: s,
+					predicate: c(r(m), l("status", "verified"), ...n === void 0 ? [] : [u("id", n)]),
+					lock: "update",
+					order: [{
+						column: "id",
+						direction: "asc"
+					}],
+					take: 500,
+					skip: void 0,
+					projection: [
+						"id",
+						"host",
+						"isPrimary"
+					]
+				});
+				if (t.length === 0) break;
+				for (let n of t) {
+					if (typeof n.id != "string" || n.id === "" || typeof n.host != "string" || i(n.host) !== n.host || typeof n.isPrimary != "boolean" || f && n.isPrimary) throw new e({ reason: "state" });
+					f ||= n.isPrimary, yield o({
+						key: n.host,
+						value: {
+							version: 1,
+							tenantId: m.tenantId,
+							site: m.site,
+							host: n.host,
+							primary: n.isPrimary
+						}
+					});
+				}
+				n = String(t[t.length - 1].id);
+			}
+		}
+	};
+};
+export { d as snapshotDomainSource };

package/dist/snapshotEnvironment.js

@@ -0,0 +1,30 @@
+import { verifyPublicationState as e } from "./publicationState.js";
+import { copySnapshotResource as t } from "./buildSnapshot.js";
+import { lockEnvironmentAlias as n } from "./environmentAliases.js";
+// src/snapshotEnvironment.ts
+var r = async (r, i, a, o, s = Date.now()) => {
+	let c = {
+		tenantId: i.tenantId,
+		site: i.site
+	}, l = await n(r, c, a, o), u = {
+		...c,
+		environment: l.environment
+	}, d = t({
+		key: "environment",
+		value: {
+			version: 1,
+			alias: { ...l },
+			target: { ...u }
+		}
+	});
+	return {
+		scope: { ...u },
+		source: {
+			format: "voltro.cms.environment/v1",
+			entries: async function* (t) {
+				await e(r, u, t, s), yield d;
+			}
+		}
+	};
+};
+export { r as snapshotEnvironmentSource };