@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryAdministration.js

@@ -0,0 +1,190 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { geometryPersistenceId as r, geometryPersistenceInteger as i } from "./geometryPersistenceData.js";
+import { captureRoomGeometryReloadRequest as a, captureRoomGeometryRollbackRequest as o } from "./geometryAdminData.js";
+import { ROOMS_TABLE as s } from "./identities.js";
+import { assertRoomSubjectAdmission as c } from "./subjectAdmission.js";
+import { captureRoomSnapshotEffectRunner as l } from "./snapshotBlobIndex.js";
+import { GEO_CHUNK_DELTAS_TABLE as u, GEO_VERSIONS_TABLE as d } from "./geometryPersistence.js";
+import { RoomGeometryAdministrationPort as f } from "./geometryAdministrationPorts.js";
+import { WORLD_CELLS_TABLE as p } from "./worldCells.js";
+import { worldGeometryChunkOwner as m } from "./geometryCellCoverage.js";
+import { and as h, eq as g } from "@voltro/database";
+import { Subject as _ } from "@voltro/protocol";
+import { Effect as v, Layer as y, Schema as b } from "effect";
+//#region src/geometryAdministration.ts
+var x = () => new t({ detail: "Geometry administration remains unconfirmed" }), S = (e) => y.succeed(f, e), C = (t, f) => {
+	let y = n(f, [
+		"control",
+		"authorize",
+		"worlds",
+		"maxChunks",
+		"maxScannedChunks"
+	], ["control", "authorize"]), S = n(y.control, ["reload", "rollback"]);
+	if (Object.values(S).some((e) => typeof e != "function") || typeof y.authorize != "function") throw x();
+	let C = S.reload.bind(y.control), w = S.rollback.bind(y.control), T = y.authorize, E = (n, u, d, f) => {
+		let p, m, y;
+		try {
+			if (p = r(u), m = b.decodeUnknownSync(_)(structuredClone(f)), m.type !== "user" || !m.id || !m.tenantId) throw x();
+			r(m.id), r(m.tenantId), m = Object.freeze({
+				...m,
+				...m.scopes === void 0 ? {} : { scopes: Object.freeze([...m.scopes]) }
+			}), y = n === "reload" ? a(d) : o(d);
+		} catch {
+			return v.fail(x());
+		}
+		let S = m;
+		return v.flatMap(v.context(), (a) => v.uninterruptible(v.tryPromise({
+			try: async () => {
+				let e = l(a), o = async (t) => {
+					if (!v.isEffect(t)) throw x();
+					return e(t);
+				}, u = async () => {
+					if (await o(T(n, p, y, S)) !== void 0) throw x();
+					await c(t, {
+						tenantId: S.tenantId,
+						subjectId: S.id
+					});
+					let e = n === "rollback" ? y.target : null;
+					e !== null && await c(t, {
+						tenantId: S.tenantId,
+						subjectId: e.id
+					});
+				}, d = async () => {
+					let e = await t.query({
+						table: s,
+						predicate: h(g("tenantId", S.tenantId), g("id", p)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: [
+							"id",
+							"tenantId",
+							"hostId",
+							"epoch",
+							"state"
+						]
+					});
+					if (e.length !== 1 || e[0].id !== p || e[0].tenantId !== S.tenantId || e[0].state !== "live") throw x();
+					return Object.freeze({
+						hostId: r(e[0].hostId),
+						epoch: i(e[0].epoch, 1)
+					});
+				};
+				await u();
+				let f = await d();
+				if (await u(), await o(n === "reload" ? C(f.hostId, p, y, S) : w(f.hostId, p, y, S)) !== void 0) throw x();
+				await u();
+				let m = await d();
+				if (m.hostId !== f.hostId || m.epoch !== f.epoch) throw x();
+			},
+			catch: (t) => t instanceof e ? t : x()
+		})));
+	}, D = Object.hasOwn(y, "worlds") ? y.worlds.filter((e) => e.geometry) : void 0, O = Object.hasOwn(y, "maxChunks") ? i(y.maxChunks, 1, 4096) : 256, k = Object.hasOwn(y, "maxScannedChunks") ? i(y.maxScannedChunks, 1, 65536) : 4096;
+	if (D !== void 0 && !D.length) throw x();
+	return Object.freeze({
+		reload: (e, t, n) => E("reload", e, t, n),
+		rollback: (e, t, n) => E("rollback", e, t, n),
+		...D === void 0 ? {} : { chunks: (n, a) => {
+			let o, s;
+			try {
+				o = r(n);
+				let e = b.decodeUnknownSync(_)(structuredClone(a));
+				if (e.type !== "user" || !e.id || !e.tenantId) throw x();
+				r(e.id), r(e.tenantId), s = e;
+			} catch {
+				return v.fail(x());
+			}
+			return v.flatMap(v.context(), (n) => v.tryPromise({
+				try: async () => {
+					let a = l(n);
+					if (await (async (e) => {
+						if (!v.isEffect(e)) throw x();
+						return a(e);
+					})(T("chunks", o, null, s)) !== void 0) throw x();
+					await c(t, {
+						tenantId: s.tenantId,
+						subjectId: s.id
+					});
+					let f = await t.query({
+						table: p,
+						predicate: h(g("tenantId", s.tenantId), g("roomId", o)),
+						order: [],
+						take: 2,
+						skip: void 0,
+						projection: [
+							"worldId",
+							"zoneId",
+							"cellId"
+						]
+					});
+					if (f.length !== 1) throw x();
+					let _ = r(f[0].worldId), y = r(f[0].zoneId), b = r(f[0].cellId), S = D.find((e) => e.name === _);
+					if (!S) throw x();
+					let C = await t.query({
+						table: d,
+						predicate: h(g("tenantId", s.tenantId), g("worldId", _)),
+						order: [],
+						take: 257,
+						skip: void 0,
+						projection: ["manifest"]
+					});
+					if (C.length > 256) throw new e({
+						budget: "geometryChunkViewVersions",
+						limit: 256
+					});
+					let w = (e) => JSON.stringify([
+						e.version,
+						e.layerSetId,
+						e.cx,
+						e.cy,
+						e.cz ?? null
+					]), E = /* @__PURE__ */ new Map();
+					for (let e of C) for (let t of e.manifest.chunks) E.set(w(t), t.blobSha256);
+					let A = await t.query({
+						table: u,
+						predicate: g("tenantId", s.tenantId),
+						order: [{
+							column: "updatedAt",
+							direction: "desc"
+						}],
+						take: k + 1,
+						skip: void 0,
+						projection: [
+							"scope",
+							"revision",
+							"blobSha256",
+							"updatedAt"
+						]
+					}), j = [];
+					for (let e of A.slice(0, k)) {
+						let t = e.scope;
+						if (t.worldId !== _) continue;
+						let n = m(S, t);
+						n.zone === y && n.id === b && j.push(Object.freeze({
+							cx: t.cx,
+							cy: t.cy,
+							...t.cz === void 0 ? {} : { cz: t.cz },
+							layerSetId: t.layerSetId,
+							version: t.version,
+							revision: i(e.revision),
+							changed: E.get(w(t)) !== e.blobSha256,
+							updatedAt: new Date(e.updatedAt).getTime()
+						}));
+					}
+					return Object.freeze({
+						roomId: o,
+						worldId: _,
+						zoneId: y,
+						cellId: b,
+						chunks: Object.freeze(j.slice(0, O)),
+						truncated: A.length > k || j.length > O
+					});
+				},
+				catch: (t) => t instanceof e ? t : x()
+			}));
+		} }
+	});
+};
+//#endregion
+export { C as dataStoreGeometryAdministration, S as roomGeometryAdministrationLayer };

package/dist/geometryAdministrationPorts.js

@@ -0,0 +1,5 @@
+import { Context as e } from "effect";
+//#region src/geometryAdministrationPorts.ts
+var t = class extends e.Service()("@voltro/RoomGeometryAdministrationPort") {};
+//#endregion
+export { t as RoomGeometryAdministrationPort };

package/dist/geometryApiBinding.js

@@ -0,0 +1,165 @@
+import { ProtocolError as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { geometryOwnData as n } from "./geometryTileCodec.js";
+import { captureGeometryDense as r, captureGeometryKind as i, captureGeometryOwner as a, captureGeometryPersistenceScope as o, captureGeometryPrivacyTarget as s, captureGeometryStaticReference as c, captureGeometrySubject as l, geometryPersistenceId as u } from "./geometryPersistenceData.js";
+import { captureWorldCatalog as d } from "./world.js";
+import { captureGeometryPlayerAdmission as f } from "./geometryPlayerAdmission.js";
+import { captureGeometryMigrationReceipt as p } from "./geometryMigrations.js";
+import { Effect as m } from "effect";
+//#region src/geometryApiBinding.ts
+var h = (t, i) => {
+	let a = n(t, [
+		"worlds",
+		"service",
+		"manifest",
+		"readGrants",
+		"migrations",
+		"assetGrants",
+		"archives",
+		"retention",
+		"administration"
+	], ["worlds", "service"]), o = d(a.worlds), s = n(a.service, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]);
+	if (o.length !== i.length || o.some((e, t) => e !== i[t]) || Object.values(s).some((e) => typeof e != "function")) throw new e({ detail: "Rooms geometry binding must match its declared catalogue and complete actual service" });
+	let c = a.service, l = Object.hasOwn(a, "manifest") ? n(a.manifest, ["observe"]) : void 0;
+	if (l && typeof l.observe != "function") throw new e({ detail: "Geometry manifest binding requires its actual own source method" });
+	let u = a.manifest, f = Object.hasOwn(a, "readGrants") ? n(a.readGrants, ["grant"]) : void 0;
+	if (f && typeof f.grant != "function") throw new e({ detail: "Geometry read grant binding requires actual own source method" });
+	let h = a.readGrants, g = Object.hasOwn(a, "assetGrants") ? n(a.assetGrants, ["grant"]) : void 0, _ = a.assetGrants;
+	if (g && typeof g.grant != "function") throw new e({ detail: "Geometry assets require actual own grant source" });
+	let v = Object.hasOwn(a, "migrations") ? n(a.migrations, [
+		"migrate",
+		"exportSubject",
+		"eraseSubject"
+	]) : void 0, y = a.migrations;
+	if (v && Object.values(v).some((e) => typeof e != "function")) throw new e({ detail: "Geometry migrations require actual complete own methods and privacy" });
+	let b = Object.hasOwn(a, "archives") ? n(a.archives, [
+		"archive",
+		"load",
+		"exportSubject",
+		"eraseSubject"
+	]) : void 0, x = a.archives;
+	if (b && Object.values(b).some((e) => typeof e != "function")) throw new e({ detail: "Geometry archives require complete actual methods and privacy" });
+	let S = Object.hasOwn(a, "retention") ? n(a.retention, ["run"]) : void 0, C = a.retention;
+	if (S && typeof S.run != "function") throw new e({ detail: "Geometry retention requires its actual own sweep" });
+	let w = Object.hasOwn(a, "administration") ? n(a.administration, [
+		"reload",
+		"rollback",
+		"chunks"
+	], ["reload", "rollback"]) : void 0, T = a.administration;
+	if (w && Object.values(w).some((e) => typeof e != "function")) throw new e({ detail: "Geometry administration requires both actual own methods" });
+	let E = (t) => m.uninterruptible(m.suspend(() => {
+		let n = t();
+		return m.isEffect(n) ? n : m.fail(new e({ detail: "Migration binding needs its actual Effect" }));
+	})).pipe(m.catchCause(() => m.fail(new e({ detail: "Actual migration binding remains incomplete" })))), D = y ? (() => {
+		let t = y.migrate.bind(y), n = y.exportSubject.bind(y), i = y.eraseSubject.bind(y);
+		return Object.freeze({
+			migrate: (e) => E(() => t(e)),
+			exportSubject: (t) => E(() => n(t)).pipe(m.flatMap((n) => m.try({
+				try: () => {
+					let e = r(n, 4096, p);
+					if (e.some((e) => e.from.tenantId !== t.tenantId) || new Set(e.map((e) => e.requestKey)).size !== e.length || new TextEncoder().encode(JSON.stringify(e)).length > 16777216) throw Error("Invalid migration export");
+					return e;
+				},
+				catch: () => new e({ detail: "Migration binding export escaped its actual scope" })
+			}))),
+			eraseSubject: (t) => E(() => i(t)).pipe(m.flatMap((t) => t === void 0 ? m.void : m.fail(new e({ detail: "Migration binding erasure did not confirm void" }))))
+		});
+	})() : void 0, O = x ? (() => {
+		let t = x.archive.bind(x), n = x.load.bind(x), r = x.exportSubject.bind(x), i = x.eraseSubject.bind(x);
+		return Object.freeze({
+			archive: (e, n) => E(() => t(e, n)),
+			load: (e, t) => E(() => n(e, t)),
+			exportSubject: (e) => E(() => r(e)),
+			eraseSubject: (t) => E(() => i(t)).pipe(m.flatMap((t) => t === void 0 ? m.void : m.fail(new e({ detail: "Geometry archive erasure did not confirm void" }))))
+		});
+	})() : void 0;
+	return Object.freeze({
+		worlds: o,
+		...T ? { administration: Object.freeze({
+			reload: T.reload.bind(T),
+			rollback: T.rollback.bind(T),
+			...T.chunks ? { chunks: T.chunks.bind(T) } : {}
+		}) } : {},
+		...C ? { retention: Object.freeze({ run: C.run.bind(C) }) } : {},
+		...O ? { archives: O } : {},
+		..._ ? { assetGrants: Object.freeze({ grant: _.grant.bind(_) }) } : {},
+		...D ? { migrations: D } : {},
+		...h ? { readGrants: Object.freeze({ grant: h.grant.bind(h) }) } : {},
+		...u ? { manifest: Object.freeze({ observe: u.observe.bind(u) }) } : {},
+		service: Object.freeze({
+			publish: c.publish.bind(c),
+			observe: c.observe.bind(c),
+			commit: c.commit.bind(c),
+			exportSubject: c.exportSubject.bind(c),
+			eraseSubject: c.eraseSubject.bind(c)
+		})
+	});
+}, g = (p, h) => {
+	let g = d(p), _ = (t) => {
+		let n = g.find((e) => e.name === t.worldId);
+		if (!n?.geometry || n.geometry.kind !== t.kind) throw new e({ detail: "Rooms geometry request escaped its installed World kind" });
+	}, v = (t, n) => {
+		try {
+			let e = t();
+			return h((t) => n(t, e));
+		} catch {
+			return m.fail(new e({ detail: "Rooms geometry request could not be captured" }));
+		}
+	};
+	return Object.freeze({
+		publish: (e) => v(() => {
+			let t = n(e, [
+				"tenantId",
+				"kind",
+				"worldId",
+				"version",
+				"chunks"
+			]), a = Object.freeze({
+				tenantId: u(t.tenantId),
+				kind: i(t.kind),
+				worldId: u(t.worldId, 96),
+				version: u(t.version, 96),
+				chunks: r(t.chunks, 4096, c)
+			});
+			return _(a), a;
+		}, (e, t) => e.publish(t)),
+		observe: (e) => v(() => {
+			let t = o(e);
+			return _(t), t;
+		}, (e, t) => e.observe(t)),
+		commit: (e) => v(() => {
+			let r = n(e, [
+				"scope",
+				"owner",
+				"subject",
+				"requestId",
+				"patch",
+				"actualSession"
+			], [
+				"scope",
+				"owner",
+				"subject",
+				"requestId",
+				"patch"
+			]), i = o(r.scope), s = a(r.owner), c = l(r.subject), d = Object.hasOwn(r, "actualSession") ? f(r.actualSession, i, s, c) : null;
+			return _(i), Object.freeze({
+				scope: i,
+				owner: s,
+				subject: c,
+				requestId: u(r.requestId),
+				patch: t(r.patch, 16777216, "roomsGeometryPatchBytes"),
+				...d ? { actualSession: d.actualSession } : {}
+			});
+		}, (e, t) => e.commit(t)),
+		exportSubject: (e) => v(() => s(e), (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => v(() => s(e), (e, t) => e.eraseSubject(t))
+	});
+};
+//#endregion
+export { h as captureRoomsGeometryBinding, g as makeRoomsGeometryFacade };

package/dist/geometryAppStorage.js

@@ -0,0 +1,58 @@
+import { ProtocolError as e } from "./errors.js";
+import { storageGeometry as t } from "./geometryStorage.js";
+import { storageGeometryReadGrants as n } from "./geometryStorageGrant.js";
+import { Effect as r } from "effect";
+import { appStorageObjects as i } from "@voltro/plugin-storage";
+//#region src/geometryAppStorage.ts
+var a = (a, o) => {
+	if (!Array.isArray(a) || typeof o?.authorize != "function") throw new e({ detail: "App Storage geometry needs the app plugins and a Storage authorization policy" });
+	let s, c = () => {
+		if (s) return s;
+		let e = i(a);
+		return s = t(e.service, {
+			...o,
+			bucket: e.bucket,
+			metadata: e.metadata
+		});
+	}, l = (t) => r.suspend(() => {
+		let n;
+		try {
+			n = c();
+		} catch {
+			return r.fail(new e({ detail: "The app has no single bound Storage for geometry" }));
+		}
+		return t(n);
+	});
+	return Object.freeze({
+		source: Object.freeze({ load: (e) => l((t) => t.source.load(e)) }),
+		store: (e, t) => l((n) => n.store(e, t)),
+		release: (e) => l((t) => t.release(e)),
+		readGrants: (t) => {
+			if (typeof t?.authorize != "function" || typeof t.origin != "string") throw new e({ detail: "App Storage geometry read grants need the API origin and a read policy" });
+			if (o.visibility !== "public") throw new e({ detail: "Player chunk URLs need public geometry objects (visibility: public); a private object is readable by its owner only" });
+			let s;
+			return Object.freeze({ grant: (o, c) => r.suspend(() => {
+				if (!s) {
+					let o;
+					try {
+						o = i(a);
+					} catch {
+						return r.fail(new e({ detail: "The app has no single bound Storage for geometry" }));
+					}
+					s = n({
+						head: o.service.head.bind(o.service),
+						mintUrl: o.service.mintUrl.bind(o.service)
+					}, {
+						...t,
+						bucket: o.bucket,
+						metadata: o.metadata,
+						visibility: "public"
+					});
+				}
+				return s.grant(o, c);
+			}) });
+		}
+	});
+};
+//#endregion
+export { a as appStorageGeometry };

package/dist/geometryArtifacts.js

@@ -0,0 +1,198 @@
+import { geometryEnvelopeMagic as e } from "./geometryEnvelope.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { fieldId as n } from "./room.js";
+import { RoomInputCodec as r, RoomStateCodec as i } from "./stateCodec.js";
+import { GeometryTileChunkSchema as a, GeometryTileMaterialSchema as o, GeometryTileRunSchema as s } from "./geometrySchemas.js";
+import { createGeometryTileCodec as c, geometryTileRefusal as l } from "./geometryTileCodec.js";
+import { geometrySha256 as u } from "./geometryDigest.js";
+import { GeometryHeightfieldChunkSchema as d, createGeometryHeightfieldCodec as f } from "./geometryHeightfield.js";
+import { GeometryShapeSchema as p, GeometryShapesChunkSchema as m, createGeometryShapesCodec as h } from "./geometryShapes.js";
+import { GeometryVoxelChunkSchema as g, GeometryVoxelSectionSchema as _, createGeometryVoxelCodec as v } from "./geometryVoxel.js";
+import { Result as y, Schema as b } from "effect";
+//#region src/geometryArtifacts.ts
+var x = b.Struct({
+	kind: b.Literal("2d-tiles").pipe(n(1)),
+	formatVersion: b.Literal(1).pipe(n(2)),
+	width: b.Int.pipe(n(3)),
+	height: b.Int.pipe(n(4)),
+	tileSizeRaw: b.Int.pipe(n(5)),
+	palette: b.Array(o).pipe(n(6)),
+	runs: b.Array(s).pipe(n(7))
+}), S = b.Struct({
+	kind: b.Literal("2d-heightfield").pipe(n(1)),
+	formatVersion: b.Literal(1).pipe(n(2)),
+	width: b.Int.pipe(n(3)),
+	height: b.Int.pipe(n(4)),
+	sampleSpacingRaw: b.Int.pipe(n(5)),
+	baseHeightRaw: b.Int.pipe(n(6)),
+	heightQuantumRaw: b.Int.pipe(n(7)),
+	heights: b.Array(b.Int).pipe(n(8))
+}), C = b.Struct({
+	kind: b.Literal("3d-shapes").pipe(n(1)),
+	formatVersion: b.Literal(1).pipe(n(2)),
+	extentXRaw: b.Int.pipe(n(3)),
+	extentYRaw: b.Int.pipe(n(4)),
+	extentZRaw: b.Int.pipe(n(5)),
+	shapes: b.Array(p).pipe(n(6))
+}), w = b.Struct({
+	kind: b.Literal("3d-voxel").pipe(n(1)),
+	formatVersion: b.Literal(1).pipe(n(2)),
+	side: b.Int.pipe(n(3)),
+	voxelSizeRaw: b.Int.pipe(n(4)),
+	palette: b.Array(o).pipe(n(5)),
+	sections: b.Array(_).pipe(n(6))
+}), T = (e, t) => {
+	if (e === "2d-tiles") {
+		let e = c(t);
+		return {
+			profileLimits: Object.freeze({ ...e.limits }),
+			schema: a,
+			maxBytes: e.limits.maxBytes,
+			contentLimits: {
+				maxBytes: e.limits.maxBytes - 12,
+				maxCollectionLength: Math.max(e.limits.maxPalette, e.limits.maxRuns),
+				maxFieldId: 16
+			},
+			capture: e.capture,
+			encode: (t) => e.encode(t),
+			decode: e.decode
+		};
+	}
+	if (e === "2d-heightfield") {
+		let e = f(t);
+		return {
+			profileLimits: Object.freeze({ ...e.limits }),
+			schema: d,
+			maxBytes: e.limits.maxBytes,
+			contentLimits: {
+				maxBytes: e.limits.maxBytes - 12,
+				maxCollectionLength: e.limits.maxSamples,
+				maxFieldId: 16
+			},
+			capture: e.capture,
+			encode: (t) => e.encode(t),
+			decode: e.decode
+		};
+	}
+	if (e === "3d-shapes") {
+		let e = h(t);
+		return {
+			profileLimits: Object.freeze({ ...e.limits }),
+			schema: m,
+			maxBytes: e.limits.maxBytes,
+			contentLimits: {
+				maxBytes: e.limits.maxBytes - 12,
+				maxCollectionLength: e.limits.maxShapes,
+				maxFieldId: 16
+			},
+			capture: e.capture,
+			encode: (t) => e.encode(t),
+			decode: e.decode
+		};
+	}
+	if (e === "3d-voxel") {
+		let e = v(t);
+		return {
+			profileLimits: Object.freeze({ ...e.limits }),
+			schema: g,
+			maxBytes: e.limits.maxBytes,
+			contentLimits: {
+				maxBytes: e.limits.maxBytes - 12,
+				maxCollectionLength: Math.max(e.limits.maxPalette, e.limits.maxSections, e.limits.maxRunsPerSection),
+				maxFieldId: 16
+			},
+			capture: e.capture,
+			encode: (t) => e.encode(t),
+			decode: e.decode
+		};
+	}
+	return l();
+}, E = /* @__PURE__ */ new WeakSet(), D = (e) => !e || typeof e != "object" || !E.has(e) ? l() : e, O = (e, t = {}) => T(e, t).profileLimits, k = (e, t) => {
+	let n = new r(e, t, "f64");
+	return Object.freeze({
+		schemaHash: n.schemaHash,
+		limits: n.limits,
+		schemaDescription: () => n.schemaDescription(),
+		full: (e) => n.full(e),
+		decodeFull: (e) => n.decodeFull(e),
+		decodeDelta: (e) => n.decodeFull(e),
+		delta: (e, t, r = !1) => y.flatMap(n.full(e), (e) => y.map(n.full(t), (t) => !r && t.length === e.length && t.every((t, n) => t === e[n]) ? null : e))
+	});
+}, A = (e, t, n) => e === "3d-shapes" ? k(t, n) : new i(t, n), j = (e, t = {}) => {
+	let n = T(e, t);
+	return A(e, n.schema, n.contentLimits);
+}, M = (e, t, n = {}) => {
+	let r = T(e, n), i = r.capture(t);
+	return r.encode(i), i;
+}, N = (e, t = {}) => T(e.kind, t).encode(e).length, P = (e) => {
+	if (!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype) return l();
+	let t = Object.getOwnPropertyDescriptor(e, "kind");
+	return !t?.enumerable || !("value" in t) || ![
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	].includes(t.value) ? l() : t.value;
+}, F = (t, n, r, i) => {
+	let a = A(t, n, i), o = a.full(r);
+	if (y.isFailure(o)) return l();
+	let s = new Uint8Array(12 + o.success.length), c = new DataView(s.buffer);
+	return s.set(e.content), c.setUint32(4, a.schemaHash, !0), c.setUint32(8, o.success.length, !0), s.set(o.success, 12), s;
+}, I = (e, t = {}) => {
+	let n = T(e, t);
+	return A(e, e === "2d-tiles" ? x : e === "2d-heightfield" ? S : e === "3d-shapes" ? C : w, n.contentLimits);
+}, L = (e, t) => e.kind === "2d-tiles" ? F(e.kind, x, {
+	kind: e.kind,
+	formatVersion: e.formatVersion,
+	width: e.width,
+	height: e.height,
+	tileSizeRaw: e.tileSizeRaw,
+	palette: e.palette,
+	runs: e.runs
+}, t) : e.kind === "2d-heightfield" ? F(e.kind, S, {
+	kind: e.kind,
+	formatVersion: e.formatVersion,
+	width: e.width,
+	height: e.height,
+	sampleSpacingRaw: e.sampleSpacingRaw,
+	baseHeightRaw: e.baseHeightRaw,
+	heightQuantumRaw: e.heightQuantumRaw,
+	heights: e.heights
+}, t) : e.kind === "3d-shapes" ? F(e.kind, C, {
+	kind: e.kind,
+	formatVersion: e.formatVersion,
+	extentXRaw: e.extentXRaw,
+	extentYRaw: e.extentYRaw,
+	extentZRaw: e.extentZRaw,
+	shapes: e.shapes
+}, t) : F(e.kind, w, {
+	kind: e.kind,
+	formatVersion: e.formatVersion,
+	side: e.side,
+	voxelSizeRaw: e.voxelSizeRaw,
+	palette: e.palette,
+	sections: e.sections
+}, t), R = async (e, t, n, r) => {
+	let [i, a] = await Promise.all([r === void 0 ? u(n) : Promise.resolve(r), u(L(t, e.contentLimits))]), o = Object.freeze({
+		chunk: t,
+		blobSha256: i,
+		contentSha256: a,
+		bytes: () => new Uint8Array(n)
+	});
+	return E.add(o), o;
+}, z = async (e, t = {}) => {
+	let n = T(P(e), t), r = n.capture(e);
+	return R(n, r, n.encode(r));
+}, B = async (e, n, r, i = {}) => {
+	if (typeof r != "string" || !/^[a-f0-9]{64}$/.test(r)) return l();
+	let a = T(e, i), o;
+	try {
+		o = t(n, a.maxBytes, "geometryArtifactBytes");
+	} catch {
+		return l();
+	}
+	let s = await u(o);
+	return s === r ? R(a, a.decode(o), o, s) : l();
+};
+//#endregion
+export { M as admitGeometryChunkForKind, D as captureGeometryArtifact, z as createGeometryArtifact, I as geometryArtifactContentCodec, O as geometryArtifactProfileLimits, j as geometryArtifactStateCodec, N as geometryEncodedChunkSize, B as verifyGeometryArtifact };