@voltro/cms 0.86.0 → 0.87.0

package/dist/snapshotSeoOutput.js

@@ -0,0 +1,173 @@
+import { readSnapshotRouteAdmission as e } from "./snapshotRouteAdmission.js";
+import { SnapshotSeoReadUnavailable as t } from "./snapshotSeoRead.js";
+import { snapshotSitemapFiles as n } from "./snapshotSitemapFiles.js";
+import { readSnapshotSeoControls as r } from "./snapshotSeoControls.js";
+import { copySnapshotSeoDocumentsSelection as i } from "./snapshotSeoPathSets.js";
+import { readSnapshotSeoDocuments as a, snapshotOutputSafetyBinding as o } from "./snapshotSeoDocuments.js";
+import { filterSnapshotSeoSafety as s, mergeSnapshotSeoDocuments as c } from "./snapshotSeoMerge.js";
+import { copyOutputSafetySelection as l, readVerifiedOutputSafetyArtifact as u } from "./outputSafetyArtifact.js";
+import { createHash as d } from "node:crypto";
+import { canonicalJson as f } from "@voltro/runtime";
+//#region src/snapshotSeoOutput.ts
+var p = (d, p, m, h, g) => {
+	let _ = {
+		tenantId: p.tenantId,
+		site: p.site,
+		environment: p.environment
+	}, v = {
+		id: m.id,
+		digest: m.digest
+	}, y = h.documents === void 0 ? void 0 : i(h.documents), b = h.safety === void 0 ? void 0 : l(h.safety), x = {
+		token: h.token,
+		consumerId: h.consumerId,
+		buildId: h.buildId,
+		host: h.host
+	}, S = g.use === void 0 ? void 0 : { ...g.use }, C = g.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), w = g.now ?? Date.now, T = () => d.transactional((e) => r(e, _, v, x, {
+		keys: C,
+		now: w()
+	}));
+	return {
+		read: async () => {
+			let e = await T();
+			if (y === void 0) {
+				if (e.productionDocumentRequired || b !== void 0) throw new t({ reason: "binding" });
+				return {
+					...e,
+					documents: null,
+					app: null,
+					safety: null,
+					indexedUrls: null
+				};
+			}
+			if (S === void 0 || g.maxBytes === void 0 || b === void 0) throw new t({ reason: "binding" });
+			let r, i = await u(d, _, b.artifactId, {
+				provider: g.provider,
+				maxBytes: g.maxBytes,
+				admit: async (e) => {
+					let t = await a(e, _, {
+						...x,
+						snapshot: v
+					}, y, {
+						keys: C,
+						now: w,
+						provider: g.provider,
+						use: S
+					});
+					return r = t, o(t);
+				}
+			});
+			if (r === void 0) throw new t({ reason: "binding" });
+			let l = new Set(r.inventory.records.map((e) => e.url)), p = s(c(e.urls.filter((e) => l.has(e.path)), r.native, e), r.inventory.records, i.entries), m = n(p, e.origin, e.xDefault && e.defaultLanguage !== null ? e.defaultLanguage : void 0), h = p.map((e) => e.path), E = 2;
+			for (let e = 0; e < h.length; e++) if (E += Buffer.byteLength(f(h[e]), "utf8") + (e === 0 ? 0 : 1), E > Math.min(g.maxBytes, 25165824)) throw new t({ reason: "binding" });
+			return {
+				...e,
+				urls: p,
+				files: m,
+				sitemap: m[0].text,
+				documents: i.binding.documents,
+				app: i.binding.app,
+				safety: {
+					artifactId: i.artifactId,
+					generation: i.generation,
+					safetyDigest: i.safetyDigest
+				},
+				indexedUrls: h
+			};
+		},
+		readAuthority: () => d.transactional((t) => e(t, _, v, {
+			...x,
+			path: "/"
+		}, {
+			keys: C,
+			now: w()
+		})),
+		place: _,
+		original: v,
+		input: x
+	};
+}, m = (e, t, n) => ({
+	version: e.documents === null ? 1 : 3,
+	profile: e.documents === null ? "voltro.cms.snapshot-seo-output/v1" : "voltro.cms.snapshot-seo-output/v3",
+	kind: n,
+	...e.documents === null ? {} : {
+		documents: e.documents,
+		app: e.app,
+		safety: e.safety,
+		indexedUrls: e.indexedUrls
+	},
+	...t.place,
+	snapshot: t.original,
+	consumerId: t.input.consumerId,
+	buildId: t.input.buildId,
+	host: t.input.host,
+	controlsDigest: d("sha256").update(f(e)).digest("hex"),
+	urlCount: e.urls.length
+}), h = async (...e) => {
+	let n = e[4], r = p(...e), { read: i, readAuthority: a } = r, o = await i(), s = [];
+	try {
+		let e = [];
+		for (let [t, i] of [["sitemap", o.files], ["robots", [{
+			path: "/robots.txt",
+			text: o.robots,
+			contentType: "text/plain"
+		}]]]) {
+			s.length > 0 && await a();
+			let c = await n.provider.begin();
+			s.push(c);
+			for (let e of i) {
+				let t = Buffer.from(e.text, "utf8");
+				await c.write({
+					path: e.path.slice(1),
+					size: t.length,
+					contentType: e.contentType,
+					digest: d("sha256").update(t).digest("hex")
+				}, (async function* () {
+					yield t;
+				})());
+			}
+			e.push({
+				stage: c,
+				subject: m(o, r, t)
+			});
+		}
+		let c = [];
+		for (let t of e) await a(), c.push((await t.stage.seal(t.subject)).id);
+		if (f(await i()) !== f(o)) throw new t({ reason: "binding" });
+		return {
+			sitemapArtifactId: c[0],
+			robotsArtifactId: c[1],
+			urlCount: o.urls.length
+		};
+	} catch (e) {
+		throw await Promise.allSettled(s.map((e) => e.abort())), e;
+	}
+}, g = async (e, n, r, i, a) => {
+	let o = i.id, s = i.kind, c = p(e, n, r, i, a);
+	if (!/^[a-f0-9]{64}$/.test(o) || !["sitemap", "robots"].includes(s) || a.provider.read === void 0) throw new t({ reason: "binding" });
+	let l = a.provider.read.bind(a.provider), u = await c.read(), h = s === "sitemap" ? u.files : [{
+		path: "/robots.txt",
+		text: u.robots,
+		contentType: "text/plain"
+	}], g = {
+		version: 1,
+		subject: m(u, c, s),
+		files: h.map((e) => {
+			let t = Buffer.from(e.text, "utf8");
+			return {
+				path: e.path.slice(1),
+				size: t.length,
+				contentType: e.contentType,
+				digest: d("sha256").update(t).digest("hex")
+			};
+		}).sort((e, t) => e.path < t.path ? -1 : +(e.path > t.path))
+	};
+	if (d("sha256").update(f(g)).digest("hex") !== o) throw new t({ reason: "binding" });
+	let _ = await l(o);
+	if (_.id !== o || f(_.manifest) !== f(g) || f(await c.read()) !== f(u)) throw new t({ reason: "binding" });
+	return structuredClone(_);
+};
+//#endregion
+export { g as readSnapshotSeoOutputArtifact, h as renderSnapshotSeoControls };

package/dist/snapshotSeoPathSets.js

@@ -0,0 +1,105 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+import { copyStaticPathContext as t, staticPathUrl as n } from "./staticPathSet.js";
+import { SnapshotSeoReadUnavailable as r } from "./snapshotSeoRead.js";
+import { STATIC_PATH_SETS_TABLE as i, pageStaticPathSet as a, readStaticPathSet as o } from "./staticPathSetStore.js";
+import { readSnapshotStaticPathAdmission as s } from "./staticPathSetService.js";
+import { and as c, eq as l } from "@voltro/database";
+import { canonicalJson as u } from "@voltro/runtime";
+//#region src/snapshotSeoPathSets.ts
+var d = () => {
+	throw new r({ reason: "binding" });
+}, f = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), p = (e) => typeof e != "object" || !e || Array.isArray(e) ? d() : e, m = (t) => {
+	let n = p(e({
+		key: "seo-documents",
+		value: { selection: t }
+	}).value.selection);
+	if (Object.keys(n).sort().join(",") !== "pathSets" || !Array.isArray(n.pathSets) || n.pathSets.length === 0 || n.pathSets.length > 64) return d();
+	let r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+	return { pathSets: n.pathSets.map((e) => {
+		let t = p(e);
+		return Object.keys(t).sort().join(",") !== "digest,id" || typeof t.id != "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(t.id) || !f(t.digest) || r.has(t.id) || i.has(t.digest) ? d() : (r.add(t.id), i.add(t.digest), {
+			id: t.id,
+			digest: t.digest
+		});
+	}) };
+}, h = (t) => {
+	let n = p(e({
+		key: "seo-documents",
+		value: { selection: t }
+	}).value.selection);
+	return Object.keys(n).sort().join(",") !== "artifactId,pathSets" || !f(n.artifactId) ? d() : {
+		artifactId: n.artifactId,
+		...m({ pathSets: n.pathSets })
+	};
+}, g = async (e, r, f, p, h) => {
+	let g = m(p), _ = {
+		tenantId: r.tenantId,
+		site: r.site,
+		environment: r.environment
+	}, v = {
+		snapshot: {
+			id: f.snapshot.id,
+			digest: f.snapshot.digest
+		},
+		token: f.token,
+		consumerId: f.consumerId,
+		buildId: f.buildId,
+		host: f.host
+	}, y = h.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), b = h.now ?? Date.now, x = [], S = /* @__PURE__ */ new Set(), C = [], w;
+	for (let r of g.pathSets) {
+		let [f] = await e.query({
+			table: i,
+			predicate: c(l("tenantId", _.tenantId), l("site", _.site), l("environment", _.environment), l("id", r.id)),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (f === void 0) return d();
+		let p = t(f.context), m = {
+			...v,
+			localeIds: p.localeIds,
+			owners: p.owners
+		}, h = await s(e, _, m, {
+			keys: y,
+			now: b()
+		}), g = await o(e, h.context, r.id, y);
+		if (g.sealed === null || g.sealed.id !== r.digest) return d();
+		for (let t = 0; t < Math.max(1, g.sealed.manifest.pages.length); t++) {
+			let i = await a(e, h.context, r.id, t, y);
+			if (i.set.id !== r.digest) return d();
+			for (let e of i.entries) {
+				let t = n(e.host, e.path);
+				if (e.host !== v.host || S.has(t) || x.length >= 1e5) return d();
+				if (e.owner === "code" && h.app.web !== void 0) {
+					let t = e.file === null ? void 0 : h.routing.definition?.claims[e.file];
+					if (t?.kind !== "code" || t.public !== !0) return d();
+				}
+				S.add(t), x.push(e);
+			}
+		}
+		let T = await s(e, _, m, {
+			keys: y,
+			now: b()
+		});
+		if (u(T.context) !== u(h.context)) return d();
+		C.push(T.context), w ??= T;
+	}
+	return w === void 0 ? d() : (x.sort((e, t) => e.path < t.path ? -1 : +(e.path > t.path)), {
+		selection: g,
+		admission: w,
+		entries: x,
+		contexts: C
+	});
+}, _ = async (e, t, n, r, i) => {
+	let a = h(r);
+	return {
+		...await g(e, t, n, { pathSets: a.pathSets }, i),
+		selection: a
+	};
+};
+//#endregion
+export { m as copySnapshotPathSetSelection, h as copySnapshotSeoDocumentsSelection, g as readSnapshotPathSets, _ as readSnapshotSeoPathSets };

package/dist/snapshotSeoRead.js

@@ -0,0 +1,88 @@
+import { defineSiteDelivery as e } from "./siteDelivery.js";
+import { resolveScopedContentSeo as t } from "./publicationSeo.js";
+import { readVerifiedSnapshotResource as n } from "./buildSnapshot.js";
+import { admitSnapshotPublicDocument as r } from "./snapshotPublicAccess.js";
+import { snapshotSeoMetadataSource as i } from "./snapshotSeoMetadata.js";
+import { Schema as a } from "effect";
+import { createHash as o } from "node:crypto";
+import { canonicalJson as s } from "@voltro/runtime";
+//#region src/snapshotSeoRead.ts
+var c = class extends a.TaggedError()("SnapshotSeoReadUnavailable", { reason: a.Literals([
+	"binding",
+	"projection",
+	"publication",
+	"media",
+	"access"
+]) }) {}, l = (e) => {
+	throw new c({ reason: e });
+}, u = (e) => o("sha256").update(s(e)).digest("hex"), d = async (a, o, c, d) => {
+	let { snapshot: f, route: p, output: m } = c;
+	if (f.manifest.parts.find((e) => e.part === "seo")?.format !== "voltro.cms.seo-metadata/v1") return l("binding");
+	let h = (await n(a, o, f, "seo", "configuration")).value;
+	if (typeof h.xDefault != "boolean") return l("binding");
+	let g = await i(a, o, f, {
+		now: d,
+		xDefault: h.xDefault,
+		routeKey: `path:${u(m.path)}`
+	}), _, v = !1;
+	for await (let e of g.entries(f.manifest.publication)) {
+		if (e.key === "configuration") {
+			let t = (e) => Object.fromEntries(Object.entries(e).filter(([e]) => e !== "sourceSnapshot"));
+			if (s(t(e.value)) !== s(t(h))) return l("binding");
+			v = !0;
+			continue;
+		}
+		if (_ !== void 0 || e.key !== m.routeId) return l("binding");
+		let t = await n(a, o, f, "seo", e.key);
+		if (s(t) !== s(e) || e.value.state !== "resolved") return l("binding");
+		_ = e.value;
+	}
+	if (!v || _ === void 0) return l("binding");
+	let y = (await n(a, o, f, "schema", `type:${m.contentType}`)).value, b = t(y.definition, m.values, {
+		...o,
+		locale: m.sourceLocale
+	});
+	if (s(b) !== s(_.metadata)) return l("projection");
+	if (b?.findings.some((e) => e.kind !== "recommendation")) return l("publication");
+	let x = b?.social.imageKey == null ? null : b.sources["social.image"];
+	if (b?.social.imageKey != null && (typeof x != "string" || !Object.hasOwn(m.values, x))) return l("media");
+	let S = (await n(a, o, f, "routes", "configuration")).value, C = e(S.site).locales.find((e) => e.contentLocale === m.sourceLocale)?.tag;
+	if (C === void 0) return l("binding");
+	let w = [];
+	for (let e of _.alternates) {
+		let t = await r(a, o, f, m.contentType, e.localeId, String(p.documentId), d);
+		if (t === null) continue;
+		let i = (await n(a, o, f, "routes", `identity:${e.routeId}`)).value, s = (await n(a, o, f, "routes", String(i.target))).value, c = t.chain[0];
+		if (s.routeId !== e.routeId || s.fallback !== !1 || s.sourceLocale !== c.locale || s.variantId !== c.variantId || s.revisionId !== c.revisionId || s.revision !== c.revision) return l("binding");
+		w.push({
+			locale: e.locale,
+			href: e.href
+		});
+	}
+	let T = b?.canonical === "omit" ? null : String(_.canonical);
+	return T !== null && !w.some((e) => e.href === T) ? l("access") : {
+		image: x == null ? null : {
+			fieldPath: [x],
+			origin: new URL(String(_.canonical)).origin
+		},
+		seo: {
+			title: b?.title ?? null,
+			description: b?.description ?? null,
+			canonical: T,
+			alternates: w,
+			xDefault: w.some((e) => e.href === _.xDefault) ? String(_.xDefault) : null,
+			languageTag: C,
+			robots: b?.robots ?? {
+				index: !1,
+				follow: !1
+			},
+			social: {
+				title: b?.social.title ?? null,
+				description: b?.social.description ?? null
+			},
+			structuredData: b?.structuredData ?? null
+		}
+	};
+};
+//#endregion
+export { c as SnapshotSeoReadUnavailable, d as readAdmittedSnapshotSeo };

package/dist/snapshotSite.js

@@ -0,0 +1,128 @@
+import { SiteBindingUnavailable as e } from "./errors.js";
+import { compileSiteDelivery as t } from "./siteDelivery.js";
+import { readPublicationBoundary as n } from "./changes.js";
+import { readCapturedDocument as r, verifyPublicationState as i } from "./publicationState.js";
+import { copySnapshotResource as a } from "./buildSnapshot.js";
+import { copySnapshotAppCodePin as o } from "./snapshotDefinitions.js";
+import { lockSiteContentBinding as s, siteContentBindingRevision as c } from "./siteBindings.js";
+import { createHash as l } from "node:crypto";
+import { canonicalJson as u } from "@voltro/runtime";
+//#region src/snapshotSite.ts
+var d = (n, r, i) => {
+	let s = {
+		tenantId: n.tenantId,
+		site: n.site,
+		environment: n.environment
+	}, c = t(r), d = c.definition, f = o(i);
+	if (d.id !== s.site || !d.environments.includes(s.environment)) throw new e({ reason: "scope" });
+	let p = l("sha256").update(u(d)).digest("hex");
+	return {
+		compiled: c,
+		definitionDigest: p,
+		site: a({
+			key: "configuration",
+			value: {
+				version: 3,
+				...s,
+				app: f,
+				definitionDigest: p,
+				definition: {
+					id: d.id,
+					version: d.version,
+					environments: d.environments,
+					defaultEnvironment: d.defaultEnvironment,
+					bindings: d.bindings,
+					...d.seo === void 0 ? {} : { seo: d.seo }
+				}
+			}
+		}),
+		locales: a({
+			key: "policy",
+			value: {
+				version: 1,
+				...s,
+				app: f,
+				definitionDigest: p,
+				definition: {
+					version: d.version,
+					defaultLocale: d.defaultLocale,
+					sourceLocale: d.sourceLocale,
+					locales: d.locales
+				},
+				compiled: {
+					contentLocales: c.contentLocales,
+					defaultLocale: c.defaultLocale,
+					sourceLocale: c.sourceLocale,
+					fallback: c.fallback,
+					prefixes: c.prefixes,
+					tags: c.tags,
+					directions: c.directions
+				},
+				resolution: "per-node"
+			}
+		})
+	};
+}, f = (t, o, l, u, f = Date.now()) => {
+	let p = {
+		tenantId: o.tenantId,
+		site: o.site,
+		environment: o.environment
+	}, m = d(p, l, u), { compiled: h, definitionDigest: g } = m, _ = h.definition, v = h.contentLocales, y = async (r) => {
+		let a = await n(t, p);
+		if (a.generation !== r.generation || a.releaseId !== r.releaseId || a.checkpoint !== r.checkpoint) throw new e({ reason: "state" });
+		let o = await i(t, p, r, f);
+		if (o.locales.length !== v.length || o.locales.some((e) => !v.includes(e))) throw new e({ reason: "scope" });
+		return o;
+	};
+	return {
+		site: {
+			format: "voltro.cms.site/v3",
+			entries: async function* (n) {
+				let i = await y(n);
+				yield a(m.site);
+				for (let [o, l] of Object.entries(_.bindings).sort(([e], [t]) => e < t ? -1 : +(e > t))) {
+					let u = await s(t, p, o);
+					if (u.contentType !== l || !i.types.includes(l)) throw new e({ reason: "target" });
+					let d = await c(t, p, o, u.revisionId);
+					if (d.contentType !== u.contentType || d.documentId !== u.documentId) throw new e({ reason: "state" });
+					yield a({
+						key: `binding:${o}`,
+						value: {
+							version: 3,
+							...p,
+							binding: { ...u },
+							locales: v,
+							definitionDigest: g
+						}
+					});
+					let m = !1;
+					for (let e of v) {
+						let i = await r(t, p, n.id, u.contentType, e, u.documentId, f);
+						m ||= i !== null, yield a({
+							key: `binding:${o}:locale:${e}`,
+							value: {
+								version: 3,
+								locale: e,
+								documentId: u.documentId,
+								variant: i === null ? null : {
+									id: i.id,
+									revisionId: i.revisionId,
+									revision: i.revision
+								}
+							}
+						});
+					}
+					if (!m) throw new e({ reason: "target" });
+				}
+			}
+		},
+		locales: {
+			format: "voltro.cms.locales/v1",
+			entries: async function* (e) {
+				await y(e), yield a(m.locales);
+			}
+		}
+	};
+};
+//#endregion
+export { d as snapshotSiteConfiguration, f as snapshotSiteSources };

package/dist/snapshotSitemapFiles.js

@@ -0,0 +1,36 @@
+import { sitemapXml as e } from "./seo.js";
+import { SnapshotSeoReadUnavailable as t } from "./snapshotSeoRead.js";
+//#region src/snapshotSitemapFiles.ts
+var n = () => {
+	throw new t({ reason: "binding" });
+}, r = 5e4, i = 52428800, a = (e) => e.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;"), o = (t, o, s) => {
+	let c = new URL(o);
+	if (c.protocol !== "https:" || c.origin !== o) return n();
+	let l = e([], (e, t) => t, s), u = l.slice(0, l.indexOf(">\n", l.indexOf("<urlset")) + 2), d = "\n</urlset>\n", f = Buffer.byteLength(u + d), p = [], m = [], h = f, g = () => {
+		p.push(u + m.join("\n") + d), m = [], h = f;
+	};
+	for (let a of t) {
+		for (let e of [a.path, ...a.alternates.map((e) => e.path)]) if (e.length >= 2048 || /[\x00-\x20\x7f]/.test(e) || new URL(e).origin !== o) return n();
+		let t = e([a], (e, t) => t, s).slice(u.length, -11), c = Buffer.byteLength(t);
+		if (c + f > i) return n();
+		(m.length === r || h + c + (m.length === 0 ? 0 : 1) > i) && g(), h += c + (m.length === 0 ? 0 : 1), m.push(t);
+	}
+	if ((m.length > 0 || p.length === 0) && g(), p.length === 1) return [{
+		path: "/sitemap.xml",
+		contentType: "application/xml",
+		text: p[0]
+	}];
+	if (p.length > r) return n();
+	let _ = p.map((e, t) => ({
+		path: `/sitemaps/sitemap-${String(t + 1).padStart(5, "0")}.xml`,
+		contentType: "application/xml",
+		text: e
+	})), v = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<sitemapindex xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n" + _.map((e) => `  <sitemap><loc>${a(o + e.path)}</loc></sitemap>`).join("\n") + "\n</sitemapindex>\n";
+	return Buffer.byteLength(v) > i ? n() : [{
+		path: "/sitemap.xml",
+		contentType: "application/xml",
+		text: v
+	}, ..._];
+};
+//#endregion
+export { o as snapshotSitemapFiles };

package/dist/snapshotTreeDependencies.js

@@ -0,0 +1,58 @@
+import { createHash as e } from "node:crypto";
+import { canonicalJson as t } from "@voltro/runtime";
+//#region src/snapshotTreeDependencies.ts
+var n = () => {
+	throw Error("Snapshot tree dependencies unavailable");
+}, r = (n) => e("sha256").update(t(n)).digest("hex"), i = (e) => {
+	if (!Array.isArray(e.reads) || e.reads.length > 4112) return n();
+	let t = new Map(Object.entries(e.trees).map(([t, n]) => [r({
+		path: e.path,
+		name: t
+	}), {
+		name: t,
+		data: n
+	}])), i = [], a = [], o = "";
+	for (let s of e.reads) {
+		if (typeof s != "object" || !s || Array.isArray(s)) return n();
+		let c = s;
+		if (Object.keys(c).sort().join(",") !== "inputDigest,tag,valueDigest" || typeof c.inputDigest != "string" || !/^[a-f0-9]{64}$/.test(c.inputDigest) || typeof c.valueDigest != "string" || !/^[a-f0-9]{64}$/.test(c.valueDigest)) return n();
+		if (c.tag === "cms.snapshot.reference" || c.tag === "cms.snapshot.link") {
+			if (e.owner !== "cms") return n();
+			i.push(s);
+			continue;
+		}
+		if (c.tag !== "cms.snapshot.tree") return n();
+		let l = t.get(c.inputDigest);
+		if (l === void 0 || l.name <= o || c.valueDigest !== r(l.data)) return n();
+		o = l.name, a.push({
+			name: l.name,
+			inputDigest: c.inputDigest,
+			valueDigest: c.valueDigest
+		});
+	}
+	return {
+		references: i,
+		graph: {
+			version: 1,
+			coverage: "captured-queries",
+			selectiveReuse: !1,
+			inputs: {
+				owner: e.owner,
+				snapshotDigest: e.snapshotDigest,
+				inputsId: e.inputsId,
+				executionId: e.executionId,
+				routeId: e.routeId,
+				path: e.path,
+				contextDigest: r(e.context),
+				trees: Object.fromEntries(Object.entries(e.trees).map(([e, t]) => [e, {
+					contentType: t.contentType,
+					localeId: t.localeId,
+					valueDigest: r(t)
+				}]))
+			},
+			reads: a
+		}
+	};
+};
+//#endregion
+export { i as snapshotTreeDependencies };

package/dist/snapshotTreeLoader.js

@@ -0,0 +1,10 @@
+//#region src/snapshotTreeLoader.ts
+var e = async (e, t) => {
+	if (e.query === void 0) throw Error("Snapshot tree unavailable");
+	return e.query("cms.snapshot.tree", {
+		path: e.pathname,
+		name: t
+	});
+};
+//#endregion
+export { e as snapshotTreeLoader };