@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/geometryImportGltf.js

@@ -0,0 +1,300 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { geometryOwnData as n, geometryTileRefusal as r } from "./geometryTileCodec.js";
+import { createGeometryShapesCodec as i } from "./geometryShapes.js";
+import { importArray as a, importInteger as o, importRecord as s } from "./geometryImportTiles.js";
+//#region src/geometryImportGltf.ts
+var c = {
+	axes: [
+		0,
+		1,
+		2
+	],
+	scales: [
+		65536,
+		65536,
+		65536
+	],
+	translation: [
+		0,
+		0,
+		0
+	]
+}, l = (e) => typeof e == "number" && Number.isFinite(e) ? o(e * 65536) : r(), u = (e, t) => {
+	let n = a(e, 3);
+	return n.length === 3 ? [
+		t(n[0]),
+		t(n[1]),
+		t(n[2])
+	] : r();
+}, d = (e, t) => {
+	let n = BigInt(e) * BigInt(t);
+	return n % 65536n ? r() : o(Number(n / 65536n));
+}, f = (e) => {
+	if (Object.hasOwn(e, "matrix")) {
+		if ([
+			"translation",
+			"scale",
+			"rotation"
+		].some((t) => Object.hasOwn(e, t))) return r();
+		let t = a(e.matrix, 16).map(l);
+		if (t.length !== 16 || t[3] !== 0 || t[7] !== 0 || t[11] !== 0 || t[15] !== 65536) return r();
+		let n = [], i = [];
+		for (let e = 0; e < 3; e++) {
+			let a = [
+				0,
+				1,
+				2
+			].filter((n) => t[n * 4 + e] !== 0);
+			if (a.length !== 1 || n.includes(a[0])) return r();
+			n.push(a[0]), i.push(t[a[0] * 4 + e]);
+		}
+		return {
+			axes: [
+				n[0],
+				n[1],
+				n[2]
+			],
+			scales: [
+				i[0],
+				i[1],
+				i[2]
+			],
+			translation: [
+				t[12],
+				t[13],
+				t[14]
+			]
+		};
+	}
+	let t = Object.hasOwn(e, "translation") ? u(e.translation, l) : c.translation, n = Object.hasOwn(e, "scale") ? u(e.scale, l) : c.scales;
+	if (n.some((e) => !e)) return r();
+	let i = [
+		1,
+		1,
+		1
+	];
+	if (Object.hasOwn(e, "rotation")) {
+		let t = a(e.rotation, 4);
+		if (t.length !== 4 || t.some((e) => e !== 0 && e !== 1 && e !== -1) || t.filter((e) => e !== 0).length !== 1) return r();
+		i = t[0] ? [
+			1,
+			-1,
+			-1
+		] : t[1] ? [
+			-1,
+			1,
+			-1
+		] : t[2] ? [
+			-1,
+			-1,
+			1
+		] : [
+			1,
+			1,
+			1
+		];
+	}
+	return {
+		axes: [
+			0,
+			1,
+			2
+		],
+		scales: [
+			o(n[0] * i[0]),
+			o(n[1] * i[1]),
+			o(n[2] * i[2])
+		],
+		translation: t
+	};
+}, p = (e, t) => ({
+	axes: [
+		t.axes[e.axes[0]],
+		t.axes[e.axes[1]],
+		t.axes[e.axes[2]]
+	],
+	scales: [
+		d(e.scales[0], t.scales[e.axes[0]]),
+		d(e.scales[1], t.scales[e.axes[1]]),
+		d(e.scales[2], t.scales[e.axes[2]])
+	],
+	translation: [
+		o(e.translation[0] + d(e.scales[0], t.translation[e.axes[0]])),
+		o(e.translation[1] + d(e.scales[1], t.translation[e.axes[1]])),
+		o(e.translation[2] + d(e.scales[2], t.translation[e.axes[2]]))
+	]
+}), m = (e, t) => [
+	o(t.translation[0] + d(e[t.axes[0]], t.scales[0])),
+	o(t.translation[1] + d(e[t.axes[1]], t.scales[1])),
+	o(t.translation[2] + d(e[t.axes[2]], t.scales[2]))
+], h = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : r(), g = (d, g) => {
+	let _ = n(g, [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"chunks",
+		"chunkSizeRaw",
+		"scene",
+		"collisionNodes",
+		"collision",
+		"buffers",
+		"maxInputBytes",
+		"maxBufferBytes",
+		"maxNodes",
+		"maxVertices",
+		"maxChunks",
+		"maxShapes",
+		"codecLimits"
+	], [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"chunks",
+		"scene",
+		"collisionNodes",
+		"collision",
+		"buffers"
+	]), v = (e, t, n) => o(Object.hasOwn(_, e) ? _[e] : t, 1, n), y = v("maxInputBytes", 16777216, 67108864), b = v("maxBufferBytes", 33554432, 268435456), x = v("maxNodes", 4096, 16384), S = v("maxVertices", 1048576, 4194304), C = v("maxChunks", 256, 4096), w = v("maxShapes", 4096, 65536), T = v("chunkSizeRaw", 4194304, 2147483647), E = n(_.origin, [
+		"cx",
+		"cy",
+		"cz"
+	]), D = o(E.cx), O = o(E.cy), k = o(E.cz), A = n(_.chunks, [
+		"x",
+		"y",
+		"z"
+	]), j = o(A.x, 1, C), M = o(A.y, 1, C), N = o(A.z, 1, C), ee = h(_.worldId), te = h(_.layerSetId), ne = h(_.version), P = ["maxShapes", "maxBytes"], F = Object.hasOwn(_, "codecLimits") ? n(_.codecLimits, P, []) : {}, I = Object.fromEntries(P.filter((e) => Object.hasOwn(F, e)).map((e) => [e, o(F[e], 1, 16777216)])), L = i(I), re = t(d, y, "geometryImportBytes");
+	if (_.collision !== "mesh-aabb") return r();
+	if (j * M * N > C) throw new e({
+		budget: "geometryImportChunks",
+		limit: C
+	});
+	o(j * T, 1), o(M * T, 1), o(N * T, 1), o(D + j - 1), o(O + M - 1), o(k + N - 1);
+	let R;
+	try {
+		R = s(JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(re)));
+	} catch {
+		return r();
+	}
+	if (s(R.asset).version !== "2.0" || R.extensionsRequired !== void 0 && a(R.extensionsRequired, x).length || R.animations !== void 0 && a(R.animations, x).length) return r();
+	let z = a(R.nodes, x).map(s), B = a(R.scenes, x).map(s), V = a(R.meshes, x).map(s), H = a(R.accessors, x * 4).map(s), U = a(R.bufferViews, x * 4).map(s), W = a(R.buffers, x).map(s), G = a(_.buffers, x);
+	if (W.length !== G.length) return r();
+	let K = 0, q = G.map((n, i) => {
+		let a = o(W[i].byteLength, 1, b);
+		if (K += a, K > b) throw new e({
+			budget: "geometryImportBufferBytes",
+			limit: b
+		});
+		let s = t(n, a, "geometryImportBufferBytes");
+		return s.length === a ? new DataView(s.buffer) : r();
+	}), J = /* @__PURE__ */ new Map(), Y = (e, t, n) => {
+		let i = o(e, 0, z.length - 1);
+		if (n > 64 || J.has(i)) return r();
+		let s = z[i];
+		if (Object.hasOwn(s, "skin") || Object.hasOwn(s, "weights") || Object.hasOwn(s, "extensions")) return r();
+		let c = p(t, f(s));
+		if (J.set(i, c), Object.hasOwn(s, "children")) for (let e of a(s.children, x)) Y(e, c, n + 1);
+	}, ie = B[o(_.scene, 0, B.length - 1)];
+	for (let e of a(ie.nodes, x)) Y(e, c, 0);
+	let X = a(_.collisionNodes, Math.min(w, x)).map((e) => o(e, 0, z.length - 1));
+	if (!X.length || new Set(X).size !== X.length || X.some((e) => !J.has(e))) return r();
+	let Z = 0, ae = 0, Q = /* @__PURE__ */ new Map();
+	for (let t of X) {
+		let n = z[t], i = V[o(n.mesh, 0, V.length - 1)], c = [
+			Infinity,
+			Infinity,
+			Infinity
+		], d = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		];
+		if (Object.hasOwn(i, "weights") || Object.hasOwn(i, "extensions")) return r();
+		let f = a(i.primitives, w).map(s);
+		if (!f.length) return r();
+		for (let n of f) {
+			if (Object.hasOwn(n, "targets") || Object.hasOwn(n, "extensions")) return r();
+			let i = s(n.attributes), a = H[o(i.POSITION, 0, H.length - 1)], f = o(a.count, 1, S);
+			if (Z += f, Z > S) throw new e({
+				budget: "geometryImportVertices",
+				limit: S
+			});
+			if (a.componentType !== 5126 || a.type !== "VEC3" || a.normalized !== void 0 && a.normalized !== !1 || Object.hasOwn(a, "sparse") || Object.hasOwn(a, "extensions")) return r();
+			let p = U[o(a.bufferView, 0, U.length - 1)], h = q[o(p.buffer, 0, q.length - 1)], g = o(p.byteOffset ?? 0, 0, h.byteLength), _ = o(p.byteLength, 1, h.byteLength), v = o(a.byteOffset ?? 0, 0, _), y = o(p.byteStride ?? 12, 12, 252);
+			if (Object.hasOwn(p, "extensions") || g % 4 || v % 4 || y % 4 || g + _ > h.byteLength || v + y * (f - 1) + 12 > _) return r();
+			let b = [
+				Infinity,
+				Infinity,
+				Infinity
+			], x = [
+				-Infinity,
+				-Infinity,
+				-Infinity
+			];
+			for (let e = 0; e < f; e++) {
+				let n = [
+					l(h.getFloat32(g + v + e * y, !0)),
+					l(h.getFloat32(g + v + e * y + 4, !0)),
+					l(h.getFloat32(g + v + e * y + 8, !0))
+				];
+				for (let e = 0; e < 3; e++) b[e] = Math.min(b[e], n[e]), x[e] = Math.max(x[e], n[e]);
+				let r = m(n, J.get(t));
+				for (let e = 0; e < 3; e++) c[e] = Math.min(c[e], r[e]), d[e] = Math.max(d[e], r[e]);
+			}
+			let C = u(a.min, (e) => l(typeof e == "number" ? Math.fround(e) : e)), w = u(a.max, (e) => l(typeof e == "number" ? Math.fround(e) : e));
+			if (b.some((e, t) => e !== C[t]) || x.some((e, t) => e !== w[t])) return r();
+		}
+		let p = [
+			j * T,
+			M * T,
+			N * T
+		];
+		if (c.some((e, t) => e < 0 || e >= d[t] || d[t] > p[t])) return r();
+		let h = c.map((e) => Math.floor(e / T)), g = d.map((e) => Math.ceil(e / T) - 1);
+		for (let n = h[2]; n <= g[2]; n++) for (let r = h[1]; r <= g[1]; r++) for (let i = h[0]; i <= g[0]; i++) {
+			if (++ae > w) throw new e({
+				budget: "geometryImportShapes",
+				limit: w
+			});
+			let a = [
+				i * T,
+				r * T,
+				n * T
+			], s = c.map((e, t) => Math.max(e - a[t], 0)), l = d.map((e, t) => Math.min(e - a[t], T)), u = s.map((e, t) => o((e + l[t]) / 2)), f = s.map((e, t) => o((l[t] - e) / 2, 1)), p = `${i}:${r}:${n}`, m = Q.get(p) ?? [];
+			if (m.push({
+				kind: "aabb",
+				id: `node:${t}`,
+				xRaw: u[0],
+				yRaw: u[1],
+				zRaw: u[2],
+				halfXRaw: f[0],
+				halfYRaw: f[1],
+				halfZRaw: f[2]
+			}), m.length > L.limits.maxShapes) throw new e({
+				budget: "geometryShapes",
+				limit: L.limits.maxShapes
+			});
+			Q.set(p, m);
+		}
+	}
+	let $ = [];
+	for (let e = 0; e < N; e++) for (let t = 0; t < M; t++) for (let n = 0; n < j; n++) $.push(L.create({
+		address: {
+			worldId: ee,
+			layerSetId: te,
+			cx: D + n,
+			cy: O + t,
+			cz: k + e
+		},
+		version: ne,
+		extentXRaw: T,
+		extentYRaw: T,
+		extentZRaw: T,
+		shapes: Q.get(`${n}:${t}:${e}`) ?? []
+	}));
+	return Object.freeze($);
+};
+//#endregion
+export { g as importGltfGeometry };

package/dist/geometryImportLdtk.js

@@ -0,0 +1,54 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryTileRefusal as t } from "./geometryTileCodec.js";
+import { admitTileImport as n, collectImportedTiles as r, importArray as i, importInteger as a, importMaterial as o, importName as s, importRecord as c } from "./geometryImportTiles.js";
+//#region src/geometryImportLdtk.ts
+var l = (l, u) => {
+	let d = n(u, [
+		"level",
+		"layer",
+		"emptyMaterial",
+		"worldIid"
+	], ["level", "layer"]), f = d.parse(l), p = s(d.data.level), m = s(d.data.layer), h = d.data.worldIid === void 0 ? void 0 : s(d.data.worldIid), g = f;
+	if (h !== void 0) {
+		let e = i(f.worlds, d.maxRegions).map(c).filter((e) => e.iid === h);
+		if (e.length !== 1) return t();
+		g = e[0];
+	} else if (Object.hasOwn(f, "worlds") && i(f.worlds, d.maxRegions).length) return t();
+	let _ = (Object.hasOwn(g, "levels") ? i(g.levels, d.maxRegions).map(c) : [g]).filter((e) => e.identifier === p);
+	if (_.length !== 1) return t();
+	let v = i(_[0].layerInstances, d.maxRegions).map(c).filter((e) => e.__identifier === m);
+	if (v.length !== 1) return t();
+	let y = v[0], b = a(y.__cWid, 1, d.maxCells), x = a(y.__cHei, 1, d.maxCells), S = b * x, C = a(y.__gridSize, 1, 1048576), w = a(y.__pxTotalOffsetX), T = a(y.__pxTotalOffsetY);
+	if (S > d.maxCells) throw new e({
+		budget: "geometryImportCells",
+		limit: d.maxCells
+	});
+	if (w % C || T % C) return t();
+	let E;
+	if (y.__type === "IntGrid") {
+		let e = i(y.intGridCsv, S);
+		if (e.length !== S || d.data.emptyMaterial !== void 0) return t();
+		E = e.map((e) => d.selectMaterial(a(e, 0)));
+	} else if (y.__type === "Tiles" || y.__type === "AutoLayer") {
+		let e = o(d.data.emptyMaterial), n = i(y[y.__type === "Tiles" ? "gridTiles" : "autoLayerTiles"], d.maxCells), r = new Uint8Array(S);
+		E = Array.from({ length: S }, () => e);
+		for (let e of n) {
+			let n = c(e), o = i(n.px, 2);
+			if (o.length !== 2) return t();
+			let s = a(o[0], 0), l = a(o[1], 0);
+			if (s % C || l % C || s / C >= b || l / C >= x) return t();
+			let u = l / C * b + s / C;
+			if (r[u]) return t();
+			r[u] = 1, E[u] = d.selectMaterial(a(n.t, 0), a(n.f, 0, 3));
+		}
+	} else return t();
+	return r(d, [{
+		x: a(d.x + w / C),
+		y: a(d.y + T / C),
+		width: b,
+		height: x,
+		cells: E
+	}]);
+};
+//#endregion
+export { l as importLdtkGeometry };

package/dist/geometryImportPng.js

@@ -0,0 +1,144 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { captureSimulationBytes as t } from "./simulationBytes.js";
+import { geometryOwnData as n, geometryTileRefusal as r } from "./geometryTileCodec.js";
+import { createGeometryHeightfieldCodec as i } from "./geometryHeightfield.js";
+import { importInteger as a } from "./geometryImportTiles.js";
+import { inflateSync as o } from "node:zlib";
+//#region src/geometryImportPng.ts
+var s = Uint32Array.from({ length: 256 }, (e, t) => {
+	let n = t;
+	for (let e = 0; e < 8; e++) n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+	return n >>> 0;
+}), c = (e) => {
+	let t = 4294967295;
+	for (let n of e) t = s[(t ^ n) & 255] ^ t >>> 8;
+	return (t ^ 4294967295) >>> 0;
+}, l = (e, t, n) => {
+	let r = e + t - n, i = Math.abs(r - e), a = Math.abs(r - t), o = Math.abs(r - n);
+	return i <= a && i <= o ? e : a <= o ? t : n;
+}, u = (e) => typeof e == "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,95}$/.test(e) ? e : r(), d = (s, d) => {
+	let f = n(d, [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"cellsPerChunk",
+		"sampleSpacingRaw",
+		"baseHeightRaw",
+		"heightQuantumRaw",
+		"sampleZero",
+		"maxInputBytes",
+		"maxSamples",
+		"maxChunks",
+		"maxPngChunks",
+		"codecLimits"
+	], [
+		"worldId",
+		"layerSetId",
+		"version",
+		"origin",
+		"baseHeightRaw",
+		"heightQuantumRaw",
+		"sampleZero"
+	]), p = (e, t, n) => a(Object.hasOwn(f, e) ? f[e] : t, 1, n), m = p("maxInputBytes", 16777216, 67108864), h = p("maxSamples", 1048576, 4194304), g = p("maxChunks", 256, 4096), _ = p("maxPngChunks", 4096, 16384), v = p("cellsPerChunk", 64, 1024), y = p("sampleSpacingRaw", 65536, 2147483647), b = a(f.baseHeightRaw), x = a(f.heightQuantumRaw, 1), S = a(f.sampleZero, 0, 65535), C = n(f.origin, ["cx", "cy"]), w = a(C.cx), T = a(C.cy), E = u(f.worldId), D = u(f.layerSetId), O = u(f.version), k = [
+		"maxSide",
+		"maxSamples",
+		"maxBytes"
+	], A = Object.hasOwn(f, "codecLimits") ? n(f.codecLimits, k, []) : {}, j = Object.fromEntries(k.filter((e) => Object.hasOwn(A, e)).map((e) => [e, a(A[e], 1, 16777216)])), M = i(j), N = t(s, m, "geometryImportBytes"), P = new DataView(N.buffer);
+	if (v + 1 > M.limits.maxSide || (v + 1) ** 2 > M.limits.maxSamples || v * y > 2147483647 || N.length < 57 || [
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	].some((e, t) => N[t] !== e)) return r();
+	let F = 8, I = 0, L = 0, R = 0, z = 0, B = !1, V = 0, H = 0, U = [];
+	for (; F < N.length;) {
+		if (++z > _) throw new e({
+			budget: "geometryPngChunks",
+			limit: _
+		});
+		if (N.length - F < 12) return r();
+		let t = P.getUint32(F), n = F + 12 + t;
+		if (t > 2147483647 || n > N.length) return r();
+		let i = String.fromCharCode(...N.subarray(F + 4, F + 8)), o = N.subarray(F + 8, F + 8 + t);
+		if (!/^[A-Za-z]{2}[A-Z][A-Za-z]$/.test(i) || c(N.subarray(F + 4, n - 4)) !== P.getUint32(n - 4) || z === 1 && i !== "IHDR") return r();
+		if (i === "IHDR") {
+			if (z !== 1 || t !== 13 || (I = a(P.getUint32(F + 8), 2, 2147483647), L = a(P.getUint32(F + 12), 2, 2147483647), R = o[8], o[9] !== 0 || ![8, 16].includes(R) || o[10] !== 0 || o[11] !== 0 || o[12] !== 0 || S >= 2 ** R)) return r();
+			if (I * L > h) throw new e({
+				budget: "geometryImportSamples",
+				limit: h
+			});
+			if ((I - 1) % v || (L - 1) % v) return r();
+			let n = (I - 1) / v, i = (L - 1) / v;
+			if (n * i > g) throw new e({
+				budget: "geometryImportChunks",
+				limit: g
+			});
+			a(w + n - 1), a(T + i - 1);
+		} else if (i === "IDAT") {
+			if (!I || V === 2) return r();
+			V = 1, H += o.length, U.push(o);
+		} else if (V === 1 && (V = 2), i === "IEND") {
+			if (t !== 0 || !H || n !== N.length) return r();
+			B = !0;
+		} else if (i === "tRNS" || [
+			"acTL",
+			"fcTL",
+			"fdAT"
+		].includes(i) || i[0] === i[0].toUpperCase()) return r();
+		F = n;
+	}
+	if (!B || !H) return r();
+	let W = new Uint8Array(H), G = 0;
+	for (let e of U) W.set(e, G), G += e.length;
+	let K = R / 8, q = I * K, J = (q + 1) * L, Y;
+	try {
+		let e = o(W, {
+			maxOutputLength: J,
+			info: !0
+		});
+		if (!e || typeof e != "object" || !("buffer" in e) || !(e.buffer instanceof Uint8Array) || !("engine" in e) || !e.engine || typeof e.engine != "object" || !("bytesWritten" in e.engine) || e.engine.bytesWritten !== H || e.buffer.length !== J) return r();
+		Y = e.buffer;
+	} catch {
+		return r();
+	}
+	let X = new Uint8Array(q * L);
+	for (let e = 0; e < L; e++) {
+		let t = Y[e * (q + 1)];
+		if (t > 4) return r();
+		for (let n = 0; n < q; n++) {
+			let r = e * q + n, i = n >= K ? X[r - K] : 0, a = e ? X[r - q] : 0, o = e && n >= K ? X[r - q - K] : 0, s = t === 0 ? 0 : t === 1 ? i : t === 2 ? a : t === 3 ? Math.floor((i + a) / 2) : l(i, a, o);
+			X[r] = Y[e * (q + 1) + n + 1] + s & 255;
+		}
+	}
+	let Z = (I - 1) / v, Q = (L - 1) / v, $ = [], ee = new DataView(X.buffer);
+	for (let e = 0; e < Q; e++) for (let t = 0; t < Z; t++) {
+		let n = [];
+		for (let r = 0; r <= v; r++) for (let i = 0; i <= v; i++) {
+			let o = (e * v + r) * q + (t * v + i) * K, s = R === 8 ? X[o] : ee.getUint16(o), c = a(s - S, -32768, 32767);
+			n.push(a(b + c * x));
+		}
+		$.push(M.create({
+			address: {
+				worldId: E,
+				layerSetId: D,
+				cx: w + t,
+				cy: T + e
+			},
+			version: O,
+			width: v + 1,
+			height: v + 1,
+			sampleSpacingRaw: y,
+			baseHeightRaw: b,
+			heightQuantumRaw: x,
+			heightRawSamples: n
+		}));
+	}
+	return Object.freeze($);
+};
+//#endregion
+export { d as importPngGeometry };

package/dist/geometryImportPublication.js

@@ -0,0 +1,67 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryOwnData as t, geometryTileRefusal as n } from "./geometryTileCodec.js";
+import { createGeometryArtifact as r } from "./geometryArtifacts.js";
+import { captureGeometryCodecProfiles as i, captureGeometryDense as a, geometryPersistenceId as o, geometryPersistenceInteger as s } from "./geometryPersistenceData.js";
+import { captureGeometryVersion as c } from "./geometryPersistenceCapture.js";
+//#region src/geometryImportPublication.ts
+var l = async (l, u, d = {}) => {
+	let f = o(l), p = t(d, [
+		"maxChunks",
+		"maxArtifactBytes",
+		"maxManifestBytes",
+		"codecLimits"
+	], []), m = (e, t, n, r) => s(Object.hasOwn(p, e) ? p[e] : t, n, r), h = m("maxChunks", 256, 1, 4096), g = m("maxArtifactBytes", 52428800, 64, 268435456), _ = m("maxManifestBytes", 262144, 256, 16777216), v = i(Object.hasOwn(p, "codecLimits") ? p.codecLimits : {}), y = a(u, h, (e) => e), b = [];
+	if (!y.length) return n();
+	let x = 0;
+	for (let i of y) {
+		let a = t(i, [
+			"kind",
+			"formatVersion",
+			"address",
+			"version",
+			"width",
+			"height",
+			"tileSizeRaw",
+			"palette",
+			"runs",
+			"sampleSpacingRaw",
+			"baseHeightRaw",
+			"heightQuantumRaw",
+			"heights",
+			"extentXRaw",
+			"extentYRaw",
+			"extentZRaw",
+			"shapes",
+			"side",
+			"voxelSizeRaw",
+			"sections"
+		], ["kind"]).kind;
+		if (a !== "2d-tiles" && a !== "2d-heightfield" && a !== "3d-voxel" && a !== "3d-shapes") return n();
+		let o = await r(i, v.get(a) ?? {});
+		if (x += o.bytes().byteLength, x > g) throw new e({
+			budget: "geometryImportArtifactBytes",
+			limit: g
+		});
+		b.push(o);
+	}
+	let S = b[0].chunk, C = c({
+		tenantId: f,
+		kind: S.kind,
+		worldId: S.address.worldId,
+		version: S.version,
+		chunks: b.map((e) => ({
+			tenantId: f,
+			kind: e.chunk.kind,
+			version: e.chunk.version,
+			...e.chunk.address,
+			blobSha256: e.blobSha256,
+			contentSha256: e.contentSha256
+		}))
+	}, h, _);
+	return Object.freeze({
+		manifest: C,
+		artifacts: Object.freeze(b)
+	});
+};
+//#endregion
+export { l as prepareGeometryImportPublication };

package/dist/geometryImportTiled.js

@@ -0,0 +1,39 @@
+import { BudgetExceeded as e } from "./errors.js";
+import { geometryTileRefusal as t } from "./geometryTileCodec.js";
+import { admitTileImport as n, collectImportedTiles as r, importArray as i, importInteger as a, importName as o, importRecord as s } from "./geometryImportTiles.js";
+//#region src/geometryImportTiled.ts
+var c = (c, l) => {
+	let u = n(l, ["layerPath"], ["layerPath"]), d = u.parse(c), f = i(u.data.layerPath, 32).map(o), p = a(d.tilewidth, 1, 1048576), m = a(d.tileheight, 1, 1048576);
+	if (d.type !== "map" || d.orientation !== "orthogonal" || p !== m || typeof d.infinite != "boolean" || !f.length || i(u.data.materials, 4096).some((e) => s(e).flip !== void 0 && s(e).flip !== 0)) return t();
+	let h = d, g = u.x, _ = u.y, v = (e) => {
+		let n = a(e ?? 0);
+		return n % p === 0 ? n / p : t();
+	};
+	for (let e = 0; e < f.length; e++) {
+		let n = i(h.layers, u.maxRegions).map(s).filter((t) => t.name === f[e]);
+		if (n.length !== 1 || (h = n[0], g += a(h.x ?? 0) + v(h.offsetx), _ += a(h.y ?? 0) + v(h.offsety), e + 1 < f.length && h.type !== "group")) return t();
+	}
+	if (h.type !== "tilelayer" || h.encoding !== void 0 && h.encoding !== "csv" || h.compression !== void 0 && h.compression !== "") return t();
+	let y = d.infinite ? i(h.chunks, u.maxRegions).map(s) : [h], b = [];
+	if (d.infinite && Object.hasOwn(h, "data")) return t();
+	let x = 0;
+	for (let n of y) {
+		let r = a(n.width, 1, u.maxCells), o = a(n.height, 1, u.maxCells), s = r * o;
+		if (x += s, x > u.maxCells) throw new e({
+			budget: "geometryImportCells",
+			limit: u.maxCells
+		});
+		let c = i(n.data, s);
+		if (c.length !== s) return t();
+		b.push({
+			x: a(g + (d.infinite ? a(n.x) : 0)),
+			y: a(_ + (d.infinite ? a(n.y) : 0)),
+			width: r,
+			height: o,
+			cells: c.map((e) => u.selectMaterial(e))
+		});
+	}
+	return r(u, b);
+};
+//#endregion
+export { c as importTiledGeometry };