@genex-ai/multiplayer 0.17.6 → 0.17.9

package/dist/chunk-TVTVIMIH.js

@@ -0,0 +1,675 @@
+// src/world-fit/level-build.ts
+var LevelRefusalCode = {
+  /** Not a glb or a glTF, or not a file that can be read. */
+  NotGltf: "not_gltf",
+  /** A glb's chunks do not add up. */
+  BadContainer: "bad_container",
+  /** glTF 1 or a version this reader does not take. */
+  BadVersion: "bad_version",
+  /** An index that names nothing: a scene, a node, a mesh, an accessor, a buffer. */
+  BadReference: "bad_reference",
+  /** An accessor or a view that does not fit what it reads or is not what it must be. */
+  BadAccessor: "bad_accessor",
+  /** A triangle's index past its vertices. */
+  BadIndex: "bad_index",
+  /** A transform or a field of the wrong shape. */
+  BadValue: "bad_value",
+  /** NaN, an infinity, or a coordinate past the format's range. */
+  NotFinite: "not_finite",
+  /** A cycle, or a node with two parents. */
+  NodeCycle: "node_cycle",
+  /** Past a stated limit (LEVEL_LIMITS). */
+  TooLarge: "too_large",
+  /** Draco or meshopt on something that collides. */
+  Compressed: "compressed",
+  /** A required extension this reader cannot honour. */
+  UnknownExtension: "unknown_extension",
+  /** A buffer URI that leaves the input's folder, names the network, or is not a plain file. */
+  UriRefused: "uri_refused",
+  /** A skinned mesh that collides. */
+  Skinned: "skinned",
+  /** A mesh posed by morph targets that collides. */
+  Morphed: "morphed",
+  /** A kind of three.js object the helper cannot read. */
+  Unsupported: "unsupported",
+  /** A mesh with no triangle left of any area. */
+  Degenerate: "degenerate",
+  /** More triangles on one edge than any surface has. */
+  NonManifold: "non_manifold",
+  /** No spawn: a fit starts from where a hull can stand. */
+  NoSpawn: "no_spawn",
+  /** Nothing collides. */
+  NoSurface: "no_surface",
+  /** A mark that is not one. */
+  BadMark: "bad_mark"
+};
+var LevelRefusal = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`level: ${message} (${code})`);
+    this.name = "LevelRefusal";
+    this.code = code;
+  }
+};
+var LEVEL_LIMITS = {
+  /** One glb, or one external buffer, and all buffers together. */
+  maxFileBytes: 2 ** 30,
+  /** Triangles in the level, instances counted. A fit reads a scene of this size; art past it needs a proxy. */
+  maxTriangles: 8e6,
+  /** Vertices one accessor may read. */
+  maxVertices: 24e6,
+  maxNodes: 1e6,
+  maxDepth: 1024,
+  /** Points a `hull` holds, as the scene format says. */
+  maxHullPoints: 4096,
+  /** No surface puts more triangles on one edge: past this it is junk, or an attack on what reads it. */
+  maxTrianglesOnEdge: 64
+};
+var LevelCollide = { Both: "both", Move: "move", Shot: "shot", None: "none" };
+var LevelShape = { Mesh: "mesh", Box: "box", Hull: "hull" };
+var NAME_MARKS = [
+  ["nocol_", { collide: LevelCollide.None }],
+  ["clip_", { collide: LevelCollide.Move }],
+  ["shot_", { collide: LevelCollide.Shot }],
+  ["box_", { shape: LevelShape.Box }],
+  ["hull_", { shape: LevelShape.Hull }],
+  ["movable_", { movable: true }],
+  ["prop_", { prop: true }],
+  ["spawn_", { spawn: true }]
+];
+var MARK_FIELDS = /* @__PURE__ */ new Set(["collide", "shape", "movable", "prop", "spawn", "tags"]);
+var SETTING_FIELDS = /* @__PURE__ */ new Set(["unitsPerMeter", "hull"]);
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function splitNameMarks(name) {
+  let rest = name;
+  let mark = {};
+  for (; ; ) {
+    const lower = rest.toLowerCase();
+    const found = NAME_MARKS.find(([prefix]) => lower.startsWith(prefix));
+    if (found === void 0) return { rest, mark };
+    rest = rest.slice(found[0].length);
+    mark = { ...mark, ...found[1] };
+  }
+}
+function extrasMark(raw, where, allowSettings) {
+  if (raw === void 0) return {};
+  if (!isObject(raw)) throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex is not an object`);
+  for (const key of Object.keys(raw)) {
+    if (MARK_FIELDS.has(key) || allowSettings && SETTING_FIELDS.has(key)) continue;
+    throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex.${key} is not a mark (${[...MARK_FIELDS].join(", ")})`);
+  }
+  const out = {};
+  if (raw.collide !== void 0) {
+    if (!Object.values(LevelCollide).includes(raw.collide)) throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex.collide is not ${Object.values(LevelCollide).join(", ")}`);
+    out.collide = raw.collide;
+  }
+  if (raw.shape !== void 0) {
+    if (!Object.values(LevelShape).includes(raw.shape)) throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex.shape is not ${Object.values(LevelShape).join(", ")}`);
+    out.shape = raw.shape;
+  }
+  for (const key of ["movable", "prop", "spawn"]) {
+    if (raw[key] === void 0) continue;
+    if (typeof raw[key] !== "boolean") throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex.${key} is not true or false`);
+    out[key] = raw[key];
+  }
+  if (raw.tags !== void 0) {
+    const tags = raw.tags;
+    const fine = Array.isArray(tags) && tags.length <= MAX_TAGS && tags.every((t) => typeof t === "string" && t.length > 0 && t.length <= MAX_NAME_CHARS);
+    if (!fine) throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex.tags is not a list of up to ${MAX_TAGS} names`);
+    out.tags = tags;
+  }
+  return out;
+}
+function levelMarkOf(name, genex, where = name, allowSettings = false) {
+  return { ...splitNameMarks(name).mark, ...extrasMark(genex, where, allowSettings) };
+}
+function inheritMark(parent, own) {
+  const { spawn: _notInherited, ...passed } = parent;
+  const tags = [.../* @__PURE__ */ new Set([...parent.tags ?? [], ...own.tags ?? []])];
+  return { ...passed, ...own, ...tags.length > 0 ? { tags } : {} };
+}
+function levelSettingsOf(genex, where) {
+  if (genex === void 0) return {};
+  if (!isObject(genex)) throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex is not an object`);
+  const out = {};
+  const units = genex.unitsPerMeter;
+  if (units !== void 0) {
+    if (typeof units !== "number" || !Number.isFinite(units) || units <= 0) throw new LevelRefusal(LevelRefusalCode.BadMark, `${where}: extras.genex.unitsPerMeter is not above zero`);
+    out.unitsPerMeter = units;
+  }
+  if (genex.hull !== void 0) out.hull = hullOf(genex.hull, where);
+  return out;
+}
+function hullOf(raw, where) {
+  const bad = (field) => new LevelRefusal(LevelRefusalCode.BadMark, `${where}: hull.${field} is not a usable size`);
+  if (!isObject(raw)) throw bad("");
+  const size = (field, positive) => {
+    const v = raw[field];
+    const fine = typeof v === "number" && Number.isFinite(v) && Math.abs(v) <= MAX_COORD && (positive ? v > 0 : v >= 0);
+    if (!fine) throw bad(field);
+    return v;
+  };
+  const hull = { radius: size("radius", true), height: size("height", true), crouchHeight: size("crouchHeight", true), step: size("step", true), jump: size("jump", false), leap: size("leap", false) };
+  if (hull.crouchHeight > hull.height) throw bad("crouchHeight");
+  return hull;
+}
+function multiplyMatrix(a, b) {
+  const out = new Float64Array(16);
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 4; col++) {
+      const k = col * 4;
+      out[k + row] = a[row] * b[k] + a[row + 4] * b[k + 1] + a[row + 8] * b[k + 2] + a[row + 12] * b[k + 3];
+    }
+  }
+  return out;
+}
+function composeMatrix(t, q, s) {
+  const [x, y, z, w] = q;
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const xy = x * y2;
+  const xz = x * z2;
+  const yy = y * y2;
+  const yz = y * z2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  const [sx, sy, sz] = s;
+  return Float64Array.of(
+    (1 - (yy + zz)) * sx,
+    (xy + wz) * sx,
+    (xz - wy) * sx,
+    0,
+    (xy - wz) * sy,
+    (1 - (xx + zz)) * sy,
+    (yz + wx) * sy,
+    0,
+    (xz + wy) * sz,
+    (yz - wx) * sz,
+    (1 - (xx + yy)) * sz,
+    0,
+    t[0],
+    t[1],
+    t[2],
+    1
+  );
+}
+var IDENTITY_MATRIX = Float64Array.of(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+var SNAP = 256;
+var MAX_COORD = 1e9;
+var MAX_NAME_CHARS = 256;
+var MAX_TAGS = 64;
+var MIN_CROSS_SQUARED = 1e-12;
+var SQUARE_TOLERANCE = 1e-6;
+var ON_AXIS = 1 - 1e-9;
+var SHOWN_NAMES = 8;
+var CUBE_CORNERS = 8;
+var CUBE_TRIANGLES = 12;
+var CUBE_FACES = 6;
+var FACE_COVER_TOLERANCE = 1e-6;
+var snap = (v) => Math.fround(Math.round(v * SNAP) / SNAP) + 0;
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64(bytes) {
+  const out = new Uint8Array(Math.ceil(bytes.length / 3) * 4);
+  const alphabet = new TextEncoder().encode(BASE64);
+  let o = 0;
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1] ?? 0;
+    const c = bytes[i + 2] ?? 0;
+    out[o++] = alphabet[a >> 2];
+    out[o++] = alphabet[(a & 3) << 4 | b >> 4];
+    out[o++] = i + 1 < bytes.length ? alphabet[(b & 15) << 2 | c >> 6] : 61;
+    out[o++] = i + 2 < bytes.length ? alphabet[c & 63] : 61;
+  }
+  return new TextDecoder().decode(out);
+}
+function f32le(values) {
+  const bytes = new Uint8Array(values.length * 4);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < values.length; i++) view.setFloat32(i * 4, values[i], true);
+  return { f32le: base64(bytes) };
+}
+function u32le(values) {
+  const bytes = new Uint8Array(values.length * 4);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < values.length; i++) view.setUint32(i * 4, values[i], true);
+  return { u32le: base64(bytes) };
+}
+var Welder = class {
+  positions = [];
+  slots;
+  mask;
+  constructor(expected) {
+    let size = 16;
+    while (size < expected * 2) size *= 2;
+    this.slots = new Int32Array(size).fill(-1);
+    this.mask = size - 1;
+  }
+  add(x, y, z) {
+    const h = (Math.imul(Math.round(x * SNAP) | 0, 73856093) ^ Math.imul(Math.round(y * SNAP) | 0, 19349663) ^ Math.imul(Math.round(z * SNAP) | 0, 83492791)) >>> 0;
+    let slot = h & this.mask;
+    for (; ; ) {
+      const at = this.slots[slot];
+      if (at < 0) break;
+      const p = this.positions;
+      if (p[at * 3] === x && p[at * 3 + 1] === y && p[at * 3 + 2] === z) return at;
+      slot = slot + 1 & this.mask;
+    }
+    const index = this.positions.length / 3;
+    this.slots[slot] = index;
+    this.positions.push(x, y, z);
+    return index;
+  }
+};
+function checkPrimitive(p, name) {
+  const { positions, indices } = p;
+  for (let i = 0; i < positions.length; i++) {
+    const v = positions[i];
+    if (!Number.isFinite(v) || Math.abs(v) > MAX_COORD) throw new LevelRefusal(LevelRefusalCode.NotFinite, `${name}: vertex ${Math.floor(i / 3)} holds ${v}, which is no coordinate`);
+  }
+  const count = positions.length / 3;
+  for (let i = 0; i < indices.length; i++) {
+    if (indices[i] >= count) throw new LevelRefusal(LevelRefusalCode.BadIndex, `${name}: index ${indices[i]} is past the ${count} vertices`);
+  }
+}
+function boxOf(positions, triangles, vertices) {
+  if (vertices.length !== CUBE_CORNERS || triangles.length !== CUBE_TRIANGLES * 3) return null;
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (const v of vertices) {
+    for (let a = 0; a < 3; a++) {
+      const value = positions[v * 3 + a];
+      if (value < min[a]) min[a] = value;
+      if (value > max[a]) max[a] = value;
+    }
+  }
+  const size = [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
+  if (size.some((s) => s <= 0)) return null;
+  const corners = /* @__PURE__ */ new Set();
+  for (const v of vertices) {
+    let corner = 0;
+    for (let a = 0; a < 3; a++) {
+      const value = positions[v * 3 + a];
+      if (value === max[a]) corner |= 1 << a;
+      else if (value !== min[a]) return null;
+    }
+    corners.add(corner);
+  }
+  if (corners.size !== CUBE_CORNERS) return null;
+  const covered = new Float64Array(CUBE_FACES);
+  for (let t = 0; t < triangles.length; t += 3) {
+    const face = faceOf(positions, triangles, t, min, max);
+    if (face < 0) return null;
+    covered[face] = covered[face] + triangleArea(positions, triangles, t);
+  }
+  for (let a = 0; a < 3; a++) {
+    const want = size[(a + 1) % 3] * size[(a + 2) % 3];
+    for (const face of [a * 2, a * 2 + 1]) {
+      if (Math.abs(covered[face] - want) > want * FACE_COVER_TOLERANCE) return null;
+    }
+  }
+  return { min, max };
+}
+function faceOf(positions, tri, t, min, max) {
+  for (let a = 0; a < 3; a++) {
+    const p0 = positions[tri[t] * 3 + a];
+    const p1 = positions[tri[t + 1] * 3 + a];
+    const p2 = positions[tri[t + 2] * 3 + a];
+    if (p0 === p1 && p1 === p2) {
+      if (p0 === min[a]) return a * 2;
+      if (p0 === max[a]) return a * 2 + 1;
+    }
+  }
+  return -1;
+}
+function triangleArea(p, tri, t) {
+  const a = tri[t] * 3;
+  const b = tri[t + 1] * 3;
+  const c = tri[t + 2] * 3;
+  const ux = p[b] - p[a];
+  const uy = p[b + 1] - p[a + 1];
+  const uz = p[b + 2] - p[a + 2];
+  const vx = p[c] - p[a];
+  const vy = p[c + 1] - p[a + 1];
+  const vz = p[c + 2] - p[a + 2];
+  const cx = uy * vz - uz * vy;
+  const cy = uz * vx - ux * vz;
+  const cz = ux * vy - uy * vx;
+  return Math.sqrt(cx * cx + cy * cy + cz * cz) / 2;
+}
+function analyse(p, findBoxes) {
+  if (!findBoxes) return { boxes: [], rest: p.indices };
+  const welder = new Welder(p.positions.length / 3);
+  const welded = new Int32Array(p.positions.length / 3);
+  for (let i = 0; i < welded.length; i++) welded[i] = welder.add(p.positions[i * 3], p.positions[i * 3 + 1], p.positions[i * 3 + 2]);
+  const parent = Int32Array.from({ length: welder.positions.length / 3 }, (_, i) => i);
+  const find = (x) => {
+    let r = x;
+    while (parent[r] !== r) {
+      parent[r] = parent[parent[r]];
+      r = parent[r];
+    }
+    return r;
+  };
+  const tri = p.indices;
+  for (let t = 0; t < tri.length; t += 3) {
+    const a = find(welded[tri[t]]);
+    parent[find(welded[tri[t + 1]])] = a;
+    parent[find(welded[tri[t + 2]])] = a;
+  }
+  const pieces = /* @__PURE__ */ new Map();
+  for (let t = 0; t < tri.length; t += 3) {
+    const root = find(welded[tri[t]]);
+    let list = pieces.get(root);
+    if (list === void 0) {
+      list = [];
+      pieces.set(root, list);
+    }
+    list.push(tri[t], tri[t + 1], tri[t + 2]);
+  }
+  const weldedPositions = Float64Array.from(welder.positions);
+  const boxes = [];
+  const rest = [];
+  for (const list of pieces.values()) {
+    const found = list.length === CUBE_TRIANGLES * 3 ? pieceBox(list, welded, weldedPositions) : null;
+    if (found === null) {
+      for (const v of list) rest.push(v);
+      continue;
+    }
+    boxes.push(found);
+  }
+  return { boxes, rest: Uint32Array.from(rest) };
+}
+function pieceBox(list, welded, positions) {
+  const triangles = new Uint32Array(list.length);
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < list.length; i++) {
+    const v = welded[list[i]];
+    triangles[i] = v;
+    seen.add(v);
+  }
+  const bounds = boxOf(positions, triangles, [...seen]);
+  return bounds === null ? null : { ...bounds, triangles: Uint32Array.from(list) };
+}
+function transformPoint(m, x, y, z, scale, out) {
+  const wx = m[0] * x + m[4] * y + m[8] * z + m[12];
+  const wy = m[1] * x + m[5] * y + m[9] * z + m[13];
+  const wz = m[2] * x + m[6] * y + m[10] * z + m[14];
+  out[0] = wx * scale;
+  out[1] = -wz * scale;
+  out[2] = wy * scale;
+}
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+function placeBox(box, m, scale) {
+  const point = new Float64Array(3);
+  const halfLocal = [0, 1, 2].map((a) => (box.max[a] - box.min[a]) / 2);
+  const mid = [0, 1, 2].map((a) => (box.max[a] + box.min[a]) / 2);
+  transformPoint(m, mid[0], mid[1], mid[2], scale, point);
+  const center = [snap(point[0]), snap(point[1]), snap(point[2])];
+  const sides = [0, 1, 2].map((a) => {
+    const lx = m[a * 4] * halfLocal[a] * scale;
+    const ly = m[a * 4 + 1] * halfLocal[a] * scale;
+    const lz = m[a * 4 + 2] * halfLocal[a] * scale;
+    return [lx, -lz, ly];
+  });
+  const lengths = sides.map((s) => Math.sqrt(dot(s, s)));
+  if (lengths.some((l) => l === 0)) return null;
+  for (const [a, b] of [[0, 1], [1, 2], [0, 2]]) {
+    if (Math.abs(dot(sides[a], sides[b])) > SQUARE_TOLERANCE * lengths[a] * lengths[b]) return cornersHull(box, m, scale);
+  }
+  const axes = sides.map((s, i) => s.map((v) => v / lengths[i]));
+  const onWorld = axes.map((u) => u.findIndex((v) => Math.abs(v) >= ON_AXIS));
+  if (new Set(onWorld).size === 3 && !onWorld.includes(-1)) {
+    const half = [0, 0, 0];
+    onWorld.forEach((w, i) => {
+      half[w] = snap(lengths[i]);
+    });
+    return { kind: "box", center, half };
+  }
+  const cross = [axes[0][1] * axes[1][2] - axes[0][2] * axes[1][1], axes[0][2] * axes[1][0] - axes[0][0] * axes[1][2], axes[0][0] * axes[1][1] - axes[0][1] * axes[1][0]];
+  const third = dot(cross, axes[2]) < 0 ? axes[2].map((v) => -v) : axes[2];
+  return { kind: "box", center, axes: [axes[0], axes[1], third].map((u) => u.map((v) => Math.fround(v) + 0)), half: lengths.map(snap) };
+}
+function cornersHull(box, m, scale) {
+  const point = new Float64Array(3);
+  const points = [];
+  for (let corner = 0; corner < CUBE_CORNERS; corner++) {
+    const x = corner & 1 ? box.max[0] : box.min[0];
+    const y = corner & 2 ? box.max[1] : box.min[1];
+    const z = corner & 4 ? box.max[2] : box.min[2];
+    transformPoint(m, x, y, z, scale, point);
+    points.push([snap(point[0]), snap(point[1]), snap(point[2])]);
+  }
+  return { kind: "hull", points };
+}
+function boundsOf(p) {
+  if (p.indices.length === 0) return null;
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < p.indices.length; i++) {
+    const v = p.indices[i] * 3;
+    for (let a = 0; a < 3; a++) {
+      const value = p.positions[v + a];
+      if (value < min[a]) min[a] = value;
+      if (value > max[a]) max[a] = value;
+    }
+  }
+  return { min, max };
+}
+function edgeLoad(indices) {
+  const edges = new Float64Array(indices.length);
+  const vertices = 2 ** 26;
+  for (let t = 0, e = 0; t < indices.length; t += 3) {
+    for (let k = 0; k < 3; k++) {
+      const a = indices[t + k];
+      const b = indices[t + (k + 1) % 3];
+      edges[e++] = a < b ? a * vertices + b : b * vertices + a;
+    }
+  }
+  edges.sort();
+  let overTwo = 0;
+  let most = 0;
+  let run = 0;
+  for (let i = 0; i < edges.length; i++) {
+    run = i > 0 && edges[i] === edges[i - 1] ? run + 1 : 1;
+    if (run > most) most = run;
+    if (run === 3) overTwo++;
+  }
+  return { overTwo, most };
+}
+function placeTriangles(p, triangles, m, scale, name) {
+  const world = new Float64Array(p.positions.length);
+  const point = new Float64Array(3);
+  const done = new Uint8Array(p.positions.length / 3);
+  const welder = new Welder(Math.min(triangles.length, p.positions.length / 3));
+  const out = [];
+  let dropped = 0;
+  const place = (v) => {
+    if (done[v] === 1) return;
+    done[v] = 1;
+    transformPoint(m, p.positions[v * 3], p.positions[v * 3 + 1], p.positions[v * 3 + 2], scale, point);
+    for (let a = 0; a < 3; a++) {
+      const value = point[a];
+      if (!Number.isFinite(value) || Math.abs(value) > MAX_COORD) throw new LevelRefusal(LevelRefusalCode.NotFinite, `${name}: a vertex lands at ${value}, past the scene's range`);
+      world[v * 3 + a] = snap(value);
+    }
+  };
+  for (let t = 0; t < triangles.length; t += 3) {
+    const a = triangles[t];
+    const b = triangles[t + 1];
+    const c = triangles[t + 2];
+    place(a);
+    place(b);
+    place(c);
+    const ux = world[b * 3] - world[a * 3];
+    const uy = world[b * 3 + 1] - world[a * 3 + 1];
+    const uz = world[b * 3 + 2] - world[a * 3 + 2];
+    const vx = world[c * 3] - world[a * 3];
+    const vy = world[c * 3 + 1] - world[a * 3 + 1];
+    const vz = world[c * 3 + 2] - world[a * 3 + 2];
+    const cx = uy * vz - uz * vy;
+    const cy = uz * vx - ux * vz;
+    const cz = ux * vy - uy * vx;
+    if (cx * cx + cy * cy + cz * cz <= MIN_CROSS_SQUARED) {
+      dropped++;
+      continue;
+    }
+    out.push(welder.add(world[a * 3], world[a * 3 + 1], world[a * 3 + 2]), welder.add(world[b * 3], world[b * 3 + 1], world[b * 3 + 2]), welder.add(world[c * 3], world[c * 3 + 1], world[c * 3 + 2]));
+  }
+  return { vertices: welder.positions, indices: out, dropped };
+}
+function channelsOf(collide) {
+  if (collide === LevelCollide.Move) return { channels: ["move"] };
+  if (collide === LevelCollide.Shot) return { channels: ["shot"] };
+  return {};
+}
+function actorTags(mark) {
+  const tags = new Set(mark.tags ?? []);
+  if (mark.movable === true) tags.add("movable");
+  if (mark.prop === true) tags.add("prop");
+  return [...tags];
+}
+function actorNames(meshes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const m of meshes) counts.set(m.name, (counts.get(m.name) ?? 0) + 1);
+  const used = /* @__PURE__ */ new Map();
+  return meshes.map((m) => {
+    const wanted = counts.get(m.name) > 1 ? m.path : m.name;
+    const seen = used.get(wanted) ?? 0;
+    used.set(wanted, seen + 1);
+    const name = seen === 0 ? wanted : `${wanted}#${seen + 1}`;
+    return name.length <= MAX_NAME_CHARS ? name : `\u2026${name.slice(name.length - MAX_NAME_CHARS + 1)}`;
+  });
+}
+function surfacesOf(node, name, scale, analysed, notes, tally) {
+  const surfaces = [];
+  const channels = channelsOf(node.mark.collide);
+  const shape = node.mark.shape;
+  let dropped = 0;
+  let overTwo = 0;
+  for (const p of node.primitives) checkPrimitive(p, name);
+  for (const matrix of node.instances) {
+    for (const p of node.primitives) {
+      if (shape === LevelShape.Hull || shape === LevelShape.Box) {
+        const placed = shape === LevelShape.Box ? markedBox(p, matrix, scale) : markedHull(p, matrix, scale, name);
+        if (placed === null) continue;
+        if (placed.kind === "box") tally.boxes++;
+        else tally.hulls++;
+        surfaces.push({ ...placed, ...channels });
+        continue;
+      }
+      let found = analysed.get(p);
+      if (found === void 0) {
+        found = analyse(p, shape !== LevelShape.Mesh);
+        analysed.set(p, found);
+      }
+      const flattened = [];
+      for (const box of found.boxes) {
+        const placed = placeBox(box, matrix, scale);
+        if (placed === null) {
+          flattened.push(box.triangles);
+          continue;
+        }
+        if (placed.kind === "box") tally.boxes++;
+        else tally.hulls++;
+        surfaces.push({ ...placed, ...channels });
+      }
+      for (const triangles of [...flattened, found.rest]) {
+        if (triangles.length === 0) continue;
+        const placed = placeTriangles(p, triangles, matrix, scale, name);
+        dropped += placed.dropped;
+        if (placed.indices.length === 0) continue;
+        const load = edgeLoad(placed.indices);
+        if (load.most > LEVEL_LIMITS.maxTrianglesOnEdge) throw new LevelRefusal(LevelRefusalCode.NonManifold, `${name}: one edge holds ${load.most} triangles, past the ${LEVEL_LIMITS.maxTrianglesOnEdge} a surface can (repeated or fanned faces); clean the mesh or give it a collision proxy`);
+        overTwo += load.overTwo;
+        tally.meshes++;
+        tally.triangles += placed.indices.length / 3;
+        surfaces.push({ kind: "mesh", vertices: f32le(placed.vertices), indices: u32le(placed.indices), ...channels });
+      }
+    }
+  }
+  if (dropped > 0) notes.push(`${name}: dropped ${dropped} zero-area triangles`);
+  if (overTwo > 0) notes.push(`${name}: kept ${overTwo} non-manifold edges (three or more triangles on one edge)`);
+  return surfaces;
+}
+function markedBox(p, matrix, scale) {
+  const bounds = boundsOf(p);
+  return bounds === null ? null : placeBox(bounds, matrix, scale);
+}
+function markedHull(p, matrix, scale, name) {
+  if (p.indices.length === 0) return null;
+  const point = new Float64Array(3);
+  const welder = new Welder(Math.min(p.positions.length / 3, LEVEL_LIMITS.maxHullPoints * 2));
+  const used = new Set(p.indices);
+  for (const v of used) {
+    transformPoint(matrix, p.positions[v * 3], p.positions[v * 3 + 1], p.positions[v * 3 + 2], scale, point);
+    welder.add(snap(point[0]), snap(point[1]), snap(point[2]));
+    if (welder.positions.length / 3 > LEVEL_LIMITS.maxHullPoints) throw new LevelRefusal(LevelRefusalCode.TooLarge, `${name}: a hull holds up to ${LEVEL_LIMITS.maxHullPoints} points and this mesh has more; simplify it or leave the hull mark off`);
+  }
+  const points = [];
+  for (let i = 0; i < welder.positions.length; i += 3) points.push([welder.positions[i], welder.positions[i + 1], welder.positions[i + 2]]);
+  return { kind: "hull", points };
+}
+function buildLevelScene(input, options) {
+  const notes = [...input.notes];
+  const tally = { boxes: 0, hulls: 0, meshes: 0, triangles: 0 };
+  const names = actorNames(input.meshes);
+  const analysed = /* @__PURE__ */ new Map();
+  const actors = [];
+  input.meshes.forEach((node, i) => {
+    const name = names[i];
+    const surfaces = surfacesOf(node, name, options.scale, analysed, notes, tally);
+    if (surfaces.length === 0) throw new LevelRefusal(LevelRefusalCode.Degenerate, `${name}: no triangle has any area (a scale of zero, or every triangle repeats a point); fix the mesh or mark it nocol_`);
+    const tags = actorTags(node.mark);
+    actors.push({ name, ...tags.length > 0 ? { tags } : {}, surfaces });
+  });
+  if (actors.length === 0) throw new LevelRefusal(LevelRefusalCode.NoSurface, "nothing collides: the level holds no mesh, or every mesh is marked nocol_");
+  const point = new Float64Array(3);
+  const spawns = input.spawns.map((s) => {
+    transformPoint(IDENTITY_MATRIX, s.at[0], s.at[1], s.at[2], options.scale, point);
+    const at = [snap(point[0]), snap(point[1]), snap(point[2])];
+    if (at.some((v) => Math.abs(v) > MAX_COORD)) throw new LevelRefusal(LevelRefusalCode.NotFinite, `spawn ${s.name}: past the scene's range`);
+    return { at, ...s.name === "" ? {} : { name: s.name.slice(0, MAX_NAME_CHARS) }, ...s.tags.length > 0 ? { tags: s.tags } : {} };
+  });
+  for (const s of options.spawns ?? []) spawns.push({ at: [s.at[0], s.at[1], s.at[2]], ...s.name === void 0 ? {} : { name: s.name }, ...s.tags === void 0 ? {} : { tags: s.tags } });
+  if (spawns.length === 0) throw new LevelRefusal(LevelRefusalCode.NoSpawn, "no spawn: name an empty node spawn_<name> (or set extras.genex.spawn) where a player starts; the fit works out what a hull can reach from there");
+  const scene = {
+    format: "genex-world-scene",
+    version: 1,
+    unitsPerMeter: options.unitsPerMeter,
+    source: options.source,
+    ...options.hull === void 0 ? {} : { hull: options.hull },
+    actors,
+    spawns
+  };
+  return { scene, notes, stats: { actors: actors.length, ...tally, spawns: spawns.length }, json: `${JSON.stringify(scene)}
+` };
+}
+function namesInRefusal(names) {
+  const shown = names.slice(0, SHOWN_NAMES).join(", ");
+  return names.length > SHOWN_NAMES ? `${shown} and ${names.length - SHOWN_NAMES} more` : shown;
+}
+function spawnNameOf(name) {
+  return splitNameMarks(name).rest;
+}
+
+export {
+  LevelRefusalCode,
+  LevelRefusal,
+  LEVEL_LIMITS,
+  LevelCollide,
+  LevelShape,
+  levelMarkOf,
+  inheritMark,
+  levelSettingsOf,
+  multiplyMatrix,
+  composeMatrix,
+  IDENTITY_MATRIX,
+  buildLevelScene,
+  namesInRefusal,
+  spawnNameOf
+};