@voltro/cms 0.86.0 → 0.87.0

package/dist/snapshotCodeSeo.js

@@ -0,0 +1,29 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+//#region src/snapshotCodeSeo.ts
+var t = () => {
+	throw Error("Invalid retained code SEO");
+}, n = (e, t) => typeof e == "string" && e.length > 0 && e.length <= t && !/[\x00-\x1f\x7f]/.test(e), r = (r) => {
+	let i = e({
+		key: "native-seo",
+		value: { metadata: r }
+	}).value.metadata;
+	if (typeof i != "object" || !i || Array.isArray(i)) return t();
+	let a = i;
+	if (Object.keys(a).sort().join(",") !== "alternates,canonical,noIndex,version" || a.version !== 1 || a.canonical !== null && !n(a.canonical, 8192) || typeof a.noIndex != "boolean" || !Array.isArray(a.alternates) || a.alternates.length > 1024) return t();
+	let o = a.alternates.map((e) => {
+		if (typeof e != "object" || !e || Array.isArray(e)) return t();
+		let r = e;
+		return Object.keys(r).sort().join(",") !== "href,locale" || !n(r.href, 8192) || !n(r.locale, 128) ? t() : {
+			href: r.href,
+			locale: r.locale
+		};
+	});
+	return new Set(o.map((e) => e.locale)).size === o.length ? {
+		version: 1,
+		canonical: a.canonical,
+		noIndex: a.noIndex,
+		alternates: o
+	} : t();
+};
+//#endregion
+export { r as copySnapshotCodeSeo };

package/dist/snapshotComponent.js

@@ -0,0 +1,34 @@
+import { renderCapturedFrontendComponent as e } from "./frontendBindings.js";
+import { snapshotComponentSource as t } from "./snapshotComponentSource.js";
+import { snapshotObserver as n, snapshotProjectedValue as r } from "./snapshotObservation.js";
+//#region src/snapshotComponent.ts
+var i = (i, a, o, s = "content") => {
+	let c = r(i, o), l = n(i), u = [...o];
+	if (typeof c != "object" || !c || Array.isArray(c)) throw Error("Snapshot component unavailable");
+	let d = c;
+	if (typeof d.componentId != "string" || d.props === null || typeof d.props != "object" || Array.isArray(d.props)) throw Error("Snapshot component unavailable");
+	return e(a, {
+		componentId: d.componentId,
+		props: d.props,
+		context: i.context,
+		state: s,
+		presentation: i.presentation,
+		consentPurposes: i.consentPurposes,
+		source: t(i, u, d),
+		observe: (e) => l({
+			kind: "component",
+			fieldPath: u,
+			...e
+		}),
+		media: {
+			entries: i.media,
+			fieldPath: [...u, "props"],
+			observe: (e) => l({
+				kind: "media",
+				...e
+			})
+		}
+	});
+};
+//#endregion
+export { i as renderSnapshotComponent };

package/dist/snapshotComponentSource.js

@@ -0,0 +1,24 @@
+import { snapshotReference as e } from "./snapshotReference.js";
+import { snapshotLink as t } from "./snapshotLink.js";
+import { copySnapshotContentIdentity as n } from "./snapshotContentIdentity.js";
+//#region src/snapshotComponentSource.ts
+var r = (r, i, a) => {
+	let o = Object.freeze([...i]), s = a.type === "component" ? a.id : a.instanceId;
+	return Object.freeze({
+		content: Object.freeze(n(r.content)),
+		fieldPath: o,
+		instanceId: typeof s == "string" && s.length > 0 ? s : null,
+		link: (e) => t(r, [
+			...o,
+			"props",
+			...e
+		]),
+		reference: (t) => e(r, [
+			...o,
+			"props",
+			...t
+		])
+	});
+};
+//#endregion
+export { r as snapshotComponentSource };

package/dist/snapshotConsumer.js

@@ -0,0 +1,87 @@
+import { readVerifiedSnapshotResource as e } from "./buildSnapshot.js";
+import { copyRenderReadAuthority as t, readRenderReadAuthority as n } from "./renderReadAuthority.js";
+import { resolveSnapshotReadBinding as r } from "./snapshotReadAdmission.js";
+import { issueRenderReadGrant as i, verifyRenderReadRenewal as a } from "./renderReadGrant.js";
+import { Schema as o } from "effect";
+import { generateId as s } from "@voltro/database";
+import { dataStoreApiKeyStore as c, makeApiKeyService as l } from "@voltro/runtime";
+//#region src/snapshotConsumer.ts
+var u = class extends o.TaggedError()("SnapshotConsumerUnavailable", { reason: o.Literals([
+	"configuration",
+	"credential",
+	"projection",
+	"expiry"
+]) }) {}, d = (e) => {
+	throw new u({ reason: e });
+}, f = (e) => Number.isSafeInteger(e) && Number.isFinite(new Date(e).getTime()), p = (e, t) => {
+	if (typeof e != "object" || !e || Array.isArray(e)) return d("configuration");
+	let n = e;
+	if (Object.keys(n).length !== 3 || Object.keys(n).some((e) => ![
+		"id",
+		"requiredScope",
+		"maxGrantMs"
+	].includes(e))) return d("configuration");
+	let { id: r, requiredScope: i, maxGrantMs: a } = n;
+	return !f(t) || typeof r != "string" || !/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(r) || typeof i != "string" || !/^[A-Za-z][A-Za-z0-9:_.-]{0,127}$/.test(i) || typeof a != "number" || !Number.isSafeInteger(a) || a <= 0 || !f(t + a) ? d("configuration") : {
+		id: r,
+		requiredScope: i,
+		maxGrantMs: a
+	};
+}, m = async (o, u, m, h) => {
+	let g = {
+		tenantId: u.tenantId,
+		site: u.site,
+		environment: u.environment
+	}, _ = {
+		id: m.snapshot.id,
+		digest: m.snapshot.digest
+	}, v = m.apiKey, y = m.resume === void 0 ? void 0 : {
+		token: m.resume.token,
+		buildId: m.resume.buildId
+	}, b = h.now ?? Date.now(), x = p(h.consumer, b), S = {
+		id: h.key.id,
+		material: new Uint8Array(h.key.material)
+	}, C = (h.verificationKeys ?? []).map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	}));
+	if (typeof v != "string" || v.length === 0 || v.length > 512) return d("credential");
+	let w = await l(c(o)).verify(v, b);
+	if (w === null) return d("credential");
+	let T = t({
+		kind: "apiKey",
+		id: w.id,
+		scope: x.requiredScope
+	});
+	if (T === null) return d("credential");
+	let E = await n(o, g, T, b);
+	if (E === null) return d("credential");
+	let D = y?.buildId ?? s({
+		kind: "typeid",
+		prefix: "cmsbuild"
+	}, "_voltro_cms_render_read_grants"), { snapshot: O, binding: k } = await r(o, g, _, {
+		consumerId: x.id,
+		buildId: D
+	}, b), A = (await e(o, g, O, "projection", "registry")).value;
+	if (A.version !== 1 || A.id !== x.id) return d("projection");
+	y !== void 0 && await a(o, y.token, k, T, {
+		keys: [S, ...C],
+		now: b
+	});
+	let j = Math.min(b + x.maxGrantMs, O.expiresAt, E.expiresAt ?? 2 ** 53 - 1);
+	return !f(j) || j <= b ? d("expiry") : {
+		...await i(o, k, {
+			key: S,
+			now: b,
+			expiresAt: j,
+			maxExpiresAt: j,
+			authority: T
+		}),
+		consumerId: x.id,
+		buildId: D,
+		snapshotId: O.id,
+		snapshotDigest: O.digest
+	};
+};
+//#endregion
+export { u as SnapshotConsumerUnavailable, p as copySnapshotConsumer, m as issueSnapshotReadGrant };

package/dist/snapshotContentIdentity.js

@@ -0,0 +1,10 @@
+//#region src/snapshotContentIdentity.ts
+var e = ({ contentType: e, documentId: t, variantId: n, revisionId: r, revision: i }) => ({
+	contentType: e,
+	documentId: t,
+	variantId: n,
+	revisionId: r,
+	revision: i
+});
+//#endregion
+export { e as copySnapshotContentIdentity };

package/dist/snapshotDefinitions.js

@@ -0,0 +1,264 @@
+import { copySnapshotResource as e } from "./buildSnapshot.js";
+import { Schema as t } from "effect";
+import { createHash as n } from "node:crypto";
+import { canonicalJson as r } from "@voltro/runtime";
+//#region src/snapshotDefinitions.ts
+var i = class extends t.TaggedError()("SnapshotDefinitionUnavailable", { reason: t.Literals([
+	"app",
+	"definition",
+	"duplicate",
+	"component-conflict",
+	"cycle",
+	"bounds"
+]) }) {}, a = (e) => {
+	throw new i({ reason: e });
+}, o = (e) => n("sha256").update(r(e)).digest("hex"), s = (e) => typeof e == "string" && e.trim().length > 0, c = (e) => !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(e.commit) || ![e.artifactDigest, e.configDigest].every((e) => /^[0-9a-f]{64}$/.test(e)) ? a("app") : {
+	commit: e.commit,
+	artifactDigest: e.artifactDigest,
+	configDigest: e.configDigest
+}, l = {
+	kind: "data",
+	editorHint: "data",
+	isOptional: "data",
+	publishRequired: "data",
+	maxLength: "data",
+	pattern: "data",
+	literals: "data",
+	literalLabels: "data",
+	token: "data",
+	action: "data",
+	fraction: "data",
+	unique: "data",
+	richText: "richText",
+	referenceType: "data",
+	element: "field",
+	struct: "fields",
+	components: "components",
+	derived: "derived"
+}, u = {
+	id: "data",
+	displayName: "data",
+	props: "fields",
+	fingerprint: "data",
+	description: "data",
+	jobs: "data",
+	variants: "data",
+	fixtures: "data",
+	migrations: "migrations",
+	consent: "data"
+}, d = {
+	name: "data",
+	displayName: "data",
+	pluralName: "data",
+	fields: "fields",
+	asset: "data",
+	list: "data",
+	idPrefix: "data",
+	revalidate: "data",
+	tree: "data",
+	address: "data",
+	locations: "data",
+	seo: "data",
+	seoSites: "data",
+	review: "review",
+	availability: "data",
+	lifecycle: "data",
+	templates: "templates",
+	changeFeed: "data",
+	search: "data",
+	quality: "quality",
+	taxonomy: "data",
+	derivedFields: "data",
+	uniqueFields: "data"
+}, f = {
+	name: "data",
+	version: "data",
+	id: "data",
+	blocks: "data",
+	headings: "data",
+	marks: "data",
+	styles: "data",
+	components: "components",
+	contactPoints: "data",
+	contactLiterals: "data"
+}, p = {
+	id: "data",
+	displayName: "data",
+	values: "data",
+	sections: "sections",
+	required: "components",
+	first: "component",
+	max: "limits",
+	regions: "regions",
+	widths: "widths",
+	maxDepth: "data"
+}, m = {
+	id: "data",
+	label: "data",
+	approverScope: "data",
+	after: "data",
+	when: "implementation",
+	slaHours: "data",
+	evidence: "data"
+}, h = {
+	id: "data",
+	field: "data",
+	message: "data",
+	blocking: "data",
+	pack: "data",
+	sites: "data",
+	locales: "data",
+	check: "implementation"
+}, g = {
+	source: "data",
+	transform: "implementation"
+}, _ = {
+	images: "data",
+	files: "data",
+	links: "data",
+	profile: "profile"
+}, v = {
+	field: "data",
+	components: "data",
+	width: "data",
+	list: "templateList"
+}, y = {
+	allowed: "components",
+	required: "components",
+	maxItems: "data"
+}, b = {
+	id: "data",
+	version: "data",
+	steps: "steps"
+}, x = (t, n, i = []) => {
+	let x = c(n);
+	if (t.length === 0 && i.length === 0 || t.some((e) => !s(e.name))) return a("definition");
+	if (new Set(t.map((e) => e.name)).size !== t.length) return a("duplicate");
+	let S = /* @__PURE__ */ new Set(), C = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), T = (e, t) => {
+		if (typeof e != "object" || !e || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e))) return a("definition");
+		if (S.has(e)) return a("cycle");
+		if (S.size >= 64) return a("bounds");
+		if (Object.getOwnPropertySymbols(e).length > 0) return a("definition");
+		let n = Object.getOwnPropertyDescriptors(e);
+		if (Object.values(n).some((e) => !e.enumerable || !("value" in e))) return a("definition");
+		S.add(e);
+		try {
+			return t(Object.fromEntries(Object.entries(n).map(([e, t]) => [e, t.value])));
+		} finally {
+			S.delete(e);
+		}
+	}, E = (t) => e({
+		key: "metadata",
+		value: { data: t }
+	}).value.data, D = (e, t) => {
+		if (typeof e != "function") return a("definition");
+		let n = r(t), i = w.get(n);
+		return i !== void 0 && i !== e ? a("component-conflict") : (w.set(n, e), {
+			kind: "app-implementation",
+			app: x,
+			path: [...t]
+		});
+	}, O = (e, t, n) => {
+		if (!Array.isArray(e) || Object.getOwnPropertySymbols(e).length > 0 || Object.keys(e).length !== e.length || Object.keys(e).some((e, t) => e !== String(t))) return a("definition");
+		let r = Object.getOwnPropertyDescriptors(e);
+		return Object.entries(r).some(([e, t]) => e !== "length" && (!t.enumerable || !("value" in t))) ? a("definition") : Array.from({ length: e.length }, (e, i) => n(r[String(i)].value, [...t, String(i)]));
+	}, k = (e, t, n) => T(e, (e) => Object.fromEntries(Object.keys(e).sort().map((r) => [r, n(e[r], [...t, r])]))), A = (e, t, n, r = !1) => T(e, (e) => Object.fromEntries(Object.keys(e).sort().flatMap((i) => r && [
+		"pipe",
+		"optional",
+		"requiredToPublish"
+	].includes(i) ? typeof e[i] == "function" ? [] : a("definition") : Object.hasOwn(t, i) ? e[i] === void 0 ? [] : [[i, M(t[i], e[i], [...n, i])]] : a("definition")))), j = (t) => {
+		let n = typeof t == "object" && t ? Object.getOwnPropertyDescriptor(t, "id")?.value : void 0;
+		if (!s(n)) return a("definition");
+		let r = {
+			version: 1,
+			app: x,
+			definition: A(t, u, ["components", n])
+		}, i = e({
+			key: `component:${n}`,
+			value: r
+		}), c = o(i.value), l = C.get(n);
+		return l !== void 0 && l.digest !== c ? a("component-conflict") : (C.set(n, {
+			resource: i,
+			digest: c
+		}), {
+			id: n,
+			digest: c
+		});
+	}, M = (e, t, n) => {
+		switch (e) {
+			case "data": return E(t);
+			case "implementation": return D(t, n);
+			case "migrations": return k(t, n, D);
+			case "fields": return k(t, n, (e, t) => A(e, l, t, !0));
+			case "field": return A(t, l, n, !0);
+			case "component": return j(t);
+			case "components": return O(t, n, j);
+			case "richText": return A(t, _, n);
+			case "profile": return A(t, f, n);
+			case "derived": return A(t, g, n);
+			case "review": return A(t, {
+				required: "data",
+				workflow: "workflow"
+			}, n);
+			case "workflow": return A(t, b, n);
+			case "steps": return O(t, n, (e, t) => A(e, m, t));
+			case "quality": return O(t, n, (e, t) => A(e, h, t));
+			case "templates": return A(t, v, n);
+			case "templateList": return O(t, n, (e, t) => A(e, p, t));
+			case "sections": return O(t, n, (e, t) => A(e, {
+				component: "component",
+				props: "data"
+			}, t));
+			case "limits": return O(t, n, (e, t) => A(e, {
+				component: "component",
+				count: "data"
+			}, t));
+			case "widths": return O(t, n, (e, t) => A(e, {
+				component: "component",
+				allowed: "data"
+			}, t));
+			case "regions": return k(t, n, (e, t) => A(e, y, t));
+		}
+	}, N = [...t].sort((e, t) => e.name < t.name ? -1 : +(e.name > t.name)).map((t) => e({
+		key: `type:${t.name}`,
+		value: {
+			version: 1,
+			app: x,
+			definition: A(t, d, ["types", t.name])
+		}
+	}));
+	for (let e of i) j(e);
+	let P = (t, n) => {
+		let r = [e({
+			key: "registry",
+			value: {
+				version: 1,
+				app: x,
+				count: n.length
+			}
+		}), ...n];
+		return {
+			format: `voltro.cms.${t}/v1`,
+			entries: () => structuredClone(r)
+		};
+	};
+	return {
+		schema: P("schema", N),
+		components: P("components", [...C.keys()].sort().map((e) => C.get(e).resource)),
+		definition: (t) => {
+			let n = N.find((e) => e.key === `type:${t}`);
+			return n === void 0 ? a("definition") : e(n);
+		}
+	};
+}, S = (e, t) => {
+	let { schema: n, components: r } = x(e, t);
+	return {
+		schema: n,
+		components: r
+	};
+}, C = (e, t) => x([e], t).definition(e.name), w = (e, t) => {
+	for (let n of x([], t, [e]).components.entries()) if (n.key === `component:${e.id}`) return n;
+	return a("definition");
+};
+//#endregion
+export { i as SnapshotDefinitionUnavailable, c as copySnapshotAppCodePin, w as snapshotComponentDefinition, C as snapshotContentTypeDefinition, S as snapshotDefinitionSources };

package/dist/snapshotDocumentAssembly.js

@@ -0,0 +1,193 @@
+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";
+//#region 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
+			});
+		}
+	};
+};
+//#endregion
+export { y as createSnapshotDocumentAssembly };