@voltro/cms 0.86.0 → 0.87.0

package/dist/snapshotPublicAccess.js

@@ -0,0 +1,161 @@
+import { compileSiteDelivery as e } from "./siteDelivery.js";
+import { readCapturedDocument as t, verifyPublicationState as n } from "./publicationState.js";
+import { copySnapshotResource as r, readVerifiedSnapshotResource as i, verifyBuildSnapshot as a } from "./buildSnapshot.js";
+import { copySnapshotAppCodePin as o, snapshotContentTypeDefinition as s } from "./snapshotDefinitions.js";
+import { copySnapshotConsentPurposes as c } from "./snapshotPresentation.js";
+import { Schema as l } from "effect";
+import { createHash as u } from "node:crypto";
+import { canonicalJson as d } from "@voltro/runtime";
+//#region src/snapshotPublicAccess.ts
+var f = class extends l.TaggedError()("SnapshotPublicAccessUnavailable", { reason: l.Literals([
+	"definition",
+	"binding",
+	"scope",
+	"publication",
+	"bounds"
+]) }) {}, p = (e) => {
+	throw new f({ reason: e });
+}, m = (e) => u("sha256").update(d(e)).digest("hex"), h = (e) => typeof e == "object" && !!e && !Array.isArray(e), g = (e) => typeof e == "string" && e.length > 0 && e.length <= 256 && !/[\x00-\x1f\x7f]/.test(e), _ = (e) => h(e) ? e.kind === "public" || e.kind === "deny" ? Object.keys(e).length === 1 ? { kind: e.kind } : p("definition") : e.kind !== "field" || Object.keys(e).length !== 4 || !g(e.field) || !Array.isArray(e.values) || e.values.length === 0 || e.values.length > 64 || !e.values.every(g) || new Set(e.values).size !== e.values.length || e.missing !== "public" && e.missing !== "deny" ? p("definition") : {
+	kind: "field",
+	field: e.field,
+	values: [...e.values].sort(),
+	missing: e.missing
+} : p("definition"), v = (e, t) => {
+	if (e.kind !== "field") return;
+	let n = Object.hasOwn(t, e.field) ? t[e.field] : void 0;
+	if (!h(n) || !["string", "literal"].includes(String(n.kind))) return p("definition");
+	let r = n.literals;
+	if (n.kind === "literal" && (!Array.isArray(r) || e.values.some((e) => !r.includes(e)))) return p("definition");
+}, y = (e, t, n, i = []) => {
+	let a = o(t), l = r({
+		key: "configuration",
+		value: {
+			version: 2,
+			app: a,
+			consentPurposes: c(i)
+		}
+	}), u = r({
+		key: "definitions",
+		value: n
+	}).value;
+	if (e.length === 0 || new Set(e.map((e) => e.name)).size !== e.length || Object.keys(u).length !== e.length || Object.keys(u).some((t) => !e.some((e) => e.name === t))) return p("definition");
+	let d = [...e].sort((e, t) => e.name < t.name ? -1 : +(e.name > t.name)).map((e) => {
+		let t = _(u[e.name]);
+		return v(t, e.fields), r({
+			key: `type:${e.name}`,
+			value: {
+				version: 1,
+				app: a,
+				contentType: e.name,
+				decision: t,
+				schemaDigest: m(s(e, a).value)
+			}
+		});
+	}), f = r({
+		key: "registry",
+		value: {
+			version: 2,
+			app: a,
+			types: d.map((e) => e.value.contentType),
+			consentDigest: m(l),
+			definitionDigest: m([...d, l])
+		}
+	});
+	return {
+		format: "voltro.cms.public-access/v2",
+		entries: function* () {
+			yield r(f), yield r(l);
+			for (let e of d) yield r(e);
+		}
+	};
+}, b = async (e, t, n, r, i, a, o = Date.now()) => x(e, t, n, r, { profile: i }, a, o), x = async (e, t, r, i, o, s, c) => {
+	if (![
+		i,
+		"profile" in o ? o.profile : o.exact,
+		s
+	].every(g)) return p("scope");
+	let l = await a(e, t, r, c);
+	return w(e, t, l, await n(e, t, l.manifest.publication, c), i, o, s, c);
+}, S = async (e, t, n, r, i, a, o, s) => w(e, t, n, r, i, { profile: a }, o, s), C = async (e, t, n, r, i, a, o, s) => w(e, t, n, r, i, { exact: a }, o, s), w = async (n, r, a, o, s, c, l, u) => {
+	if (![
+		s,
+		"profile" in c ? c.profile : c.exact,
+		l
+	].every(g)) return p("scope");
+	for (let [e, t] of [
+		["policies", "voltro.cms.public-access/v2"],
+		["schema", "voltro.cms.schema/v1"],
+		["site", "voltro.cms.site/v3"],
+		["locales", "voltro.cms.locales/v1"]
+	]) if (a.manifest.parts.find((t) => t.part === e)?.format !== t) return p("binding");
+	if (!o.types.includes(s)) return p("scope");
+	let f = (await i(n, r, a, "policies", `type:${s}`)).value, y = (await i(n, r, a, "schema", `type:${s}`)).value, b = (await i(n, r, a, "site", "configuration")).value, x = (await i(n, r, a, "locales", "policy")).value;
+	if (f.version !== 1 || y.version !== 1 || b.version !== 3 || x.version !== 1 || f.contentType !== s || f.schemaDigest !== m(y) || [
+		f,
+		b,
+		x
+	].some((e) => d(e.app) !== d(y.app)) || [b, x].some((e) => e.tenantId !== r.tenantId || e.site !== r.site || e.environment !== r.environment) || !h(b.definition) || !h(x.definition) || x.resolution !== "per-node") return p("binding");
+	let S = e({
+		...b.definition,
+		...x.definition
+	}), C = {
+		contentLocales: S.contentLocales,
+		defaultLocale: S.defaultLocale,
+		sourceLocale: S.sourceLocale,
+		fallback: S.fallback,
+		prefixes: S.prefixes,
+		tags: S.tags,
+		directions: S.directions
+	};
+	if (S.definition.id !== r.site || !S.definition.environments.includes(r.environment) || [b, x].some((e) => e.definitionDigest !== m(S.definition)) || d(x.compiled) !== d(C) || o.locales.length !== S.contentLocales.length || o.locales.some((e) => !S.contentLocales.includes(e))) return p("binding");
+	let w = "profile" in c ? S.definition.locales.find((e) => e.id === c.profile && e.enabled)?.contentLocale : S.contentLocales.includes(c.exact) ? c.exact : void 0;
+	if (w === void 0) return p("scope");
+	let T = y.definition;
+	if (!h(T) || T.name !== s || !h(T.fields)) return p("binding");
+	let E = _(f.decision);
+	if (v(E, T.fields), E.kind === "deny") return null;
+	let D = T.tree, O;
+	if (D !== void 0) {
+		if (!h(D) || !g(D.parent)) return p("binding");
+		O = D.parent;
+		let e = T.fields[O];
+		if (!h(e) || e.kind !== "reference" || e.referenceType !== s) return p("binding");
+	}
+	let k = [], A = /* @__PURE__ */ new Set(), j = [w, ..."profile" in c ? S.fallback[w] : []], M = l;
+	for (;;) {
+		if (A.has(M)) return null;
+		if (A.size >= 128) return p("bounds");
+		A.add(M);
+		let e = null;
+		for (let i of j) if (e = await t(n, r, a.manifest.publication.id, s, i, M, u), e !== null) break;
+		if (e === null) return null;
+		if (e.status !== "published" || e.documentId !== M || ![
+			e.id,
+			e.revisionId,
+			e.locale
+		].every(g) || !Number.isSafeInteger(e.revision) || Number(e.revision) < 1) return p("publication");
+		if (E.kind === "field") {
+			let t = e[E.field];
+			if (t == null) {
+				if (E.missing !== "public") return null;
+			} else if (typeof t != "string" || !E.values.includes(t)) return null;
+		}
+		k.push({
+			documentId: M,
+			variantId: String(e.id),
+			revisionId: String(e.revisionId),
+			revision: Number(e.revision),
+			locale: String(e.locale)
+		});
+		let i = O === void 0 ? void 0 : e[O];
+		if (i == null || i === "") return {
+			contentType: s,
+			requestedLocale: w,
+			chain: k
+		};
+		if (!g(i)) return p("publication");
+		M = i;
+	}
+};
+//#endregion
+export { f as SnapshotPublicAccessUnavailable, b as admitSnapshotPublicDocument, S as admitVerifiedSnapshotPublicDocument, C as admitVerifiedSnapshotPublicDocumentLocale, y as snapshotPublicAccessSource };

package/dist/snapshotPublicRouteHistory.js

@@ -0,0 +1,40 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { copySnapshotResource as t } from "./buildSnapshot.js";
+import { compileCmsPublicRouteDeclaration as n } from "./initializePublicRoutes.js";
+import { readPublicRouteHistoryView as r } from "./publicRouteHistoryView.js";
+import { canonicalJson as i } from "@voltro/runtime";
+//#region src/snapshotPublicRouteHistory.ts
+var a = (a, o, s) => {
+	let c = n(s);
+	return {
+		format: "voltro.cms.source-route-history/v1",
+		entries: async function* () {
+			let n = await r(a, o);
+			if (i(n.namespace.binding.definition) !== i(c)) return e("configuration");
+			yield t({
+				key: "configuration",
+				value: {
+					version: 1,
+					...n.namespace.scope,
+					kind: "source-configuration",
+					coverage: "declared-content-source",
+					nativeInventory: "not-enumerated",
+					binding: n.namespace.binding,
+					currentNamespaceDigest: n.namespace.sourceDigest,
+					...n.history
+				}
+			});
+			for await (let e of n.entries()) yield t({
+				key: "url:" + e.urlKey,
+				value: {
+					version: 1,
+					...n.namespace.scope,
+					kind: "source-observed",
+					...e
+				}
+			});
+		}
+	};
+};
+//#endregion
+export { a as snapshotPublicRouteHistorySource };

package/dist/snapshotReadAdmission.js

@@ -0,0 +1,38 @@
+import { verifyBuildSnapshot as e } from "./buildSnapshot.js";
+import { Schema as t } from "effect";
+//#region src/snapshotReadAdmission.ts
+var n = class extends t.TaggedError()("SnapshotReadAdmissionUnavailable", { reason: t.Literals(["binding"]) }) {}, r = async (t, r, i, a) => {
+	let o = await e(t, r, i, a);
+	for (let [e, t] of Object.entries({
+		policies: "voltro.cms.public-access/v2",
+		projection: "voltro.cms.field-projection/v1",
+		routes: "voltro.cms.content-routes/v4",
+		domains: "voltro.cms.domains/v1",
+		schema: "voltro.cms.schema/v1",
+		components: "voltro.cms.components/v1",
+		assets: "voltro.cms.media-custody/v2",
+		site: "voltro.cms.site/v3",
+		locales: "voltro.cms.locales/v1",
+		seo: "voltro.cms.seo-metadata/v1"
+	})) if (o.manifest.parts.find((t) => t.part === e)?.format !== t) throw new n({ reason: "binding" });
+	return o;
+}, i = async (e, t, n, i, a) => {
+	let o = await r(e, t, n, a);
+	return {
+		snapshot: o,
+		binding: {
+			tenantId: t.tenantId,
+			site: t.site,
+			environment: t.environment,
+			consumerId: i.consumerId,
+			buildId: i.buildId,
+			snapshotId: o.id,
+			snapshotDigest: o.digest,
+			releaseId: o.manifest.publication.releaseId,
+			policyDigest: o.manifest.parts.find((e) => e.part === "policies").digest,
+			projectionDigest: o.manifest.parts.find((e) => e.part === "projection").digest
+		}
+	};
+};
+//#endregion
+export { n as SnapshotReadAdmissionUnavailable, r as readAdmittedBuildSnapshot, i as resolveSnapshotReadBinding };

package/dist/snapshotRedirectOutput.js

@@ -0,0 +1,151 @@
+import { lockSiteState as e } from "./siteState.js";
+import { routeDispositionFail as t } from "./routeDispositions.js";
+import { lockOutputRouteHistoryCapture as n } from "./outputActivationStore.js";
+import { copySnapshotSeoDocumentsSelection as r } from "./snapshotSeoPathSets.js";
+import { readSnapshotSeoDocuments as i, snapshotOutputSafetyBinding as a } from "./snapshotSeoDocuments.js";
+import { copyOutputSafetySelection as o, readVerifiedOutputSafetyArtifact as s } from "./outputSafetyArtifact.js";
+import { readSnapshotRouteDispositionPlan as c } from "./snapshotRouteDispositionPlan.js";
+import { copySnapshotRedirectTargets as l } from "./snapshotRedirectTargets.js";
+import { createHash as u } from "node:crypto";
+import { canonicalJson as d } from "@voltro/runtime";
+//#region src/snapshotRedirectOutput.ts
+var f = (u, d, f, p, m) => {
+	let h = {
+		tenantId: d.tenantId,
+		site: d.site,
+		environment: d.environment
+	}, g = {
+		snapshot: {
+			id: f.id,
+			digest: f.digest
+		},
+		token: p.token,
+		consumerId: p.consumerId,
+		buildId: p.buildId,
+		host: p.host
+	}, _ = r(p.documents), v = o(p.safety), y = l(p.targets, g.host), b = m.keys.map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	})), x = typeof m.declaration == "function" ? m.declaration.bind(m) : m.declaration, S = { ...m.use }, C = m.now ?? Date.now;
+	if (!Number.isSafeInteger(m.maxBytes) || m.maxBytes < 1) return t("bounds");
+	let w = Math.min(m.maxBytes, 67108864);
+	return {
+		read: async () => {
+			let r, o, l, d = await s(u, h, v.artifactId, {
+				provider: m.provider,
+				maxBytes: w,
+				admit: async (s) => {
+					let u = await n(s, h);
+					await e(s, h);
+					let d = await i(s, h, g, _, {
+						provider: m.provider,
+						use: S,
+						keys: b,
+						now: C
+					}), f = [d];
+					for (let e of y) f.push(await i(s, h, {
+						...g,
+						host: e.host
+					}, e.documents, {
+						provider: m.provider,
+						use: S,
+						keys: b,
+						now: C
+					}));
+					let p = f.flatMap((e) => e.paths.entries), v = f.flatMap((e) => e.paths.contexts);
+					if (o = f.flatMap((e) => e.inventory.records), p.length > 1e5 || o.length > 1e5) return t("bounds");
+					l = f.map((e) => ({
+						host: e.paths.admission.admission.input.host,
+						artifactId: e.paths.selection.artifactId,
+						pathSetIds: e.inventory.pathSetIds
+					})).sort((e, t) => e.host < t.host ? -1 : +(e.host > t.host));
+					let w = d.paths.admission.app, T = typeof x == "function" ? x({
+						inputsId: w.inputsId,
+						executionId: w.executionId,
+						code: { ...w.app },
+						routeDiscovery: structuredClone(w.routes.value)
+					}) : x;
+					return r = await c(s, h, {
+						admission: d.paths.admission.admission,
+						site: d.paths.admission.site,
+						entries: p,
+						contexts: v
+					}, T, u, C()), a(d);
+				}
+			});
+			if (r === void 0 || o === void 0 || l === void 0) return t("state");
+			let f = new Set(d.entries.filter((e) => e.target.kind === "url").map((e) => e.target.kind === "url" ? e.target.url : "")), p = new Set(d.entries.filter((e) => e.target.kind === "asset").map((e) => e.target.kind === "asset" ? e.target.digest : ""));
+			for (let e of o) e.media.some((e) => p.has(e.digest)) && f.add(e.url);
+			for (let e of r.definitions) if (f.has(e.source.url) || e.action.kind === "redirect" && f.has(e.action.target.url)) return t("graph");
+			return {
+				...r,
+				binding: d.binding,
+				targetDocuments: l,
+				safety: {
+					artifactId: d.artifactId,
+					generation: d.generation,
+					safetyDigest: d.safetyDigest
+				}
+			};
+		},
+		place: h,
+		budget: w
+	};
+}, p = (e, t) => ({
+	version: 2,
+	profile: "voltro.cms.snapshot-redirect-output/v2",
+	kind: "redirects",
+	...t,
+	...e.binding,
+	targetDocuments: e.targetDocuments,
+	safety: e.safety,
+	routeState: e.routeState,
+	count: e.definitions.length
+}), m = async (...e) => {
+	let n = e[4], { read: r, place: i, budget: a } = f(...e), o = await r(), s = Buffer.from(d({
+		version: 1,
+		definitions: o.definitions
+	}) + "\n", "utf8");
+	if (s.length > a) return t("bounds");
+	let c;
+	try {
+		if (c = await n.provider.begin(), await c.write({
+			path: "redirects.json",
+			contentType: "application/json",
+			size: s.length,
+			digest: u("sha256").update(s).digest("hex")
+		}, (async function* () {
+			yield s;
+		})()), d(await r()) !== d(o)) return t("state");
+		let e = await c.seal(p(o, i));
+		return /^[a-f0-9]{64}$/.test(e.id) ? {
+			artifactId: e.id,
+			count: o.definitions.length
+		} : t("state");
+	} catch (e) {
+		throw c !== void 0 && await Promise.allSettled([c.abort()]), e;
+	}
+}, h = async (e, n, r, i, a) => {
+	let o = i.id, s = f(e, n, r, i, a);
+	if (!/^[a-f0-9]{64}$/.test(o) || a.provider.read === void 0) return t("state");
+	let c = a.provider.read.bind(a.provider), l = await s.read(), m = Buffer.from(d({
+		version: 1,
+		definitions: l.definitions
+	}) + "\n", "utf8");
+	if (m.length > s.budget) return t("bounds");
+	let h = {
+		version: 1,
+		subject: p(l, s.place),
+		files: [{
+			path: "redirects.json",
+			contentType: "application/json",
+			size: m.length,
+			digest: u("sha256").update(m).digest("hex")
+		}]
+	};
+	if (u("sha256").update(d(h)).digest("hex") !== o) return t("state");
+	let g = await c(o);
+	return g.id !== o || d(g.manifest) !== d(h) || d(await s.read()) !== d(l) ? t("state") : structuredClone(g);
+};
+//#endregion
+export { h as readSnapshotRedirectOutputArtifact, m as renderSnapshotRouteDispositions };

package/dist/snapshotRedirectTargets.js

@@ -0,0 +1,24 @@
+import { normalizeHost as e } from "./domainHost.js";
+import { copySnapshotResource as t } from "./buildSnapshot.js";
+import { routeDispositionFail as n } from "./routeDispositions.js";
+import { copySnapshotSeoDocumentsSelection as r } from "./snapshotSeoPathSets.js";
+//#region src/snapshotRedirectTargets.ts
+var i = (i, a) => {
+	if (e(a) !== a) return n("input");
+	let o = t({
+		key: "redirect-targets",
+		value: { targets: i }
+	}).value.targets;
+	if (!Array.isArray(o) || o.length > 255) return n("bounds");
+	let s = "";
+	return o.map((t) => {
+		if (typeof t != "object" || !t || Array.isArray(t) || Object.keys(t).sort().join(",") !== "documents,host") return n("input");
+		let i = t, o = i.host;
+		return typeof o != "string" || e(o) !== o || o === a || o <= s ? n("input") : (s = o, {
+			host: o,
+			documents: r(i.documents)
+		});
+	});
+};
+//#endregion
+export { i as copySnapshotRedirectTargets };

package/dist/snapshotRedirects.js

@@ -0,0 +1,132 @@
+import { readPublicationBoundary as e } from "./changes.js";
+import { CMS_PATHS_TABLE as t, CMS_REDIRECTS_TABLE as n } from "./redirects.js";
+import { verifyPublicationState as r } from "./publicationState.js";
+import { copySnapshotResource as i } from "./buildSnapshot.js";
+import { snapshotObservedRouteHistorySource as a } from "./snapshotObservedRouteHistory.js";
+import { snapshotPublicRouteHistorySource as o } from "./snapshotPublicRouteHistory.js";
+import { snapshotApprovedRouteDispositionsSource as s } from "./snapshotApprovedRouteDispositions.js";
+import { Schema as c } from "effect";
+import { and as l, eq as u, gt as d, inSet as f } from "@voltro/database";
+import { createHash as p } from "node:crypto";
+import { canonicalJson as m } from "@voltro/runtime";
+//#region src/snapshotRedirects.ts
+var h = class extends c.TaggedError()("SnapshotRedirectUnavailable", { reason: c.Literals([
+	"scope",
+	"checkpoint",
+	"row",
+	"history"
+]) }) {}, g = (e) => {
+	throw new h({ reason: e });
+}, _ = (e) => typeof e == "string" && e.length > 0, v = (c, h, v, y, b = Date.now()) => {
+	let x = {
+		tenantId: h.tenantId,
+		site: h.site,
+		environment: h.environment
+	};
+	if (!Object.values(x).every(_)) return g("scope");
+	let S = o(c, x, y);
+	return {
+		format: "voltro.cms.redirect-history/v4",
+		entries: async function* (o) {
+			let h = await e(c, x);
+			if (h.generation !== o.generation || h.releaseId !== o.releaseId || h.checkpoint !== o.checkpoint) return g("checkpoint");
+			let y = await r(c, x, o, b), C = !1;
+			for await (let e of a(c, x, b).entries(o)) if (e.key === "configuration") {
+				if (C || e.value.revision !== v.generation || e.value.sourceDigest !== v.sourceDigest || v.generation === 0 != (v.activationId === null)) return g("history");
+				C = !0, yield i({
+					key: "configuration",
+					value: {
+						...e.value,
+						version: 4,
+						coverage: "source-and-activated-output",
+						activationId: v.activationId,
+						status: v.generation === 0 ? "before-first-activation" : "observed"
+					}
+				});
+			} else {
+				if (!C) return g("history");
+				yield i({
+					key: "observed:" + e.key,
+					value: {
+						...e.value,
+						version: 2,
+						kind: "observed"
+					}
+				});
+			}
+			if (!C) return g("history");
+			for await (let e of S.entries(o)) yield i({
+				key: "source:" + e.key,
+				value: e.value
+			});
+			for await (let e of s(c, x, b).entries(o)) yield i({
+				key: "disposition:" + e.key,
+				value: {
+					...e.value,
+					kind: e.key === "configuration" ? "disposition-configuration" : "disposition"
+				}
+			});
+			for (let [e, r, a] of [[
+				"path",
+				t,
+				"path"
+			], [
+				"redirect",
+				n,
+				"fromPath"
+			]]) {
+				let t;
+				for (;;) {
+					let n = await c.query({
+						table: r,
+						predicate: l(u("tenantId", x.tenantId), u("site", x.site), u("environment", x.environment), f("contentType", y.types), f("locale", y.locales), ...t === void 0 ? [] : [d("id", t)]),
+						lock: "update",
+						order: [{
+							column: "id",
+							direction: "asc"
+						}],
+						take: 500,
+						skip: void 0,
+						projection: [
+							"id",
+							"contentType",
+							"locale",
+							"documentId",
+							a
+						]
+					});
+					if (n.length === 0) break;
+					for (let t of n) {
+						if (![
+							t.id,
+							t.contentType,
+							t.locale,
+							t.documentId
+						].every(_) || typeof t[a] != "string") return g("row");
+						let n = [
+							t.contentType,
+							t.locale,
+							e === "path" ? t.documentId : t[a]
+						], r = `${e}:${p("sha256").update(m(n)).digest("hex")}`;
+						yield i({
+							key: r,
+							value: {
+								version: 1,
+								kind: e,
+								...x,
+								id: t.id,
+								contentType: t.contentType,
+								locale: t.locale,
+								documentId: t.documentId,
+								path: t[a]
+							}
+						});
+					}
+					t = String(n[n.length - 1].id);
+				}
+			}
+		}
+	};
+};
+//#endregion
+export { h as SnapshotRedirectUnavailable, v as snapshotRedirectSource };

package/dist/snapshotReference.js

@@ -0,0 +1,8 @@
+//#region src/snapshotReference.ts
+var e = (e, t) => {
+	let n = Object.getOwnPropertyDescriptor(e, Symbol.for("voltro.cms.snapshot.reference/v1"));
+	if (n === void 0 || n.enumerable || n.writable || typeof n.value != "function") throw Error("Snapshot reference unavailable");
+	return n.value(t);
+};
+//#endregion
+export { e as snapshotReference };

package/dist/snapshotReferenceAddress.js

@@ -0,0 +1,10 @@
+import { readCapturedPublicAddress as e } from "./snapshotAddressRead.js";
+//#region src/snapshotReferenceAddress.ts
+var t = (t, n, r, i, a, o) => e(t, n, r.snapshot, {
+	contentType: i.targetType,
+	documentId: i.targetDocumentId,
+	localeId: r.output.localeId,
+	mappingId: a
+}, o);
+//#endregion
+export { t as readPlannedSnapshotReferenceAddress };

package/dist/snapshotReferenceGraph.js

@@ -0,0 +1,79 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copySnapshotReferenceTypes as t } from "./snapshotProjection.js";
+import { coversSnapshotComponents as n } from "./snapshotFrontend.js";
+import { SnapshotRouteReadUnavailable as r } from "./snapshotRouteAdmission.js";
+import { readAdmittedSnapshotFieldPlan as i } from "./snapshotFieldPlan.js";
+import { readPlannedSnapshotReferenceContext as a } from "./snapshotReferenceRead.js";
+import { createHash as o } from "node:crypto";
+import { canonicalJson as s } from "@voltro/runtime";
+//#region src/snapshotReferenceGraph.ts
+var c = (e) => {
+	throw new r({ reason: e });
+}, l = (e) => o("sha256").update(s(e)).digest("hex"), u = async (r, o, u, d, f, p) => {
+	if (u.length === 0 || u.length > 65 || u[0]?.source !== null || new Set(u.map((e) => e.source)).size !== u.length) return c("bounds");
+	let m = u[0].context.snapshot;
+	if (u.some((e) => e.context.snapshot.id !== m.id || e.context.snapshot.digest !== m.digest || e.context.output.localeId !== f.localeId || e.source?.startsWith("@ref:"))) return c("binding");
+	let h = (await e(r, o, m, "projection", "registry")).value;
+	if (!Array.isArray(h.types) || !h.types.every((e) => typeof e == "string")) return c("binding");
+	let g = new Set(t(h.referenceTypes, h.types)), _ = Object.create(null), v = [], y = /* @__PURE__ */ new Map(), b = u.map((e) => ({
+		...e,
+		selection: {
+			...e.source === null ? {} : { binding: e.source },
+			references: []
+		}
+	})), x = u.reduce((e, t) => e + t.fields.media.length, 0);
+	if (x > 1024) return c("bounds");
+	if (g.size === 0) return {
+		nodes: _,
+		edges: v
+	};
+	for (let e = 0; e < b.length; e++) {
+		let t = b[e];
+		for (let e of t.fields.references) {
+			if (!g.has(e.targetType)) continue;
+			if (v.length >= 8192) return c("bounds");
+			let s = l([
+				e.targetType,
+				e.targetDocumentId,
+				t.context.output.localeId
+			]), u = y.get(s);
+			if (!y.has(s)) {
+				if (y.size >= 256 || t.selection.references.length >= 16) return c("bounds");
+				let l = await a(r, o, t.context, e, p);
+				if (l === null) u = null;
+				else {
+					if (!n(d, l.components, f)) return c("binding");
+					let a = await i(r, o, l, p);
+					if (x += a.media.length, x > 1024) return c("bounds");
+					u = "@ref:" + s;
+					let m = {
+						...t.selection,
+						references: [...t.selection.references, [...e.path]]
+					};
+					_[u] = {
+						selection: m,
+						output: l.output,
+						fields: a
+					}, b.push({
+						source: u,
+						context: l,
+						fields: a,
+						selection: m
+					});
+				}
+				y.set(s, u);
+			}
+			v.push({
+				source: t.source,
+				fieldPath: [...e.path],
+				target: u ?? null
+			});
+		}
+	}
+	return v.sort((e, t) => s(e) < s(t) ? -1 : +(s(e) > s(t))), {
+		nodes: _,
+		edges: v
+	};
+};
+//#endregion
+export { u as readAdmittedSnapshotReferenceGraph };