@voltro/cms 0.86.0 → 0.87.0

package/dist/staticPathSetService.js

@@ -0,0 +1,249 @@
+import { defineSiteDelivery as e } from "./siteDelivery.js";
+import { normalizeHost as t } from "./domainHost.js";
+import { verifyPublicationState as n } from "./publicationState.js";
+import { findVerifiedSnapshotResources as r, pageSnapshotResources as i } from "./buildSnapshot.js";
+import { nativeSnapshotRouteId as a, readSnapshotRouting as o, snapshotCmsPage as s, snapshotRouteDispatch as c, verifySnapshotRouteOwnership as l } from "./snapshotRouting.js";
+import { StaticPathSetConflict as u, StaticPathSetUnavailable as d, copyStaticPathContext as f, copyStaticPathOwners as p, staticPathHash as m, staticPathUrl as h } from "./staticPathSet.js";
+import { readSnapshotAppExecution as g, verifySnapshotAppExecution as _ } from "./snapshotAppExecution.js";
+import { readSnapshotRouteAdmission as v, verifySnapshotContentRoute as y } from "./snapshotRouteAdmission.js";
+import { readAdmittedSnapshotContentRoute as b } from "./snapshotRouteRead.js";
+import { snapshotPathLocale as x } from "./snapshotPathLocale.js";
+import { appendStaticPathStage as S, beginStaticPathSet as C, pageStaticPathSet as w, readStaticPathSet as T, sealStaticPathSet as E } from "./staticPathSetStore.js";
+import { Effect as D } from "effect";
+import { canonicalJson as O } from "@voltro/runtime";
+//#region src/staticPathSetService.ts
+var k = (e) => {
+	throw new d({ reason: e });
+}, A = (e) => typeof e != "object" || !e || Array.isArray(e) ? k("integrity") : e, j = (e) => D.tryPromise({
+	try: e,
+	catch: (e) => e instanceof d || e instanceof u ? e : new d({ reason: "state" })
+}), M = (e) => ({
+	id: e.id,
+	revision: e.progress.revision,
+	phase: e.progress.phase,
+	enumerated: e.progress.inputCount,
+	set: e.sealed
+}), N = (e) => ({
+	snapshot: {
+		id: e.snapshot.id,
+		digest: e.snapshot.digest
+	},
+	token: e.token,
+	consumerId: e.consumerId,
+	buildId: e.buildId,
+	host: e.host,
+	...e.localeIds === void 0 ? {} : { localeIds: [...e.localeIds] },
+	...e.owners === void 0 ? {} : { owners: [...e.owners] }
+}), P = async (r, i, a, s) => {
+	let c = await v(r, i, a.snapshot, {
+		...a,
+		path: "/"
+	}, {
+		keys: s.keys,
+		now: s.now
+	}), l = await n(r, i, c.snapshot.manifest.publication, c.now), u = await g(r, i, c.snapshot), d = o(c.configuration), m = e(c.configuration.site), h = m.locales.filter((e) => e.enabled).map((e) => e.id).sort(), _ = a.localeIds === void 0 ? h : [...a.localeIds].sort();
+	if (_.length === 0 || _.some((e, t) => !h.includes(e) || t > 0 && _[t - 1] === e)) return k("input");
+	let y = p(a.owners ?? ["cms", "code"]), b = t(a.host);
+	if (b === null) return k("input");
+	let x = (e) => c.snapshot.manifest.parts.find((t) => t.part === e)?.digest ?? k("integrity"), S = f({
+		...i,
+		snapshotId: c.snapshot.id,
+		snapshotDigest: c.snapshot.digest,
+		releaseId: c.snapshot.manifest.publication.releaseId,
+		consumerId: a.consumerId,
+		buildId: a.buildId,
+		inputsId: u.inputsId,
+		executionId: u.executionId,
+		routesDigest: x("routes"),
+		domainsDigest: x("domains"),
+		localesDigest: x("locales"),
+		policyDigest: x("policies"),
+		projectionDigest: x("projection"),
+		host: b,
+		localeIds: _,
+		owners: y
+	}), C = d.discovery === null ? [] : d.discovery.pages;
+	if (!Array.isArray(C)) return k("integrity");
+	let w = C.map(A).sort((e, t) => String(e.file) < String(t.file) ? -1 : +(String(e.file) > String(t.file)));
+	return {
+		admission: c,
+		partitions: l,
+		app: u,
+		routing: d,
+		site: m,
+		context: S,
+		nativePages: w,
+		codePages: y.includes("code") ? w.filter((e) => {
+			let t = d.definition?.claims[String(e.file)];
+			return t?.kind !== "cms" && (u.web === void 0 || t?.kind === "code" && t.public === !0);
+		}) : []
+	};
+}, F = (e) => {
+	let { store: t, execution: n } = e, o = {
+		tenantId: e.scope.tenantId,
+		site: e.scope.site,
+		environment: e.scope.environment
+	}, u = e.now ?? Date.now, d = {
+		id: e.key.id,
+		material: new Uint8Array(e.key.material)
+	}, f = [d, ...(e.verificationKeys ?? []).map((e) => ({
+		id: e.id,
+		material: new Uint8Array(e.material)
+	}))], p = (e, t) => P(e, o, t, {
+		keys: f,
+		now: u()
+	}), g = (e, t, n) => {
+		if (t === null) return {};
+		let r = e.nativePages.find((e) => e.file === t);
+		if (r === void 0) return k("integrity");
+		let i = A(r.matcher), a = i.paramNames;
+		if (typeof i.source != "string" || i.flags !== "" || !Array.isArray(a) || a.some((e) => typeof e != "string") || new Set(a).size !== a.length) return k("integrity");
+		let o = new RegExp(i.source, "").exec(n);
+		if (o === null) return k("integrity");
+		try {
+			return Object.fromEntries(a.map((e, t) => [e, decodeURIComponent(o[t + 1] ?? "")]));
+		} catch {
+			return k("integrity");
+		}
+	}, v = (e, t) => {
+		if (O(e) !== O(t)) return k("changed");
+	};
+	return {
+		begin: (e) => j(async () => {
+			let n = N(e);
+			return t.transactional(async (e) => {
+				let t = await p(e, n), r = await C(e, t.context, f);
+				return await p(e, n), M(r);
+			});
+		}),
+		advance: (e) => j(async () => {
+			let u = N(e), C = e.id, w = e.revision;
+			if (!Number.isSafeInteger(w) || w < 0) return k("input");
+			let D = await t.transactional(async (e) => {
+				let t = await p(e, u), n = await T(e, t.context, C, f);
+				return {
+					...t,
+					set: n
+				};
+			});
+			if (w > D.set.progress.revision) return k("changed");
+			if (w < D.set.progress.revision || D.set.sealed !== null) return M(D.set);
+			if (D.set.progress.phase === "cms") return t.transactional(async (e) => {
+				let t = await p(e, u);
+				v(t.context, D.context);
+				let n = await i(e, o, t.admission.snapshot.id, "routes", {
+					now: t.admission.now,
+					limit: 200,
+					...D.set.progress.after === null ? {} : { after: D.set.progress.after }
+				}), r = [];
+				for (let i of n.items) {
+					if (!i.key.startsWith("path:")) continue;
+					let n = i.value, a = n.path;
+					if (typeof a != "string" || i.key !== "path:" + m(a)) return k("integrity");
+					if (y(o, a, n), l(t.admission.configuration, n).owner !== "cms" || !t.context.owners.includes("cms") || !t.context.localeIds.includes(String(n.localeId))) continue;
+					let c = await b(e, {
+						...t.admission,
+						input: {
+							...t.admission.input,
+							path: a
+						},
+						route: n
+					}, t.partitions);
+					if (c === null) continue;
+					if (x(t.site, a).id !== c.output.localeId) return k("integrity");
+					let u = t.app.nativePages ? s(t.routing, a) : null;
+					r.push({
+						host: t.context.host,
+						path: a,
+						localeId: c.output.localeId,
+						routeId: c.output.routeId,
+						owner: "cms",
+						file: u?.file ?? null,
+						sourceDigest: u?.sourceDigest ?? null,
+						parameters: g(t, u?.file ?? null, a)
+					});
+				}
+				let a = await S(e, D.set, {
+					source: "cms:" + D.set.progress.revision,
+					receiptDigest: m({
+						routesDigest: t.context.routesDigest,
+						items: n.items
+					}),
+					entries: r,
+					next: {
+						phase: n.next === null ? t.codePages.length === 0 ? "seal" : "code" : "cms",
+						after: n.next,
+						codeIndex: 0
+					}
+				}, d, f);
+				return await p(e, u), M(a);
+			});
+			if (D.set.progress.phase === "code") {
+				let e = D.codePages[D.set.progress.codeIndex];
+				if (e === void 0 || typeof e.file != "string" || typeof e.pattern != "string" || !D.app.nativePages) return k("state");
+				let i = {
+					version: 1,
+					file: e.file
+				}, s = await n.run({
+					inputsId: D.app.inputsId,
+					executionId: D.app.executionId,
+					exportName: "__voltro_staticPaths",
+					inputJson: O(i)
+				});
+				_(D.app, "__voltro_staticPaths", i, s);
+				let b = A(s.value);
+				return Object.keys(b).sort().join(",") !== "file,paths,pattern,version" || b.version !== 1 || b.file !== e.file || b.pattern !== e.pattern || !Array.isArray(b.paths) || b.paths.length > 1e4 ? k("integrity") : t.transactional(async (t) => {
+					let n = await p(t, u);
+					v(n.context, D.context);
+					let i = [], _ = b.paths.map((e) => typeof e == "string" ? (h(n.context.host, e), e) : k("integrity"));
+					for (let s = 0; s < _.length; s += 200) {
+						let u = _.slice(s, s + 200), d = await r(t, o, n.admission.snapshot, "routes", u.map((e) => "path:" + m(e)));
+						for (let t of u) {
+							let r = d.get("path:" + m(t))?.value;
+							r !== void 0 && y(o, t, r);
+							let s = r === void 0 ? c(n.routing, t, !1) : l(n.admission.configuration, r);
+							if (s?.owner !== "code" || s.code === null || s.code.file !== e.file) continue;
+							let u = x(n.site, t);
+							n.context.localeIds.includes(u.id) && i.push({
+								host: n.context.host,
+								path: t,
+								localeId: u.id,
+								routeId: a(o, u.id, s.code.file, t),
+								owner: "code",
+								file: s.code.file,
+								sourceDigest: s.code.sourceDigest,
+								parameters: g(n, s.code.file, t)
+							});
+						}
+					}
+					let C = D.set.progress.codeIndex + 1, w = await S(t, D.set, {
+						source: "code:" + e.file,
+						receiptDigest: m(s),
+						entries: i,
+						next: {
+							phase: C === n.codePages.length ? "seal" : "code",
+							after: null,
+							codeIndex: C
+						}
+					}, d, f);
+					return await p(t, u), M(w);
+				});
+			}
+			return t.transactional(async (e) => {
+				let t = await p(e, u);
+				v(t.context, D.context);
+				let n = await E(e, D.set, d, f);
+				return await p(e, u), M(n);
+			});
+		}),
+		page: (e) => j(async () => {
+			let n = N(e), r = e.id, i = e.index, a = e.digest;
+			return t.transactional(async (e) => {
+				let t = await p(e, n), o = await w(e, t.context, r, i, f);
+				return o.set.id === a ? (await p(e, n), o) : k("changed");
+			});
+		})
+	};
+};
+//#endregion
+export { F as createCmsStaticPathSets, P as readSnapshotStaticPathAdmission };

package/dist/staticPathSetStore.js

@@ -0,0 +1,338 @@
+import { StaticPathSetConflict as e, StaticPathSetUnavailable as t, copyStaticPathContext as n, copyStaticPathEntry as r, signStaticPathSet as i, staticPathHash as a, staticPathUrl as o, verifyStaticPathPage as s, verifyStaticPathSet as c } from "./staticPathSet.js";
+import { and as l, eq as u, generateId as d, id as f, integer as p, json as m, table as h, text as g } from "@voltro/database";
+import { tenant as _ } from "@voltro/plugin-multitenancy/mixin";
+import { createHash as v, createHmac as y, timingSafeEqual as b } from "node:crypto";
+import { canonicalJson as x } from "@voltro/runtime";
+//#region src/staticPathSetStore.ts
+var S = "_voltro_cms_static_path_sets", C = "_voltro_cms_static_path_pages", w = h(S, {
+	id: f({ prefix: "cpaths" }),
+	site: g().maxLength(64),
+	environment: g().maxLength(64),
+	contextDigest: g().maxLength(64),
+	context: m(),
+	progress: m(),
+	sealed: m().nullable()
+}).with(_()).unique("cms_static_path_set_context", [
+	"tenantId",
+	"site",
+	"environment",
+	"contextDigest"
+]), T = h(C, {
+	id: f({ prefix: "cpathpg" }),
+	site: g().maxLength(64),
+	environment: g().maxLength(64),
+	setId: g().maxLength(64),
+	kind: g().oneOf([
+		"input",
+		"stage",
+		"output"
+	]),
+	ordinal: p(),
+	value: m(),
+	digest: g().maxLength(64)
+}).with(_()).unique("cms_static_path_page", [
+	"tenantId",
+	"setId",
+	"kind",
+	"ordinal"
+]), E = Object.freeze([w, T]), D = (e) => {
+	throw new t({ reason: e });
+}, O = (e) => typeof e == "string" && /^[A-Za-z0-9_-]{1,64}$/.test(e), k = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e), A = (e) => typeof e != "object" || !e || Array.isArray(e) ? D("state") : e, j = (e) => l(u("tenantId", e.tenantId), u("site", e.site), u("environment", e.environment)), M = (e) => {
+	let t = A(e);
+	return Object.keys(t).sort().join(",") !== "after,chain,codeIndex,inputBytes,inputCount,inputPages,phase,revision,version" || t.version !== 1 || ![
+		"cms",
+		"code",
+		"seal",
+		"ready"
+	].includes(String(t.phase)) || !(t.after === null || O(t.after)) || !k(t.chain) || ![
+		"codeIndex",
+		"inputBytes",
+		"inputCount",
+		"inputPages",
+		"revision"
+	].every((e) => Number.isSafeInteger(t[e]) && Number(t[e]) >= 0) || Number(t.codeIndex) > 4096 || Number(t.inputCount) > 1e5 || Number(t.inputPages) > 1e5 || Number(t.inputBytes) > 67108864 || Number(t.revision) > 1e5 ? D("state") : { ...t };
+}, N = (e, t, n) => {
+	if (!O(e.id) || e.contextDigest !== a(t) || x(e.context) !== x(t)) return D("changed");
+	let r = M(e.progress), i = e.sealed === null ? null : c(e.sealed, n);
+	return i !== null != (r.phase === "ready") || i !== null && x(i.manifest.context) !== x(t) ? D("state") : {
+		id: e.id,
+		context: t,
+		progress: r,
+		sealed: i
+	};
+}, P = async (e, t, r, i, a = !1) => {
+	let o = n(t);
+	if (!O(r)) return D("input");
+	let [s] = await e.query({
+		table: S,
+		predicate: l(j(o), u("id", r)),
+		...a ? { lock: "update" } : {},
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (s === void 0) return D("state");
+	let c = N(s, o, i);
+	return await L(e, c, i), c;
+}, F = async (e, t, r) => {
+	let i = n(t), o = a(i), s = d({
+		kind: "typeid",
+		prefix: "cpaths"
+	}, S);
+	if (s === null) return D("state");
+	let c = {
+		version: 1,
+		phase: "cms",
+		after: null,
+		codeIndex: 0,
+		revision: 0,
+		inputPages: 0,
+		inputCount: 0,
+		inputBytes: 0,
+		chain: a({ context: i })
+	};
+	await e.insertIgnore(S, {
+		id: s,
+		tenantId: i.tenantId,
+		site: i.site,
+		environment: i.environment,
+		contextDigest: o,
+		context: i,
+		progress: c,
+		sealed: null
+	}, { conflictColumns: [
+		"tenantId",
+		"site",
+		"environment",
+		"contextDigest"
+	] });
+	let [f] = await e.query({
+		table: S,
+		predicate: l(j(i), u("contextDigest", o)),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (f === void 0) return D("state");
+	let p = N(f, i, r);
+	return await L(e, p, r), p;
+}, I = (e, t) => !O(t.id) || !(t.material instanceof Uint8Array) || t.material.byteLength < 32 ? D("key") : y("sha256", t.material).update(x({
+	purpose: "voltro.cms.static-path-stage/v1",
+	value: e,
+	keyId: t.id
+})).digest("hex"), L = async (e, t, n) => {
+	if (t.progress.revision === 0) {
+		let e = {
+			version: 1,
+			phase: "cms",
+			after: null,
+			codeIndex: 0,
+			revision: 0,
+			inputPages: 0,
+			inputCount: 0,
+			inputBytes: 0,
+			chain: a({ context: t.context })
+		};
+		return x(t.progress) !== x(e) || t.sealed !== null ? D("integrity") : void 0;
+	}
+	let r = A(await R(e, t, "stage", t.progress.revision)), i = A(r.body), o = n.find((e) => e.id === r.keyId), s = {
+		...t.progress,
+		chain: "",
+		...t.sealed === null ? {} : { phase: "seal" }
+	};
+	if (o === void 0 || !k(r.signature) || i.setId !== t.id || i.contextDigest !== a(t.context) || a(i) !== t.progress.chain || x(i.next) !== x(s) || !b(Buffer.from(I(i, o), "hex"), Buffer.from(r.signature, "hex"))) return D("integrity");
+}, R = async (e, t, n, r) => {
+	let [i] = await e.query({
+		table: C,
+		predicate: l(j(t.context), u("setId", t.id), u("kind", n), u("ordinal", r)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	return i === void 0 || i.digest !== a(i.value) ? D("integrity") : i.value;
+}, z = (e, t, n, r, i) => e.insert(C, {
+	tenantId: t.context.tenantId,
+	site: t.context.site,
+	environment: t.context.environment,
+	setId: t.id,
+	kind: n,
+	ordinal: r,
+	value: i,
+	digest: a(i)
+}), B = async (e, t, n, i, o) => {
+	if (t.sealed !== null || !k(n.receiptDigest) || n.source.length === 0 || n.source.length > 2048 || n.entries.length > 1e4) return D("input");
+	if (t.progress.phase === "seal" || t.progress.phase === "ready" || n.next.phase === "ready" || t.progress.phase === "cms" && (n.next.codeIndex !== 0 || n.next.phase === "cms" && (n.next.after === null || n.next.after === t.progress.after) || n.next.phase !== "cms" && n.next.after !== null) || t.progress.phase === "code" && (n.next.phase === "cms" || n.next.after !== null || n.next.codeIndex !== t.progress.codeIndex + 1)) return D("state");
+	let s = n.entries.map(r), c = t.progress.revision + 1;
+	if (s.some((e) => e.host !== t.context.host || !t.context.localeIds.includes(e.localeId) || !t.context.owners.includes(e.owner))) return D("input");
+	let l = Buffer.byteLength(x(s)), u = M({
+		...t.progress,
+		...n.next,
+		revision: c,
+		inputPages: t.progress.inputPages + Math.ceil(s.length / 200),
+		inputCount: t.progress.inputCount + s.length,
+		inputBytes: t.progress.inputBytes + l
+	}), d = {
+		contextDigest: a(t.context),
+		setId: t.id,
+		revision: c,
+		source: n.source,
+		receiptDigest: n.receiptDigest,
+		previous: t.progress.chain,
+		pages: Array.from({ length: Math.ceil(s.length / 200) }, (e, t) => a(s.slice(t * 200, (t + 1) * 200))),
+		next: {
+			...u,
+			chain: ""
+		}
+	}, f = a(d), p = {
+		...u,
+		chain: f
+	}, m = await P(e, t.context, t.id, o, !0);
+	if (m.progress.revision >= c) {
+		let t = A(await R(e, m, "stage", c));
+		return a(t.body) === f ? m : D("changed");
+	}
+	if (x(m.progress) !== x(t.progress)) return D("changed");
+	for (let n = 0; n < d.pages.length; n++) await z(e, m, "input", t.progress.inputPages + n + 1, s.slice(n * 200, (n + 1) * 200));
+	return await z(e, m, "stage", c, {
+		body: d,
+		keyId: i.id,
+		signature: I(d, i)
+	}), await e.update(S, t.id, { progress: p }), {
+		...m,
+		progress: p
+	};
+}, V = async (t, n, s, c) => {
+	let l = await P(t, n.context, n.id, c, !0);
+	if (l.sealed !== null) return l;
+	if (l.progress.phase !== "seal" || x(l.progress) !== x(n.progress)) return D("changed");
+	let u = [], d = v("sha256"), f = a({ context: l.context }), p = 0, m = 0;
+	for (let e = 1; e <= l.progress.revision; e++) {
+		let n = A(await R(t, l, "stage", e)), i = A(n.body), o = c.find((e) => e.id === n.keyId);
+		if (o === void 0 || !k(n.signature) || !b(Buffer.from(I(i, o), "hex"), Buffer.from(n.signature, "hex")) || i.contextDigest !== a(l.context) || i.setId !== l.id || i.revision !== e || i.previous !== f || !Array.isArray(i.pages) || i.pages.length > 50 || i.pages.some((e) => !k(e))) return D("integrity");
+		f = a(i), d.update(x({
+			source: i.source,
+			receiptDigest: i.receiptDigest,
+			pages: i.pages
+		}) + "\n");
+		let s = [];
+		for (let e of i.pages) {
+			let n = await R(t, l, "input", ++p);
+			if (!Array.isArray(n) || n.length < 1 || n.length > 200 || a(n) !== e) return D("integrity");
+			s.push(...n.map(r));
+		}
+		if (m += Buffer.byteLength(x(s)), u.length + s.length > 1e5 || m > 67108864) return D("bounds");
+		u.push(...s);
+	}
+	if (f !== l.progress.chain || p !== l.progress.inputPages || u.length !== l.progress.inputCount || m !== l.progress.inputBytes) return D("integrity");
+	let h = u.map((e) => ({
+		entry: e,
+		url: o(e.host, e.path)
+	})).sort((e, t) => e.url < t.url ? -1 : +(e.url > t.url));
+	for (let t = 0; t < h.length; t++) {
+		let n = h[t];
+		if (n.entry.host !== l.context.host || !l.context.localeIds.includes(n.entry.localeId) || !l.context.owners.includes(n.entry.owner)) return D("integrity");
+		if (t > 0 && h[t - 1].url === n.url) throw new e({
+			url: n.url,
+			owners: [h[t - 1].entry, n.entry].map((e) => `${e.owner}:${e.file ?? e.routeId}`),
+			repair: "Change the captured location or native path enumeration and capture a new build snapshot."
+		});
+	}
+	let g = [];
+	for (let e = 0; e < h.length; e += 200) {
+		let n = h.slice(e, e + 200), r = n.map((e) => e.entry);
+		g.push({
+			count: r.length,
+			digest: a(r),
+			first: n[0].url,
+			last: n[n.length - 1].url
+		}), await z(t, l, "output", g.length, r);
+	}
+	let _ = i({
+		version: 1,
+		context: l.context,
+		sort: "host-nfc-path/v1",
+		pageSize: 200,
+		count: h.length,
+		sources: {
+			count: l.progress.revision,
+			digest: d.digest("hex")
+		},
+		pages: g
+	}, s), y = {
+		...l.progress,
+		phase: "ready"
+	};
+	return await t.update(S, l.id, {
+		progress: y,
+		sealed: _
+	}), {
+		...l,
+		progress: y,
+		sealed: _
+	};
+}, H = async (e, t, n, r, i) => {
+	let a = await P(e, t, n, i);
+	if (a.sealed === null || !Number.isSafeInteger(r) || r < 0 || r > a.sealed.manifest.pages.length) return D("state");
+	if (a.sealed.manifest.count > 0 && r >= a.sealed.manifest.pages.length) return D("bounds");
+	if (a.sealed.manifest.count === 0 && r === 0) return {
+		set: a.sealed,
+		index: r,
+		entries: [],
+		next: null
+	};
+	let o = s(a.sealed, r, await R(e, a, "output", r + 1));
+	return {
+		set: a.sealed,
+		index: r,
+		entries: o,
+		next: r + 1 < a.sealed.manifest.pages.length ? r + 1 : null
+	};
+}, U = async (e, t, r, i) => {
+	if (typeof t != "object" || !t || Array.isArray(t) || !O(t.tenantId) || !O(t.site) || !O(t.environment) || !O(r?.id) || !k(r?.digest)) return D("input");
+	let a = {
+		tenantId: t.tenantId,
+		site: t.site,
+		environment: t.environment
+	}, [o] = await e.query({
+		table: S,
+		predicate: l(j(a), u("id", r.id)),
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (o === void 0) return D("state");
+	let c = n(o.context);
+	if (c.tenantId !== a.tenantId || c.site !== a.site || c.environment !== a.environment) return D("changed");
+	let d = await P(e, c, r.id, i), f = d.sealed;
+	if (f === null) return D("state");
+	if (f.id !== r.digest) return D("changed");
+	let p = await e.query({
+		table: C,
+		predicate: l(j(a), u("setId", r.id), u("kind", "output")),
+		order: [{
+			column: "ordinal",
+			direction: "asc"
+		}],
+		take: f.manifest.pages.length + 1,
+		skip: void 0,
+		projection: ["ordinal"]
+	});
+	if (p.length !== f.manifest.pages.length || p.some((e, t) => e.ordinal !== t + 1)) return D("integrity");
+	let m = [], h = 0, g = Buffer.byteLength(x(f));
+	for (let t = 0; t < f.manifest.pages.length; t++) {
+		let n = s(f, t, await R(e, d, "output", t + 1));
+		if (g += Buffer.byteLength(x(n)), h += n.length, g > 67108864 || h > 1e5) return D("bounds");
+		m.push([...n]);
+	}
+	return h === f.manifest.count ? {
+		set: f,
+		pages: m
+	} : D("integrity");
+};
+//#endregion
+export { C as STATIC_PATH_PAGES_TABLE, S as STATIC_PATH_SETS_TABLE, B as appendStaticPathStage, F as beginStaticPathSet, H as pageStaticPathSet, P as readStaticPathSet, U as readStaticPathSetEvidence, V as sealStaticPathSet, T as staticPathPagesTable, E as staticPathSetTables, w as staticPathSetsTable };

package/dist/tree.js

@@ -19,13 +19,13 @@ var e = (e, t) => {
 		let n = e(t.row, i), r = o.get(n) ?? [];
 		r.push(t), o.set(n, r);
 	}
-	let s = (e, r) => t(e.row, i) - t(r.row, i) || n(e.row, i).localeCompare(n(r.row, i)) || String(e.row.documentId).localeCompare(String(r.row.documentId)), c = [], l = /* @__PURE__ */ new Set(), u = (e, t) => {
-		for (let r of [...o.get(e) ?? []].sort(s)) {
+	let s = (e, t) => e < t ? -1 : +(e > t), c = (e, r) => t(e.row, i) - t(r.row, i) || s(n(e.row, i), n(r.row, i)) || s(String(e.row.documentId), String(r.row.documentId)), l = [], u = /* @__PURE__ */ new Set(), d = (e, t) => {
+		for (let r of [...o.get(e) ?? []].sort(c)) {
 			let a = r.row.documentId, o = n(r.row, i);
-			if (o === "" || l.has(a)) continue;
-			l.add(a);
+			if (o === "" || u.has(a)) continue;
+			u.add(a);
 			let s = [...t, o];
-			c.push({
+			l.push({
 				documentId: a,
 				parent: e,
 				depth: t.length,
@@ -34,12 +34,12 @@ var e = (e, t) => {
 				row: r.row,
 				locale: r.locale,
 				fallback: r.fallback
-			}), u(a, s);
+			}), d(a, s);
 		}
 	};
-	return u(null, []), {
-		nodes: c,
-		orphans: [...a.keys()].filter((e) => !l.has(e)).sort()
+	return d(null, []), {
+		nodes: l,
+		orphans: [...a.keys()].filter((e) => !u.has(e)).sort()
 	};
 }, i = (e) => e != null && e !== "", a = (e, t, n, r = {}) => {
 	let a = new Map(e.nodes.map((e) => [e.documentId, e])), o = r.ancestorsOnly === !0 ? t.parent === null ? void 0 : a.get(t.parent) : t, s = /* @__PURE__ */ new Set();