@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/geometryMigrations.js

@@ -0,0 +1,322 @@
+import { BudgetExceeded as e, ProtocolError as t } from "./errors.js";
+import { captureSimulationBytes as n } from "./simulationBytes.js";
+import { geometryOwnData as r } from "./geometryTileCodec.js";
+import { captureGeometryArtifact as i, verifyGeometryArtifact as a } from "./geometryArtifacts.js";
+import { assertGeometryArtifactScope as o, captureGeometryDense as s, captureGeometryOwner as c, captureGeometryPersistenceScope as l, captureGeometryPrivacyTarget as u, geometryPersistenceId as d, geometryPersistenceInteger as f, geometryPersistenceSha as p } from "./geometryPersistenceData.js";
+import { createGeometryPatch as m } from "./geometryPatch.js";
+import { captureWorldCatalog as h } from "./world.js";
+import { GEO_MIGRATIONS_TABLE as g, geometryMigrationsTable as _ } from "./geometryMigrationJournal.js";
+import { captureRoomSnapshotEffectRunner as v } from "./snapshotBlobIndex.js";
+import { assertGeometryPrivacyFence as y } from "./geometryPrivacyFence.js";
+import { captureGeometryStoredVersion as b, geometryPersistenceDigest as x, geometryPersistenceScopeKey as S, geometryPersistenceVersionKey as C } from "./geometryPersistenceCapture.js";
+import { prepareGeometryVersionMigration as ee } from "./geometryVersionMigration.js";
+import { assertGeometrySqlOwner as w } from "./geometrySqlOwner.js";
+import { GEO_CHUNK_DELTAS_TABLE as T, GEO_VERSIONS_TABLE as E } from "./geometryPersistence.js";
+import { and as D, eq as O, generateId as k } from "@voltro/database";
+import { Context as A, Effect as j, Layer as M } from "effect";
+// src/geometryMigrations.ts
+var N = (e) => {
+	let n = r(e, [
+		"from",
+		"to",
+		"expectedRevision",
+		"owner",
+		"requestId"
+	]), i = l(n.from), a = l(n.to);
+	if (i.version === a.version || i.tenantId !== a.tenantId || i.kind !== a.kind || i.worldId !== a.worldId || i.layerSetId !== a.layerSetId || i.cx !== a.cx || i.cy !== a.cy || i.cz !== a.cz) throw new t({ detail: "Migration request must change only the actual immutable version" });
+	return Object.freeze({
+		from: i,
+		to: a,
+		expectedRevision: f(n.expectedRevision),
+		owner: c(n.owner),
+		requestId: d(n.requestId)
+	});
+}, P = class extends A.Service()("@voltro/GeometryVersionMigrationPort") {}, F = (e) => M.succeed(P, e);
+function I() {
+	throw new t({ detail: "Geometry SQL migration requires actual published versions, current owner and unchanged source revision" });
+}
+var L = (e, t) => JSON.stringify(e) === JSON.stringify(t), R = (e) => {
+	let t = r(e, [
+		"requestKey",
+		"inputSha256",
+		"from",
+		"to",
+		"fromRevision",
+		"revision",
+		"decision",
+		"staticChanged",
+		"fromManifestSha256",
+		"toManifestSha256",
+		"blobSha256",
+		"contentSha256"
+	]), n = l(t.from), i = l(t.to), a = t.decision, o = t.staticChanged;
+	return n.version === i.version || n.tenantId !== i.tenantId || n.kind !== i.kind || n.worldId !== i.worldId || n.layerSetId !== i.layerSetId || n.cx !== i.cx || n.cy !== i.cy || n.cz !== i.cz || ![
+		"kept",
+		"discarded",
+		"custom"
+	].includes(a) || typeof o != "boolean" || a === "kept" && o || a === "discarded" && !o ? I() : Object.freeze({
+		requestKey: p(t.requestKey),
+		inputSha256: p(t.inputSha256),
+		from: n,
+		to: i,
+		fromRevision: f(t.fromRevision),
+		revision: f(t.revision, 0, 1),
+		decision: a,
+		staticChanged: o,
+		fromManifestSha256: p(t.fromManifestSha256),
+		toManifestSha256: p(t.toManifestSha256),
+		blobSha256: p(t.blobSha256),
+		contentSha256: p(t.contentSha256)
+	});
+}, z = (c, d, _) => {
+	let A = h(d), M = r(_, [
+		"persistence",
+		"staticSource",
+		"authorize",
+		"epochNow",
+		"maxManifestChunks",
+		"maxManifestBytes",
+		"maxPatchBytes",
+		"maxAccountedBytes",
+		"privacy",
+		"maxPrivacyRows",
+		"maxPrivacyBytes",
+		"strategies"
+	], [
+		"persistence",
+		"staticSource",
+		"authorize",
+		"epochNow",
+		"privacy"
+	]), P = r(M.persistence, [
+		"publish",
+		"observe",
+		"commit",
+		"exportSubject",
+		"eraseSubject"
+	]), F = r(M.staticSource, ["load"]), z = M.persistence, B = M.staticSource, V = r(M.privacy, ["exportSubject", "eraseSubject"]), H = M.privacy;
+	if (Object.values(V).some((e) => typeof e != "function") || Object.values(P).some((e) => typeof e != "function") || typeof F.load != "function" || typeof M.authorize != "function" || typeof M.epochNow != "function") return I();
+	let U = r(Object.hasOwn(M, "strategies") ? M.strategies : {}, ["migrateDelta", "compaction"], []);
+	if (Object.values(U).some((e) => typeof e != "function")) return I();
+	let te = Object.freeze({
+		...Object.hasOwn(U, "migrateDelta") ? { migrateDelta: U.migrateDelta } : {},
+		...Object.hasOwn(U, "compaction") ? { compaction: U.compaction } : {}
+	}), ne = P.observe.bind(z), W = F.load.bind(B), re = M.authorize.bind(_), ie = M.epochNow.bind(_), ae = V.exportSubject.bind(H), oe = V.eraseSubject.bind(H), G = (e, t, n, r) => Object.hasOwn(M, e) ? f(M[e], n, r) : t, K = G("maxManifestChunks", 256, 1, 4096), se = G("maxManifestBytes", 262144, 1024, 16777216), q = G("maxPatchBytes", 262144, 512, 16777216), ce = G("maxAccountedBytes", 52428800, 512, 268435456), le = G("maxPrivacyRows", 256, 1, 65536), J = G("maxPrivacyBytes", 1048576, 512, 67108864), Y = (e, t, n, r = !1) => e.query({
+		table: t,
+		predicate: n,
+		order: [{
+			column: "id",
+			direction: "asc"
+		}],
+		take: 2,
+		skip: void 0,
+		projection: void 0,
+		...r ? { lock: "update" } : {}
+	}), X = (e) => D(O("tenantId", e.tenantId), O("versionKey", C(e))), ue = (e) => D(O("tenantId", e.tenantId), O("scopeKey", S(e))), Z = async (e, t) => j.isEffect(t) ? e(t) : I(), Q = async (e, t) => {
+		if (await Z(e, re(t)) !== void 0) return I();
+	}, $ = (n) => j.flatMap(j.context(), (r) => j.uninterruptible(j.tryPromise({
+		try: () => n(v(r)),
+		catch: (n) => n instanceof e ? n : new t({ detail: "Actual migration privacy remains incomplete" })
+	})));
+	return Object.freeze({
+		exportSubject: (n) => {
+			try {
+				let t = u(n);
+				return $(async (n) => {
+					let r = s(await Z(n, ae(t)), le, R);
+					if (r.some((e) => e.from.tenantId !== t.tenantId) || new Set(r.map((e) => e.requestKey)).size !== r.length) return I();
+					if (new TextEncoder().encode(JSON.stringify(r)).length > J) throw new e({
+						budget: "geometryMigrationPrivacyBytes",
+						limit: J
+					});
+					return r;
+				});
+			} catch {
+				return j.fail(new t({ detail: "Actual migration privacy target could not be captured" }));
+			}
+		},
+		eraseSubject: (e) => {
+			try {
+				let t = u(e);
+				return $(async (e) => {
+					if (await y(c, t), await Z(e, oe(t)) !== void 0) return I();
+					await y(c, t);
+				});
+			} catch {
+				return j.fail(new t({ detail: "Actual migration privacy target could not be captured" }));
+			}
+		},
+		migrate: (s) => {
+			try {
+				let u = N(s), d = u.from, h = u.to, _ = A.find((e) => e.name === d.worldId), y = x(JSON.stringify([d.tenantId, u.requestId])), M = x(JSON.stringify(u)), P = D(O("tenantId", d.tenantId), O("requestKey", y));
+				if (!_?.geometry || _.geometry.kind !== d.kind || d.version === h.version || d.tenantId !== h.tenantId || d.kind !== h.kind || d.worldId !== h.worldId || d.layerSetId !== h.layerSetId || d.cx !== h.cx || d.cy !== h.cy || d.cz !== h.cz) return I();
+				let F = (e) => {
+					let t = R(e.receipt);
+					return e.tenantId !== d.tenantId || e.requestKey !== y || e.inputSha256 !== M || e.fromScopeKey !== S(d) || e.toScopeKey !== S(h) || t.requestKey !== y || t.inputSha256 !== M || !L(t.from, d) || !L(t.to, h) || t.fromRevision !== u.expectedRevision ? I() : t;
+				}, z = async (e, t, n) => {
+					let r = await Y(e, E, X(t), n);
+					return r.length === 1 ? b(r[0], t, K, se) : I();
+				}, B = async (e) => {
+					let t = [d, h].sort((e, t) => C(e).localeCompare(C(t))), n = /* @__PURE__ */ new Map();
+					for (let r of t) n.set(C(r), await z(e, r, !0));
+					return await w(e, d, u.owner), {
+						before: n.get(C(d)),
+						after: n.get(C(h))
+					};
+				};
+				return j.flatMap(j.context(), (s) => j.uninterruptible(j.tryPromise({
+					try: async () => {
+						let e = v(s);
+						await Q(e, u);
+						let t = await Y(c, g, P);
+						if (t.length > 1) return I();
+						if (t.length) return c.transactional(async (e) => {
+							await B(e);
+							let t = await Y(e, g, P, !0);
+							return t.length === 1 ? F(t[0]) : I();
+						});
+						let b = await z(c, d, !1), x = await z(c, h, !1), C = b.chunks.find((e) => S(e) === S(d)), w = x.chunks.find((e) => S(e) === S(h));
+						if (!C || !w) return I();
+						let E = r(await Z(e, ne(d)), [
+							"scope",
+							"revision",
+							"artifact"
+						]), D = Object.freeze({
+							scope: l(E.scope),
+							revision: f(E.revision),
+							artifact: i(E.artifact)
+						});
+						if (!L(D.scope, d) || D.revision !== u.expectedRevision) return I();
+						let O = await a(d.kind, await Z(e, W(C)), C.blobSha256), A = await a(h.kind, await Z(e, W(w)), w.blobSha256);
+						o(O, d), o(A, h);
+						let j = m(O, D.artifact, 0, { limits: {
+							maxBytes: q,
+							maxMetadataBytes: Math.min(4096, q - 16)
+						} }).bytes(), N = await Z(e, ee(_, {
+							from: {
+								reference: C,
+								static: O,
+								current: D
+							},
+							to: {
+								reference: w,
+								static: A
+							}
+						}, {
+							strategies: te,
+							maxPatchBytes: Math.min(q, _.geometry.dynamic.maxDeltaBytesPerChunk),
+							maxAccountedBytes: Math.min(ce, _.geometry.budgets.maxPreparedBytes)
+						})), V = R({
+							requestKey: y,
+							inputSha256: M,
+							from: d,
+							to: h,
+							fromRevision: D.revision,
+							revision: N.patch.metadata.revision,
+							decision: N.decision,
+							staticChanged: N.staticChanged,
+							fromManifestSha256: b.manifestSha256,
+							toManifestSha256: x.manifestSha256,
+							blobSha256: N.artifact.blobSha256,
+							contentSha256: N.artifact.contentSha256
+						}), H = N.patch.bytes(), U = new Date(f(ie(), 0, 864e13));
+						return await Q(e, u), c.transactional(async (e) => {
+							let t = await B(e);
+							if (t.before.manifestSha256 !== b.manifestSha256 || t.after.manifestSha256 !== x.manifestSha256) return I();
+							let r = await Y(e, g, P, !0);
+							if (r.length > 1) return I();
+							if (r.length) return F(r[0]);
+							let i = /* @__PURE__ */ new Map();
+							for (let t of [d, h].sort((e, t) => S(e).localeCompare(S(t)))) i.set(S(t), await Y(e, T, ue(t), !0));
+							let a = i.get(S(d)), o = i.get(S(h));
+							if (a.length > 1 || o.length !== 0) return I();
+							let s = a[0], c = s ? f(s.revision, 1) : 0, u = s ? p(s.blobSha256) : C.blobSha256, m = s ? p(s.contentSha256) : C.contentSha256;
+							if (s && (!L(l(s.scope), d) || s.tenantId !== d.tenantId || s.scopeKey !== S(d)) || c !== D.revision || u !== D.artifact.blobSha256 || m !== D.artifact.contentSha256) return I();
+							if (s) {
+								let e = n(s.delta, q, "geometryMigrationSourceDeltaBytes");
+								if (e.length !== j.length || e.some((e, t) => e !== j[t])) return I();
+							}
+							return V.revision > 0 && await e.insert(T, {
+								id: k({
+									kind: "typeid",
+									prefix: "gdelta"
+								}, T),
+								tenantId: h.tenantId,
+								scopeKey: S(h),
+								scope: h,
+								revision: V.revision,
+								blobSha256: V.blobSha256,
+								contentSha256: V.contentSha256,
+								delta: H,
+								updatedAt: U
+							}), await e.insert(g, {
+								id: k({
+									kind: "typeid",
+									prefix: "gmigrate"
+								}, g),
+								tenantId: d.tenantId,
+								requestKey: y,
+								inputSha256: M,
+								fromScopeKey: S(d),
+								toScopeKey: S(h),
+								receipt: V,
+								createdAt: U
+							}), V;
+						});
+					},
+					catch: (n) => n instanceof e ? n : new t({ detail: "Actual atomic geometry SQL migration remains unconfirmed" })
+				})));
+			} catch {
+				return j.fail(new t({ detail: "Geometry SQL migration request could not be captured" }));
+			}
+		}
+	});
+}, B = (e) => {
+	let n = r(e, [
+		"migrate",
+		"exportSubject",
+		"eraseSubject"
+	]);
+	if (Object.values(n).some((e) => typeof e != "function")) return I();
+	let i = n.eraseSubject.bind(e), a = n.exportSubject.bind(e), o = (e, t) => u({
+		tenantId: t.tenantId,
+		requestId: t.requestId,
+		subject: {
+			id: e,
+			kind: t.kind
+		}
+	}), c = (e) => j.uninterruptible(j.suspend(() => {
+		let n = e();
+		return j.isEffect(n) ? n : j.fail(new t({ detail: "Migration privacy contribution requires its actual Effect" }));
+	})).pipe(j.catchCause(() => j.fail(new t({ detail: "Actual migration privacy contribution remains incomplete" }))));
+	return Object.freeze({
+		extendSchema: Object.freeze({ tables: Object.freeze([_]) }),
+		subjectPrivacy: Object.freeze({
+			tables: Object.freeze([g]),
+			kinds: Object.freeze(["user", "guest"])
+		}),
+		onErase: (e, n) => {
+			try {
+				let r = o(e, n);
+				return c(() => i(r).pipe(j.flatMap((e) => e === void 0 ? j.void : j.fail(new t({ detail: "Migration privacy withdrawal did not confirm void" })))));
+			} catch {
+				return j.fail(new t({ detail: "Actual migration privacy target could not be captured" }));
+			}
+		},
+		onExport: (e, n) => {
+			try {
+				let r = o(e, n);
+				return c(() => a(r).pipe(j.flatMap((e) => j.try({
+					try: () => {
+						let t = s(e, 4096, R);
+						return t.some((e) => e.from.tenantId !== r.tenantId) || new Set(t.map((e) => e.requestKey)).size !== t.length || new TextEncoder().encode(JSON.stringify(t)).length > 16777216 ? I() : t;
+					},
+					catch: () => new t({ detail: "Actual migration export escaped its admitted scope or budget" })
+				}))));
+			} catch {
+				return j.fail(new t({ detail: "Actual migration privacy target could not be captured" }));
+			}
+		}
+	});
+};
+export { P as GeometryVersionMigrationPort, R as captureGeometryMigrationReceipt, N as captureGeometryMigrationRequest, z as dataStoreGeometryMigrations, B as geometryMigrationContribution, F as geometryVersionMigrationLayer };

package/dist/geometryNativeMetadata.js

@@ -0,0 +1,51 @@
+import { geometryEnvelopeMagic as e } from "./geometryEnvelope.js";
+import { RoomInputCodec as t } from "./stateCodec.js";
+import { geometryArtifactContentCodec as n, geometryArtifactProfileLimits as r, geometryArtifactStateCodec as i } from "./geometryArtifacts.js";
+import { defaultGeometryPatchLimits as a, geometryPatchMetadataCodec as o } from "./geometryPatch.js";
+import { defaultGeometryTileNavigationLimits as s } from "./geometryTileNavigation.js";
+import { geometryChunkHttpHeaders as c } from "./geometryChunkHttp.js";
+import { GeometryManifestFragmentSchema as l, geometryManifestFragmentBytes as u } from "./geometryManifestChannel.js";
+import { GeometryDeltaFragmentSchema as d, geometryDeltaFragmentBytes as f } from "./geometryChannel.js";
+import { GeometryEditMessageSchema as p } from "./geometryEditChannel.js";
+// src/geometryNativeMetadata.ts
+var m = () => {
+	let m = (e) => Object.freeze({
+		schemaHash: e.schemaHash,
+		description: e.schemaDescription(),
+		limits: Object.freeze({ ...e.limits })
+	});
+	return Object.freeze({
+		profile: "default",
+		httpHeaders: c,
+		navigation: s,
+		navigationReaderLimit: 64,
+		envelopes: e,
+		channels: Object.freeze({
+			manifest: Object.freeze({
+				codec: m(new t(l)),
+				fragmentBytes: u
+			}),
+			delta: Object.freeze({
+				codec: m(new t(d)),
+				fragmentBytes: f
+			}),
+			edit: Object.freeze({ codec: m(new t(p)) })
+		}),
+		chunks: Object.freeze([
+			"2d-tiles",
+			"2d-heightfield",
+			"3d-shapes",
+			"3d-voxel"
+		].map((e) => Object.freeze({
+			kind: e,
+			profileLimits: r(e),
+			state: m(i(e)),
+			content: m(n(e))
+		}))),
+		patch: Object.freeze({
+			limits: Object.freeze({ ...a }),
+			metadata: m(o(a))
+		})
+	});
+};
+export { m as geometryNativeCodecMetadata };

package/dist/geometryPatch.js

@@ -0,0 +1,169 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryEnvelopeMagic as t } from "./geometryEnvelope.js";
+import { captureSimulationBytes as n } from "./simulationBytes.js";
+import { fieldId as r } from "./room.js";
+import { RoomStateCodec as i } from "./stateCodec.js";
+import { geometryOwnData as a, geometryTileRefusal as o } from "./geometryTileCodec.js";
+import { admitGeometryChunkForKind as s, captureGeometryArtifact as c, createGeometryArtifact as l, geometryArtifactStateCodec as u } from "./geometryArtifacts.js";
+import { Result as d, Schema as f } from "effect";
+// src/geometryPatch.ts
+var p = f.Struct({
+	kind: f.Literals([
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	]).pipe(r(1)),
+	formatVersion: f.Literal(1).pipe(r(2)),
+	worldId: f.String.pipe(r(3)),
+	layerSetId: f.String.pipe(r(4)),
+	cx: f.Int.pipe(r(5)),
+	cy: f.Int.pipe(r(6)),
+	cz: f.optional(f.Int.pipe(r(7))),
+	version: f.String.pipe(r(8)),
+	baseRevision: f.Int.pipe(r(9)),
+	revision: f.Int.pipe(r(10)),
+	baseBlobSha256: f.String.pipe(r(11)),
+	blobSha256: f.String.pipe(r(12)),
+	baseContentSha256: f.String.pipe(r(13)),
+	contentSha256: f.String.pipe(r(14)),
+	changed: f.Boolean.pipe(r(15)),
+	stateSchemaHash: f.Int.pipe(r(16))
+}), m = Object.freeze({
+	maxBytes: 262144,
+	maxMetadataBytes: 4096
+}), h = /* @__PURE__ */ new WeakMap(), g = (e) => !e || typeof e != "object" || !h.has(e) ? o() : e, _ = (e, t, n) => typeof e == "number" && Number.isSafeInteger(e) && e >= t && e <= n ? e === 0 ? 0 : e : o(), v = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : o(), y = (e) => typeof e == "string" && /^[a-f0-9]{64}$/.test(e) ? e : o(), b = (e, t) => e.kind === t.kind && e.version === t.version && e.address.worldId === t.address.worldId && e.address.layerSetId === t.address.layerSetId && e.address.cx === t.address.cx && e.address.cy === t.address.cy && ("cz" in e.address ? e.address.cz : void 0) === ("cz" in t.address ? t.address.cz : void 0), x = (e) => {
+	let t = a(e, ["maxBytes", "maxMetadataBytes"], []), n = Object.freeze({
+		maxBytes: Object.hasOwn(t, "maxBytes") ? _(t.maxBytes, 80, 16777216) : m.maxBytes,
+		maxMetadataBytes: Object.hasOwn(t, "maxMetadataBytes") ? _(t.maxMetadataBytes, 64, 65536) : m.maxMetadataBytes
+	});
+	return n.maxMetadataBytes > n.maxBytes - 16 ? o() : n;
+}, S = (e) => new i(p, {
+	maxBytes: e.maxMetadataBytes,
+	maxCollectionLength: 16,
+	maxFieldId: 16
+}), C = (e, t) => {
+	let n = [
+		"kind",
+		"formatVersion",
+		"worldId",
+		"layerSetId",
+		"cx",
+		"cy",
+		"cz",
+		"version",
+		"baseRevision",
+		"revision",
+		"baseBlobSha256",
+		"blobSha256",
+		"baseContentSha256",
+		"contentSha256",
+		"changed",
+		"stateSchemaHash"
+	], r = a(e, n, n.filter((e) => e !== "cz")), i = r.kind;
+	if (![
+		"2d-tiles",
+		"2d-heightfield",
+		"3d-shapes",
+		"3d-voxel"
+	].includes(i) || r.formatVersion !== 1 || typeof r.changed != "boolean") return o();
+	let s = _(r.baseRevision, 0, 2147483647), c = _(r.revision, 0, 2147483647), l = r.changed, u = y(r.baseBlobSha256), d = y(r.blobSha256), f = y(r.baseContentSha256), p = y(r.contentSha256);
+	if (l ? t < 1 || s === 2147483647 || c !== s + 1 : t !== 0 || c !== s || u !== d || f !== p) return o();
+	let m = i === "3d-shapes" || i === "3d-voxel";
+	return m === Object.hasOwn(r, "cz") ? Object.freeze({
+		kind: i,
+		formatVersion: 1,
+		worldId: v(r.worldId),
+		layerSetId: v(r.layerSetId),
+		cx: _(r.cx, -2147483648, 2147483647),
+		cy: _(r.cy, -2147483648, 2147483647),
+		...m ? { cz: _(r.cz, -2147483648, 2147483647) } : {},
+		version: v(r.version),
+		baseRevision: s,
+		revision: c,
+		baseBlobSha256: u,
+		blobSha256: d,
+		baseContentSha256: f,
+		contentSha256: p,
+		changed: l,
+		stateSchemaHash: _(r.stateSchemaHash, 0, 4294967295)
+	}) : o();
+}, w = (e, t, n) => {
+	let r = Object.freeze({
+		metadata: e,
+		bytes: () => new Uint8Array(n)
+	});
+	return h.set(r, {
+		metadata: e,
+		delta: t,
+		bytes: n
+	}), r;
+}, T = (n, r, i) => {
+	let a = S(i), s = a.full(n);
+	if (d.isFailure(s)) return o();
+	if (16 + s.success.length + r.length > i.maxBytes) throw new e({
+		budget: "geometryPatchBytes",
+		limit: i.maxBytes
+	});
+	let c = new Uint8Array(16 + s.success.length + r.length), l = new DataView(c.buffer);
+	return c.set(t.patch), l.setUint32(4, a.schemaHash, !0), l.setUint32(8, s.success.length, !0), l.setUint32(12, r.length, !0), c.set(s.success, 16), c.set(r, 16 + s.success.length), c;
+}, E = (e, t, n, r = {}) => {
+	let i = a(r, ["limits", "codecLimits"], []), l = x(i.limits === void 0 ? {} : i.limits), f = c(e), p = c(t);
+	if (_(n, 0, 2147483647), !b(f.chunk, p.chunk)) return o();
+	let m = i.codecLimits === void 0 ? {} : i.codecLimits, h = s(f.chunk.kind, f.chunk, m), g = s(f.chunk.kind, p.chunk, m), v = u(f.chunk.kind, m), y = v.delta(g, h);
+	if (d.isFailure(y)) return o();
+	let S = y.success !== null, E = y.success ?? /* @__PURE__ */ new Uint8Array(), D = C({
+		kind: f.chunk.kind,
+		formatVersion: 1,
+		worldId: f.chunk.address.worldId,
+		layerSetId: f.chunk.address.layerSetId,
+		cx: f.chunk.address.cx,
+		cy: f.chunk.address.cy,
+		..."cz" in f.chunk.address ? { cz: f.chunk.address.cz } : {},
+		version: f.chunk.version,
+		baseRevision: n,
+		revision: S ? n + 1 : n,
+		baseBlobSha256: f.blobSha256,
+		blobSha256: p.blobSha256,
+		baseContentSha256: f.contentSha256,
+		contentSha256: p.contentSha256,
+		changed: S,
+		stateSchemaHash: v.schemaHash
+	}, E.length);
+	return w(D, E, T(D, E, l));
+}, D = (r, i = {}) => {
+	let a = x(i), s;
+	try {
+		s = n(r, a.maxBytes, "geometryPatchBytes");
+	} catch (t) {
+		if (t instanceof e) throw t;
+		return o();
+	}
+	if (s.length < 16 || t.patch.some((e, t) => s[t] !== e)) return o();
+	let c = S(a), l = new DataView(s.buffer, s.byteOffset, 16), u = l.getUint32(8, !0), f = l.getUint32(12, !0);
+	if (l.getUint32(4, !0) !== c.schemaHash || u < 1 || u > a.maxMetadataBytes || 16 + u + f !== s.length) return o();
+	let p = c.decodeFull(s.subarray(16, 16 + u));
+	if (d.isFailure(p)) return o();
+	let m = C(p.success, f), h = s.slice(16 + u), g = T(m, h, a);
+	return g.length !== s.length || g.some((e, t) => e !== s[t]) ? o() : w(m, h, s);
+}, O = async (e, t, n, r = {}) => {
+	let i = c(e), a = h.get(t);
+	if (!a) return o();
+	_(n, 0, 2147483647);
+	let f = a.metadata, p = i.chunk.address;
+	if (f.kind !== i.chunk.kind || f.version !== i.chunk.version || f.worldId !== p.worldId || f.layerSetId !== p.layerSetId || f.cx !== p.cx || f.cy !== p.cy || f.cz !== ("cz" in p ? p.cz : void 0) || f.baseRevision !== n || f.baseBlobSha256 !== i.blobSha256 || f.baseContentSha256 !== i.contentSha256) return o();
+	let m = s(f.kind, i.chunk, r), g = u(f.kind, r);
+	if (g.schemaHash !== f.stateSchemaHash) return o();
+	if (!f.changed) return Object.freeze({
+		artifact: e,
+		revision: n
+	});
+	let v = g.decodeDelta(a.delta, m);
+	if (d.isFailure(v)) return o();
+	let y = await l(v.success, r), x = g.delta(y.chunk, m);
+	return d.isFailure(x) || x.success === null || x.success.length !== a.delta.length || x.success.some((e, t) => e !== a.delta[t]) || !b(i.chunk, y.chunk) || y.blobSha256 !== f.blobSha256 || y.contentSha256 !== f.contentSha256 ? o() : Object.freeze({
+		artifact: y,
+		revision: f.revision
+	});
+};
+export { p as GeometryPatchMetadataSchema, O as applyGeometryPatch, g as captureGeometryPatch, x as captureGeometryPatchLimits, E as createGeometryPatch, D as decodeGeometryPatch, m as defaultGeometryPatchLimits, S as geometryPatchMetadataCodec };