@voltro/cms 0.86.0 → 0.88.0

package/dist/publicOutputService.js

@@ -0,0 +1,286 @@
+import { normalizeHost as e } from "./domainHost.js";
+import { OutputActivationUnavailable as t } from "./outputActivation.js";
+import { CmsPublicBuildUnavailable as n, canonicalCmsPublicPath as r } from "./publicBuild.js";
+import { copySnapshotResource as i } from "./buildSnapshot.js";
+import { readActiveOutput as a, readOutputSafetyPage as o } from "./outputActivationStore.js";
+import { AssetUseRightsUnavailable as s, retainCapturedAssetUseRights as c } from "./assetUseRights.js";
+import { copyPublicConsentChoices as l, selectPublicPresentation as u } from "./publicPresentation.js";
+import { createCmsPublicBuilds as d } from "./publicBuildService.js";
+import { admitPublicRouteDisposition as f, assertPublicRouteDispositionTime as p } from "./publicRouteDispositionAdmission.js";
+import { Effect as m, Semaphore as h } from "effect";
+import { createHash as g } from "node:crypto";
+import { canonicalJson as _ } from "@voltro/runtime";
+// src/publicOutputService.ts
+var v = (e) => {
+	throw new n(e);
+}, y = (e) => e instanceof n ? e : e instanceof s ? new n("denied") : e instanceof t ? new n(e.reason === "denied" ? "denied" : "changed") : new n("transport"), b = (t) => {
+	let s = h.makeUnsafe(1), b = (e) => s.withPermit(m.uninterruptible(e)), x = {
+		...t,
+		scope: { ...t.scope },
+		keys: t.keys.map((e) => ({
+			id: e.id,
+			material: new Uint8Array(e.material)
+		})),
+		regionKeys: Object.fromEntries(Object.entries(t.regionKeys).map(([e, t]) => [e, t.map((e) => ({
+			id: e.id,
+			material: new Uint8Array(e.material)
+		}))]))
+	}, S = x.now ?? Date.now, C = (e) => {
+		let t = S();
+		try {
+			for (let n of e) n(t);
+		} catch (e) {
+			throw y(e);
+		}
+	}, w = async (e, t, n, r, i, o) => {
+		for (let s of i) if (await a(e, x.scope, {
+			kind: "asset",
+			digest: s.digest
+		}, {
+			...x,
+			lock: "share",
+			admit: async (e, i, a, l) => {
+				if (i.id !== t.id || l.outputId !== n.outputId) return v("changed");
+				await x.admit(e, i, a, l), o.push(await c(e, x.scope, s.rights, S(), x.use(r)));
+			}
+		}) === null) return v("changed");
+	}, T = (e) => m.suspend(() => {
+		let t = [], n = d({
+			...x,
+			admit: async (...e) => {
+				await x.admit(...e), C(t);
+			},
+			readPage: async (e, n, r, i) => {
+				try {
+					let a = await x.readDocument(e, n, r, i);
+					return a.found ? (await w(e, n, r, i, a.media, t), {
+						found: !0,
+						page: a.projectPage()
+					}) : a;
+				} catch (e) {
+					throw y(e);
+				}
+			}
+		}).page;
+		return m.flatMap(n(e), (e) => m.try({
+			try: () => (C(t), e),
+			catch: y
+		}));
+	}), E = (t, n) => m.tryPromise({
+		try: async () => {
+			let o = e(n.host), s = r(n.path), c = l(n.choices);
+			if (o !== n.host || s !== n.path) return v("request");
+			let d = {
+				host: o,
+				path: s
+			}, f = [], p = await x.store.transactional(async (e) => {
+				let n, r, l = await a(e, x.scope, {
+					kind: "url",
+					url: "https://" + o + s
+				}, {
+					...x,
+					lock: "share",
+					admit: async (e, l, p, m) => {
+						if (!l.manifest.paths.some((e) => e.host === o)) return v("not-found");
+						await x.admit(e, l, p, m);
+						let h = u(await x.readPresentations(e, l, m), c), g = {
+							...d,
+							presentation: h
+						}, y = t === "asset" ? await x.readAsset(e, l, m, g) : await x.readDocument(e, l, m, g);
+						if (!y.found) return v("not-found");
+						let b;
+						if ("media" in y) b = y.media;
+						else {
+							let t = y.uses.filter((e) => new URL(e.documentUrl).hostname === o && _(e.presentation) === _(h));
+							if ((s.startsWith("/__voltro/media/") || y.uses.length > 0) && t.length === 0) return v("not-found");
+							if (b = t.map((e) => ({
+								digest: y.digest,
+								rights: e.rights
+							})), t.length === 0 && await a(e, x.scope, {
+								kind: "asset",
+								digest: y.digest
+							}, {
+								...x,
+								lock: "share",
+								admit: async (e, t, n, r) => {
+									if (t.id !== l.id || r.outputId !== m.outputId) return v("changed");
+									await x.admit(e, t, n, r);
+								}
+							}) === null) return v("changed");
+						}
+						if (await w(e, l, m, d, b, f), await x.admit(e, l, p, m), n = {
+							bytes: new Uint8Array(y.bytes),
+							digest: y.digest,
+							contentType: y.contentType
+						}, t === "admitted-document") {
+							if (!("media" in y)) return v("transport");
+							let e = y.source === void 0 ? void 0 : i({
+								key: "public-document-source",
+								value: { source: y.source }
+							}).value.source;
+							r = {
+								admission: {
+									setId: l.id,
+									region: m.region,
+									outputId: m.outputId,
+									snapshotDigest: l.manifest.snapshot.digest,
+									app: structuredClone(l.manifest.app),
+									target: structuredClone(g)
+								},
+								...e === void 0 ? {} : { source: e }
+							};
+						}
+					}
+				});
+				if (l === null || n === void 0) return v("not-found");
+				let p = r === void 0 ? void 0 : {
+					...n,
+					...r.source === void 0 ? {} : { source: r.source },
+					admission: {
+						...r.admission,
+						generation: l.marker.generation,
+						safetyGeneration: l.safetyGeneration
+					}
+				};
+				return C(f), {
+					file: n,
+					admitted: p
+				};
+			});
+			return C(f), p;
+		},
+		catch: y
+	}), D = (t) => m.tryPromise({
+		try: async () => {
+			let n = e(t.host), i = r(t.path), s = l(t.choices);
+			if (n !== t.host || i !== t.path) return v("request");
+			let c = x.readRedirect;
+			if (c === void 0) return v("not-found");
+			let d = "https://" + n + i, m = [], h = await x.store.transactional(async (e) => {
+				let t, r, l = await a(e, x.scope, {
+					kind: "url",
+					url: d
+				}, {
+					...x,
+					admit: async (e, l, h, g) => {
+						if (!l.manifest.paths.some((e) => e.host === n)) return v("not-found");
+						await x.admit(e, l, h, g);
+						let _ = await c(e, l, g, {
+							host: n,
+							path: i
+						});
+						if (!_.found) return v("not-found");
+						if (r = _.safetyGeneration, !Number.isSafeInteger(r) || r < 0 || r > 1e5) return v("transport");
+						if ((await o(e, x.scope, { take: 1 })).generation !== r) return v("changed");
+						let y = await f(e, x.scope, _.definition, g.generation, S());
+						if (y.source.url !== d) return v("transport");
+						m.push((e) => p(y, e));
+						let b = y.action;
+						if (b.kind === "hold") return v("changed");
+						if (b.kind === "redirect") {
+							let t = new URL(b.target.url), n = {
+								host: t.hostname,
+								path: t.pathname
+							};
+							if (await a(e, x.scope, {
+								kind: "url",
+								url: b.target.url
+							}, {
+								...x,
+								admit: async (e, t, r, i) => {
+									if (t.id !== l.id || i.outputId !== g.outputId) return v("changed");
+									await x.admit(e, t, r, i);
+									let a = u(await x.readPresentations(e, t, i), s), o = await x.readDocument(e, t, i, {
+										...n,
+										presentation: a
+									});
+									if (!o.found) return v("changed");
+									await w(e, t, i, n, o.media, m), await x.admit(e, t, r, i);
+								}
+							}) === null) return v("changed");
+						}
+						await f(e, x.scope, y, g.generation, S()), await x.admit(e, l, h, g), t = {
+							status: b.status,
+							location: b.kind === "redirect" ? b.target.url : null
+						};
+					}
+				});
+				return l === null || t === void 0 ? v("not-found") : l.safetyGeneration === r ? (C(m), t) : v("changed");
+			});
+			return C(m), h;
+		},
+		catch: y
+	}), O = (t) => m.tryPromise({
+		try: async () => {
+			let n = e(t.host), i = r(t.path);
+			if (n !== t.host || i !== t.path) return v("request");
+			if (x.readControl === void 0 || i !== "/robots.txt" && i !== "/sitemap.xml" && !/^\/sitemaps\/sitemap-\d{5}\.xml$/.test(i)) return v("not-found");
+			let s = x.readControl, c = {
+				host: n,
+				path: i
+			}, l = [], u = await x.store.transactional(async (e) => {
+				let t, u, d = await a(e, x.scope, {
+					kind: "url",
+					url: "https://" + n + i
+				}, {
+					...x,
+					admit: async (e, d, f, p) => {
+						if (!d.manifest.paths.some((e) => e.host === n)) return v("not-found");
+						await x.admit(e, d, f, p);
+						let m = await s(e, d, p, c);
+						if (!m.found) return v("not-found");
+						if (m.contentType !== (i === "/robots.txt" ? "text/plain" : "application/xml") || m.bytes.byteLength > 52428800 || g("sha256").update(m.bytes).digest("hex") !== m.digest) return v("transport");
+						if (await a(e, x.scope, {
+							kind: "asset",
+							digest: m.digest
+						}, {
+							...x,
+							admit: async (e, t, n, r) => {
+								if (t.id !== d.id || r.outputId !== p.outputId) return v("changed");
+								await x.admit(e, t, n, r);
+							}
+						}) === null) return v("changed");
+						if (!Number.isSafeInteger(m.safetyGeneration) || m.safetyGeneration < 0 || m.safetyGeneration > 1e5) return v("transport");
+						if (u = m.safetyGeneration, (await o(e, x.scope, { take: 1 })).generation !== u) return v("changed");
+						if (!Array.isArray(m.uses) || m.uses.length > 1e5) return v("transport");
+						for (let t of m.uses) {
+							let n = new URL(t.documentUrl), i = {
+								host: n.hostname,
+								path: n.pathname
+							};
+							if (n.protocol !== "https:" || n.host !== n.hostname || n.origin + n.pathname !== t.documentUrl || r(i.path) !== i.path || !d.manifest.paths.some((e) => e.host === i.host)) return v("transport");
+							if (await a(e, x.scope, {
+								kind: "url",
+								url: t.documentUrl
+							}, {
+								...x,
+								admit: async (e, t, n, r) => {
+									if (t.id !== d.id || r.outputId !== p.outputId) return v("changed");
+									await x.admit(e, t, n, r);
+								}
+							}) === null) return v("changed");
+							await w(e, d, p, i, t.media, l);
+						}
+						await x.admit(e, d, f, p), t = {
+							bytes: new Uint8Array(m.bytes),
+							digest: m.digest,
+							contentType: m.contentType
+						};
+					}
+				});
+				return d === null || t === void 0 ? v("not-found") : u === d.safetyGeneration ? (C(l), t) : v("changed");
+			});
+			return C(l), u;
+		},
+		catch: y
+	});
+	return {
+		page: (e) => b(T(e)),
+		redirect: (e) => b(D(e)),
+		document: (e) => b(m.map(E("document", e), (e) => e.file)),
+		asset: (e) => b(m.map(E("asset", e), (e) => e.file)),
+		control: (e) => b(O(e)),
+		admittedDocument: (e) => b(m.flatMap(E("admitted-document", e), (e) => e.admitted === void 0 ? m.fail(new n("transport")) : m.succeed(e.admitted)))
+	};
+};
+export { b as createCmsPublicOutputs };

package/dist/publicPresentation.js

@@ -0,0 +1,16 @@
+import { CmsPublicBuildUnavailable as e } from "./publicBuild.js";
+import { admitSnapshotPresentation as t, copySnapshotConsentPurposes as n, snapshotPresentationFromChoices as r, snapshotPresentations as i } from "./snapshotPresentation.js";
+import { canonicalJson as a } from "@voltro/runtime";
+// src/publicPresentation.ts
+var o = (t) => {
+	if (t === void 0) return;
+	if (typeof t != "object" || !t || Array.isArray(t) || Object.keys(t).length > 128) throw new e("request");
+	let n = Object.entries(Object.getOwnPropertyDescriptors(t)).filter(([, e]) => e.enumerable);
+	if (n.some(([, e]) => !Object.hasOwn(e, "value") || !Number.isSafeInteger(e.value) || e.value < 0)) throw new e("request");
+	return Object.fromEntries(n.map(([e, t]) => [e, Number(t.value)]));
+}, s = (o, s) => {
+	let c = n(o.consentPurposes), l = o.presentations.map((e) => a(t(c, e))).sort(), u = i(c, 257).map(a).sort();
+	if (a(l) !== a(u)) throw new e("transport");
+	return r(c, s);
+};
+export { o as copyPublicConsentChoices, s as selectPublicPresentation };

package/dist/publicRouteDispositionAdmission.js

@@ -0,0 +1,37 @@
+import { lockSiteState as e } from "./siteState.js";
+import { CmsPublicBuildUnavailable as t } from "./publicBuild.js";
+import { readPublicRouteHistoryPage as n, readPublicRouteHistoryUrl as r } from "./publicRouteHistoryStore.js";
+import { readPublicRouteBinding as i } from "./publicRouteRegistryBinding.js";
+import { copyRouteDispositionDefinition as a } from "./routeDispositions.js";
+import { readApprovedRouteDispositionUrl as o } from "./routeDispositionStore.js";
+import { readRouteHistoryPage as s, readRouteHistoryUrl as c } from "./routeHistoryStore.js";
+import { lockOutputRouteHistoryCapture as l } from "./outputActivationStore.js";
+import { isPrivateNativeRouteReservation as u } from "./privateNativeRouteReservation.js";
+import { canonicalJson as d } from "@voltro/runtime";
+// src/publicRouteDispositionAdmission.ts
+var f = (e) => {
+	throw new t(e);
+}, p = (e, t) => {
+	if (!Number.isSafeInteger(t) || t < 0 || e.action.kind === "hold" || e.activeFrom !== null && t < e.activeFrom || e.activeUntil !== null && t >= e.activeUntil) return f("changed");
+}, m = async (t, m, h, g, _) => {
+	let v = a(h), y = await l(t, m);
+	if (y.generation !== g) return f("changed");
+	await e(t, m);
+	let b = await i(t, m);
+	if (b === null || (await s(t, m, {
+		expectedRevision: g,
+		take: 1
+	})).sourceDigest !== y.sourceDigest || (await n(t, m, { take: 1 })).revision < 1) return f("changed");
+	let x = await r(t, m, v.source.url), S = await c(t, m, v.source.url);
+	if (x?.active || S?.active || u(b.definition.routing, new URL(v.source.url).pathname, !1)) return f("not-found");
+	if (x === null && S === null) return f("transport");
+	if (x !== null && x.routeId !== v.source.routeId || S !== null && S.routeId !== v.source.routeId) return f("changed");
+	let C = await o(t, m, v.source.url);
+	if (C === null || d(C.definition) !== d(v)) return f("changed");
+	if (p(v, _), v.action.kind === "redirect") {
+		let e = v.action.target, n = await r(t, m, e.url), i = await c(t, m, e.url);
+		if (u(b.definition.routing, new URL(e.url).pathname, n?.active === !0) || n !== null && (!n.active || n.routeId !== e.routeId) || i === null || !i.active || i.routeId !== e.routeId) return f("changed");
+	}
+	return v;
+};
+export { m as admitPublicRouteDisposition, p as assertPublicRouteDispositionTime };

package/dist/publicRouteHistoryStore.js

@@ -0,0 +1,11 @@
+import { createRouteHistoryStore as e } from "./routeHistoryStorage.js";
+// src/publicRouteHistoryStore.ts
+var t = "_voltro_cms_public_route_history_heads", n = "_voltro_cms_public_route_history", { routeHistoryTables: r, readRouteHistoryPage: i, readRouteHistoryUrl: a, replaceRouteHistory: o, iterateRouteHistory: s } = e({
+	heads: t,
+	entries: n,
+	headPrefix: "cprh",
+	entryPrefix: "cpre",
+	headIndex: "cms_public_route_history_head_scope",
+	entryIndex: "cms_public_route_history_url_scope"
+});
+export { n as PUBLIC_ROUTE_HISTORY_ENTRIES, t as PUBLIC_ROUTE_HISTORY_HEADS, s as iteratePublicRouteHistory, r as publicRouteHistoryTables, i as readPublicRouteHistoryPage, a as readPublicRouteHistoryUrl, o as replacePublicRouteHistory };

package/dist/publicRouteHistoryView.js

@@ -0,0 +1,33 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { outputActivationHash as t } from "./outputActivation.js";
+import { copyObservedRoutes as n } from "./routeHistoryStorage.js";
+import { iteratePublicRouteHistory as r, readPublicRouteHistoryPage as i } from "./publicRouteHistoryStore.js";
+import { readPublicRouteNamespace as a, withPublicRouteNamespaceBoundary as o } from "./publicRouteNamespace.js";
+import { canonicalJson as s } from "@voltro/runtime";
+// src/publicRouteHistoryView.ts
+var c = 1e5, l = 67108864, u = (u, d) => o(async () => {
+	let f = await a(u, d), { entries: p, next: m, ...h } = await i(u, d, { take: 1 });
+	return h.revision === 0 ? e("history") : h.historyCount > c ? e("bounds") : t(n(f.routes)) === h.currentDigest ? {
+		namespace: f,
+		history: h,
+		entries: async function* () {
+			let i = [], a = 2, c = r(u, d, h.revision)[Symbol.asyncIterator]();
+			for (;;) {
+				let t = await o(() => c.next());
+				if (t.done) break;
+				let n = t.value;
+				if (a += Buffer.byteLength(s(n)) + 1, a > l) return e("bounds");
+				if (n.active) {
+					if (i.length >= h.currentCount) return e("history");
+					i.push({
+						url: n.url,
+						routeId: n.routeId
+					});
+				}
+				yield n;
+			}
+			if (i.length !== h.currentCount || t(n(i)) !== h.currentDigest) return e("history");
+		}
+	} : e("history");
+});
+export { u as readPublicRouteHistoryView };

package/dist/publicRouteIntegrity.js

@@ -0,0 +1,4 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+// src/publicRouteIntegrity.ts
+var t = (t, n) => t.integrityQuery === void 0 ? e("configuration") : t.integrityQuery(n);
+export { t as queryPublicRouteIntegrity };

package/dist/publicRouteMutation.js

@@ -0,0 +1,5 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { readPublicRouteBinding as t } from "./publicRouteRegistryBinding.js";
+// src/publicRouteMutation.ts
+var n = async (n, r, i, a) => n.savepoint === void 0 ? i || await t(n, r) !== null ? e("configuration") : a() : n.savepoint(a), r = async (t, n) => t.savepoint === void 0 ? e("configuration") : t.savepoint(n);
+export { n as withPublicRouteMutation, r as withPublicRouteStateMutation };

package/dist/publicRouteNamespace.js

@@ -0,0 +1,133 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { ContentLocationUnavailable as t } from "./errors.js";
+import { readPublicationBoundary as n } from "./changes.js";
+import { queryPublicRouteIntegrity as r } from "./publicRouteIntegrity.js";
+import { normalizeHost as i } from "./domainHost.js";
+import { copyOutputActivationScope as a, outputActivationHash as o } from "./outputActivation.js";
+import { copyCanonicalPublicRouteUrl as s } from "./publicRouteUrl.js";
+import { RouteHistoryUnavailable as c } from "./routeHistoryStorage.js";
+import { readPublicRouteHistoryPage as l, replacePublicRouteHistory as u } from "./publicRouteHistoryStore.js";
+import { SnapshotRoutingUnavailable as d, nativeSnapshotRouteId as f } from "./snapshotRouting.js";
+import { CMS_SITE_DOMAINS_TABLE as p } from "./domains.js";
+import { readLiveContentRouteView as m } from "./liveContentRouteView.js";
+import { ContentRouteMaterializationUnavailable as h, materializeContentRoutes as g } from "./contentRouteMaterializer.js";
+import { and as _, eq as v, gt as y } from "@voltro/database";
+import { canonicalJson as b } from "@voltro/runtime";
+// src/publicRouteNamespace.ts
+var x = 1e5, S = 67108864, C = async (t, n) => {
+	let a = [], o = /* @__PURE__ */ new Set(), s, c = 0, l = 0;
+	for (;;) {
+		let u = await r(t, {
+			table: p,
+			predicate: _(v("tenantId", n.tenantId), v("site", n.site), ...s === void 0 ? [] : [y("id", s)]),
+			lock: "update",
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 200,
+			skip: void 0,
+			projection: void 0
+		});
+		if (u.length === 0) break;
+		for (let t of u) {
+			if (++l > 1e4) return e("bounds");
+			if (typeof t.id != "string" || t.id <= (s ?? "") || t.tenantId !== n.tenantId || t.site !== n.site || typeof t.host != "string" || i(t.host) !== t.host || o.has(t.host) || typeof t.isPrimary != "boolean" || !["pending", "verified"].includes(String(t.status))) return e("state");
+			if (s = t.id, o.add(t.host), t.status === "pending") {
+				if (t.isPrimary) return e("state");
+				continue;
+			}
+			let r = t.verifiedAt instanceof Date ? t.verifiedAt.getTime() : NaN;
+			if (!Number.isSafeInteger(r) || r < 0 || t.isPrimary && ++c > 1) return e("state");
+			a.push({
+				host: t.host,
+				primary: t.isPrimary
+			});
+		}
+	}
+	return a.sort((e, t) => e.host < t.host ? -1 : +(e.host > t.host));
+}, w = async (t, r) => {
+	let i;
+	try {
+		i = a(r);
+	} catch {
+		return e("scope");
+	}
+	let { binding: c, site: l, view: u } = await m(t, i), d = await n(t, i), p = await C(t, i), h = /* @__PURE__ */ new Map(), _ = [], v = 2;
+	for await (let t of g({
+		scope: i,
+		site: l,
+		types: c.definition.types,
+		routing: c.definition.routing,
+		definitionDigest: c.definition.definitionDigest
+	}, u)) {
+		if (!t.key.startsWith("path:")) continue;
+		let n = t.value.path;
+		if (typeof n != "string" || t.key !== "path:" + o(n)) return e("state");
+		if (h.has(n)) return e("conflict");
+		if (h.size >= x || (v += Buffer.byteLength(b(t)), v > S)) return e("bounds");
+		h.set(n, t);
+	}
+	let y = [...h.values()].sort((e, t) => String(e.value.path) < String(t.value.path) ? -1 : 1);
+	for (let t of y) {
+		let n = t.value, r = String(n.path), a = n.ownership, o = a.owner === "cms" ? String(n.routeId) : a.code === null ? e("state") : f(i, String(n.localeId), a.code.file, r);
+		for (let t of p) {
+			if (_.length >= x) return e("bounds");
+			let n;
+			try {
+				n = s("https://" + t.host + r);
+			} catch {
+				return e("state");
+			}
+			if (v += Buffer.byteLength(b({
+				url: n,
+				routeId: o
+			})), v > S) return e("bounds");
+			_.push({
+				url: n,
+				routeId: o
+			});
+		}
+	}
+	let w = o({
+		scope: i,
+		bindingId: c.id,
+		bindingRevision: c.revision,
+		definition: c.definition,
+		boundary: d,
+		domains: p,
+		paths: y
+	});
+	return {
+		scope: i,
+		binding: c,
+		boundary: d,
+		domains: p,
+		paths: y,
+		routes: _,
+		sourceDigest: w
+	};
+}, T = async (t, n) => {
+	let r = await D(t, n), i = await l(t, r.scope, { take: 1 });
+	if (i.revision === 0) return e("history");
+	let a = await u(t, r.scope, {
+		expectedRevision: i.revision,
+		sourceDigest: r.sourceDigest,
+		routes: r.routes
+	});
+	return {
+		...r,
+		history: a
+	};
+}, E = async (n) => {
+	try {
+		return await n();
+	} catch (n) {
+		if (n instanceof t) return e(n.reason === "bounds" ? "bounds" : "location");
+		if (n instanceof c) return e(n.reason === "bounds" || n.reason === "revision" || n.reason === "scope" ? n.reason : "history");
+		if (n instanceof h) return e(n.reason === "publication" ? "state" : n.reason);
+		if (n instanceof d) return e(n.reason === "collision" ? "conflict" : "configuration");
+		throw n;
+	}
+}, D = (...e) => E(() => w(...e)), O = (...e) => E(() => T(...e));
+export { D as readPublicRouteNamespace, O as reconcilePublicRouteNamespace, E as withPublicRouteNamespaceBoundary };

package/dist/publicRoutePublication.js

@@ -0,0 +1,35 @@
+import { publicRouteRegistryFail as e } from "./publicRouteRegistry.js";
+import { compileContentRouteTypes as t } from "./contentRouteTypes.js";
+import { readPublicRouteBinding as n } from "./publicRouteRegistryBinding.js";
+import { reconcilePublicRouteNamespace as r } from "./publicRouteNamespace.js";
+import { canonicalJson as i } from "@voltro/runtime";
+// src/publicRoutePublication.ts
+var a = /* @__PURE__ */ new WeakMap(), o = (e) => i(e), s = (t, n) => typeof t.tenantId != "string" || t.tenantId === "" ? e("scope") : {
+	tenantId: t.tenantId,
+	site: n.site,
+	environment: n.environment
+}, c = async (c, l, u, d) => {
+	let f = s(u, d), p = await n(c, f);
+	if (p === null) return l.locations !== void 0 && l.locations.length > 0 ? e("configuration") : void 0;
+	let m = p.definition.types.find((e) => e.name === l.name);
+	if (m === void 0) return l.locations !== void 0 && l.locations.length > 0 ? e("configuration") : void 0;
+	let h = t([l]);
+	if (!h.ok || i(h.types[0]) !== i(m)) return e("configuration");
+	let g = a.get(c)?.get(o(f));
+	g === void 0 ? await r(c, f) : g.dirty = !0;
+}, l = async (t, n, i) => t.savepoint === void 0 ? e("configuration") : t.savepoint(async () => {
+	let e = a.get(t);
+	e === void 0 && (e = /* @__PURE__ */ new Map(), a.set(t, e));
+	let s = o(n), c = e.get(s) ?? {
+		depth: 0,
+		dirty: !1
+	};
+	e.set(s, c), c.depth++;
+	try {
+		let e = await i();
+		return c.depth === 1 && c.dirty && await r(t, n), e;
+	} finally {
+		c.depth--, c.depth === 0 && e.delete(s), e.size === 0 && a.delete(t);
+	}
+});
+export { s as publicationRouteScope, c as reconcilePublishedContentRoutes, l as withPublicRoutePublicationBatch };

package/dist/publicRouteRegistry.js

@@ -0,0 +1,16 @@
+import { Schema as e } from "effect";
+// src/publicRouteRegistry.ts
+var t = class extends e.TaggedError()("PublicRouteRegistryUnavailable", { reason: e.Literals([
+	"scope",
+	"definition",
+	"configuration",
+	"history",
+	"state",
+	"revision",
+	"conflict",
+	"bounds",
+	"location"
+]) }) {}, n = (e) => {
+	throw new t({ reason: e });
+};
+export { t as PublicRouteRegistryUnavailable, n as publicRouteRegistryFail };