@genex-ai/multiplayer 0.17.6 → 0.17.8

package/dist/world-fit/index.js

@@ -0,0 +1,4763 @@
+import {
+  IDENTITY_MATRIX,
+  LEVEL_LIMITS,
+  LevelCollide,
+  LevelRefusal,
+  LevelRefusalCode,
+  LevelShape,
+  buildLevelScene,
+  composeMatrix,
+  inheritMark,
+  levelMarkOf,
+  levelSettingsOf,
+  multiplyMatrix,
+  namesInRefusal,
+  spawnNameOf
+} from "../chunk-TVTVIMIH.js";
+import {
+  ClaimVerdict,
+  ShotWorldCost
+} from "../chunk-TSYEWPVO.js";
+import {
+  WorldLimits
+} from "../chunk-2NGXXQDS.js";
+
+// src/world-fit/lattice.ts
+function makeLattice(h, min, max) {
+  const x0 = Math.floor(min[0] / h) * h;
+  const y0 = Math.floor(min[1] / h) * h;
+  const z0 = Math.floor(min[2] / h) * h;
+  const nx = Math.max(1, Math.ceil((max[0] - x0) / h));
+  const ny = Math.max(1, Math.ceil((max[1] - y0) / h));
+  const nz = Math.max(1, Math.ceil((max[2] - z0) / h));
+  return { h, x0, y0, z0, nx, ny, nz, w: Math.ceil(nz / 32) };
+}
+var CELL_EPSILON = 1e-4;
+var cellFloor = (v) => Math.floor(v + CELL_EPSILON);
+var cellCeil = (v) => Math.ceil(v - CELL_EPSILON);
+var newLayer = (l) => new Uint32Array(l.nx * l.ny * l.w);
+var cellCount = (l) => l.nx * l.ny * l.nz;
+var centreX = (l, i) => l.x0 + (i + 0.5) * l.h;
+var centreY = (l, j) => l.y0 + (j + 0.5) * l.h;
+var plane = (l, k) => l.z0 + k * l.h;
+function testBit(layer, offset, k) {
+  return (layer[offset + (k >>> 5)] >>> (k & 31) & 1) === 1;
+}
+function setBit(layer, offset, k) {
+  const at = offset + (k >>> 5);
+  layer[at] = layer[at] | 1 << (k & 31);
+}
+function wordMask(first, a, b) {
+  const lo = Math.max(a - first, 0);
+  const hi = Math.min(b - first, 31);
+  if (lo > hi) return 0;
+  const top = hi === 31 ? 4294967295 : (1 << hi + 1) - 1 >>> 0;
+  return (top & ~((1 << lo) - 1)) >>> 0;
+}
+function setRun(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  if (lo > hi) return;
+  for (let word = lo >>> 5; word <= hi >>> 5; word++) {
+    const at = offset + word;
+    layer[at] = (layer[at] | wordMask(word * 32, lo, hi)) >>> 0;
+  }
+}
+function clearRun(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  if (lo > hi) return;
+  for (let word = lo >>> 5; word <= hi >>> 5; word++) {
+    const at = offset + word;
+    layer[at] = (layer[at] & ~wordMask(word * 32, lo, hi)) >>> 0;
+  }
+}
+function anyInRun(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  for (let word = lo >>> 5; word <= hi >>> 5; word++) {
+    if ((layer[offset + word] & wordMask(word * 32, lo, hi)) !== 0) return true;
+  }
+  return false;
+}
+function popcount(v) {
+  let n = v - (v >>> 1 & 1431655765);
+  n = (n & 858993459) + (n >>> 2 & 858993459);
+  return (n + (n >>> 4) & 252645135) * 16843009 >>> 24;
+}
+function countInRun(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  let count = 0;
+  for (let word = lo >>> 5; word <= hi >>> 5; word++) count += popcount((layer[offset + word] & wordMask(word * 32, lo, hi)) >>> 0);
+  return count;
+}
+function firstSet(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  for (let word = lo >>> 5; word <= hi >>> 5; word++) {
+    const v = (layer[offset + word] & wordMask(word * 32, lo, hi)) >>> 0;
+    if (v !== 0) return word * 32 + (31 - Math.clz32(v & -v));
+  }
+  return -1;
+}
+function firstClear(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  for (let word = lo >>> 5; word <= hi >>> 5; word++) {
+    const v = (~layer[offset + word] & wordMask(word * 32, lo, hi)) >>> 0;
+    if (v !== 0) return word * 32 + (31 - Math.clz32(v & -v));
+  }
+  return -1;
+}
+function lastSet(l, layer, offset, a, b) {
+  const lo = Math.max(a, 0);
+  const hi = Math.min(b, l.nz - 1);
+  for (let word = hi >>> 5; word >= lo >>> 5; word--) {
+    const v = (layer[offset + word] & wordMask(word * 32, lo, hi)) >>> 0;
+    if (v !== 0) return word * 32 + (31 - Math.clz32(v));
+  }
+  return -1;
+}
+function dilateXY(l, from, radius) {
+  const out = from.slice();
+  if (radius <= 0) return out;
+  const { nx, ny, w } = l;
+  const size = 2 * radius + 1;
+  const passes = [
+    [nx, 1, ny],
+    [ny, nx, nx]
+  ];
+  const prefix = new Uint32Array(Math.max(nx, ny));
+  const suffix = new Uint32Array(Math.max(nx, ny));
+  for (const [length, stride, lines] of passes) {
+    const lineStride = stride === 1 ? nx : 1;
+    for (let word = 0; word < w; word++) {
+      for (let line = 0; line < lines; line++) {
+        const base = line * lineStride * w + word;
+        let any = 0;
+        for (let i = 0; i < length; i++) any |= out[base + i * stride * w];
+        if (any === 0) continue;
+        for (let i = 0; i < length; i++) {
+          const v = out[base + i * stride * w];
+          prefix[i] = i % size === 0 ? v : prefix[i - 1] | v;
+        }
+        for (let i = length - 1; i >= 0; i--) {
+          const v = out[base + i * stride * w];
+          suffix[i] = i === length - 1 || (i + 1) % size === 0 ? v : suffix[i + 1] | v;
+        }
+        for (let i = 0; i < length; i++) {
+          const a = Math.max(0, i - radius);
+          const b = Math.min(length - 1, i + radius);
+          out[base + i * stride * w] = (suffix[a] | prefix[b]) >>> 0;
+        }
+      }
+    }
+  }
+  return out;
+}
+function reachDown(l, from, span) {
+  const out = from.slice();
+  const { w } = l;
+  let filled = 1;
+  while (filled < span) {
+    const shift = Math.min(filled, span - filled);
+    const words = shift >>> 5;
+    const bits = shift & 31;
+    for (let o = 0; o < out.length; o += w) {
+      for (let i = 0; i < w; i++) {
+        const a = i + words < w ? out[o + i + words] : 0;
+        const b = i + words + 1 < w ? out[o + i + words + 1] : 0;
+        const moved = bits === 0 ? a : a >>> bits | b << 32 - bits;
+        out[o + i] = (out[o + i] | moved) >>> 0;
+      }
+    }
+    filled += shift;
+  }
+  return out;
+}
+function reachUp(l, from, span) {
+  const out = from.slice();
+  const { w } = l;
+  let filled = 1;
+  while (filled < span) {
+    const shift = Math.min(filled, span - filled);
+    const words = shift >>> 5;
+    const bits = shift & 31;
+    for (let o = 0; o < out.length; o += w) {
+      for (let i = w - 1; i >= 0; i--) {
+        const a = i - words >= 0 ? out[o + i - words] : 0;
+        const b = i - words - 1 >= 0 ? out[o + i - words - 1] : 0;
+        const moved = bits === 0 ? a : a << bits | b >>> 32 - bits;
+        out[o + i] = (out[o + i] | moved) >>> 0;
+      }
+    }
+    filled += shift;
+  }
+  return out;
+}
+
+// src/world-fit/scene.ts
+var WORLD_SCENE_FORMAT = "genex-world-scene";
+var WORLD_SCENE_VERSION = 1;
+var SceneChannel = { Move: "move", Shot: "shot" };
+var SceneTag = {
+  /** Moves or disappears at run time: never part of the static world. Named in the report. */
+  Movable: "movable",
+  /** May be simplified or dropped when a budget runs out, before anything else that costs reach. */
+  Prop: "prop"
+};
+var SceneSurfaceKind = {
+  Box: "box",
+  Hull: "hull",
+  Sphere: "sphere",
+  Capsule: "capsule",
+  Mesh: "mesh",
+  Heightfield: "heightfield"
+};
+var WorldSceneError = class extends RangeError {
+  path;
+  constructor(path, message) {
+    super(`world scene: ${path} ${message}`);
+    this.name = "WorldSceneError";
+    this.path = path;
+  }
+};
+var MAX_COORD = 1e9;
+var MAX_NAME_CHARS = 256;
+var MAX_TAGS = 64;
+var MAX_HULL_POINTS = 4096;
+var MAX_HEIGHTFIELD_SIDE = 16384;
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function finite(v, path) {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new WorldSceneError(path, "is not a finite number");
+  if (Math.abs(v) > MAX_COORD) throw new WorldSceneError(path, `is past \xB1${MAX_COORD}`);
+  return v;
+}
+function positive(v, path) {
+  const n = finite(v, path);
+  if (!(n > 0)) throw new WorldSceneError(path, "is not above zero");
+  return n;
+}
+function vec3(v, path) {
+  if (!Array.isArray(v) || v.length !== 3) throw new WorldSceneError(path, "is not [x, y, z]");
+  return [finite(v[0], `${path}[0]`), finite(v[1], `${path}[1]`), finite(v[2], `${path}[2]`)];
+}
+function text(v, path) {
+  if (typeof v !== "string" || v.length === 0) throw new WorldSceneError(path, "is not a name");
+  if (v.length > MAX_NAME_CHARS) throw new WorldSceneError(path, `is longer than ${MAX_NAME_CHARS} characters`);
+  return v;
+}
+function textList(v, path) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) throw new WorldSceneError(path, "is not a list");
+  if (v.length > MAX_TAGS) throw new WorldSceneError(path, `holds more than ${MAX_TAGS}`);
+  return v.map((t, i) => text(t, `${path}[${i}]`));
+}
+function floats(v, path) {
+  if (Array.isArray(v)) {
+    const out = new Float32Array(v.length);
+    for (let i = 0; i < v.length; i++) out[i] = v[i] === null ? Number.NaN : finite(v[i], `${path}[${i}]`);
+    return out;
+  }
+  if (isObject(v) && typeof v.f32le === "string") {
+    const bytes = Buffer.from(v.f32le, "base64");
+    if (bytes.length % 4 !== 0) throw new WorldSceneError(path, "is not a whole number of float32s");
+    const out = new Float32Array(bytes.length / 4);
+    for (let i = 0; i < out.length; i++) out[i] = bytes.readFloatLE(i * 4);
+    return out;
+  }
+  throw new WorldSceneError(path, "is not an array of numbers or { f32le }");
+}
+function indices(v, path) {
+  if (Array.isArray(v)) {
+    const out = new Uint32Array(v.length);
+    for (let i = 0; i < v.length; i++) {
+      const n = v[i];
+      if (typeof n !== "number" || !Number.isInteger(n) || n < 0 || n > 4294967295) throw new WorldSceneError(`${path}[${i}]`, "is not an index");
+      out[i] = n;
+    }
+    return out;
+  }
+  if (isObject(v) && typeof v.u32le === "string") {
+    const bytes = Buffer.from(v.u32le, "base64");
+    if (bytes.length % 4 !== 0) throw new WorldSceneError(path, "is not a whole number of u32s");
+    const out = new Uint32Array(bytes.length / 4);
+    for (let i = 0; i < out.length; i++) out[i] = bytes.readUInt32LE(i * 4);
+    return out;
+  }
+  throw new WorldSceneError(path, "is not an array of indices or { u32le }");
+}
+function common(raw, path) {
+  const out = {};
+  if (raw.channels !== void 0) {
+    if (!Array.isArray(raw.channels)) throw new WorldSceneError(`${path}.channels`, "is not a list");
+    out.channels = raw.channels.map((c, i) => {
+      if (c !== SceneChannel.Move && c !== SceneChannel.Shot) throw new WorldSceneError(`${path}.channels[${i}]`, "is not move or shot");
+      return c;
+    });
+  }
+  if (raw.tags !== void 0) out.tags = textList(raw.tags, `${path}.tags`);
+  return out;
+}
+function parseBox(raw, path) {
+  const half = vec3(raw.half, `${path}.half`);
+  half.forEach((h, i) => {
+    if (h < 0) throw new WorldSceneError(`${path}.half[${i}]`, "is below zero");
+  });
+  const box = { kind: "box", center: vec3(raw.center, `${path}.center`), half, ...common(raw, path) };
+  if (raw.axes === void 0) return box;
+  if (!Array.isArray(raw.axes) || raw.axes.length !== 3) throw new WorldSceneError(`${path}.axes`, "is not three axes");
+  const axes = [vec3(raw.axes[0], `${path}.axes[0]`), vec3(raw.axes[1], `${path}.axes[1]`), vec3(raw.axes[2], `${path}.axes[2]`)];
+  for (const [i, a] of axes.entries()) {
+    if (Math.abs(Math.hypot(a[0], a[1], a[2]) - 1) > 1e-3) throw new WorldSceneError(`${path}.axes[${i}]`, "is not a unit vector");
+  }
+  return { ...box, axes };
+}
+function parseHeightfield(raw, path) {
+  const cols = raw.cols;
+  const rows = raw.rows;
+  const isSide = (n) => typeof n === "number" && Number.isInteger(n) && n >= 2 && n <= MAX_HEIGHTFIELD_SIDE;
+  if (!isSide(cols)) throw new WorldSceneError(`${path}.cols`, `is not an integer in 2..${MAX_HEIGHTFIELD_SIDE}`);
+  if (!isSide(rows)) throw new WorldSceneError(`${path}.rows`, `is not an integer in 2..${MAX_HEIGHTFIELD_SIDE}`);
+  if (!Array.isArray(raw.origin) || raw.origin.length !== 2) throw new WorldSceneError(`${path}.origin`, "is not [x, y]");
+  if (!Array.isArray(raw.cell) || raw.cell.length !== 2) throw new WorldSceneError(`${path}.cell`, "is not [dx, dy]");
+  const heights = floats(raw.heights, `${path}.heights`);
+  if (heights.length !== cols * rows) throw new WorldSceneError(`${path}.heights`, `holds ${heights.length} values, not cols \xD7 rows = ${cols * rows}`);
+  for (let i = 0; i < heights.length; i++) {
+    const h = heights[i];
+    if (Number.isFinite(h) ? Math.abs(h) > MAX_COORD : !Number.isNaN(h)) throw new WorldSceneError(`${path}.heights[${i}]`, "is not a height or a hole");
+  }
+  return {
+    kind: "heightfield",
+    origin: [finite(raw.origin[0], `${path}.origin[0]`), finite(raw.origin[1], `${path}.origin[1]`)],
+    cell: [positive(raw.cell[0], `${path}.cell[0]`), positive(raw.cell[1], `${path}.cell[1]`)],
+    cols,
+    rows,
+    heights,
+    ...common(raw, path)
+  };
+}
+function parseMesh(raw, path) {
+  const vertices = floats(raw.vertices, `${path}.vertices`);
+  const tris = indices(raw.indices, `${path}.indices`);
+  if (vertices.length % 3 !== 0) throw new WorldSceneError(`${path}.vertices`, "is not x y z per vertex");
+  if (tris.length % 3 !== 0) throw new WorldSceneError(`${path}.indices`, "is not three per triangle");
+  for (let i = 0; i < vertices.length; i++) {
+    const v = vertices[i];
+    if (!Number.isFinite(v) || Math.abs(v) > MAX_COORD) throw new WorldSceneError(`${path}.vertices[${i}]`, "is not a usable coordinate");
+  }
+  const count = vertices.length / 3;
+  for (let i = 0; i < tris.length; i++) {
+    if (tris[i] >= count) throw new WorldSceneError(`${path}.indices[${i}]`, `is past the ${count} vertices`);
+  }
+  return { kind: "mesh", vertices, indices: tris, ...common(raw, path) };
+}
+function parseSurface(raw, path) {
+  if (!isObject(raw)) throw new WorldSceneError(path, "is not an object");
+  switch (raw.kind) {
+    case SceneSurfaceKind.Box:
+      return parseBox(raw, path);
+    case SceneSurfaceKind.Hull: {
+      if (!Array.isArray(raw.points) || raw.points.length === 0) throw new WorldSceneError(`${path}.points`, "is not a list of points");
+      if (raw.points.length > MAX_HULL_POINTS) throw new WorldSceneError(`${path}.points`, `holds more than ${MAX_HULL_POINTS}`);
+      return { kind: "hull", points: raw.points.map((p, i) => vec3(p, `${path}.points[${i}]`)), ...common(raw, path) };
+    }
+    case SceneSurfaceKind.Sphere:
+      return { kind: "sphere", center: vec3(raw.center, `${path}.center`), radius: positive(raw.radius, `${path}.radius`), ...common(raw, path) };
+    case SceneSurfaceKind.Capsule:
+      return { kind: "capsule", a: vec3(raw.a, `${path}.a`), b: vec3(raw.b, `${path}.b`), radius: positive(raw.radius, `${path}.radius`), ...common(raw, path) };
+    case SceneSurfaceKind.Mesh:
+      return parseMesh(raw, path);
+    case SceneSurfaceKind.Heightfield:
+      return parseHeightfield(raw, path);
+    default:
+      throw new WorldSceneError(`${path}.kind`, "is not box, hull, sphere, capsule, mesh or heightfield");
+  }
+}
+function parseHullSize(raw, path) {
+  if (!isObject(raw)) throw new WorldSceneError(path, "is not an object");
+  const radius = positive(raw.radius, `${path}.radius`);
+  const height = positive(raw.height, `${path}.height`);
+  const crouchHeight = positive(raw.crouchHeight, `${path}.crouchHeight`);
+  if (crouchHeight > height) throw new WorldSceneError(`${path}.crouchHeight`, "is above height");
+  return {
+    radius,
+    height,
+    crouchHeight,
+    step: positive(raw.step, `${path}.step`),
+    jump: finite(raw.jump, `${path}.jump`),
+    leap: finite(raw.leap, `${path}.leap`)
+  };
+}
+function boundCorner(raw, path) {
+  const ok = Array.isArray(raw) && raw.length === 2 && raw.every((n) => typeof n === "number" && Number.isFinite(n) && Math.abs(n) <= MAX_COORD);
+  if (!ok) throw new WorldSceneError(path, `is not two finite numbers within \xB1${MAX_COORD}`);
+  return [raw[0], raw[1]];
+}
+function parseBound(raw) {
+  if (!isObject(raw)) throw new WorldSceneError("$.bound", "is not an object");
+  const min = boundCorner(raw.min, "$.bound.min");
+  const max = boundCorner(raw.max, "$.bound.max");
+  if (max[0] <= min[0] || max[1] <= min[1]) throw new WorldSceneError("$.bound", "has a max not past its min");
+  if (raw.ceiling === void 0) return { min, max };
+  return { min, max, ceiling: finite(raw.ceiling, "$.bound.ceiling") };
+}
+function insideBound(bound, at) {
+  const inPlan = at[0] > bound.min[0] && at[0] < bound.max[0] && at[1] > bound.min[1] && at[1] < bound.max[1];
+  return inPlan && (bound.ceiling === void 0 || at[2] < bound.ceiling);
+}
+function parseWorldScene(raw) {
+  if (!isObject(raw)) throw new WorldSceneError("$", "is not an object");
+  if (raw.format !== WORLD_SCENE_FORMAT) throw new WorldSceneError("$.format", `is not ${WORLD_SCENE_FORMAT}`);
+  if (raw.version !== WORLD_SCENE_VERSION) throw new WorldSceneError("$.version", `is not ${WORLD_SCENE_VERSION}`);
+  if (!Array.isArray(raw.actors)) throw new WorldSceneError("$.actors", "is not a list");
+  if (!Array.isArray(raw.spawns)) throw new WorldSceneError("$.spawns", "is not a list");
+  const actors = raw.actors.map((a, i) => {
+    const path = `$.actors[${i}]`;
+    if (!isObject(a)) throw new WorldSceneError(path, "is not an object");
+    if (!Array.isArray(a.surfaces)) throw new WorldSceneError(`${path}.surfaces`, "is not a list");
+    return {
+      name: text(a.name, `${path}.name`),
+      tags: textList(a.tags, `${path}.tags`),
+      surfaces: a.surfaces.map((s, k) => parseSurface(s, `${path}.surfaces[${k}]`))
+    };
+  });
+  const spawns = raw.spawns.map((s, i) => {
+    const path = `$.spawns[${i}]`;
+    if (!isObject(s)) throw new WorldSceneError(path, "is not an object");
+    const spawn = { at: vec3(s.at, `${path}.at`) };
+    if (s.name !== void 0) spawn.name = text(s.name, `${path}.name`);
+    if (s.tags !== void 0) spawn.tags = textList(s.tags, `${path}.tags`);
+    return spawn;
+  });
+  const source = {};
+  if (raw.source !== void 0) {
+    if (!isObject(raw.source)) throw new WorldSceneError("$.source", "is not an object");
+    for (const [k, v] of Object.entries(raw.source)) source[k] = text(v, `$.source.${k}`);
+  }
+  const bound = raw.bound === void 0 ? void 0 : parseBound(raw.bound);
+  if (bound !== void 0) {
+    spawns.forEach((spawn, i) => {
+      if (!insideBound(bound, spawn.at)) throw new WorldSceneError(`$.spawns[${i}].at`, "is outside the bound");
+    });
+  }
+  const scene = {
+    format: WORLD_SCENE_FORMAT,
+    version: WORLD_SCENE_VERSION,
+    unitsPerMeter: positive(raw.unitsPerMeter, "$.unitsPerMeter"),
+    actors,
+    spawns,
+    ...raw.source === void 0 ? {} : { source },
+    ...raw.hull === void 0 ? {} : { hull: parseHullSize(raw.hull, "$.hull") },
+    ...bound === void 0 ? {} : { bound }
+  };
+  return scene;
+}
+function surfaceAnswers(surface, channel) {
+  return surface.channels === void 0 || surface.channels.includes(channel);
+}
+
+// src/world-fit/raster.ts
+var SPHERE_SEGMENTS = 12;
+var SPHERE_STACKS = 8;
+var HULL_EPSILON = 1e-7;
+var PLANAR_EPSILON = 1e-6;
+var BOX_CORNER_SHARE = 1e-5;
+var CLIP_CAPACITY = 16;
+var polyA = new Float64Array(CLIP_CAPACITY * 3);
+var polyB = new Float64Array(CLIP_CAPACITY * 3);
+var polyC = new Float64Array(CLIP_CAPACITY * 3);
+function clipAxis(input, count, axis, lo, hi, output, scratch) {
+  let n = 0;
+  for (let i = 0; i < count; i++) {
+    const j = (i + 1) % count;
+    const pi = input[i * 3 + axis] - lo;
+    const pj = input[j * 3 + axis] - lo;
+    if (pi >= 0) {
+      scratch[n * 3] = input[i * 3];
+      scratch[n * 3 + 1] = input[i * 3 + 1];
+      scratch[n * 3 + 2] = input[i * 3 + 2];
+      n++;
+    }
+    if (pi > 0 && pj < 0 || pi < 0 && pj > 0) {
+      const t = pi / (pi - pj);
+      scratch[n * 3] = input[i * 3] + (input[j * 3] - input[i * 3]) * t;
+      scratch[n * 3 + 1] = input[i * 3 + 1] + (input[j * 3 + 1] - input[i * 3 + 1]) * t;
+      scratch[n * 3 + 2] = input[i * 3 + 2] + (input[j * 3 + 2] - input[i * 3 + 2]) * t;
+      n++;
+    }
+  }
+  const mid = n;
+  n = 0;
+  for (let i = 0; i < mid; i++) {
+    const j = (i + 1) % mid;
+    const pi = hi - scratch[i * 3 + axis];
+    const pj = hi - scratch[j * 3 + axis];
+    if (pi >= 0) {
+      output[n * 3] = scratch[i * 3];
+      output[n * 3 + 1] = scratch[i * 3 + 1];
+      output[n * 3 + 2] = scratch[i * 3 + 2];
+      n++;
+    }
+    if (pi > 0 && pj < 0 || pi < 0 && pj > 0) {
+      const t = pi / (pi - pj);
+      output[n * 3] = scratch[i * 3] + (scratch[j * 3] - scratch[i * 3]) * t;
+      output[n * 3 + 1] = scratch[i * 3 + 1] + (scratch[j * 3 + 1] - scratch[i * 3 + 1]) * t;
+      output[n * 3 + 2] = scratch[i * 3 + 2] + (scratch[j * 3 + 2] - scratch[i * 3 + 2]) * t;
+      n++;
+    }
+  }
+  return n;
+}
+var scratchClip = new Float64Array(CLIP_CAPACITY * 3);
+function triangleColumns(l, half, ax, ay, az, bx, by, bz, cx, cy, cz, visit) {
+  const { h, nx, ny } = l;
+  const minX = Math.min(ax, bx, cx);
+  const maxX = Math.max(ax, bx, cx);
+  const minY = Math.min(ay, by, cy);
+  const maxY = Math.max(ay, by, cy);
+  const i0 = Math.max(0, cellFloor((minX - half - l.x0) / h - 0.5) + 1);
+  const i1 = Math.min(nx - 1, cellCeil((maxX + half - l.x0) / h - 0.5) - 1);
+  const j0 = Math.max(0, cellFloor((minY - half - l.y0) / h - 0.5) + 1);
+  const j1 = Math.min(ny - 1, cellCeil((maxY + half - l.y0) / h - 0.5) - 1);
+  if (i0 > i1 || j0 > j1) return;
+  polyA[0] = ax;
+  polyA[1] = ay;
+  polyA[2] = az;
+  polyA[3] = bx;
+  polyA[4] = by;
+  polyA[5] = bz;
+  polyA[6] = cx;
+  polyA[7] = cy;
+  polyA[8] = cz;
+  for (let i = i0; i <= i1; i++) {
+    const px = centreX(l, i);
+    const nA = clipAxis(polyA, 3, 0, px - half, px + half, polyB, scratchClip);
+    if (nA < 1) continue;
+    for (let j = j0; j <= j1; j++) {
+      const py = centreY(l, j);
+      const nB = clipAxis(polyB, nA, 1, py - half, py + half, polyC, scratchClip);
+      if (nB < 1) continue;
+      let zMin = Number.POSITIVE_INFINITY;
+      let zMax = Number.NEGATIVE_INFINITY;
+      for (let v = 0; v < nB; v++) {
+        const z = polyC[v * 3 + 2];
+        if (z < zMin) zMin = z;
+        if (z > zMax) zMax = z;
+      }
+      visit(i, j, zMin, zMax);
+    }
+  }
+}
+function fill(l, layer, i, j, zMin, zMax) {
+  const a = cellFloor((zMin - l.z0) / l.h);
+  const b = Math.max(a, cellCeil((zMax - l.z0) / l.h) - 1);
+  setRun(l, layer, (j * l.nx + i) * l.w, a, b);
+}
+var BOX_FACES = [0, 1, 3, 0, 3, 2, 4, 6, 7, 4, 7, 5, 0, 4, 5, 0, 5, 1, 2, 3, 7, 2, 7, 6, 0, 2, 6, 0, 6, 4, 1, 5, 7, 1, 7, 3];
+function boxCorners(surface) {
+  const { center: c, half: e } = surface;
+  const a = surface.axes ?? [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+  const out = [];
+  for (let corner = 0; corner < 8; corner++) {
+    const sx = corner & 1 ? 1 : -1;
+    const sy = corner & 2 ? 1 : -1;
+    const sz = corner & 4 ? 1 : -1;
+    for (let axis = 0; axis < 3; axis++) {
+      out.push(c[axis] + sx * e[0] * a[0][axis] + sy * e[1] * a[1][axis] + sz * e[2] * a[2][axis]);
+    }
+  }
+  return out;
+}
+function spherePoints(c, radius) {
+  const r = radius / Math.cos(Math.PI / SPHERE_SEGMENTS);
+  const out = [c[0], c[1], c[2] + r, c[0], c[1], c[2] - r];
+  for (let s = 1; s < SPHERE_STACKS; s++) {
+    const polar = s / SPHERE_STACKS * Math.PI;
+    for (let a = 0; a < SPHERE_SEGMENTS; a++) {
+      const azimuth = a / SPHERE_SEGMENTS * Math.PI * 2;
+      out.push(c[0] + r * Math.sin(polar) * Math.cos(azimuth), c[1] + r * Math.sin(polar) * Math.sin(azimuth), c[2] + r * Math.cos(polar));
+    }
+  }
+  return out;
+}
+function convexHullFaces(points) {
+  const n = points.length / 3;
+  const at = (i) => [points[i * 3], points[i * 3 + 1], points[i * 3 + 2]];
+  let size = 0;
+  for (let i = 1; i < n; i++) {
+    const [x, y, z] = at(i);
+    size = Math.max(size, Math.abs(x - points[0]), Math.abs(y - points[1]), Math.abs(z - points[2]));
+  }
+  if (n < 3 || size === 0) return [];
+  const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+  const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  const p0 = at(0);
+  let i1 = 0;
+  let best = 0;
+  for (let i = 1; i < n; i++) {
+    const d = sub(at(i), p0);
+    const v = dot(d, d);
+    if (v > best) {
+      best = v;
+      i1 = i;
+    }
+  }
+  const lineDir = sub(at(i1), p0);
+  let i2 = -1;
+  best = (PLANAR_EPSILON * size) ** 2 * dot(lineDir, lineDir);
+  for (let i = 0; i < n; i++) {
+    const c = cross(lineDir, sub(at(i), p0));
+    const v = dot(c, c);
+    if (v > best) {
+      best = v;
+      i2 = i;
+    }
+  }
+  if (i2 < 0) return [];
+  const normal = cross(lineDir, sub(at(i2), p0));
+  const normalLength = Math.sqrt(dot(normal, normal));
+  let i3 = -1;
+  best = PLANAR_EPSILON * size;
+  for (let i = 0; i < n; i++) {
+    const v = Math.abs(dot(normal, sub(at(i), p0))) / normalLength;
+    if (v > best) {
+      best = v;
+      i3 = i;
+    }
+  }
+  if (i3 < 0) {
+    const centre = [0, 0, 0];
+    for (let i = 0; i < n; i++) {
+      const p = at(i);
+      centre[0] += p[0] / n;
+      centre[1] += p[1] / n;
+      centre[2] += p[2] / n;
+    }
+    const u = lineDir;
+    const v = cross(normal, u);
+    const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => {
+      const da = sub(at(a), centre);
+      const db = sub(at(b), centre);
+      return Math.atan2(dot(da, v), dot(da, u) * Math.hypot(...v) / Math.hypot(...u)) - Math.atan2(dot(db, v), dot(db, u) * Math.hypot(...v) / Math.hypot(...u));
+    });
+    const fan = [];
+    for (let k = 1; k + 1 < n; k++) fan.push(order[0], order[k], order[k + 1]);
+    return fan;
+  }
+  const inner = [0, 0, 0];
+  for (const i of [0, i1, i2, i3]) {
+    const p = at(i);
+    inner[0] += p[0] / 4;
+    inner[1] += p[1] / 4;
+    inner[2] += p[2] / 4;
+  }
+  const makeFace = (a, b, c) => {
+    let m = cross(sub(at(b), at(a)), sub(at(c), at(a)));
+    const length = Math.sqrt(dot(m, m)) || 1;
+    m = [m[0] / length, m[1] / length, m[2] / length];
+    let d = dot(m, at(a));
+    if (dot(m, inner) - d > 0) {
+      m = [-m[0], -m[1], -m[2]];
+      d = -d;
+      return { a, b: c, c: b, nx: m[0], ny: m[1], nz: m[2], d };
+    }
+    return { a, b, c, nx: m[0], ny: m[1], nz: m[2], d };
+  };
+  let faces = [makeFace(0, i1, i2), makeFace(0, i1, i3), makeFace(0, i2, i3), makeFace(i1, i2, i3)];
+  const tolerance = HULL_EPSILON * size;
+  for (let p = 0; p < n; p++) {
+    const [x, y, z] = at(p);
+    const visible = faces.filter((f2) => f2.nx * x + f2.ny * y + f2.nz * z - f2.d > tolerance);
+    if (visible.length === 0) continue;
+    const edges = /* @__PURE__ */ new Map();
+    for (const f2 of visible) {
+      for (const [a, b] of [[f2.a, f2.b], [f2.b, f2.c], [f2.c, f2.a]]) {
+        if (edges.has(b * n + a)) edges.delete(b * n + a);
+        else edges.set(a * n + b, [a, b]);
+      }
+    }
+    const seen = new Set(visible);
+    faces = faces.filter((f2) => !seen.has(f2));
+    for (const [a, b] of edges.values()) faces.push(makeFace(a, b, p));
+  }
+  return faces.flatMap((f2) => [f2.a, f2.b, f2.c]);
+}
+function convexTriangles(points, indices2, sink) {
+  for (let t = 0; t + 2 < indices2.length; t += 3) {
+    const a = indices2[t] * 3;
+    const b = indices2[t + 1] * 3;
+    const c = indices2[t + 2] * 3;
+    sink(points[a], points[a + 1], points[a + 2], points[b], points[b + 1], points[b + 2], points[c], points[c + 1], points[c + 2]);
+  }
+}
+function hullAsBox(points) {
+  const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (const p of points) {
+    for (let a = 0; a < 3; a++) {
+      lo[a] = Math.min(lo[a], p[a]);
+      hi[a] = Math.max(hi[a], p[a]);
+    }
+  }
+  const size = Math.max(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]);
+  const near = (v, target) => Math.abs(v - target) <= size * BOX_CORNER_SHARE;
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of points) {
+    let corner = 0;
+    for (let a = 0; a < 3; a++) {
+      if (near(p[a], hi[a])) corner |= 1 << a;
+      else if (!near(p[a], lo[a])) return null;
+    }
+    seen.add(corner);
+  }
+  if (seen.size !== 8) return null;
+  return { min: [lo[0], lo[1], lo[2]], max: [hi[0], hi[1], hi[2]] };
+}
+function exactBoxBounds(surface) {
+  if (surface.kind === "hull") return hullAsBox(surface.points);
+  if (surface.kind !== "box") return null;
+  const a = surface.axes;
+  if (a !== void 0) {
+    const on = (v) => {
+      const big = Math.max(Math.abs(v[0]), Math.abs(v[1]), Math.abs(v[2]));
+      return big > 1 - 1e-6;
+    };
+    if (!on(a[0]) || !on(a[1]) || !on(a[2])) return null;
+  }
+  const row = (axis) => {
+    if (a === void 0) return surface.half[axis];
+    return Math.abs(a[0][axis]) * surface.half[0] + Math.abs(a[1][axis]) * surface.half[1] + Math.abs(a[2][axis]) * surface.half[2];
+  };
+  const e = [row(0), row(1), row(2)];
+  const c = surface.center;
+  return { min: [c[0] - e[0], c[1] - e[1], c[2] - e[2]], max: [c[0] + e[0], c[1] + e[1], c[2] + e[2]] };
+}
+function rasterConvex(l, layer, half, points, indices2) {
+  const spans = /* @__PURE__ */ new Map();
+  convexTriangles(points, indices2, (ax, ay, az, bx, by, bz, cx, cy, cz) => {
+    triangleColumns(l, half, ax, ay, az, bx, by, bz, cx, cy, cz, (i, j, zMin, zMax) => {
+      const key = j * l.nx + i;
+      const span = spans.get(key);
+      if (span === void 0) spans.set(key, [zMin, zMax]);
+      else {
+        if (zMin < span[0]) span[0] = zMin;
+        if (zMax > span[1]) span[1] = zMax;
+      }
+    });
+  });
+  for (const [key, span] of spans) fill(l, layer, key % l.nx, Math.floor(key / l.nx), span[0], span[1]);
+}
+function rasterTriangle(l, layer, half, ax, ay, az, bx, by, bz, cx, cy, cz) {
+  triangleColumns(l, half, ax, ay, az, bx, by, bz, cx, cy, cz, (i, j, zMin, zMax) => fill(l, layer, i, j, zMin, zMax));
+}
+function surfaceTriangles(surface, sink) {
+  switch (surface.kind) {
+    case "box":
+      convexTriangles(boxCorners(surface), BOX_FACES, sink);
+      return;
+    case "hull": {
+      const points = surface.points.flat();
+      convexTriangles(points, convexHullFaces(points), sink);
+      return;
+    }
+    case "sphere": {
+      const points = spherePoints(surface.center, surface.radius);
+      convexTriangles(points, convexHullFaces(points), sink);
+      return;
+    }
+    case "capsule": {
+      const points = [...spherePoints(surface.a, surface.radius), ...spherePoints(surface.b, surface.radius)];
+      convexTriangles(points, convexHullFaces(points), sink);
+      return;
+    }
+    case "mesh": {
+      const { vertices: v, indices: t } = surface;
+      for (let k = 0; k + 2 < t.length; k += 3) {
+        const a = t[k] * 3;
+        const b = t[k + 1] * 3;
+        const c = t[k + 2] * 3;
+        sink(v[a], v[a + 1], v[a + 2], v[b], v[b + 1], v[b + 2], v[c], v[c + 1], v[c + 2]);
+      }
+      return;
+    }
+    case "heightfield": {
+      const { origin, cell, cols, rows, heights } = surface;
+      for (let r = 0; r + 1 < rows; r++) {
+        for (let c = 0; c + 1 < cols; c++) {
+          const za = heights[r * cols + c];
+          const zb = heights[r * cols + c + 1];
+          const zc = heights[(r + 1) * cols + c];
+          const zd = heights[(r + 1) * cols + c + 1];
+          const x0 = origin[0] + c * cell[0];
+          const x1 = x0 + cell[0];
+          const y0 = origin[1] + r * cell[1];
+          const y1 = y0 + cell[1];
+          if (!Number.isNaN(za) && !Number.isNaN(zb) && !Number.isNaN(zc)) sink(x0, y0, za, x1, y0, zb, x0, y1, zc);
+          if (!Number.isNaN(zb) && !Number.isNaN(zc) && !Number.isNaN(zd)) sink(x1, y0, zb, x0, y1, zc, x1, y1, zd);
+        }
+      }
+      return;
+    }
+  }
+}
+function rasterAabb(l, layer, half, box) {
+  const { h } = l;
+  const i0 = Math.max(0, cellFloor((box.min[0] - half - l.x0) / h - 0.5) + 1);
+  const i1 = Math.min(l.nx - 1, cellCeil((box.max[0] + half - l.x0) / h - 0.5) - 1);
+  const j0 = Math.max(0, cellFloor((box.min[1] - half - l.y0) / h - 0.5) + 1);
+  const j1 = Math.min(l.ny - 1, cellCeil((box.max[1] + half - l.y0) / h - 0.5) - 1);
+  const a = cellFloor((box.min[2] - l.z0) / h);
+  const b = Math.max(a, cellCeil((box.max[2] - l.z0) / h) - 1);
+  for (let j = j0; j <= j1; j++) {
+    for (let i = i0; i <= i1; i++) setRun(l, layer, (j * l.nx + i) * l.w, a, b);
+  }
+}
+function rasterSurface(l, layer, half, surface) {
+  switch (surface.kind) {
+    case "box": {
+      const exact = exactBoxBounds(surface);
+      if (exact !== null) rasterAabb(l, layer, half, exact);
+      else rasterConvex(l, layer, half, boxCorners(surface), BOX_FACES);
+      return;
+    }
+    case "hull": {
+      const exact = exactBoxBounds(surface);
+      if (exact !== null) {
+        rasterAabb(l, layer, half, exact);
+        return;
+      }
+      const points = surface.points.flat();
+      rasterConvex(l, layer, half, points, convexHullFaces(points));
+      return;
+    }
+    case "sphere": {
+      const points = spherePoints(surface.center, surface.radius);
+      rasterConvex(l, layer, half, points, convexHullFaces(points));
+      return;
+    }
+    case "capsule": {
+      const points = [...spherePoints(surface.a, surface.radius), ...spherePoints(surface.b, surface.radius)];
+      rasterConvex(l, layer, half, points, convexHullFaces(points));
+      return;
+    }
+    case "mesh": {
+      const { vertices: v, indices: t } = surface;
+      for (let k = 0; k + 2 < t.length; k += 3) {
+        const a = t[k] * 3;
+        const b = t[k + 1] * 3;
+        const c = t[k + 2] * 3;
+        triangleColumns(l, half, v[a], v[a + 1], v[a + 2], v[b], v[b + 1], v[b + 2], v[c], v[c + 1], v[c + 2], (i, j, zMin, zMax) => fill(l, layer, i, j, zMin, zMax));
+      }
+      return;
+    }
+    case "heightfield":
+      rasterHeightfield(l, layer, half, surface);
+      return;
+  }
+}
+function rasterHeightfield(l, layer, half, surface) {
+  const { origin, cell, cols, rows, heights } = surface;
+  const below = l.z0 - l.h;
+  const solid = (i, j, _zMin, zMax) => fill(l, layer, i, j, below, zMax);
+  for (let r = 0; r + 1 < rows; r++) {
+    for (let c = 0; c + 1 < cols; c++) {
+      const za = heights[r * cols + c];
+      const zb = heights[r * cols + c + 1];
+      const zc = heights[(r + 1) * cols + c];
+      const zd = heights[(r + 1) * cols + c + 1];
+      const x0 = origin[0] + c * cell[0];
+      const x1 = x0 + cell[0];
+      const y0 = origin[1] + r * cell[1];
+      const y1 = y0 + cell[1];
+      if (!Number.isNaN(za) && !Number.isNaN(zb) && !Number.isNaN(zc)) triangleColumns(l, half, x0, y0, za, x1, y0, zb, x0, y1, zc, solid);
+      if (!Number.isNaN(zb) && !Number.isNaN(zc) && !Number.isNaN(zd)) triangleColumns(l, half, x1, y0, zb, x0, y1, zc, x1, y1, zd, solid);
+    }
+  }
+}
+function stopsShot(actor, surface) {
+  if (actor.tags.includes(SceneTag.Movable) || surface.tags?.includes(SceneTag.Movable)) return false;
+  return surfaceAnswers(surface, SceneChannel.Shot);
+}
+function blocksHull(actor, surface) {
+  if (actor.tags.includes(SceneTag.Movable) || surface.tags?.includes(SceneTag.Movable)) return false;
+  return surfaceAnswers(surface, SceneChannel.Move);
+}
+function rasterScene(l, layer, half, actors) {
+  for (const actor of actors) {
+    for (const surface of actor.surfaces) {
+      if (blocksHull(actor, surface)) rasterSurface(l, layer, half, surface);
+    }
+  }
+}
+function surfaceBounds(surface) {
+  const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  const add = (x, y, z) => {
+    if (x < lo[0]) lo[0] = x;
+    if (y < lo[1]) lo[1] = y;
+    if (z < lo[2]) lo[2] = z;
+    if (x > hi[0]) hi[0] = x;
+    if (y > hi[1]) hi[1] = y;
+    if (z > hi[2]) hi[2] = z;
+  };
+  switch (surface.kind) {
+    case "box": {
+      const corners = boxCorners(surface);
+      for (let i = 0; i < 24; i += 3) add(corners[i], corners[i + 1], corners[i + 2]);
+      break;
+    }
+    case "hull":
+      for (const p of surface.points) add(p[0], p[1], p[2]);
+      break;
+    case "sphere": {
+      const r = surface.radius;
+      add(surface.center[0] - r, surface.center[1] - r, surface.center[2] - r);
+      add(surface.center[0] + r, surface.center[1] + r, surface.center[2] + r);
+      break;
+    }
+    case "capsule": {
+      const r = surface.radius;
+      for (const p of [surface.a, surface.b]) {
+        add(p[0] - r, p[1] - r, p[2] - r);
+        add(p[0] + r, p[1] + r, p[2] + r);
+      }
+      break;
+    }
+    case "mesh": {
+      const v = surface.vertices;
+      for (const i of surface.indices) add(v[i * 3], v[i * 3 + 1], v[i * 3 + 2]);
+      break;
+    }
+    case "heightfield": {
+      const { origin, cell, cols, rows, heights } = surface;
+      for (const z of heights) {
+        if (Number.isNaN(z)) continue;
+        add(origin[0], origin[1], z);
+        add(origin[0] + (cols - 1) * cell[0], origin[1] + (rows - 1) * cell[1], z);
+      }
+      break;
+    }
+  }
+  return { min: [lo[0], lo[1], lo[2]], max: [hi[0], hi[1], hi[2]] };
+}
+function visitTops(l, half, actors, visit) {
+  const onColumn = (i, j, _zMin, zMax) => visit(j * l.nx + i, zMax);
+  const triangles = (points, faces) => convexTriangles(points, faces, (ax, ay, az, bx, by, bz, cx, cy, cz) => triangleColumns(l, half, ax, ay, az, bx, by, bz, cx, cy, cz, onColumn));
+  for (const actor of actors) {
+    for (const surface of actor.surfaces) {
+      if (!blocksHull(actor, surface)) continue;
+      const exact = exactBoxBounds(surface);
+      if (exact !== null) {
+        const i0 = Math.max(0, cellFloor((exact.min[0] - half - l.x0) / l.h - 0.5) + 1);
+        const i1 = Math.min(l.nx - 1, cellCeil((exact.max[0] + half - l.x0) / l.h - 0.5) - 1);
+        const j0 = Math.max(0, cellFloor((exact.min[1] - half - l.y0) / l.h - 0.5) + 1);
+        const j1 = Math.min(l.ny - 1, cellCeil((exact.max[1] + half - l.y0) / l.h - 0.5) - 1);
+        for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) visit(j * l.nx + i, exact.max[2]);
+        continue;
+      }
+      if (surface.kind === "box") triangles(boxCorners(surface), BOX_FACES);
+      else if (surface.kind === "hull") {
+        const points = surface.points.flat();
+        triangles(points, convexHullFaces(points));
+      } else if (surface.kind === "sphere") {
+        const points = spherePoints(surface.center, surface.radius);
+        triangles(points, convexHullFaces(points));
+      } else if (surface.kind === "capsule") {
+        const points = [...spherePoints(surface.a, surface.radius), ...spherePoints(surface.b, surface.radius)];
+        triangles(points, convexHullFaces(points));
+      } else if (surface.kind === "mesh") {
+        const { vertices: v, indices: t } = surface;
+        for (let k = 0; k + 2 < t.length; k += 3) {
+          const a = t[k] * 3;
+          const b = t[k + 1] * 3;
+          const c = t[k + 2] * 3;
+          triangleColumns(l, half, v[a], v[a + 1], v[a + 2], v[b], v[b + 1], v[b + 2], v[c], v[c + 1], v[c + 2], onColumn);
+        }
+      } else {
+        const { origin, cell, cols, rows, heights } = surface;
+        for (let r = 0; r + 1 < rows; r++) {
+          for (let c = 0; c + 1 < cols; c++) {
+            const za = heights[r * cols + c];
+            const zb = heights[r * cols + c + 1];
+            const zc = heights[(r + 1) * cols + c];
+            const zd = heights[(r + 1) * cols + c + 1];
+            const x0 = origin[0] + c * cell[0];
+            const y0 = origin[1] + r * cell[1];
+            if (!Number.isNaN(za) && !Number.isNaN(zb) && !Number.isNaN(zc)) triangleColumns(l, half, x0, y0, za, x0 + cell[0], y0, zb, x0, y0 + cell[1], zc, onColumn);
+            if (!Number.isNaN(zb) && !Number.isNaN(zc) && !Number.isNaN(zd)) triangleColumns(l, half, x0 + cell[0], y0, zb, x0, y0 + cell[1], zc, x0 + cell[0], y0 + cell[1], zd, onColumn);
+          }
+        }
+      }
+    }
+  }
+}
+
+// src/world-fit/cover.ts
+var SolidStage = {
+  Exact: "exact",
+  Ramp: "ramp",
+  Tile: "tile",
+  Cover: "cover",
+  Prop: "prop"
+};
+var MIN_THICKNESS_CELLS = 1 / 8;
+var GAP_MARGIN_CELLS = 1 / 8;
+var SEAM_OVERLAP_CELLS = GAP_MARGIN_CELLS * 1.25;
+var MAX_GROW_CELLS = 512;
+var MIN_TILE_FOOTPRINTS = 1;
+var MIN_PIECE_SHARE = 1 / 4;
+var MIN_RAMP_FOOTPRINTS = 3;
+var RAMP_PASSES = 4;
+var RAMP_SEED_STRIDE_FOOTPRINTS = 1;
+var WINDOW_TRIES = [0, 0.5, 1];
+var TILE_DEPTH_RANGES = 1;
+var TILE_DEPTH_CELLS = 2;
+var f = Math.fround;
+var ActorIndex = class {
+  bins = /* @__PURE__ */ new Map();
+  binSize;
+  constructor(actors, binSize) {
+    this.binSize = binSize;
+    for (const [actor, a] of actors.entries()) {
+      for (const surface of a.surfaces) {
+        if (!blocksHull(a, surface)) continue;
+        const box = surfaceBounds(surface);
+        const entry = { actor, box };
+        this.eachBin(box.min[0], box.min[1], box.max[0], box.max[1], (key) => {
+          const list = this.bins.get(key);
+          if (list === void 0) this.bins.set(key, [entry]);
+          else list.push(entry);
+        });
+      }
+    }
+  }
+  eachBin(x0, y0, x1, y1, visit) {
+    const a0 = Math.floor(x0 / this.binSize);
+    const a1 = Math.floor(x1 / this.binSize);
+    const b0 = Math.floor(y0 / this.binSize);
+    const b1 = Math.floor(y1 / this.binSize);
+    if ((a1 - a0 + 1) * (b1 - b0 + 1) > 4096) {
+      visit(Number.MAX_SAFE_INTEGER);
+      return;
+    }
+    for (let a = a0; a <= a1; a++) for (let b = b0; b <= b1; b++) visit(a * 1000003 + b);
+  }
+  owner(min, max) {
+    let best = -1;
+    let bestScore = -1;
+    const score = (entry) => {
+      let volume = 1;
+      for (let axis = 0; axis < 3; axis++) {
+        const overlap = Math.min(max[axis], entry.box.max[axis]) - Math.max(min[axis], entry.box.min[axis]);
+        if (overlap < 0) return;
+        volume *= overlap + 1;
+      }
+      if (volume > bestScore) {
+        bestScore = volume;
+        best = entry.actor;
+      }
+    };
+    this.eachBin(min[0], min[1], max[0], max[1], (key) => {
+      for (const entry of this.bins.get(key) ?? []) score(entry);
+    });
+    for (const entry of this.bins.get(Number.MAX_SAFE_INTEGER) ?? []) score(entry);
+    return best;
+  }
+};
+function footRange(l, radius, min, max, origin, count) {
+  return [Math.max(0, cellFloor((min - radius - origin) / l.h - 0.5) + 1), Math.min(count - 1, cellCeil((max + radius - origin) / l.h - 0.5) - 1)];
+}
+function markBox(input, covered, box, zLow, zHigh) {
+  const { l, radius } = input;
+  const [i0, i1] = footRange(l, radius, box[0], box[3], l.x0, l.nx);
+  const [j0, j1] = footRange(l, radius, box[1], box[4], l.y0, l.ny);
+  for (let j = j0; j <= j1; j++) {
+    for (let i = i0; i <= i1; i++) setRun(l, covered, (j * l.nx + i) * l.w, zLow, zHigh);
+  }
+}
+function hullTouches(input, box) {
+  const { l, radius, body, touch } = input;
+  const [i0, i1] = footRange(l, radius + l.h, box.min[0], box.max[0], l.x0, l.nx);
+  const [j0, j1] = footRange(l, radius + l.h, box.min[1], box.max[1], l.y0, l.ny);
+  const a = cellFloor((box.min[2] - l.z0) / l.h) - 1;
+  const b = cellCeil((box.max[2] - l.z0) / l.h);
+  for (let j = j0; j <= j1; j++) {
+    for (let i = i0; i <= i1; i++) {
+      if (anyInRun(l, body, (j * l.nx + i) * l.w, a, b) || anyInRun(l, touch, (j * l.nx + i) * l.w, a, b)) return true;
+    }
+  }
+  return false;
+}
+function solidOfExact(box, h) {
+  const axis = (lo, hi) => {
+    const a = f(lo);
+    const b = f(hi);
+    if (a < b) return [a, b];
+    const pad = h * MIN_THICKNESS_CELLS;
+    return [f(lo - pad / 2), f(hi + pad / 2)];
+  };
+  const [x0, x1] = axis(box.min[0], box.max[0]);
+  const [y0, y1] = axis(box.min[1], box.max[1]);
+  const [z0, z1] = axis(box.min[2], box.max[2]);
+  return [x0, y0, z0, x1, y1, z1];
+}
+function placeExactBoxes(input, knobs, placed, covered, exactSolid) {
+  const { actors, l } = input;
+  for (const [index, actor] of actors.entries()) {
+    const bounded = knobs.boundedActors.has(index);
+    for (const surface of actor.surfaces) {
+      if (!blocksHull(actor, surface)) continue;
+      const exact = bounded ? surfaceBounds(surface) : exactBoxBounds(surface);
+      if (exact === null || !hullTouches(input, exact)) continue;
+      const box = solidOfExact(exact, l.h);
+      placed.boxes.push(box);
+      placed.boxInfo.push({ stage: bounded ? SolidStage.Prop : SolidStage.Exact, actor: index });
+      markBox(input, covered, box, cellFloor((box[2] - l.z0) / l.h), cellCeil((box[5] - l.z0) / l.h) - 1);
+      rasterAabb(l, exactSolid, l.h / 2, exact);
+    }
+  }
+}
+function readFloors(input) {
+  const { l, solid, envelope, actors } = input;
+  const { nx, ny, w } = l;
+  const columns = nx * ny;
+  const offsets = new Int32Array(columns + 1);
+  let total = 0;
+  const visit = (write) => {
+    for (let col = 0; col < columns; col++) {
+      const o = col * w;
+      if (write === null) offsets[col] = total;
+      for (let word = 0; word < w; word++) {
+        const s = solid[o + word];
+        if (s === 0) continue;
+        const above = s >>> 1 | (word + 1 < w ? solid[o + word + 1] << 31 : 0);
+        const open = envelope[o + word] >>> 1 | (word + 1 < w ? envelope[o + word + 1] << 31 : 0);
+        let tops2 = (s & ~above & open) >>> 0;
+        while (tops2 !== 0) {
+          const bit = 31 - Math.clz32(tops2 & -tops2);
+          tops2 = (tops2 & tops2 - 1) >>> 0;
+          if (write !== null) write[total] = word * 32 + bit;
+          total += 1;
+        }
+      }
+    }
+    if (write === null) offsets[columns] = total;
+  };
+  visit(null);
+  const cells = new Int16Array(total);
+  total = 0;
+  visit(cells);
+  const tops = new Float32Array(total);
+  for (let at = 0; at < total; at++) tops[at] = plane(l, cells[at] + 1);
+  const seen = new Uint8Array(total);
+  visitTops(l, l.h / 2, actors, (col, top) => {
+    const cell = cellCeil((top - l.z0) / l.h) - 1;
+    for (let at = offsets[col]; at < offsets[col + 1]; at++) {
+      if (cells[at] !== cell) continue;
+      if (seen[at] === 0 || top > tops[at]) tops[at] = top;
+      seen[at] = 1;
+    }
+  });
+  return { offsets, cells, tops };
+}
+function floorsLeft(l, base, exactSolid) {
+  const cells = base.cells.slice();
+  for (let col = 0; col < l.nx * l.ny; col++) {
+    for (let at = base.offsets[col]; at < base.offsets[col + 1]; at++) {
+      if (testBit(exactSolid, col * l.w, cells[at])) cells[at] = -1;
+    }
+  }
+  return { offsets: base.offsets, tops: base.tops, cells };
+}
+function floorBottom(input, i0, i1, j0, j1, lowest, depth) {
+  const { l, envelope } = input;
+  let bottom = Math.max(0, lowest - depth);
+  for (let j = j0; j <= j1; j++) {
+    for (let i = i0; i <= i1; i++) {
+      const hit = lastSet(l, envelope, (j * l.nx + i) * l.w, bottom, lowest - 1);
+      if (hit >= bottom) bottom = hit + 1;
+    }
+  }
+  return bottom;
+}
+function floorIn(image, col, lo, hi) {
+  for (let at = image.offsets[col]; at < image.offsets[col + 1]; at++) {
+    const z = image.cells[at];
+    if (z >= lo && z <= hi) return z;
+  }
+  return -1;
+}
+function consume(image, col, lo, hi) {
+  for (let at = image.offsets[col]; at < image.offsets[col + 1]; at++) {
+    const z = image.cells[at];
+    if (z >= lo && z <= hi) image.cells[at] = -1;
+  }
+}
+function zoneColumnsOf(l, zone) {
+  if (zone === null) return null;
+  const out = new Uint8Array(l.nx * l.ny);
+  for (let col = 0; col < out.length; col++) {
+    for (let word = 0; word < l.w; word++) {
+      if (zone[col * l.w + word] !== 0) {
+        out[col] = 1;
+        break;
+      }
+    }
+  }
+  return out;
+}
+var MAX_BLOCK_CELLS = 256;
+function cutBlock(input, heights, zoneColumns, bx, by, side, floorRange, out) {
+  const { l, envelope } = input;
+  const { nx, ny, w } = l;
+  const levels = Math.round(Math.log2(side));
+  let blockLo = Number.MAX_SAFE_INTEGER;
+  let blockHi = -1;
+  for (let y = by; y < Math.min(ny, by + side); y++) {
+    for (let x = bx; x < Math.min(nx, bx + side); x++) {
+      const z = heights[y * nx + x];
+      if (z < 0) continue;
+      if (z < blockLo) blockLo = z;
+      if (z > blockHi) blockHi = z;
+    }
+  }
+  if (blockHi < 0) return;
+  const offsets = [];
+  let states = 0;
+  const key = (a, b) => a * (levels + 1) + b;
+  for (let a = 0; a <= levels; a++) {
+    for (let b = 0; b <= levels; b++) {
+      offsets[key(a, b)] = states;
+      states += (side >> a) * (side >> b);
+    }
+  }
+  const lo = new Int16Array(states);
+  const hi = new Int16Array(states);
+  const flags = new Uint8Array(states);
+  const cost = new Int32Array(states);
+  const BLOCKS = 1;
+  const ZONED = 2;
+  const SPLIT_X = 4;
+  const SPLIT_Y = 8;
+  const at = (a, b, x, y) => offsets[key(a, b)] + (y >> b) * (side >> a) + (x >> a);
+  for (let dy = 0; dy < side; dy++) {
+    for (let dx = 0; dx < side; dx++) {
+      const i = at(0, 0, dx, dy);
+      const x = bx + dx;
+      const y = by + dy;
+      const inside = x < nx && y < ny;
+      const col = y * nx + x;
+      const z = inside ? heights[col] : -1;
+      lo[i] = z >= 0 ? z : 32767;
+      hi[i] = z;
+      if (z >= 0) {
+        cost[i] = 1;
+        if (zoneColumns !== null && zoneColumns[col] === 1) flags[i] = ZONED;
+      } else if (inside && anyInRun(l, envelope, col * w, blockLo, blockHi + 1)) {
+        flags[i] = BLOCKS;
+      }
+    }
+  }
+  for (let sum = 1; sum <= 2 * levels; sum++) {
+    for (let a = Math.max(0, sum - levels); a <= Math.min(levels, sum); a++) {
+      const b = sum - a;
+      const stepX = 1 << a;
+      const stepY = 1 << b;
+      for (let y = 0; y < side; y += stepY) {
+        for (let x = 0; x < side; x += stepX) {
+          const i = at(a, b, x, y);
+          const p = a > 0 ? at(a - 1, b, x, y) : at(a, b - 1, x, y);
+          const q = a > 0 ? at(a - 1, b, x + (stepX >> 1), y) : at(a, b - 1, x, y + (stepY >> 1));
+          const low = Math.min(lo[p], lo[q]);
+          const high = Math.max(hi[p], hi[q]);
+          const f2 = (flags[p] | flags[q]) & (BLOCKS | ZONED);
+          lo[i] = low;
+          hi[i] = high;
+          const range = f2 & ZONED ? 0 : floorRange;
+          if (!(f2 & BLOCKS) && (high < 0 || high - low <= range)) {
+            flags[i] = f2;
+            cost[i] = high < 0 ? 0 : 1;
+            continue;
+          }
+          let best = Number.POSITIVE_INFINITY;
+          let split = 0;
+          if (a > 0) {
+            best = cost[at(a - 1, b, x, y)] + cost[at(a - 1, b, x + (stepX >> 1), y)];
+            split = SPLIT_X;
+          }
+          if (b > 0) {
+            const viaY = cost[at(a, b - 1, x, y)] + cost[at(a, b - 1, x, y + (stepY >> 1))];
+            if (viaY < best) {
+              best = viaY;
+              split = SPLIT_Y;
+            }
+          }
+          flags[i] = f2 | split;
+          cost[i] = best;
+        }
+      }
+    }
+  }
+  const stack = [[levels, levels, 0, 0]];
+  while (stack.length > 0) {
+    const [a, b, x, y] = stack.pop();
+    const i = at(a, b, x, y);
+    if (cost[i] === 0) continue;
+    const f2 = flags[i];
+    if (f2 & SPLIT_X) {
+      stack.push([a - 1, b, x + (1 << a >> 1), y], [a - 1, b, x, y]);
+      continue;
+    }
+    if (f2 & SPLIT_Y) {
+      stack.push([a, b - 1, x, y + (1 << b >> 1)], [a, b - 1, x, y]);
+      continue;
+    }
+    let x0 = Number.MAX_SAFE_INTEGER;
+    let x1 = -1;
+    let y0 = Number.MAX_SAFE_INTEGER;
+    let y1 = -1;
+    for (let v = by + y; v < Math.min(ny, by + y + (1 << b)); v++) {
+      for (let u = bx + x; u < Math.min(nx, bx + x + (1 << a)); u++) {
+        if (heights[v * nx + u] < 0) continue;
+        if (u < x0) x0 = u;
+        if (u > x1) x1 = u;
+        if (v < y0) y0 = v;
+        if (v > y1) y1 = v;
+      }
+    }
+    out.push({ x0, x1, y0, y1, lo: lo[i], hi: hi[i], range: f2 & ZONED ? 0 : floorRange });
+  }
+}
+function cutFloor(input, heights, zoneColumns, bounds, floorRange) {
+  const size = Math.max(bounds.x1 - bounds.x0, bounds.y1 - bounds.y0) + 1;
+  const side = Math.min(MAX_BLOCK_CELLS, 2 ** Math.ceil(Math.log2(size)));
+  const out = [];
+  for (let by = bounds.y0; by <= bounds.y1; by += side) {
+    for (let bx = bounds.x0; bx <= bounds.x1; bx += side) cutBlock(input, heights, zoneColumns, bx, by, side, floorRange, out);
+  }
+  return out;
+}
+function trimOffHulls(input, t) {
+  const { l, radius, body } = input;
+  const { nx, w, h } = l;
+  const below = t.lo - t.range - 1;
+  if (below < 0) return true;
+  const edge = radius / h;
+  for (; ; ) {
+    const [i0, i1] = footRange(l, radius, l.x0 + t.x0 * h, l.x0 + (t.x1 + 1) * h, l.x0, l.nx);
+    const [j0, j1] = footRange(l, radius, l.y0 + t.y0 * h, l.y0 + (t.y1 + 1) * h, l.y0, l.ny);
+    let hitI = -1;
+    let hitJ = -1;
+    for (let j = j0; j <= j1 && hitI < 0; j++) {
+      for (let i = i0; i <= i1; i++) {
+        const o = (j * nx + i) * w;
+        if (testBit(body, o, below) && testBit(body, o, t.lo)) {
+          hitI = i;
+          hitJ = j;
+          break;
+        }
+      }
+    }
+    if (hitI < 0) return true;
+    const left = Math.floor(hitI + 0.5 - edge - 1);
+    const right = Math.ceil(hitI + 0.5 + edge);
+    const near = Math.floor(hitJ + 0.5 - edge - 1);
+    const far = Math.ceil(hitJ + 0.5 + edge);
+    const width = t.x1 - t.x0 + 1;
+    const depth = t.y1 - t.y0 + 1;
+    const options = [
+      [(left - t.x0 + 1) * depth, () => {
+        t.x1 = left;
+      }],
+      [(t.x1 - right + 1) * depth, () => {
+        t.x0 = right;
+      }],
+      [(near - t.y0 + 1) * width, () => {
+        t.y1 = near;
+      }],
+      [(t.y1 - far + 1) * width, () => {
+        t.y0 = far;
+      }]
+    ];
+    let best = options[0];
+    for (const option of options) if (option[0] > best[0]) best = option;
+    if (best[0] <= 0) return false;
+    best[1]();
+  }
+}
+function mergeTiles(tiles) {
+  let current = tiles;
+  for (; ; ) {
+    const byEdge = /* @__PURE__ */ new Map();
+    const gone = /* @__PURE__ */ new Set();
+    let merged = false;
+    const tryJoin = (key, edgeKey, t, join3) => {
+      const other = byEdge.get(edgeKey);
+      if (other !== void 0 && !gone.has(other)) {
+        const lo = Math.min(other.lo, t.lo);
+        const hi = Math.max(other.hi, t.hi);
+        if (hi - lo <= Math.min(other.range, t.range)) {
+          join3(other);
+          other.lo = lo;
+          other.hi = hi;
+          gone.add(t);
+          merged = true;
+          return true;
+        }
+      }
+      byEdge.set(key, t);
+      return false;
+    };
+    const sorted = [...current].sort((a, b) => a.y0 - b.y0 || a.x0 - b.x0);
+    for (const t of sorted) {
+      if (tryJoin(`x${t.y0},${t.y1},${t.x1 + 1}`, `x${t.y0},${t.y1},${t.x0}`, t, (o) => {
+        o.x1 = t.x1;
+        byEdge.set(`x${o.y0},${o.y1},${o.x1 + 1}`, o);
+      })) continue;
+    }
+    byEdge.clear();
+    const remaining = sorted.filter((t) => !gone.has(t));
+    gone.clear();
+    for (const t of remaining) {
+      tryJoin(`y${t.x0},${t.x1},${t.y1 + 1}`, `y${t.x0},${t.x1},${t.y0}`, t, (o) => {
+        o.y1 = t.y1;
+        byEdge.set(`y${o.x0},${o.x1},${o.y1 + 1}`, o);
+      });
+    }
+    current = remaining.filter((t) => !gone.has(t));
+    if (!merged) return current;
+  }
+}
+function placeTiles(input, knobs, image, footprintCells, stepCells, index, placed, covered) {
+  const { l } = input;
+  const { nx, ny, h } = l;
+  const zoneColumns = zoneColumnsOf(l, knobs.zone);
+  const minArea = MIN_TILE_FOOTPRINTS * footprintCells * footprintCells;
+  const minTile = MIN_PIECE_SHARE * footprintCells * footprintCells;
+  const heights = new Int16Array(nx * ny).fill(-1);
+  const surface = new Float32Array(nx * ny);
+  const stack = [];
+  for (let start = 0; start < nx * ny; start++) {
+    for (let at = image.offsets[start]; at < image.offsets[start + 1]; at++) {
+      const z0 = image.cells[at];
+      if (z0 < 0) continue;
+      const members = [];
+      const bounds = { x0: nx, x1: -1, y0: ny, y1: -1 };
+      image.cells[at] = -1;
+      heights[start] = z0;
+      surface[start] = image.tops[at];
+      stack.push(start);
+      while (stack.length > 0) {
+        const col = stack.pop();
+        members.push(col);
+        const y = Math.floor(col / nx);
+        const x = col - y * nx;
+        if (x < bounds.x0) bounds.x0 = x;
+        if (x > bounds.x1) bounds.x1 = x;
+        if (y < bounds.y0) bounds.y0 = y;
+        if (y > bounds.y1) bounds.y1 = y;
+        const z = heights[col];
+        for (const next of [x > 0 ? col - 1 : -1, x + 1 < nx ? col + 1 : -1, y > 0 ? col - nx : -1, y + 1 < ny ? col + nx : -1]) {
+          if (next < 0 || heights[next] >= 0) continue;
+          for (let c = image.offsets[next]; c < image.offsets[next + 1]; c++) {
+            const got = image.cells[c];
+            if (got >= 0 && Math.abs(got - z) <= stepCells) {
+              image.cells[c] = -1;
+              heights[next] = got;
+              surface[next] = image.tops[c];
+              stack.push(next);
+              break;
+            }
+          }
+        }
+      }
+      if (members.length >= minArea) {
+        for (const t of mergeTiles(cutFloor(input, heights, zoneColumns, bounds, knobs.floorRange))) {
+          if ((t.x1 - t.x0 + 1) * (t.y1 - t.y0 + 1) < minTile) continue;
+          if (!trimOffHulls(input, t)) continue;
+          let lowest = Number.POSITIVE_INFINITY;
+          let highest = Number.NEGATIVE_INFINITY;
+          for (let y = t.y0; y <= t.y1; y++) {
+            for (let x = t.x0; x <= t.x1; x++) {
+              const col = y * nx + x;
+              if (heights[col] < 0) continue;
+              lowest = Math.min(lowest, surface[col]);
+              highest = Math.max(highest, surface[col]);
+            }
+          }
+          if (highest === Number.NEGATIVE_INFINITY) continue;
+          const topZ = (lowest + highest) / 2;
+          const top = Math.max(t.lo + 1, cellCeil((topZ - l.z0) / l.h));
+          const bottom = floorBottom(input, t.x0, t.x1, t.y0, t.y1, t.lo, TILE_DEPTH_CELLS + TILE_DEPTH_RANGES * t.range);
+          const zLow = Math.min(bottom, top - 1);
+          const box = [f(l.x0 + t.x0 * h), f(l.y0 + t.y0 * h), f(plane(l, zLow)), f(l.x0 + (t.x1 + 1) * h), f(l.y0 + (t.y1 + 1) * h), f(topZ)];
+          placed.boxes.push(box);
+          placed.boxInfo.push({ stage: SolidStage.Tile, actor: index.owner([box[0], box[1], box[2]], [box[3], box[4], box[5]]) });
+          markBox(input, covered, box, zLow, t.hi);
+        }
+      }
+      for (const col of members) heights[col] = -1;
+    }
+  }
+}
+function growRamp(image, l, i, j, z, axis, range, maxSlope) {
+  const { nx, ny } = l;
+  const half = range / 2 + 0.5;
+  const along = axis === 0 ? nx : ny;
+  const across = axis === 0 ? ny : nx;
+  const colAt = (a, b) => axis === 0 ? b * nx + a : a * nx + b;
+  const m = axis === 0 ? i : j;
+  const n = axis === 0 ? j : i;
+  const heights = [];
+  let hi = m;
+  let cur = z;
+  const follow = (a, near) => floorIn(image, colAt(a, n), near - 2, near + 2);
+  while (hi + 1 < along) {
+    const got = follow(hi + 1, cur);
+    if (got < 0) break;
+    heights.push(got);
+    cur = got;
+    hi += 1;
+  }
+  let lo = m;
+  cur = z;
+  const before = [];
+  while (lo - 1 >= 0) {
+    const got = follow(lo - 1, cur);
+    if (got < 0) break;
+    before.push(got);
+    cur = got;
+    lo -= 1;
+  }
+  const line = [...before.reverse(), z, ...heights];
+  let a0 = 0;
+  let a1 = line.length - 1;
+  const fitsLine = (p, q) => {
+    const s = (line[q] - line[p]) / Math.max(1, q - p);
+    if (Math.abs(s) > maxSlope) return false;
+    for (let k = p; k <= q; k++) if (Math.abs(line[k] - (line[p] + s * (k - p))) > half) return false;
+    return true;
+  };
+  const centre = m - lo;
+  while (!fitsLine(a0, a1)) {
+    if (centre - a0 > a1 - centre) a0 += 1;
+    else a1 -= 1;
+    if (a1 - a0 < 4) return null;
+  }
+  const slope = (line[a1] - line[a0]) / Math.max(1, a1 - a0);
+  const first = lo + a0;
+  const last = lo + a1;
+  const startZ = line[a0];
+  const holds = (b) => {
+    for (let a = first; a <= last; a++) {
+      const want = startZ + slope * (a - first);
+      if (floorIn(image, colAt(a, b), Math.floor(want - half), Math.ceil(want + half)) < 0) return false;
+    }
+    return true;
+  };
+  let b0 = n;
+  let b1 = n;
+  while (b1 + 1 < across && holds(b1 + 1)) b1 += 1;
+  while (b0 - 1 >= 0 && holds(b0 - 1)) b0 -= 1;
+  const area = (last - first + 1) * (b1 - b0 + 1);
+  return axis === 0 ? { axis, i0: first, i1: last, j0: b0, j1: b1, start: startZ, slope, area } : { axis, i0: b0, i1: b1, j0: first, j1: last, start: startZ, slope, area };
+}
+function placeRamps(input, knobs, image, footprintCells, index, placed, covered) {
+  if (knobs.maxRamps <= 0) return;
+  for (let pass = 0; pass < RAMP_PASSES && placed.ramps.length < knobs.maxRamps; pass++) {
+    const before = placed.ramps.length;
+    rampPass(input, knobs, image, footprintCells, index, placed, covered);
+    if (placed.ramps.length === before) return;
+  }
+}
+function rampPass(input, knobs, image, footprintCells, index, placed, covered) {
+  const { l } = input;
+  const { nx, ny, h } = l;
+  const stride = Math.max(1, Math.round(RAMP_SEED_STRIDE_FOOTPRINTS * footprintCells));
+  const minArea = MIN_RAMP_FOOTPRINTS * footprintCells * footprintCells;
+  const zoneColumns = zoneColumnsOf(l, knobs.zone);
+  const candidates = [];
+  const range = Math.max(knobs.floorRange, 1);
+  const maxSlope = 0.95;
+  for (let j = 0; j < ny; j += stride) {
+    for (let i = 0; i < nx; i += stride) {
+      const col = j * nx + i;
+      if (image.offsets[col] === image.offsets[col + 1]) continue;
+      if (zoneColumns !== null && zoneColumns[col] === 1) continue;
+      let z = -1;
+      for (let at = image.offsets[col]; at < image.offsets[col + 1] && z < 0; at++) z = image.cells[at];
+      if (z < 0) continue;
+      for (const axis of [0, 1]) {
+        const c = growRamp(image, l, i, j, z, axis, range, maxSlope);
+        if (c !== null && c.area >= minArea && Math.abs(c.slope) * (axis === 0 ? c.i1 - c.i0 : c.j1 - c.j0) >= 2) candidates.push(c);
+      }
+    }
+  }
+  candidates.sort((p, q) => q.area - p.area || p.j0 - q.j0 || p.i0 - q.i0 || p.axis - q.axis);
+  const half = range / 2 + 0.5;
+  for (const c of candidates) {
+    if (placed.ramps.length >= knobs.maxRamps) return;
+    const wantAt = (x, y) => c.start + c.slope * (c.axis === 0 ? x - c.i0 : y - c.j0);
+    let whole = true;
+    let lowest = Number.POSITIVE_INFINITY;
+    let highest = Number.NEGATIVE_INFINITY;
+    for (let y = c.j0; y <= c.j1 && whole; y++) {
+      for (let x = c.i0; x <= c.i1; x++) {
+        const want = wantAt(x, y);
+        const got = floorIn(image, y * nx + x, Math.floor(want - half), Math.ceil(want + half));
+        if (got < 0 || zoneColumns !== null && zoneColumns[y * nx + x] === 1) {
+          whole = false;
+          break;
+        }
+        if (got < lowest) lowest = got;
+        if (got > highest) highest = got;
+      }
+    }
+    if (!whole) continue;
+    const span = c.axis === 0 ? c.i1 - c.i0 : c.j1 - c.j0;
+    const lo = c.start + 0.5 - 0.5 * c.slope;
+    const hi = c.start + 0.5 + c.slope * (span + 0.5);
+    const low = floorBottom(input, c.i0, c.i1, c.j0, c.j1, Math.min(lowest, Math.floor(Math.min(lo, hi)) - 1), TILE_DEPTH_CELLS + TILE_DEPTH_RANGES * range);
+    const zLo = f(plane(l, 0) + lo * h);
+    const zHi = f(plane(l, 0) + hi * h);
+    const minZ = f(plane(l, low));
+    if (!(minZ <= zLo && minZ <= zHi)) continue;
+    const m0Try = c.axis === 0 ? l.x0 + c.i0 * h : l.y0 + c.j0 * h;
+    const m1Try = c.axis === 0 ? l.x0 + (c.i1 + 1) * h : l.y0 + (c.j1 + 1) * h;
+    const [hullI0, hullI1] = footRange(l, input.radius, l.x0 + c.i0 * h, l.x0 + (c.i1 + 1) * h, l.x0, nx);
+    const [hullJ0, hullJ1] = footRange(l, input.radius, l.y0 + c.j0 * h, l.y0 + (c.j1 + 1) * h, l.y0, ny);
+    let clear = true;
+    for (let y = hullJ0; y <= hullJ1 && clear; y++) {
+      for (let x = hullI0; x <= hullI1; x++) {
+        const centre = c.axis === 0 ? centreX(l, x) : centreY(l, y);
+        const uphill = zHi >= zLo ? Math.min(m1Try, centre + input.radius) : Math.max(m0Try, centre - input.radius);
+        const planeZ = zLo + (zHi - zLo) * (uphill - m0Try) / (m1Try - m0Try);
+        const top = cellCeil((planeZ - l.z0) / h) - 1;
+        const under = top - range - 2;
+        const o = (y * nx + x) * l.w;
+        if (under >= 0 && testBit(input.body, o, under) && testBit(input.body, o, top)) {
+          clear = false;
+          break;
+        }
+      }
+    }
+    if (!clear) continue;
+    const ramp = [f(l.x0 + c.i0 * h), f(l.y0 + c.j0 * h), minZ, f(l.x0 + (c.i1 + 1) * h), f(l.y0 + (c.j1 + 1) * h), Math.max(zLo, zHi), c.axis, zLo, zHi];
+    placed.ramps.push(ramp);
+    placed.rampInfo.push({ stage: SolidStage.Ramp, actor: index.owner([ramp[0], ramp[1], ramp[2]], [ramp[3], ramp[4], ramp[5]]) });
+    for (let y = c.j0; y <= c.j1; y++) {
+      for (let x = c.i0; x <= c.i1; x++) {
+        const want = wantAt(x, y);
+        consume(image, y * nx + x, Math.floor(want - half), Math.ceil(want + half));
+      }
+    }
+    const [i0, i1] = footRange(l, input.radius, ramp[0], ramp[3], l.x0, nx);
+    const [j0, j1] = footRange(l, input.radius, ramp[1], ramp[4], l.y0, ny);
+    const m0 = c.axis === 0 ? ramp[0] : ramp[1];
+    const m1 = c.axis === 0 ? ramp[3] : ramp[4];
+    for (let y = j0; y <= j1; y++) {
+      for (let x = i0; x <= i1; x++) {
+        const centre = c.axis === 0 ? centreX(l, x) : centreY(l, y);
+        const uphill = zHi >= zLo ? Math.min(m1, centre + input.radius) : Math.max(m0, centre - input.radius);
+        const planeZ = zLo + (zHi - zLo) * (uphill - m0) / (m1 - m0);
+        setRun(l, covered, (y * nx + x) * l.w, low, cellCeil((planeZ - l.z0) / h) - 1 + Math.ceil(half));
+      }
+    }
+  }
+}
+function placeFloors(input, knobs, footprintCells, stepCells, index, placed, covered, exactSolid, floors) {
+  const image = floorsLeft(input.l, floors, exactSolid);
+  placeRamps(input, knobs, image, footprintCells, index, placed, covered);
+  placeTiles(input, knobs, image, footprintCells, stepCells, index, placed, covered);
+}
+function mustCover(input, knobs, covered) {
+  const { l, body, foot } = input;
+  const { nx, ny, w } = l;
+  const near = knobs.slack > 0 ? dilateXY(l, body, knobs.slack) : body.slice();
+  if (knobs.zone !== null) {
+    for (let at = 0; at < near.length; at++) near[at] = (body[at] | near[at] & ~knobs.zone[at]) >>> 0;
+  }
+  const must = newLayer(l);
+  const seal = (open, skip) => {
+    for (let j = 0; j < ny; j++) {
+      for (let i = 0; i < nx; i++) {
+        const o = (j * nx + i) * w;
+        for (let word = 0; word < w; word++) {
+          let candidate = (foot[o + word] & ~open[o + word] & ~input.leanCells[o + word]) >>> 0;
+          if (skip !== null) candidate = (candidate & ~skip[o + word]) >>> 0;
+          if (candidate === 0) continue;
+          const up = word + 1 < w ? open[o + word + 1] : 0;
+          const down = word > 0 ? open[o + word - 1] : 0;
+          let touching = open[o + word] << 1 | down >>> 31 | open[o + word] >>> 1 | up << 31;
+          if (i > 0) touching |= open[o - w + word];
+          if (i + 1 < nx) touching |= open[o + w + word];
+          if (j > 0) touching |= open[o - nx * w + word];
+          if (j + 1 < ny) touching |= open[o + nx * w + word];
+          must[o + word] = (must[o + word] | candidate & touching) >>> 0;
+        }
+      }
+    }
+  };
+  seal(near, covered);
+  const sink = Math.ceil((knobs.floorRange + 1) / 2);
+  if (knobs.floorRange > 0) {
+    for (let o = 0; o < must.length; o += w) {
+      for (let word = 0; word < w; word++) {
+        let bits = must[o + word];
+        while (bits !== 0) {
+          const bit = 31 - Math.clz32(bits & -bits);
+          bits = (bits & bits - 1) >>> 0;
+          const z = word * 32 + bit;
+          if (z > 0 && anyInRun(l, covered, o, z - sink, z - 1)) must[o + word] = (must[o + word] & ~(1 << bit)) >>> 0;
+        }
+      }
+    }
+  }
+  seal(reachDown(l, near, sink + 1), covered);
+  seal(reachUp(l, near, sink + 1), covered);
+  if (knobs.slack === 0) seal(input.touch, covered);
+  const { nz } = l;
+  for (let o = 0; o < must.length; o += w) {
+    let z = firstSet(l, must, o, 0, nz - 1);
+    while (z >= 0) {
+      const clear = firstClear(l, foot, o, z, nz - 1);
+      const top = clear < 0 ? nz - 1 : clear - 1;
+      if (top >= z) setRun(l, must, o, z, top);
+      z = top + 1 < nz ? firstSet(l, must, o, top + 1, nz - 1) : -1;
+    }
+    for (let word = 0; word < w; word++) must[o + word] = (must[o + word] & ~covered[o + word] & ~near[o + word]) >>> 0;
+  }
+  return must;
+}
+function rectSolid(input, r) {
+  const { l, radius } = input;
+  const { h } = l;
+  const span = (lo, hi) => {
+    const a = lo + radius - h / 2;
+    const b = hi - radius + h / 2;
+    const hair = h * SEAM_OVERLAP_CELLS;
+    if (b - a >= h * MIN_THICKNESS_CELLS) return [a - hair, b + hair];
+    const mid = (a + b) / 2;
+    return [mid - h * MIN_THICKNESS_CELLS / 2 - hair, mid + h * MIN_THICKNESS_CELLS / 2 + hair];
+  };
+  const [x0, x1] = span(centreX(l, r.x0), centreX(l, r.x1));
+  const [y0, y1] = span(centreY(l, r.y0), centreY(l, r.y1));
+  return [f(x0), f(y0), f(plane(l, r.z0)), f(x1), f(y1), f(plane(l, r.z1 + 1))];
+}
+function placeCover(input, must, footprintCells, index, placed, limit, keepTops) {
+  const { l, body, foot } = input;
+  const { nx, ny, nz, w } = l;
+  let count = 0;
+  let stuck = 0;
+  const W = footprintCells;
+  const faceClear = (x0, x1, y0, y1, z0, z1) => {
+    if (x0 < 0 || y0 < 0 || z0 < 0 || x1 >= nx || y1 >= ny || z1 >= nz) return false;
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) if (anyInRun(l, body, (y * nx + x) * w, z0, z1)) return false;
+    }
+    return true;
+  };
+  const faceHasMust = (x0, x1, y0, y1, z0, z1) => {
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) if (anyInRun(l, must, (y * nx + x) * w, z0, z1)) return true;
+    }
+    return false;
+  };
+  const gain = (r) => {
+    let total = 0;
+    for (let y = r.y0; y <= r.y1; y++) {
+      for (let x = r.x0; x <= r.x1; x++) total += countInRun(l, must, (y * nx + x) * w, r.z0, r.z1);
+    }
+    return total;
+  };
+  const grow = (r, axis) => {
+    let moved = true;
+    while (moved) {
+      moved = false;
+      if (axis === 0) {
+        if (r.x1 - r.x0 < MAX_GROW_CELLS && faceClear(r.x1 + 1, r.x1 + 1, r.y0, r.y1, r.z0, r.z1) && faceHasMust(r.x1 + 1, r.x1 + 1, r.y0, r.y1, r.z0, r.z1) && topOk(r.x1 + 1, r.x1 + 1, r.y0, r.y1, r.z1)) {
+          r.x1 += 1;
+          moved = true;
+        }
+        if (r.x1 - r.x0 < MAX_GROW_CELLS && faceClear(r.x0 - 1, r.x0 - 1, r.y0, r.y1, r.z0, r.z1) && faceHasMust(r.x0 - 1, r.x0 - 1, r.y0, r.y1, r.z0, r.z1) && topOk(r.x0 - 1, r.x0 - 1, r.y0, r.y1, r.z1)) {
+          r.x0 -= 1;
+          moved = true;
+        }
+      } else if (axis === 1) {
+        if (r.y1 - r.y0 < MAX_GROW_CELLS && faceClear(r.x0, r.x1, r.y1 + 1, r.y1 + 1, r.z0, r.z1) && faceHasMust(r.x0, r.x1, r.y1 + 1, r.y1 + 1, r.z0, r.z1) && topOk(r.x0, r.x1, r.y1 + 1, r.y1 + 1, r.z1)) {
+          r.y1 += 1;
+          moved = true;
+        }
+        if (r.y1 - r.y0 < MAX_GROW_CELLS && faceClear(r.x0, r.x1, r.y0 - 1, r.y0 - 1, r.z0, r.z1) && faceHasMust(r.x0, r.x1, r.y0 - 1, r.y0 - 1, r.z0, r.z1) && topOk(r.x0, r.x1, r.y0 - 1, r.y0 - 1, r.z1)) {
+          r.y0 -= 1;
+          moved = true;
+        }
+      } else {
+        if (r.z1 - r.z0 < MAX_GROW_CELLS && faceClear(r.x0, r.x1, r.y0, r.y1, r.z1 + 1, r.z1 + 1) && faceHasMust(r.x0, r.x1, r.y0, r.y1, r.z1 + 1, r.z1 + 1) && topOk(r.x0, r.x1, r.y0, r.y1, r.z1 + 1)) {
+          r.z1 += 1;
+          moved = true;
+        }
+        if (r.z1 - r.z0 < MAX_GROW_CELLS && faceClear(r.x0, r.x1, r.y0, r.y1, r.z0 - 1, r.z0 - 1) && faceHasMust(r.x0, r.x1, r.y0, r.y1, r.z0 - 1, r.z0 - 1)) {
+          r.z0 -= 1;
+          moved = true;
+        }
+      }
+    }
+  };
+  const topOk = (x0, x1, y0, y1, z) => {
+    if (!keepTops) return true;
+    if (z < 0 || z >= nz) return false;
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) if (!testBit(foot, (y * nx + x) * w, z)) return false;
+    }
+    return true;
+  };
+  const allSolid = (r, z) => {
+    if (z < 0 || z >= nz) return false;
+    for (let y = r.y0; y <= r.y1; y++) {
+      for (let x = r.x0; x <= r.x1; x++) if (!testBit(foot, (y * nx + x) * w, z)) return false;
+    }
+    return true;
+  };
+  for (let j = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const o = (j * nx + i) * w;
+      for (; ; ) {
+        const z = firstSet(l, must, o, 0, nz - 1);
+        if (z < 0) break;
+        let bestX = -1;
+        let bestY = -1;
+        let bestScore = -1;
+        const tryWindow = (wx, wy) => {
+          if (wx < 0 || wy < 0 || wx + W > nx || wy + W > ny) return;
+          if (!faceClear(wx, wx + W - 1, wy, wy + W - 1, z, z) || !topOk(wx, wx + W - 1, wy, wy + W - 1, z)) return;
+          const score = gain({ x0: wx, x1: wx + W - 1, y0: wy, y1: wy + W - 1, z0: z, z1: z });
+          if (score > bestScore) {
+            bestScore = score;
+            bestX = wx;
+            bestY = wy;
+          }
+        };
+        for (const oy of WINDOW_TRIES) for (const ox of WINDOW_TRIES) tryWindow(i - Math.floor(ox * (W - 1)), j - Math.floor(oy * (W - 1)));
+        if (bestX < 0) {
+          for (let wy = j - W + 1; wy <= j; wy++) for (let wx = i - W + 1; wx <= i; wx++) tryWindow(wx, wy);
+        }
+        if (bestX < 0) {
+          stuck += 1;
+          clearRun(l, must, o, z, z);
+          continue;
+        }
+        const seed = { x0: bestX, x1: bestX + W - 1, y0: bestY, y1: bestY + W - 1, z0: z, z1: z };
+        let best = seed;
+        let bestGain = -1;
+        for (const order of [[0, 1, 2], [1, 0, 2], [2, 0, 1], [2, 1, 0]]) {
+          const r = { ...seed };
+          for (const axis of order) grow(r, axis);
+          const got = gain(r);
+          if (got > bestGain) {
+            bestGain = got;
+            best = r;
+          }
+        }
+        while (best.z1 + 1 < nz && allSolid(best, best.z1 + 1) && faceClear(best.x0, best.x1, best.y0, best.y1, best.z1 + 1, best.z1 + 1)) best.z1 += 1;
+        while (best.z0 - 1 >= 0 && allSolid(best, best.z0 - 1) && faceClear(best.x0, best.x1, best.y0, best.y1, best.z0 - 1, best.z0 - 1)) best.z0 -= 1;
+        for (let y = best.y0; y <= best.y1; y++) {
+          for (let x = best.x0; x <= best.x1; x++) clearRun(l, must, (y * nx + x) * w, best.z0, best.z1);
+        }
+        const box = rectSolid(input, best);
+        placed.boxes.push(box);
+        placed.boxInfo.push({ stage: SolidStage.Cover, actor: index.owner([box[0], box[1], box[2]], [box[3], box[4], box[5]]) });
+        count += 1;
+        if (count > limit) return { placed: count, stuck, overLimit: true };
+      }
+    }
+  }
+  return { placed: count, stuck, overLimit: false };
+}
+var SLIT_BIN_CELLS = 32;
+function closeSlits(input, placed, crouchHeight) {
+  const { l, radius, body } = input;
+  const { h, nx, ny, w } = l;
+  const bins = /* @__PURE__ */ new Map();
+  const pad = radius + h;
+  const size = SLIT_BIN_CELLS * h;
+  const binsOf = (b, visit) => {
+    for (let a = Math.floor((b[0] - pad) / size); a <= Math.floor((b[3] + pad) / size); a++) {
+      for (let c = Math.floor((b[1] - pad) / size); c <= Math.floor((b[4] + pad) / size); c++) visit(a * 1000003 + c);
+    }
+  };
+  placed.boxes.forEach((b, i) => binsOf(b, (key) => {
+    const list = bins.get(key);
+    if (list === void 0) bins.set(key, [i]);
+    else list.push(i);
+  }));
+  const holdsPoint = (from, to, origin) => {
+    const first = cellCeil((from - origin) / h - 0.5);
+    return origin + (first + 0.5) * h <= to;
+  };
+  const takesBody = (b, axis, sign, from, to) => {
+    const other = axis === 0 ? 1 : 0;
+    const origin = axis === 0 ? l.x0 : l.y0;
+    const count = axis === 0 ? nx : ny;
+    const [lo, hi] = sign > 0 ? [from, to] : [to, from];
+    const first = Math.max(0, cellCeil((lo - origin) / h - 0.5));
+    const last = Math.min(count - 1, cellFloor((hi - origin) / h - 0.5));
+    const otherOrigin = axis === 0 ? l.y0 : l.x0;
+    const otherCount = axis === 0 ? ny : nx;
+    const from2 = Math.max(0, cellCeil((b[other] - radius - otherOrigin) / h - 0.5));
+    const to2 = Math.min(otherCount - 1, cellFloor((b[other + 3] + radius - otherOrigin) / h - 0.5));
+    const zLow = cellFloor((b[2] - l.z0) / h);
+    const zHigh = cellCeil((b[5] - l.z0) / h) - 1;
+    for (let m = first; m <= last; m++) {
+      for (let n = from2; n <= to2; n++) {
+        const col = axis === 0 ? n * nx + m : m * nx + n;
+        if (anyInRun(l, body, col * w, zLow, zHigh)) return true;
+      }
+    }
+    return false;
+  };
+  let closed = 0;
+  for (let i = 0; i < placed.boxes.length; i++) {
+    if (placed.boxInfo[i]?.stage !== SolidStage.Cover) continue;
+    const b = placed.boxes[i];
+    const near = /* @__PURE__ */ new Set();
+    binsOf(b, (key) => {
+      for (const j of bins.get(key) ?? []) near.add(j);
+    });
+    for (const j of near) {
+      if (j === i) continue;
+      const o = placed.boxes[j];
+      if (Math.min(b[5], o[5]) - Math.max(b[2], o[2]) < crouchHeight) continue;
+      for (const axis of [0, 1]) {
+        const other = axis === 0 ? 1 : 0;
+        const along = b[other] - radius < o[other + 3] + radius && o[other] - radius < b[other + 3] + radius;
+        if (!along) continue;
+        const origin = axis === 0 ? l.x0 : l.y0;
+        const overlap = 2 * h * SEAM_OVERLAP_CELLS;
+        const up = o[axis] - radius - (b[axis + 3] + radius);
+        if (up > -overlap && up < h && !(up > 0 && holdsPoint(b[axis + 3] + radius, o[axis] - radius, origin))) {
+          const edge = b[axis + 3] + radius;
+          if (!takesBody(b, axis, 1, edge, o[axis] - radius + overlap)) {
+            b[axis + 3] = f(o[axis] - 2 * radius + overlap);
+            closed += 1;
+          }
+        }
+        const down = b[axis] - radius - (o[axis + 3] + radius);
+        if (down > -overlap && down < h && !(down > 0 && holdsPoint(o[axis + 3] + radius, b[axis] - radius, origin))) {
+          const edge = b[axis] - radius;
+          if (!takesBody(b, axis, -1, edge, o[axis + 3] + radius - overlap)) {
+            b[axis] = f(o[axis + 3] + 2 * radius - overlap);
+            closed += 1;
+          }
+        }
+      }
+    }
+  }
+  return closed;
+}
+function countOpenSlits(input, placed, crouchHeight) {
+  const { l, radius } = input;
+  const { h } = l;
+  const size = SLIT_BIN_CELLS * h;
+  const pad = radius + h;
+  const bins = /* @__PURE__ */ new Map();
+  const keysOf = (b) => {
+    const keys = [];
+    for (let a = Math.floor((b[0] - pad) / size); a <= Math.floor((b[3] + pad) / size); a++) {
+      for (let c = Math.floor((b[1] - pad) / size); c <= Math.floor((b[4] + pad) / size); c++) keys.push(a * 1000003 + c);
+    }
+    return keys;
+  };
+  placed.boxes.forEach((b, i) => {
+    for (const key of keysOf(b)) {
+      const list = bins.get(key);
+      if (list === void 0) bins.set(key, [i]);
+      else list.push(i);
+    }
+  });
+  const shutByAnother = (i, j, axis, at) => {
+    const b = placed.boxes[i];
+    const o = placed.boxes[j];
+    const other = axis === 0 ? 1 : 0;
+    const along = (Math.max(b[other], o[other]) + Math.min(b[other + 3], o[other + 3])) / 2;
+    const zLow = Math.max(b[2], o[2]);
+    const zHigh = Math.min(b[5], o[5]);
+    const x = axis === 0 ? at : along;
+    const y = axis === 0 ? along : at;
+    const reach = radius + 2 * h * GAP_MARGIN_CELLS;
+    for (const k of bins.get(Math.floor(x / size) * 1000003 + Math.floor(y / size)) ?? []) {
+      if (k === i || k === j) continue;
+      const c = placed.boxes[k];
+      const covers = c[0] - reach < x && c[3] + reach > x && c[1] - reach < y && c[4] + reach > y && c[2] <= zLow && c[5] >= zHigh;
+      if (covers) return true;
+    }
+    return false;
+  };
+  let open = 0;
+  placed.boxes.forEach((b, i) => {
+    const near = /* @__PURE__ */ new Set();
+    for (const key of keysOf(b)) for (const j of bins.get(key) ?? []) if (j > i) near.add(j);
+    for (const j of near) {
+      const o = placed.boxes[j];
+      const bothExact = placed.boxInfo[i]?.stage === SolidStage.Exact && placed.boxInfo[j]?.stage === SolidStage.Exact;
+      if (bothExact || Math.min(b[5], o[5]) - Math.max(b[2], o[2]) < crouchHeight) continue;
+      for (const axis of [0, 1]) {
+        const other = axis === 0 ? 1 : 0;
+        if (!(b[other] - radius < o[other + 3] + radius && o[other] - radius < b[other + 3] + radius)) continue;
+        const origin = axis === 0 ? l.x0 : l.y0;
+        const [from, to] = o[axis] >= b[axis + 3] ? [b[axis + 3] + radius, o[axis] - radius] : [o[axis + 3] + radius, b[axis] - radius];
+        const overlap = 2 * h * GAP_MARGIN_CELLS;
+        if (to - from >= h || to - from <= -overlap) continue;
+        const first = cellCeil((from - origin) / h - 0.5);
+        const isSlit = to <= from || origin + (first + 0.5) * h > to;
+        if (isSlit && !shutByAnother(i, j, axis, (from + to) / 2)) open += 1;
+      }
+    }
+  });
+  return open;
+}
+function propActors(actors, radius) {
+  const out = [];
+  const small = 8 * radius;
+  for (const [index, actor] of actors.entries()) {
+    const surfaces = actor.surfaces.filter((s) => blocksHull(actor, s));
+    if (surfaces.length === 0) continue;
+    if (actor.tags.includes(SceneTag.Prop)) {
+      out.push(index);
+      continue;
+    }
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const s of surfaces) {
+      const box = surfaceBounds(s);
+      minX = Math.min(minX, box.min[0]);
+      minY = Math.min(minY, box.min[1]);
+      maxX = Math.max(maxX, box.max[0]);
+      maxY = Math.max(maxY, box.max[1]);
+    }
+    if (maxX - minX <= small && maxY - minY <= small) out.push(index);
+  }
+  return out;
+}
+function rasterWorld(l, radius, world) {
+  const foot = newLayer(l);
+  const { h, nx, w } = l;
+  for (const b of world.boxes) {
+    const [i0, i1] = footRange(l, radius, b[0], b[3], l.x0, l.nx);
+    const [j0, j1] = footRange(l, radius, b[1], b[4], l.y0, l.ny);
+    const a = cellFloor((b[2] - l.z0) / h);
+    const c = Math.max(a, cellCeil((b[5] - l.z0) / h) - 1);
+    for (let j = j0; j <= j1; j++) {
+      for (let i = i0; i <= i1; i++) setRun(l, foot, (j * nx + i) * w, a, c);
+    }
+  }
+  for (const r of world.ramps) {
+    const [i0, i1] = footRange(l, radius, r[0], r[3], l.x0, l.nx);
+    const [j0, j1] = footRange(l, radius, r[1], r[4], l.y0, l.ny);
+    const a = cellFloor((r[2] - l.z0) / h);
+    const axis = r[6];
+    const m0 = axis === 0 ? r[0] : r[1];
+    const m1 = axis === 0 ? r[3] : r[4];
+    const lo = r[7];
+    const hi = r[8];
+    for (let j = j0; j <= j1; j++) {
+      for (let i = i0; i <= i1; i++) {
+        const centre = axis === 0 ? centreX(l, i) : centreY(l, j);
+        const uphill = hi >= lo ? Math.min(m1, centre + radius) : Math.max(m0, centre - radius);
+        const top = lo + (hi - lo) * (uphill - m0) / (m1 - m0);
+        setRun(l, foot, (j * nx + i) * w, a, Math.max(a, cellCeil((top - l.z0) / h) - 1));
+      }
+    }
+  }
+  return foot;
+}
+
+// src/world-fit/narrow.ts
+var FINE_PER_CELL = [16, 32];
+var SIDE_REACH_CELLS = 3;
+var STRIP_HEIGHTS = 8;
+var STRIP_END_CELLS = 2;
+function readAbove(l, from, up) {
+  const out = newLayer(l);
+  const words = up >>> 5;
+  const bits = up & 31;
+  for (let o = 0; o < from.length; o += l.w) {
+    for (let i = 0; i + words < l.w; i++) {
+      const a = from[o + i + words];
+      const b = i + words + 1 < l.w ? from[o + i + words + 1] : 0;
+      out[o + i] = (bits === 0 ? a : a >>> bits | b << 32 - bits) >>> 0;
+    }
+  }
+  return out;
+}
+function stripCells(l, trueBlocked, narrowBlocked, narrowFoot, crouchCells) {
+  const { nx, ny, w } = l;
+  const walls = readAbove(l, narrowFoot, crouchCells - 1);
+  const out = newLayer(l);
+  const narrowAt = (i, j, word) => i < 0 || j < 0 || i >= nx || j >= ny ? 4294967295 : walls[(j * nx + i) * w + word];
+  for (let j = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const o = (j * nx + i) * w;
+      for (let word = 0; word < w; word++) {
+        const open = (trueBlocked[o + word] & ~narrowBlocked[o + word]) >>> 0;
+        if (open === 0) continue;
+        let across = 0;
+        for (const [dx, dy] of [[1, 0], [0, 1]]) {
+          const a1 = narrowAt(i - dx, j - dy, word);
+          const b1 = narrowAt(i + dx, j + dy, word);
+          const a2 = narrowAt(i - 2 * dx, j - 2 * dy, word);
+          const b2 = narrowAt(i + 2 * dx, j + 2 * dy, word);
+          across = (across | a1 & b1 | a1 & b2 | a2 & b1) >>> 0;
+        }
+        out[o + word] = (open & across) >>> 0;
+      }
+    }
+  }
+  return out;
+}
+function gatherStrips(l, strip) {
+  const { nx, ny, nz, w } = l;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let col = 0; col < nx * ny; col++) {
+    for (let word = 0; word < w; word++) {
+      let bits = strip[col * w + word];
+      while (bits !== 0) {
+        const bit = 31 - Math.clz32(bits & -bits);
+        bits = (bits & bits - 1) >>> 0;
+        const start = col * nz + word * 32 + bit;
+        if (seen.has(start)) continue;
+        const j0 = Math.floor(col / nx);
+        const found = { cells: [], x0: col - j0 * nx, x1: col - j0 * nx, y0: j0, y1: j0, z0: word * 32 + bit, z1: word * 32 + bit };
+        const stack = [start];
+        seen.add(start);
+        while (stack.length > 0) {
+          const node = stack.pop();
+          found.cells.push(node);
+          const k = node % nz;
+          const c = (node - k) / nz;
+          const y = Math.floor(c / nx);
+          const x = c - y * nx;
+          found.x0 = Math.min(found.x0, x);
+          found.x1 = Math.max(found.x1, x);
+          found.y0 = Math.min(found.y0, y);
+          found.y1 = Math.max(found.y1, y);
+          found.z0 = Math.min(found.z0, k);
+          found.z1 = Math.max(found.z1, k);
+          for (const [dx, dy, dz] of [[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]]) {
+            const nextX = x + dx;
+            const nextY = y + dy;
+            const nextK = k + dz;
+            if (nextX < 0 || nextY < 0 || nextX >= nx || nextY >= ny || nextK < 0 || nextK >= nz) continue;
+            const nextCol = nextY * nx + nextX;
+            if ((strip[nextCol * w + (nextK >>> 5)] >>> (nextK & 31) & 1) === 0) continue;
+            const next = nextCol * nz + nextK;
+            if (seen.has(next)) continue;
+            seen.add(next);
+            stack.push(next);
+          }
+        }
+        out.push(found);
+      }
+    }
+  }
+  return out;
+}
+function stripIsOpen(l, actors, radius, crouchCells, s, trueBlocked) {
+  const { h, nx, w } = l;
+  const reach = SIDE_REACH_CELLS;
+  const stride = Math.max(1, Math.ceil((s.z1 - s.z0 + 1) / STRIP_HEIGHTS));
+  const heights = [];
+  for (let k = s.z0; k <= s.z1; k += stride) {
+    const sides = [];
+    for (let y = Math.max(0, s.y0 - reach); y <= Math.min(l.ny - 1, s.y1 + reach); y++) {
+      for (let x = Math.max(0, s.x0 - reach); x <= Math.min(nx - 1, s.x1 + reach); x++) {
+        const inBox = x >= s.x0 && x <= s.x1 && y >= s.y0 && y <= s.y1;
+        if (!inBox && (trueBlocked[(y * nx + x) * w + (k >>> 5)] >>> (k & 31) & 1) === 0) sides.push([x, y]);
+      }
+    }
+    if (sides.length >= 2 && coarseSeparated(l, sides, s, trueBlocked, k, reach)) heights.push({ k, sides });
+  }
+  if (heights.length === 0) return false;
+  const pad = reach * h;
+  const zLow = heights[0].k;
+  const zHigh = heights[heights.length - 1].k + crouchCells;
+  const min = [l.x0 + s.x0 * h - pad, l.y0 + s.y0 * h - pad, l.z0 + zLow * h];
+  const max = [l.x0 + (s.x1 + 1) * h + pad, l.y0 + (s.y1 + 1) * h + pad, l.z0 + zHigh * h];
+  const local = actors.map((a) => ({ ...a, surfaces: a.surfaces.filter((f2) => {
+    if (!blocksHull(a, f2)) return false;
+    const b = surfaceBounds(f2);
+    return b.min[0] - radius < max[0] && b.max[0] + radius > min[0] && b.min[1] - radius < max[1] && b.max[1] + radius > min[1] && b.min[2] < max[2] && b.max[2] > min[2];
+  }) })).filter((a) => a.surfaces.length > 0);
+  const doorShaped = Math.min(s.x1 - s.x0, s.y1 - s.y0) <= 1;
+  for (const finePerCell of doorShaped ? FINE_PER_CELL : FINE_PER_CELL.slice(0, 1)) {
+    const fine = makeLattice(h / finePerCell, min, max);
+    const layer = newLayer(fine);
+    rasterScene(fine, layer, radius, local);
+    for (const { k, sides } of heights) {
+      const a = Math.floor((k - zLow) * finePerCell);
+      const b = Math.min(fine.nz - 1, a + crouchCells * finePerCell - 1);
+      if (joined(l, fine, layer, a, b, sides)) return true;
+    }
+  }
+  return false;
+}
+function joined(l, fine, layer, a, b, sides) {
+  const { h } = l;
+  const free = new Uint8Array(fine.nx * fine.ny);
+  for (let c = 0; c < free.length; c++) free[c] = anyInRun(fine, layer, c * fine.w, a, b) ? 0 : 1;
+  const fineIndex = (x, y) => {
+    const i = Math.floor((l.x0 + (x + 0.5) * h - fine.x0) / fine.h);
+    const j = Math.floor((l.y0 + (y + 0.5) * h - fine.y0) / fine.h);
+    return i < 0 || j < 0 || i >= fine.nx || j >= fine.ny ? -1 : j * fine.nx + i;
+  };
+  const label = new Int32Array(free.length).fill(-1);
+  let next = 0;
+  const labels = /* @__PURE__ */ new Set();
+  for (const [x, y] of sides) {
+    const start = fineIndex(x, y);
+    if (start < 0 || free[start] === 0) continue;
+    if (label[start] >= 0) {
+      labels.add(label[start]);
+      continue;
+    }
+    const id = next++;
+    labels.add(id);
+    const stack = [start];
+    label[start] = id;
+    while (stack.length > 0) {
+      const c = stack.pop();
+      const cx = c % fine.nx;
+      for (const o of [cx > 0 ? c - 1 : -1, cx + 1 < fine.nx ? c + 1 : -1, c >= fine.nx ? c - fine.nx : -1, c + fine.nx < free.length ? c + fine.nx : -1]) {
+        if (o >= 0 && free[o] === 1 && label[o] === -1) {
+          label[o] = id;
+          stack.push(o);
+        }
+      }
+    }
+  }
+  return labels.size === 1;
+}
+function coarseSeparated(l, sides, s, trueBlocked, k, reach) {
+  const { nx, w } = l;
+  const x0 = Math.max(0, s.x0 - reach);
+  const x1 = Math.min(nx - 1, s.x1 + reach);
+  const y0 = Math.max(0, s.y0 - reach);
+  const y1 = Math.min(l.ny - 1, s.y1 + reach);
+  const clear = (x, y) => (trueBlocked[(y * nx + x) * w + (k >>> 5)] >>> (k & 31) & 1) === 0;
+  const seen = /* @__PURE__ */ new Set();
+  const first = sides[0];
+  const stack = [first[1] * nx + first[0]];
+  seen.add(stack[0]);
+  while (stack.length > 0) {
+    const c = stack.pop();
+    const y = Math.floor(c / nx);
+    const x = c - y * nx;
+    for (const [a, b] of [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]) {
+      if (a < x0 || a > x1 || b < y0 || b > y1 || !clear(a, b)) continue;
+      const n = b * nx + a;
+      if (!seen.has(n)) {
+        seen.add(n);
+        stack.push(n);
+      }
+    }
+  }
+  return sides.some(([x, y]) => !seen.has(y * nx + x));
+}
+function turnedActorNear(l, actors, radius, crouchCells, s) {
+  const { h } = l;
+  const min = [l.x0 + s.x0 * h - radius, l.y0 + s.y0 * h - radius, l.z0 + s.z0 * h];
+  const max = [l.x0 + (s.x1 + 1) * h + radius, l.y0 + (s.y1 + 1) * h + radius, l.z0 + (s.z1 + 1) * h];
+  for (const a of actors) {
+    for (const f2 of a.surfaces) {
+      if (!blocksHull(a, f2) || exactBoxBounds(f2) !== null) continue;
+      const b = surfaceBounds(f2);
+      const overlaps = b.min[0] < max[0] && b.max[0] > min[0] && b.min[1] < max[1] && b.max[1] > min[1] && b.min[2] < max[2] && b.max[2] > min[2];
+      if (overlaps && b.min[2] <= min[2] + h && b.max[2] >= min[2] + crouchCells * h) return a.name;
+    }
+  }
+  return null;
+}
+function narrowPassages(l, actors, radius, crouchCells, foot) {
+  const { nx, nz, w, h } = l;
+  const narrowFoot = newLayer(l);
+  rasterScene(l, narrowFoot, Math.max(h / 2, radius - h / 2), actors);
+  const trueBlocked = reachDown(l, foot, crouchCells);
+  const narrowBlocked = reachDown(l, narrowFoot, crouchCells);
+  const opened = newLayer(l);
+  const shut = [];
+  const strips = stripCells(l, trueBlocked, narrowBlocked, narrowFoot, crouchCells);
+  for (const s of gatherStrips(l, strips)) {
+    if (!stripIsOpen(l, actors, radius, crouchCells, s, trueBlocked)) continue;
+    const turned = turnedActorNear(l, actors, radius, crouchCells, s);
+    if (turned !== null) {
+      shut.push({ actor: turned, at: [l.x0 + (s.x0 + s.x1 + 1) / 2 * h, l.y0 + (s.y0 + s.y1 + 1) / 2 * h, l.z0 + s.z0 * h] });
+      continue;
+    }
+    const cells = new Set(s.cells);
+    let edge = s.cells;
+    for (let round = 0; round < STRIP_END_CELLS; round++) {
+      const nextEdge = [];
+      for (const node of edge) {
+        const k = node % nz;
+        const col = (node - k) / nz;
+        for (const o of [col - 1, col + 1, col - nx, col + nx]) {
+          if (o < 0 || o * w >= foot.length) continue;
+          const closedTrue = (trueBlocked[o * w + (k >>> 5)] >>> (k & 31) & 1) === 1;
+          const openNarrow = (narrowBlocked[o * w + (k >>> 5)] >>> (k & 31) & 1) === 0;
+          const id = o * nz + k;
+          if (closedTrue && openNarrow && !cells.has(id)) {
+            cells.add(id);
+            nextEdge.push(id);
+          }
+        }
+      }
+      edge = nextEdge;
+    }
+    for (const node of cells) {
+      const k = node % nz;
+      const col = (node - k) / nz;
+      if (lastSet(l, narrowBlocked, col * w, 0, k - 1) < 0) continue;
+      for (let z = k; z < k + crouchCells; z++) {
+        if (z >= nz) break;
+        const inFoot = (foot[col * w + (z >>> 5)] >>> (z & 31) & 1) === 1;
+        const inNarrow = (narrowFoot[col * w + (z >>> 5)] >>> (z & 31) & 1) === 1;
+        if (inFoot && !inNarrow) setRun(l, opened, col * w, z, z);
+      }
+    }
+  }
+  return { opened, strips, shut };
+}
+
+// src/world-fit/reach.ts
+function hullCells(hull, h) {
+  const stand = cellCeil(hull.height / h);
+  const crouch = cellCeil(hull.crouchHeight / h);
+  const jump = cellFloor(hull.jump / h);
+  return { stand, crouch, jump, climb: jump + (stand - crouch), step: cellFloor(hull.step / h), leap: cellCeil(hull.leap / h) };
+}
+var LEAP_DIRECTIONS = [
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1],
+  [Math.SQRT1_2, Math.SQRT1_2],
+  [Math.SQRT1_2, -Math.SQRT1_2],
+  [-Math.SQRT1_2, Math.SQRT1_2],
+  [-Math.SQRT1_2, -Math.SQRT1_2]
+];
+var NEIGHBOURS = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+var INITIAL_NODES = 1 << 18;
+var LEAP_OVERRUN = 1.5;
+var LEAN_MIN_DROP_CELLS = 2;
+var AXES = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+function closeLeanLedges(l, foot, closedCells, reach, hull) {
+  const { nx, ny, nz, w } = l;
+  const closed = [];
+  for (let n = 0; n < reach.count; n++) {
+    const node = reach.nodes[n];
+    const k = node % nz;
+    if (k === 0 || k + hull.crouch > nz) continue;
+    const col = (node - k) / nz;
+    if (testBit(foot, col * w, k)) continue;
+    const j = Math.floor(col / nx);
+    const i = col - j * nx;
+    for (const [dx, dy] of AXES) {
+      const wi = i + dx;
+      const wj = j + dy;
+      const oi = i - dx;
+      const oj = j - dy;
+      if (wi < 0 || wj < 0 || wi >= nx || wj >= ny || oi < 0 || oj < 0 || oi >= nx || oj >= ny) continue;
+      const face = (wj * nx + wi) * w;
+      const clear = firstClear(l, foot, face, k, nz - 1);
+      const top = clear < 0 ? nz - 1 : clear - 1;
+      if (top < k) continue;
+      let faceTop = top;
+      for (let fi = wi + dx, fj = wj + dy; fi >= 0 && fj >= 0 && fi < nx && fj < ny && faceTop - k + 1 < hull.crouch; fi += dx, fj += dy) {
+        const further = (fj * nx + fi) * w;
+        if (faceTop + 1 >= nz || !testBit(foot, further, faceTop + 1)) break;
+        const end = firstClear(l, foot, further, faceTop + 1, nz - 1);
+        faceTop = end < 0 ? nz - 1 : end - 1;
+      }
+      if (faceTop - k + 1 < hull.crouch) continue;
+      if (anyInRun(l, foot, (oj * nx + oi) * w, Math.max(0, k - LEAN_MIN_DROP_CELLS), k - 1)) continue;
+      closed.push([col * w, k, top]);
+      break;
+    }
+  }
+  for (const [o, k, top] of closed) {
+    setRun(l, foot, o, k, top);
+    setRun(l, closedCells, o, k, top);
+  }
+  return closed.length;
+}
+function floodReach(l, foot, hull, spawns) {
+  const { nx, ny, nz, w, h } = l;
+  const blocked = reachDown(l, foot, hull.crouch);
+  const standing = newLayer(l);
+  const body = newLayer(l);
+  let nodes = new Int32Array(INITIAL_NODES);
+  let tail = 0;
+  const fell = new Uint8Array(nx * ny);
+  let fellOut = 0;
+  const land = (offset, k) => {
+    const under = lastSet(l, blocked, offset, 0, k - 1);
+    return under < 0 ? -1 : under + 1;
+  };
+  const push = (col, k) => {
+    const offset = col * w;
+    if (testBit(standing, offset, k)) return;
+    setBit(standing, offset, k);
+    if (tail === nodes.length) {
+      const grown = new Int32Array(nodes.length * 2);
+      grown.set(nodes);
+      nodes = grown;
+    }
+    nodes[tail++] = col * nz + k;
+    const ceiling = firstSet(l, foot, offset, k, k + hull.jump + hull.stand);
+    setRun(l, body, offset, k, ceiling < 0 ? k + hull.jump + hull.stand : ceiling - 1);
+  };
+  const descend = (col, k) => {
+    const offset = col * w;
+    const to = land(offset, k);
+    if (to < 0) {
+      if (fell[col] === 0) {
+        fell[col] = 1;
+        fellOut += 1;
+      }
+      return -1;
+    }
+    const ceiling = firstSet(l, foot, offset, k, k + hull.stand);
+    setRun(l, body, offset, to, ceiling < 0 ? k + hull.stand - 1 : ceiling - 1);
+    push(col, to);
+    return to;
+  };
+  const unplaced = [];
+  for (const [index, s] of spawns.entries()) {
+    const i = Math.floor((s[0] - l.x0) / h);
+    const j = Math.floor((s[1] - l.y0) / h);
+    const k = Math.floor((s[2] - l.z0) / h);
+    if (i < 0 || j < 0 || i >= nx || j >= ny) {
+      unplaced.push(index);
+      continue;
+    }
+    const offset = (j * nx + i) * w;
+    const free = firstClear(l, blocked, offset, Math.max(0, k), Math.min(nz - 1, k + hull.climb));
+    if (free < 0 || descend(j * nx + i, free) < 0) unplaced.push(index);
+  }
+  const leap = (i, j, k) => {
+    const reach = hull.leap * LEAP_OVERRUN;
+    for (const [dx, dy] of LEAP_DIRECTIONS) {
+      let lastI = i;
+      let lastJ = j;
+      for (let n = 1; n <= reach; n++) {
+        const ci = Math.round(i + dx * n);
+        const cj = Math.round(j + dy * n);
+        if (ci < 0 || cj < 0 || ci >= nx || cj >= ny) break;
+        if (ci === lastI && cj === lastJ) continue;
+        const s = n / hull.leap;
+        const z = k + Math.round(4 * hull.jump * s * (1 - s));
+        if (z < 1) break;
+        const col = cj * nx + ci;
+        if (z >= nz || testBit(blocked, col * w, z)) break;
+        const cornered = ci !== lastI && cj !== lastJ && testBit(blocked, (lastJ * nx + ci) * w, z) && testBit(blocked, (cj * nx + lastI) * w, z);
+        if (cornered) break;
+        lastI = ci;
+        lastJ = cj;
+        if (descend(col, z) < 0) break;
+      }
+    }
+  };
+  let head = 0;
+  while (head < tail) {
+    const node = nodes[head++];
+    const k = node % nz;
+    const col = (node - k) / nz;
+    const j = Math.floor(col / nx);
+    const i = col - j * nx;
+    const offset = col * w;
+    const stop = firstSet(l, blocked, offset, k + 1, k + hull.climb);
+    const top = stop < 0 ? Math.min(nz - 1, k + hull.climb) : stop - 1;
+    let edge = false;
+    for (const [dx, dy] of NEIGHBOURS) {
+      const ni = i + dx;
+      const nj = j + dy;
+      if (ni < 0 || nj < 0 || ni >= nx || nj >= ny) continue;
+      const nextCol = nj * nx + ni;
+      const nextOffset = nextCol * w;
+      let at = k;
+      for (; ; ) {
+        const free = firstClear(l, blocked, nextOffset, at, top);
+        if (free < 0) break;
+        const to = descend(nextCol, free);
+        if (to < k - hull.step) edge = true;
+        const next = firstSet(l, blocked, nextOffset, free, top);
+        if (next < 0) break;
+        at = next;
+      }
+    }
+    if (edge) leap(i, j, k);
+  }
+  return { nodes: nodes.subarray(0, tail), count: tail, standing, body, fell, fellOut, unplaced };
+}
+function hasNear(l, layer, offset, k, tolerance) {
+  return firstSet(l, layer, offset, k - tolerance, k + tolerance) >= 0;
+}
+function worstRegionCells(l, mask) {
+  const { nx } = l;
+  let worst = 0;
+  const stack = [];
+  for (let s = 0; s < mask.length; s++) {
+    if (mask[s] === 0) continue;
+    let size = 0;
+    mask[s] = 0;
+    stack.push(s);
+    while (stack.length > 0) {
+      const c = stack.pop();
+      size += 1;
+      const x = c % nx;
+      if (x > 0 && mask[c - 1] !== 0) {
+        mask[c - 1] = 0;
+        stack.push(c - 1);
+      }
+      if (x < nx - 1 && mask[c + 1] !== 0) {
+        mask[c + 1] = 0;
+        stack.push(c + 1);
+      }
+      if (c >= nx && mask[c - nx] !== 0) {
+        mask[c - nx] = 0;
+        stack.push(c - nx);
+      }
+      if (c + nx < mask.length && mask[c + nx] !== 0) {
+        mask[c + nx] = 0;
+        stack.push(c + nx);
+      }
+    }
+    worst = Math.max(worst, size);
+  }
+  return worst;
+}
+function standsNear(l, standing, col, k, tolerance, radius) {
+  const { nx, ny, w } = l;
+  const j = Math.floor(col / nx);
+  const i = col - j * nx;
+  for (let y = Math.max(0, j - radius); y <= Math.min(ny - 1, j + radius); y++) {
+    for (let x = Math.max(0, i - radius); x <= Math.min(nx - 1, i + radius); x++) {
+      if (hasNear(l, standing, (y * nx + x) * w, k, tolerance)) return true;
+    }
+  }
+  return false;
+}
+function fellNear(l, fell, col, radius) {
+  const { nx, ny } = l;
+  const j = Math.floor(col / nx);
+  const i = col - j * nx;
+  for (let y = Math.max(0, j - radius); y <= Math.min(ny - 1, j + radius); y++) {
+    for (let x = Math.max(0, i - radius); x <= Math.min(nx - 1, i + radius); x++) {
+      if (fell[y * nx + x] === 1) return true;
+    }
+  }
+  return false;
+}
+function compareReach(l, truth, fit, tolerance, unitsPerMeter, sourceNear, nearCells) {
+  const { nx, ny, nz, w, h } = l;
+  const cellM2 = (h / unitsPerMeter) ** 2;
+  const lostMask = new Uint8Array(nx * ny);
+  const extraMask = new Uint8Array(nx * ny);
+  const lost = [];
+  let lostCount = 0;
+  const extra = [];
+  for (let n = 0; n < truth.count; n++) {
+    const node = truth.nodes[n];
+    const k = node % nz;
+    const col = (node - k) / nz;
+    if (hasNear(l, fit.standing, col * w, k, tolerance)) continue;
+    lostCount += 1;
+    lostMask[col] = 1;
+    if (!standsNear(l, fit.standing, col, k, tolerance, nearCells)) lost.push(node);
+  }
+  let underFloorNodes = 0;
+  for (let n = 0; n < fit.count; n++) {
+    const node = fit.nodes[n];
+    const k = node % nz;
+    const col = (node - k) / nz;
+    if (hasNear(l, truth.standing, col * w, k, tolerance)) continue;
+    extra.push(node);
+    extraMask[col] = 1;
+    if (firstSet(l, sourceNear, col * w, k - tolerance, k + tolerance) < 0 && firstSet(l, sourceNear, col * w, k + tolerance, nz - 1) >= 0) underFloorNodes += 1;
+  }
+  let newFalls = 0;
+  for (let col = 0; col < fit.fell.length; col++) {
+    if (fit.fell[col] === 1 && !fellNear(l, truth.fell, col, nearCells)) newFalls += 1;
+  }
+  const denominator = Math.max(1, truth.count);
+  const pct = (count) => Math.round(1e4 * count / denominator) / 100;
+  const area = (mask) => Math.round(worstRegionCells(l, mask) * cellM2 * 100) / 100;
+  return {
+    truthNodes: truth.count,
+    fitNodes: fit.count,
+    lostNodes: lostCount,
+    extraNodes: extra.length,
+    lostPct: pct(lostCount),
+    lostBeyondSlackPct: pct(lost.length),
+    extraPct: pct(extra.length),
+    worstLostM2: area(lostMask),
+    worstExtraM2: area(extraMask),
+    underFloorNodes,
+    newFalls,
+    lost,
+    extra
+  };
+}
+
+// src/world-fit/fit.ts
+var FitStatus = {
+  Ok: "ok",
+  /** Even the coarsest fit needs more solids than the budget. */
+  OverBudget: "over_budget",
+  /** A hull gets under the source's floor or out of the level in every fit tried. */
+  FallsThrough: "falls_through",
+  /** A fit within budget loses more reach than a fit may. */
+  ReachLost: "reach_lost",
+  /** A gap the source has shut is open, or shut by less than the stated margin, in every fit tried: never a world. */
+  OpenSlits: "open_slits",
+  /** In every fit tried, feet stay further from the source's floor than a player can miss, and the budget cannot buy them back. */
+  FloorOver: "floor_over",
+  /** No spawn stands anywhere, so there is no reach to fit. */
+  NoReach: "no_reach"
+};
+var CELLS_PER_RADIUS = 4;
+var MAX_LATTICE_CELLS = 16e8;
+var SAME_FLOOR_HEIGHTS = 1 / 3;
+var MAX_REACH_LOST_PCT = 2;
+var MAX_REPAIR_ROUNDS = 8;
+var FLOOR_P99_RADII = 0.5;
+var FLOOR_MAX_RADII = 1;
+var MAX_LEAN_FLOODS = 4;
+var BOUND_ACTOR = "Bound";
+var REACH_FLAG_PCT = 25;
+var GROUND_PLAN_SHARE = 0.25;
+var REFUSAL_NAMES = 5;
+var REPAIR_RADII = 2;
+var COARSE_CELLS = 1 << 28;
+var CROP_PAD_RADII = 6;
+var FLOOR_SAMPLES = 2e6;
+var REPORT_FLOOR_WORST = 8;
+var NARROW_MATCH_CELLS = 2;
+var REPORT_ACTORS = 12;
+var REPORT_CUT_PROPS = 64;
+var SOURCE_UNITS_PER_METER = 39.37;
+var SOURCE_HULL = { radius: 16, height: 72, crouchHeight: 54, step: 18, jump: 57, leap: 189 };
+function sceneHull(scene) {
+  if (scene.hull !== void 0) return scene.hull;
+  const k = scene.unitsPerMeter / SOURCE_UNITS_PER_METER;
+  return { radius: SOURCE_HULL.radius * k, height: SOURCE_HULL.height * k, crouchHeight: SOURCE_HULL.crouchHeight * k, step: SOURCE_HULL.step * k, jump: SOURCE_HULL.jump * k, leap: SOURCE_HULL.leap * k };
+}
+function fitWorldHash(boxes, ramps) {
+  const scratch = new DataView(new ArrayBuffer(4));
+  let hash = 2166136261;
+  const u32 = (v) => {
+    for (let shift = 0; shift < 32; shift += 8) hash = Math.imul(hash ^ v >>> shift & 255, 16777619) >>> 0;
+  };
+  const f32 = (v) => {
+    scratch.setFloat32(0, v === 0 ? 0 : v, true);
+    for (let b = 0; b < 4; b++) hash = Math.imul(hash ^ scratch.getUint8(b), 16777619) >>> 0;
+  };
+  u32(boxes.length);
+  u32(ramps.length);
+  for (const solid of [...boxes, ...ramps]) solid.forEach(f32);
+  return hash;
+}
+function sceneBounds(scene) {
+  const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  const add = (p) => {
+    for (let a = 0; a < 3; a++) {
+      lo[a] = Math.min(lo[a], p[a]);
+      hi[a] = Math.max(hi[a], p[a]);
+    }
+  };
+  for (const actor of scene.actors) {
+    for (const surface of actor.surfaces) {
+      if (!blocksHull(actor, surface)) continue;
+      const box = surfaceBounds(surface);
+      add(box.min);
+      add(box.max);
+    }
+  }
+  for (const spawn of scene.spawns) add(spawn.at);
+  return { min: [lo[0], lo[1], lo[2]], max: [hi[0], hi[1], hi[2]] };
+}
+var spawnsOf = (scene) => scene.spawns.map((s) => s.at);
+function assertWorld(boxes, ramps) {
+  const good = (s) => s.every((v) => Number.isFinite(v) && Math.fround(v) === v) && s[0] < s[3] && s[1] < s[4] && s[2] < s[5];
+  boxes.forEach((b, i) => {
+    if (!good(b)) throw new RangeError(`world fit: box ${i} is not one a room accepts: ${b.join(" ")}`);
+  });
+  ramps.forEach((r, i) => {
+    if (!good(r)) throw new RangeError(`world fit: ramp ${i} is not one a room accepts: ${r.join(" ")}`);
+  });
+}
+function cropToReach(scene, hull) {
+  const whole = sceneBounds(scene);
+  const size = [whole.max[0] - whole.min[0], whole.max[1] - whole.min[1], whole.max[2] - whole.min[2]];
+  const pad = hull.radius * CROP_PAD_RADII + hull.leap;
+  let h = hull.radius;
+  while (size[0] / h * (size[1] / h) * (size[2] / h) > COARSE_CELLS) h *= 2;
+  const l = makeLattice(h, [whole.min[0] - h, whole.min[1] - h, whole.min[2] - hull.height], [whole.max[0] + h, whole.max[1] + h, whole.max[2] + hull.height * 2]);
+  const foot = newLayer(l);
+  rasterScene(l, foot, hull.radius / 2, scene.actors);
+  const cells = { stand: Math.max(1, Math.floor(hull.height / h)), crouch: Math.max(1, Math.floor(hull.crouchHeight / h)), climb: Math.ceil((hull.jump + hull.height - hull.crouchHeight) / h), jump: Math.ceil(hull.jump / h), step: Math.ceil(hull.step / h), leap: Math.ceil(hull.leap / h) };
+  const reach = floodReach(l, foot, cells, spawnsOf(scene));
+  if (reach.count === 0) return whole;
+  let minI = l.nx;
+  let maxI = 0;
+  let minJ = l.ny;
+  let maxJ = 0;
+  let minK = l.nz;
+  let maxK = 0;
+  for (let n = 0; n < reach.count; n++) {
+    const node = reach.nodes[n];
+    const k = node % l.nz;
+    const col = (node - k) / l.nz;
+    const j = Math.floor(col / l.nx);
+    const i = col - j * l.nx;
+    if (i < minI) minI = i;
+    if (i > maxI) maxI = i;
+    if (j < minJ) minJ = j;
+    if (j > maxJ) maxJ = j;
+    if (k < minK) minK = k;
+    if (k > maxK) maxK = k;
+  }
+  return {
+    min: [l.x0 + minI * h - pad, l.y0 + minJ * h - pad, l.z0 + minK * h - pad],
+    max: [l.x0 + (maxI + 1) * h + pad, l.y0 + (maxJ + 1) * h + pad, l.z0 + (maxK + 1) * h + hull.height + hull.jump + hull.height]
+  };
+}
+function chooseCell(bounds, hull, asked) {
+  if (asked !== void 0) return asked;
+  let h = hull.radius / CELLS_PER_RADIUS;
+  const cells = (c) => (bounds.max[0] - bounds.min[0]) / c * ((bounds.max[1] - bounds.min[1]) / c) * ((bounds.max[2] - bounds.min[2]) / c);
+  while (cells(h) > MAX_LATTICE_CELLS) h *= 2;
+  return h;
+}
+function fitRungs(hull, h) {
+  const maxRange = Math.max(1, Math.floor(hull.step / h));
+  const maxSlack = Math.max(0, Math.floor(hull.radius / h) - 1);
+  const steps = [[1, 0], [1, 1], [2, 1], [2, 2], [3, 2], [3, 3], [4, 3]];
+  const rungs = [];
+  for (const [range, slack] of steps) {
+    const rung = { floorRange: Math.min(range, maxRange), slack: Math.min(slack, maxSlack), props: false };
+    const last = rungs[rungs.length - 1];
+    if (last === void 0 || last.floorRange !== rung.floorRange || last.slack !== rung.slack) rungs.push(rung);
+  }
+  const coarsest = rungs[rungs.length - 1];
+  rungs.push({ ...coarsest, props: true });
+  return rungs;
+}
+function attempt(ctx, rung, zone, bounded) {
+  const { input, l, options } = ctx;
+  const placed = { boxes: [], boxInfo: [], ramps: [], rampInfo: [] };
+  const knobs = { floorRange: rung.floorRange, slack: rung.slack, maxRamps: options.maxRamps, boundedActors: bounded, zone };
+  const covered = newLayer(l);
+  const exactSolid = newLayer(l);
+  placeExactBoxes(input, knobs, placed, covered, exactSolid);
+  placeFloors(input, knobs, ctx.footprintCells, ctx.cells.step, ctx.index, placed, covered, exactSolid, ctx.floors);
+  const must = mustCover(input, knobs, covered);
+  const left = Math.max(0, options.maxBoxes - placed.boxes.length);
+  const cover = placeCover(input, must, ctx.footprintCells, ctx.index, placed, left, rung.slack === 0);
+  closeSlits(input, placed, ctx.cells.crouch * l.h);
+  return { placed, overLimit: cover.overLimit || placed.boxes.length > options.maxBoxes, cover };
+}
+function checkView(ctx, placed) {
+  const { l, hull, cells } = ctx;
+  const margin = l.h * GAP_MARGIN_CELLS;
+  const foot = rasterWorld(l, hull.radius, placed);
+  const narrower = rasterWorld(l, hull.radius - margin, placed);
+  const solids = [...placed.boxes, ...placed.ramps].map((b) => ({ kind: "box", center: [(b[0] + b[3]) / 2, (b[1] + b[4]) / 2, (b[2] + b[5]) / 2], half: [(b[3] - b[0]) / 2, (b[4] - b[1]) / 2, (b[5] - b[2]) / 2] }));
+  const { opened: fitOpen } = narrowPassages(l, [{ name: "fit", tags: [], surfaces: solids }], hull.radius - margin, cells.crouch, narrower);
+  const opened = newLayer(l);
+  for (let at = 0; at < foot.length; at++) {
+    const left = (fitOpen[at] & ~ctx.sourceStrips[at]) >>> 0;
+    opened[at] = (ctx.opened[at] | left) >>> 0;
+    foot[at] = (foot[at] & ~opened[at]) >>> 0;
+  }
+  return { foot, opened };
+}
+function check(ctx, placed, rung) {
+  const { l, cells, truth, input } = ctx;
+  const { foot, opened } = checkView(ctx, placed);
+  const reach = floodReach(l, foot, cells, ctx.spawns);
+  const sourceNear = dilateXY(l, input.foot, rung.slack + 1);
+  const compare = compareReach(l, truth, reach, ctx.tolerance, ctx.scene.unitsPerMeter, sourceNear, rung.slack + 1);
+  const { floor, over } = measureFloors(ctx, placed, reach, opened);
+  return { reach, compare, opened, floor, floorOver: over };
+}
+function growZone(ctx, zone, compare, floorOver, rung) {
+  const { l, input, hull, cells } = ctx;
+  const { nx, nz, w, h } = l;
+  const out = zone === null ? newLayer(l) : zone;
+  const radius = Math.ceil(hull.radius * REPAIR_RADII / h);
+  const near = rung.slack > 0 ? dilateXY(l, input.body, rung.slack + 1) : input.body;
+  let added = 0;
+  const add = (node, slackAllowed, reachCells = radius) => {
+    const k = node % nz;
+    const col = (node - k) / nz;
+    if (slackAllowed && (near[col * w + (k >>> 5)] >>> (k & 31) & 1) === 1) return;
+    added += 1;
+    const j = Math.floor(col / nx);
+    const i = col - j * nx;
+    for (let y = Math.max(0, j - reachCells); y <= Math.min(l.ny - 1, j + reachCells); y++) {
+      for (let x = Math.max(0, i - reachCells); x <= Math.min(nx - 1, i + reachCells); x++) setRun(l, out, (y * nx + x) * w, k - cells.stand, k + cells.stand);
+    }
+  };
+  for (const node of compare.lost) add(node, false);
+  for (const node of compare.extra) add(node, true);
+  const footprint = Math.ceil(hull.radius / h);
+  for (const node of floorOver) add(node, false, footprint);
+  return { zone: out, added };
+}
+function actorCosts(ctx, placed) {
+  const { scene, l, truth, hull } = ctx;
+  const boxes = new Int32Array(scene.actors.length);
+  const ramps = new Int32Array(scene.actors.length);
+  for (const info of placed.boxInfo) if (info.actor >= 0) boxes[info.actor] += 1;
+  for (const info of placed.rampInfo) if (info.actor >= 0) ramps[info.actor] += 1;
+  const order = Array.from({ length: scene.actors.length }, (_, i) => i).sort((a, b) => boxes[b] + ramps[b] - (boxes[a] + ramps[a]) || a - b).slice(0, REPORT_ACTORS);
+  const out = [];
+  for (const index of order) {
+    if (boxes[index] === 0 && ramps[index] === 0) continue;
+    const actor = scene.actors[index];
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const surface of actor.surfaces) {
+      if (!blocksHull(actor, surface)) continue;
+      const b = surfaceBounds(surface);
+      minX = Math.min(minX, b.min[0]);
+      minY = Math.min(minY, b.min[1]);
+      minZ = Math.min(minZ, b.min[2]);
+      maxX = Math.max(maxX, b.max[0]);
+      maxY = Math.max(maxY, b.max[1]);
+      maxZ = Math.max(maxZ, b.max[2]);
+    }
+    let inside = 0;
+    for (let n = 0; n < truth.count; n++) {
+      const node = truth.nodes[n];
+      const k = node % l.nz;
+      const col = (node - k) / l.nz;
+      const j = Math.floor(col / l.nx);
+      const i = col - j * l.nx;
+      const x = l.x0 + (i + 0.5) * l.h;
+      const y = l.y0 + (j + 0.5) * l.h;
+      const z = l.z0 + k * l.h;
+      const overlaps = x > minX - hull.radius && x < maxX + hull.radius && y > minY - hull.radius && y < maxY + hull.radius && z < maxZ && z + hull.height > minZ;
+      if (overlaps) inside += 1;
+    }
+    out.push({ name: actor.name, boxes: boxes[index], ramps: ramps[index], reachIfBoxedPct: Math.round(1e4 * inside / Math.max(1, truth.count)) / 100 });
+  }
+  return out;
+}
+function measureFloors(ctx, placed, fitted, viewOpened) {
+  const { l, scene, hull, tolerance } = ctx;
+  const { nx, ny, nz, h } = l;
+  const stride = Math.max(1, Math.ceil(fitted.count / FLOOR_SAMPLES));
+  const count = Math.floor(fitted.count / stride);
+  const head = new Int32Array(nx * ny).fill(-1);
+  const next = new Int32Array(count);
+  const feet = new Float32Array(count);
+  for (let s = 0; s < count; s++) {
+    const node = fitted.nodes[s * stride];
+    const k = node % nz;
+    const col = (node - k) / nz;
+    feet[s] = l.z0 + k * h;
+    if (firstSet(l, viewOpened, col * l.w, k, k + ctx.cells.crouch) >= 0) continue;
+    if (k > 0 && testBit(ctx.leanCells, col * l.w, k - 1)) continue;
+    next[s] = head[col];
+    head[col] = s;
+  }
+  const margin = tolerance * h;
+  const offer = (tops) => (col, top) => {
+    for (let s = head[col]; s >= 0; s = next[s]) {
+      if (top <= feet[s] + margin && top > tops[s]) tops[s] = top;
+    }
+  };
+  const fresh = () => new Float32Array(count).fill(Number.NEGATIVE_INFINITY);
+  const sourceTops = (half) => {
+    const tops = fresh();
+    visitTops(l, half, scene.actors, offer(tops));
+    return tops;
+  };
+  const worldTops = (half) => {
+    const tops = fresh();
+    const onWorld = offer(tops);
+    const columnsOf = (min, max, origin, size) => [Math.max(0, cellFloor((min - half - origin) / h - 0.5) + 1), Math.min(size - 1, cellCeil((max + half - origin) / h - 0.5) - 1)];
+    for (const b of placed.boxes) {
+      const [i0, i1] = columnsOf(b[0], b[3], l.x0, nx);
+      const [j0, j1] = columnsOf(b[1], b[4], l.y0, ny);
+      for (let j = j0; j <= j1; j++) for (let i = i0; i <= i1; i++) onWorld(j * nx + i, b[5]);
+    }
+    for (const r of placed.ramps) {
+      const [i0, i1] = columnsOf(r[0], r[3], l.x0, nx);
+      const [j0, j1] = columnsOf(r[1], r[4], l.y0, ny);
+      const axis = r[6];
+      const m0 = axis === 0 ? r[0] : r[1];
+      const m1 = axis === 0 ? r[3] : r[4];
+      for (let j = j0; j <= j1; j++) {
+        for (let i = i0; i <= i1; i++) {
+          const centre = axis === 0 ? l.x0 + (i + 0.5) * h : l.y0 + (j + 0.5) * h;
+          const uphill = r[8] >= r[7] ? Math.min(m1, centre + half) : Math.max(m0, centre - half);
+          onWorld(j * nx + i, r[7] + (r[8] - r[7]) * (uphill - m0) / (m1 - m0));
+        }
+      }
+    }
+    return tops;
+  };
+  const { radius } = hull;
+  const source = sourceTops(radius);
+  const world = worldTops(radius);
+  const sourceWide = sourceTops(radius + h / 2);
+  const sourceNarrow = sourceTops(Math.max(h / 2, radius - h / 2));
+  const worldWide = worldTops(radius + h / 2);
+  const worldNarrow = worldTops(Math.max(h / 2, radius - h / 2));
+  const errors = [];
+  const order = [];
+  const over = [];
+  const overUnits = FLOOR_MAX_RADII * radius;
+  let above = 0;
+  let upperBound = 0;
+  let edgeFree = 0;
+  for (let s = 0; s < count; s++) {
+    const a = source[s];
+    const b = world[s];
+    const fitHigh = worldWide[s];
+    const sourceHigh = sourceWide[s];
+    const fitLow = Math.max(worldNarrow[s], Number.NEGATIVE_INFINITY);
+    const sourceLow = Math.max(sourceNarrow[s], Number.NEGATIVE_INFINITY);
+    if (fitHigh !== Number.NEGATIVE_INFINITY && sourceHigh !== Number.NEGATIVE_INFINITY) {
+      const lowOfFit = fitLow === Number.NEGATIVE_INFINITY ? fitHigh : fitLow;
+      const lowOfSource = sourceLow === Number.NEGATIVE_INFINITY ? sourceHigh : sourceLow;
+      upperBound = Math.max(upperBound, fitHigh - lowOfSource, sourceHigh - lowOfFit);
+      edgeFree = Math.max(edgeFree, lowOfFit - sourceHigh, lowOfSource - fitHigh);
+    }
+    if (a === Number.NEGATIVE_INFINITY || b === Number.NEGATIVE_INFINITY) continue;
+    errors.push(Math.abs(b - a));
+    order.push(s);
+    if (Math.abs(b - a) > overUnits) over.push(fitted.nodes[s * stride]);
+    if (b > a) above += 1;
+  }
+  const worstOrder = order.map((s, index) => [errors[index], s]).sort((p, q) => q[0] - p[0]).slice(0, REPORT_FLOOR_WORST);
+  const worst = worstOrder.map(([, s]) => {
+    const node = fitted.nodes[s * stride];
+    const k = node % nz;
+    const col = (node - k) / nz;
+    const j = Math.floor(col / nx);
+    const i = col - j * nx;
+    return { at: [l.x0 + (i + 0.5) * h, l.y0 + (j + 0.5) * h, l.z0 + k * h], source: source[s], fit: world[s] };
+  });
+  errors.sort((p, q) => p - q);
+  const at = (share) => Math.round((errors[Math.min(errors.length - 1, Math.floor(share * errors.length))] ?? 0) * 100) / 100;
+  const floor = { samples: errors.length, p50Units: at(0.5), p95Units: at(0.95), p99Units: at(0.99), maxUnits: at(1), upperBoundUnits: Math.ceil(upperBound * 100) / 100, edgeFreeUnits: Math.ceil(edgeFree * 100) / 100, abovePct: Math.round(1e4 * above / Math.max(1, errors.length)) / 100, worst };
+  return { floor, over };
+}
+function stagesOf(placed) {
+  const out = { exact: 0, ramp: 0, tile: 0, cover: 0, prop: 0 };
+  for (const info of placed.boxInfo) out[info.stage] += 1;
+  for (const info of placed.rampInfo) out[info.stage] += 1;
+  return out;
+}
+var EMPTY_COMPARE = { truthNodes: 0, fitNodes: 0, lostNodes: 0, extraNodes: 0, lostPct: 0, extraPct: 0, worstLostM2: 0, worstExtraM2: 0, lostBeyondSlackPct: 0, underFloorNodes: 0, newFalls: 0 };
+function buildReport(ctx, parts, started) {
+  const { placed, rung, checked } = parts;
+  const { scene, options, l, input, truth } = ctx;
+  const unreachable = /* @__PURE__ */ new Set();
+  for (let a = 0; a < scene.actors.length; a++) unreachable.add(a);
+  for (const info of placed.boxInfo) unreachable.delete(info.actor);
+  for (const info of placed.rampInfo) unreachable.delete(info.actor);
+  const { lost: _lost, extra: _extra, ...compare } = checked?.compare ?? { ...EMPTY_COMPARE, lost: [], extra: [] };
+  return {
+    status: parts.status,
+    detail: parts.detail,
+    budget: { maxBoxes: options.maxBoxes, maxRamps: options.maxRamps },
+    boxes: placed.boxes.length,
+    ramps: placed.ramps.length,
+    stages: stagesOf(placed),
+    cell: l.h,
+    rung,
+    floor: checked === null ? null : checked.floor,
+    floorTileSpanUnits: (rung.floorRange + 1) * l.h,
+    wallSlackUnits: rung.slack * l.h,
+    reach: { ...compare, truthFellOut: truth.fellOut, fitFellOut: checked?.reach.fellOut ?? 0 },
+    gapMarginUnits: l.h * GAP_MARGIN_CELLS,
+    openSlits: countOpenSlits(input, placed, ctx.cells.crouch * l.h),
+    narrowDoorsShut: ctx.shut,
+    leanLedges: ctx.leanLedges,
+    reachExtent: ctx.extent,
+    repairs: parts.repairs,
+    unreachableActors: unreachable.size,
+    movableActors: scene.actors.filter((a) => a.tags.includes(SceneTag.Movable)).map((a) => a.name),
+    cutProps: [...parts.bounded].slice(0, REPORT_CUT_PROPS).map((i) => scene.actors[i].name),
+    actors: actorCosts(ctx, placed),
+    spawnsNotPlaced: truth.unplaced.map((i) => scene.spawns[i]?.name ?? `spawn ${i}`),
+    seconds: Math.round((performance.now() - started) / 100) / 10
+  };
+}
+function fallsThrough(checked) {
+  return checked.compare.underFloorNodes > 0 || checked.compare.newFalls > 0;
+}
+function sameDifferences(a, b) {
+  return a.compare.lostNodes === b.compare.lostNodes && a.compare.extraNodes === b.compare.extraNodes && a.floorOver.length === b.floorOver.length;
+}
+function runRung(ctx, rung, bounded) {
+  const { options } = ctx;
+  let zone = null;
+  let repairs = 0;
+  let last = null;
+  for (let round = 0; round <= (options.noRepair ? 0 : MAX_REPAIR_ROUNDS); round++) {
+    const run = attempt(ctx, rung, zone, bounded);
+    options.log?.(`rung range ${rung.floorRange} slack ${rung.slack} props ${rung.props} round ${round}: ${run.placed.boxes.length} boxes, ${run.placed.ramps.length} ramps${run.overLimit ? " (over)" : ""}, ${run.cover.stuck} stuck`);
+    if (run.overLimit) return last;
+    const checked = check(ctx, run.placed, rung);
+    options.log?.(`  lost ${checked.compare.lostPct}% extra ${checked.compare.extraPct}% under ${checked.compare.underFloorNodes} falls ${checked.compare.newFalls} floor ${checked.floor.p99Units}/${checked.floor.maxUnits} over ${checked.floorOver.length}`);
+    const standing = last !== null && sameDifferences(last.checked, checked);
+    last = { placed: run.placed, checked, repairs };
+    if (options.noRepair || standing) return last;
+    const grown = growZone(ctx, zone, checked.compare, checked.floorOver, rung);
+    if (grown.added === 0) return last;
+    zone = grown.zone;
+    repairs += 1;
+  }
+  return last;
+}
+function prepare(given, options) {
+  const hull = sceneHull(given);
+  const scene = withBound(given, hull);
+  const crop = cropToReach(scene, hull);
+  const whole = sceneBounds(scene);
+  const bounds = {
+    min: [Math.max(crop.min[0], whole.min[0] - hull.radius * CROP_PAD_RADII), Math.max(crop.min[1], whole.min[1] - hull.radius * CROP_PAD_RADII), Math.max(crop.min[2], whole.min[2] - hull.height)],
+    max: [Math.min(crop.max[0], whole.max[0] + hull.radius * CROP_PAD_RADII), Math.min(crop.max[1], whole.max[1] + hull.radius * CROP_PAD_RADII), crop.max[2]]
+  };
+  const h = chooseCell(bounds, hull, options.cell);
+  const l = makeLattice(h, bounds.min, bounds.max);
+  options.log?.(`lattice ${l.nx} x ${l.ny} x ${l.nz} at ${h}: ${Math.round(cellCount(l) / 1e6)}M cells`);
+  const foot = newLayer(l);
+  rasterScene(l, foot, hull.radius, scene.actors);
+  const solid = newLayer(l);
+  rasterScene(l, solid, h / 2, scene.actors);
+  const cells = hullCells(hull, h);
+  const { opened, strips, shut } = narrowPassages(l, scene.actors, hull.radius, cells.crouch, foot);
+  let openedDoors = 0;
+  for (let at = 0; at < foot.length; at++) {
+    if (opened[at] !== 0) openedDoors += 1;
+    foot[at] = (foot[at] & ~opened[at]) >>> 0;
+  }
+  options.log?.(`narrow passages: ${openedDoors} cell words opened`);
+  const spawns = spawnsOf(scene);
+  let truth = floodReach(l, foot, cells, spawns);
+  let leanLedges = 0;
+  const leanCells = newLayer(l);
+  for (let flood = 0; flood < MAX_LEAN_FLOODS; flood++) {
+    let closedNow = 0;
+    for (let closed = closeLeanLedges(l, foot, leanCells, truth, cells); closed > 0; closed = closeLeanLedges(l, foot, leanCells, truth, cells)) closedNow += closed;
+    if (closedNow === 0) break;
+    leanLedges += closedNow;
+    truth = floodReach(l, foot, cells, spawns);
+  }
+  options.log?.(`truth ${truth.count} positions, ${truth.fellOut} fell out, ${leanLedges} on leaning faces closed`);
+  const footprintCells = Math.max(1, cellCeil(2 * hull.radius / h));
+  const envelope = dilateXY(l, truth.body, cellCeil(hull.radius / h));
+  const input = { l, actors: scene.actors, radius: hull.radius, foot, solid, body: truth.body, touch: strips, envelope, leanCells };
+  return {
+    scene,
+    options,
+    hull,
+    l,
+    cells,
+    input,
+    opened,
+    sourceStrips: dilateXY(l, strips, NARROW_MATCH_CELLS),
+    shut,
+    floors: readFloors(input),
+    truth,
+    leanLedges,
+    leanCells,
+    extent: measureExtent(scene, hull, l, cells, foot, truth, spawns),
+    footprintCells,
+    index: new ActorIndex(scene.actors, hull.radius * 16),
+    tolerance: Math.ceil(hull.height * SAME_FLOOR_HEIGHTS / h),
+    propIndices: propActors(scene.actors, hull.radius),
+    // A spawn with no room to stand in the source is named in the report. The check starts where the source has hulls, or
+    // that spawn's pocket, uncovered because nothing reaches it, would read as reach the fit added.
+    spawns: spawns.filter((_, index) => !truth.unplaced.includes(index))
+  };
+}
+function withBound(scene, hull) {
+  const { bound } = scene;
+  if (bound === void 0) return scene;
+  const whole = sceneBounds(scene);
+  const t = hull.radius * 2;
+  const bottom = whole.min[2] - hull.height;
+  const top = bound.ceiling ?? whole.max[2] + hull.height * 2 + hull.jump;
+  const [x0, y0] = bound.min;
+  const [x1, y1] = bound.max;
+  const slab = (ax, ay, az, bx, by, bz) => ({
+    kind: "box",
+    center: [(ax + bx) / 2, (ay + by) / 2, (az + bz) / 2],
+    half: [(bx - ax) / 2, (by - ay) / 2, (bz - az) / 2],
+    channels: [SceneChannel.Move]
+  });
+  const surfaces = [
+    slab(x0 - t, y0 - t, bottom, x0, y1 + t, top + t),
+    slab(x1, y0 - t, bottom, x1 + t, y1 + t, top + t),
+    slab(x0, y0 - t, bottom, x1, y0, top + t),
+    slab(x0, y1, bottom, x1, y1 + t, top + t)
+  ];
+  if (bound.ceiling !== void 0) surfaces.push(slab(x0, y0, bound.ceiling, x1, y1, bound.ceiling + t));
+  return { ...scene, actors: [...scene.actors, { name: BOUND_ACTOR, tags: [], surfaces }] };
+}
+function levelCore(scene, hull) {
+  const whole = sceneBounds(scene);
+  const plan = Math.max(1, (whole.max[0] - whole.min[0]) * (whole.max[1] - whole.min[1]));
+  const min = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const max = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  const take = (x0, y0, x1, y1) => {
+    min[0] = Math.min(min[0], x0);
+    min[1] = Math.min(min[1], y0);
+    max[0] = Math.max(max[0], x1);
+    max[1] = Math.max(max[1], y1);
+  };
+  for (const spawn of scene.spawns) take(spawn.at[0], spawn.at[1], spawn.at[0], spawn.at[1]);
+  for (const actor of scene.actors) {
+    const a = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+    const b = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    for (const surface of actor.surfaces) {
+      if (!blocksHull(actor, surface)) continue;
+      const box = surfaceBounds(surface);
+      for (let axis = 0; axis < 3; axis++) {
+        a[axis] = Math.min(a[axis], box.min[axis]);
+        b[axis] = Math.max(b[axis], box.max[axis]);
+      }
+    }
+    if (a[0] === Number.POSITIVE_INFINITY) continue;
+    const isGround = (b[0] - a[0]) * (b[1] - a[1]) >= plan * GROUND_PLAN_SHARE && b[2] - a[2] < hull.height;
+    if (!isGround) take(a[0], a[1], b[0], b[1]);
+  }
+  return { min, max };
+}
+function measureExtent(scene, hull, l, cells, foot, truth, spawns) {
+  const core = levelCore(scene, hull);
+  const cellM2 = (l.h / scene.unitsPerMeter) ** 2;
+  const walked = floodReach(l, foot, { ...cells, jump: 0, climb: 0, leap: 0 }, spawns);
+  const planOf = (node) => {
+    const col = (node - node % l.nz) / l.nz;
+    const j = Math.floor(col / l.nx);
+    return [l.x0 + (col - j * l.nx + 0.5) * l.h, l.y0 + (j + 0.5) * l.h];
+  };
+  const walkedMin = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+  const walkedMax = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (let n = 0; n < walked.count; n++) {
+    const [x, y] = planOf(walked.nodes[n]);
+    walkedMin[0] = Math.min(walkedMin[0], x);
+    walkedMin[1] = Math.min(walkedMin[1], y);
+    walkedMax[0] = Math.max(walkedMax[0], x);
+    walkedMax[1] = Math.max(walkedMax[1], y);
+  }
+  let outside = 0;
+  let outsideWalked = 0;
+  let farthest = 0;
+  for (let n = 0; n < truth.count; n++) {
+    const [x, y] = planOf(truth.nodes[n]);
+    if (x < walkedMin[0] - hull.leap || x > walkedMax[0] + hull.leap || y < walkedMin[1] - hull.leap || y > walkedMax[1] + hull.leap) outsideWalked += 1;
+    const dx = Math.max(core.min[0] - hull.leap - x, x - core.max[0] - hull.leap, 0);
+    const dy = Math.max(core.min[1] - hull.leap - y, y - core.max[1] - hull.leap, 0);
+    if (dx === 0 && dy === 0) continue;
+    outside += 1;
+    farthest = Math.max(farthest, Math.hypot(dx, dy));
+  }
+  const share = (part) => truth.count === 0 ? 0 : Math.round(1e4 * part / truth.count) / 100;
+  const outsideCorePct = share(outside);
+  const beyondWalkPct = share(Math.max(0, truth.count - walked.count));
+  const outsideWalkedPct = share(outsideWalked);
+  const flagged = scene.bound === void 0 && Math.max(outsideCorePct, outsideWalkedPct) >= REACH_FLAG_PCT;
+  return {
+    coreMin: core.min,
+    coreMax: core.max,
+    reachM2: Math.round(truth.count * cellM2),
+    walkedM2: Math.round(walked.count * cellM2),
+    beyondWalkPct,
+    outsideWalkedPct,
+    outsideCoreM2: Math.round(outside * cellM2),
+    outsideCorePct,
+    farthestFromCoreM: Math.round(farthest / scene.unitsPerMeter * 10) / 10,
+    bounded: scene.bound !== void 0,
+    flagged
+  };
+}
+function floorPastGate(floor, radius) {
+  return floor.maxUnits > FLOOR_MAX_RADII * radius || floor.p99Units > FLOOR_P99_RADII * radius;
+}
+function sceneReach(scene, cell) {
+  const { hull, l, truth } = prepare(scene, { maxBoxes: 0, maxRamps: 0, ...cell === void 0 ? {} : { cell } });
+  return { hull, l, truth };
+}
+var EMPTY_PLACED = { boxes: [], boxInfo: [], ramps: [], rampInfo: [] };
+function fitScene(scene, options) {
+  const started = performance.now();
+  const ctx = prepare(scene, options);
+  const rungs = options.rung !== void 0 ? [options.rung] : fitRungs(ctx.hull, ctx.l.h);
+  const finish = (parts) => {
+    const report = buildReport(ctx, parts, started);
+    const { boxes, ramps } = parts.placed;
+    if (parts.status === FitStatus.Ok) assertWorld(boxes, ramps);
+    const probe = options.keepProbe ? { probe: { l: ctx.l, truth: ctx.truth, attempted: { boxes, ramps }, fitted: parts.checked?.reach ?? null } } : {};
+    if (parts.status !== FitStatus.Ok) return { report, world: null, ...probe };
+    return { report, world: { boxes, ramps, hash: fitWorldHash(boxes, ramps) }, ...probe };
+  };
+  const noBounded = /* @__PURE__ */ new Set();
+  if (ctx.truth.count === 0) {
+    return finish({ status: FitStatus.NoReach, detail: "no spawn stands anywhere in the scene: nothing to fit from", placed: EMPTY_PLACED, rung: rungs[0], checked: null, repairs: 0, bounded: noBounded });
+  }
+  let best = null;
+  let fellThrough = null;
+  let lostTooMuch = null;
+  let slitsOpen = null;
+  let floorOver = null;
+  const boundedFor = (rung) => rung.props ? new Set(ctx.propIndices) : noBounded;
+  let finest = 0;
+  let coarsest = rungs.length - 1;
+  while (finest < coarsest) {
+    const mid = finest + coarsest >> 1;
+    const rung = rungs[mid];
+    if (attempt(ctx, rung, null, boundedFor(rung)).overLimit) finest = mid + 1;
+    else coarsest = mid;
+  }
+  for (const rung of rungs.slice(finest)) {
+    const bounded2 = boundedFor(rung);
+    const run2 = runRung(ctx, rung, bounded2);
+    if (run2 === null) continue;
+    const entry = { ...run2, rung, bounded: bounded2 };
+    if (fallsThrough(run2.checked)) {
+      fellThrough = entry;
+      continue;
+    }
+    if (countOpenSlits(ctx.input, run2.placed, ctx.cells.crouch * ctx.l.h) > 0) {
+      slitsOpen = entry;
+      continue;
+    }
+    if (floorPastGate(run2.checked.floor, ctx.hull.radius)) {
+      floorOver ??= entry;
+      continue;
+    }
+    if (run2.checked.compare.lostBeyondSlackPct > MAX_REACH_LOST_PCT) {
+      lostTooMuch = entry;
+      continue;
+    }
+    best = entry;
+    break;
+  }
+  if (best !== null) {
+    return finish({ status: FitStatus.Ok, detail: "fits", placed: best.placed, rung: best.rung, checked: best.checked, repairs: best.repairs, bounded: best.bounded });
+  }
+  if (floorOver !== null && lostTooMuch === null && slitsOpen === null) {
+    const { floor } = floorOver.checked;
+    const named2 = actorCosts(ctx, floorOver.placed).slice(0, REFUSAL_NAMES).map((a) => `${a.name} (${a.boxes} boxes, ${a.ramps} ramps)`);
+    const detail2 = `feet stay ${floor.maxUnits} units from the source's floor at worst and ${floor.p99Units} at the 99th percentile, at the finest fit the budget of ${options.maxBoxes} boxes and ${options.maxRamps} ramps holds; a fit may be ${FLOOR_MAX_RADII * ctx.hull.radius} and ${FLOOR_P99_RADII * ctx.hull.radius}. Costliest: ${named2.join(", ")}. Simplify those or raise the budget`;
+    return finish({ status: FitStatus.FloorOver, detail: detail2, placed: floorOver.placed, rung: floorOver.rung, checked: floorOver.checked, repairs: floorOver.repairs, bounded: floorOver.bounded });
+  }
+  const failed = lostTooMuch ?? slitsOpen ?? fellThrough;
+  if (failed !== null) {
+    const status = lostTooMuch !== null ? FitStatus.ReachLost : slitsOpen !== null ? FitStatus.OpenSlits : FitStatus.FallsThrough;
+    const detail2 = status === FitStatus.ReachLost ? `the only fit within budget loses ${failed.checked.compare.lostBeyondSlackPct}% of the reach; a fit may lose ${MAX_REACH_LOST_PCT}%` : status === FitStatus.OpenSlits ? "a gap too narrow for the hull stays open or barely shut between solids in every fit tried: see openSlits" : `a hull gets under the floor in every fit tried: ${failed.checked.compare.underFloorNodes} positions, ${failed.checked.compare.newFalls} places it falls out of the level`;
+    return finish({ status, detail: detail2, placed: failed.placed, rung: failed.rung, checked: failed.checked, repairs: failed.repairs, bounded: failed.bounded });
+  }
+  const last = rungs[rungs.length - 1];
+  const bounded = boundedFor(last);
+  const unlimited = { ...ctx, options: { ...options, maxBoxes: Number.MAX_SAFE_INTEGER } };
+  const run = attempt(unlimited, last, null, bounded);
+  const need = run.placed.boxes.length;
+  const named = actorCosts(ctx, run.placed).slice(0, REFUSAL_NAMES).map((a) => `${a.name} (${a.boxes} boxes, ${a.reachIfBoxedPct}% of the reach if it were one box)`);
+  const detail = `needs ${need} boxes at the coarsest fit; the budget is ${options.maxBoxes}. Costliest: ${named.join(", ")}. Simplify those or raise the budget`;
+  return finish({ status: FitStatus.OverBudget, detail, placed: run.placed, rung: last, checked: null, repairs: 0, bounded });
+}
+
+// src/world-fit/shot.ts
+var ShotFitStatus = {
+  Ok: "ok",
+  /** Even the coarsest shot world needs more boxes or bytes than the budget. */
+  OverBudget: "over_budget",
+  /** No spawn stands anywhere, so no muzzle sees anything. */
+  NoReach: "no_reach",
+  /** Within budget, but rays disagree with the source past what a shot world may. */
+  Inaccurate: "inaccurate"
+};
+var FINEST_CELL_RADII = 1 / 4;
+var CELL_RUNGS = 6;
+var MAX_LATTICE_CELLS2 = 1e9;
+var DEFAULT_RANGE_RADII = 1024;
+var DEFAULT_RAYS = 1e5;
+var DEFAULT_MAX_BYTES = 1024 * 1024;
+var SOLID_GROW_CELLS = 1 / 64;
+var MAX_GROW_CELLS2 = 256;
+var GRID_CELLS = 1 / 32;
+var SEAM_GRIDS = 1;
+var SURFACE_BAND_CELLS = 1;
+var CLAIM_MULTIPLES = [1, 0.5, 2, 4];
+var HOSTILE_PAST_RADII = 3;
+var SURFACE_STEPS_CELLS = [1 / 16, 1 / 8, 1 / 4, 1 / 2, 1, 2, 4, 8];
+var MAX_HIT_MISS_PCT = 5;
+var LEVEL_RAY_SHARE = 0.5;
+var LEVEL_RAY_SLOPE = 0.2;
+var EYE_SHARE = 8 / 9;
+var CROUCH_EYE_SHARE = 0.85;
+var CROUCH_RAY_SHARE = 0.25;
+var RAY_SEED = 20261107;
+var REPORT_WORST = 8;
+var REPORT_ACTORS2 = 12;
+var REPORT_UNSEEN = 64;
+var LEAF_ITEMS = 4;
+var STACK_DEPTH = 128;
+var REFUSAL_COUNT_FACTOR = 4;
+var REFUSAL_COUNT_LEAST = 4096;
+var BoundsTree = class {
+  bounds;
+  order;
+  first;
+  second;
+  nodes = 0;
+  constructor(itemBounds, count) {
+    const nodeCap = Math.max(1, 2 * count);
+    this.bounds = new Float64Array(nodeCap * 6);
+    this.order = new Int32Array(count);
+    this.first = new Int32Array(nodeCap);
+    this.second = new Int32Array(nodeCap);
+    for (let i = 0; i < count; i++) this.order[i] = i;
+    if (count > 0) this.build(itemBounds, 0, count);
+  }
+  /** Node n: a leaf holds order[first..second) with first < 0 written as ~first; an inner node its two children. */
+  build(items, from, to) {
+    const node = this.nodes++;
+    const b = this.bounds;
+    const at = node * 6;
+    let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+    let cx0 = Infinity, cy0 = Infinity, cz0 = Infinity, cx1 = -Infinity, cy1 = -Infinity, cz1 = -Infinity;
+    for (let n = from; n < to; n++) {
+      const o = this.order[n] * 6;
+      x0 = Math.min(x0, items[o]);
+      y0 = Math.min(y0, items[o + 1]);
+      z0 = Math.min(z0, items[o + 2]);
+      x1 = Math.max(x1, items[o + 3]);
+      y1 = Math.max(y1, items[o + 4]);
+      z1 = Math.max(z1, items[o + 5]);
+      const cx = items[o] + items[o + 3];
+      const cy = items[o + 1] + items[o + 4];
+      const cz = items[o + 2] + items[o + 5];
+      cx0 = Math.min(cx0, cx);
+      cy0 = Math.min(cy0, cy);
+      cz0 = Math.min(cz0, cz);
+      cx1 = Math.max(cx1, cx);
+      cy1 = Math.max(cy1, cy);
+      cz1 = Math.max(cz1, cz);
+    }
+    b[at] = x0;
+    b[at + 1] = y0;
+    b[at + 2] = z0;
+    b[at + 3] = x1;
+    b[at + 4] = y1;
+    b[at + 5] = z1;
+    if (to - from <= LEAF_ITEMS) {
+      this.first[node] = ~from;
+      this.second[node] = to;
+      return node;
+    }
+    const sizes = [cx1 - cx0, cy1 - cy0, cz1 - cz0];
+    const axis = sizes[0] >= sizes[1] && sizes[0] >= sizes[2] ? 0 : sizes[1] >= sizes[2] ? 1 : 2;
+    const mid = from + to >> 1;
+    this.select(items, axis, from, to - 1, mid);
+    this.first[node] = this.build(items, from, mid);
+    this.second[node] = this.build(items, mid, to);
+    return node;
+  }
+  /** Quickselect on the items' centres: order[k] ends where a full sort would put it. */
+  select(items, axis, lo, hi, k) {
+    const { order } = this;
+    const key = (index) => items[order[index] * 6 + axis] + items[order[index] * 6 + axis + 3];
+    while (lo < hi) {
+      const pivot = key(lo + hi >> 1);
+      let i = lo;
+      let j = hi;
+      while (i <= j) {
+        while (key(i) < pivot) i++;
+        while (key(j) > pivot) j--;
+        if (i <= j) {
+          const swap = order[i];
+          order[i] = order[j];
+          order[j] = swap;
+          i++;
+          j--;
+        }
+      }
+      if (k <= j) hi = j;
+      else if (k >= i) lo = i;
+      else return;
+    }
+  }
+  stack = new Int32Array(STACK_DEPTH);
+  /** Calls `test` with each item whose node the ray may enter before `best()`. */
+  walk(ox, oy, oz, ix, iy, iz, best, test) {
+    const { bounds: b, first, second, order, stack } = this;
+    if (this.nodes === 0) return;
+    let top = 0;
+    stack[top++] = 0;
+    while (top > 0) {
+      const node = stack[--top];
+      const at = node * 6;
+      const ax = (b[at] - ox) * ix, bx = (b[at + 3] - ox) * ix;
+      const ay = (b[at + 1] - oy) * iy, by = (b[at + 4] - oy) * iy;
+      const az = (b[at + 2] - oz) * iz, bz = (b[at + 5] - oz) * iz;
+      const near = Math.max(ax < bx ? ax : bx, ay < by ? ay : by, az < bz ? az : bz);
+      const far = Math.min(ax < bx ? bx : ax, ay < by ? by : ay, az < bz ? bz : az);
+      if (near > far || far < 0 || near > best()) continue;
+      const leaf = first[node];
+      if (leaf < 0) {
+        for (let n = ~leaf; n < second[node]; n++) test(order[n]);
+        continue;
+      }
+      stack[top++] = leaf;
+      stack[top++] = second[node];
+    }
+  }
+  /** Calls `visit` with each item whose node meets the box. */
+  overlap(min, max, visit) {
+    const { bounds: b, first, second, order, stack } = this;
+    if (this.nodes === 0) return;
+    let top = 0;
+    stack[top++] = 0;
+    while (top > 0) {
+      const node = stack[--top];
+      const at = node * 6;
+      if (b[at + 3] < min[0] || b[at] > max[0] || b[at + 4] < min[1] || b[at + 1] > max[1] || b[at + 5] < min[2] || b[at + 2] > max[2]) continue;
+      const leaf = first[node];
+      if (leaf < 0) {
+        for (let n = ~leaf; n < second[node]; n++) visit(order[n]);
+        continue;
+      }
+      stack[top++] = leaf;
+      stack[top++] = second[node];
+    }
+  }
+};
+var TriangleSet = class {
+  values = new Float64Array(9 * 4096);
+  owners = new Int32Array(4096);
+  count = 0;
+  add(actor, ax, ay, az, bx, by, bz, cx, cy, cz) {
+    if (this.count === this.owners.length) {
+      const values = new Float64Array(this.values.length * 2);
+      values.set(this.values);
+      this.values = values;
+      const owners = new Int32Array(this.owners.length * 2);
+      owners.set(this.owners);
+      this.owners = owners;
+    }
+    const o = this.count * 9;
+    const v = this.values;
+    v[o] = ax;
+    v[o + 1] = ay;
+    v[o + 2] = az;
+    v[o + 3] = bx;
+    v[o + 4] = by;
+    v[o + 5] = bz;
+    v[o + 6] = cx;
+    v[o + 7] = cy;
+    v[o + 8] = cz;
+    this.owners[this.count] = actor;
+    this.count += 1;
+  }
+  get vertices() {
+    return this.values;
+  }
+  owner(t) {
+    return this.owners[t];
+  }
+  tree() {
+    const items = new Float64Array(this.count * 6);
+    const v = this.values;
+    for (let t = 0; t < this.count; t++) {
+      const o = t * 9;
+      const at = t * 6;
+      items[at] = Math.min(v[o], v[o + 3], v[o + 6]);
+      items[at + 1] = Math.min(v[o + 1], v[o + 4], v[o + 7]);
+      items[at + 2] = Math.min(v[o + 2], v[o + 5], v[o + 8]);
+      items[at + 3] = Math.max(v[o], v[o + 3], v[o + 6]);
+      items[at + 4] = Math.max(v[o + 1], v[o + 4], v[o + 7]);
+      items[at + 5] = Math.max(v[o + 2], v[o + 5], v[o + 8]);
+    }
+    return new BoundsTree(items, this.count);
+  }
+};
+var inverse = (d) => d !== 0 ? 1 / d : Number.POSITIVE_INFINITY;
+var SourceRays = class {
+  tree;
+  set;
+  constructor(set) {
+    this.set = set;
+    this.tree = set.tree();
+  }
+  /** How far a point is from a surface, on any axis, read by steps of a cell: the first box round it that holds any. */
+  offSurface(x, y, z, h) {
+    const v = this.set.vertices;
+    const bounds = [0, 0, 0, 0, 0, 0];
+    for (const cells of SURFACE_STEPS_CELLS) {
+      const r = cells * h;
+      const min = [x - r, y - r, z - r];
+      const max = [x + r, y + r, z + r];
+      let found = false;
+      this.tree.overlap(min, max, (t) => {
+        if (!found) found = clippedBounds(v, t * 9, min, max, bounds);
+      });
+      if (found) return r;
+    }
+    return SURFACE_STEPS_CELLS[SURFACE_STEPS_CELLS.length - 1] * 2 * h;
+  }
+  /** The nearest triangle along a unit ray within range, or null. Both faces count: open or closed, wound either way. */
+  ray(ox, oy, oz, dx, dy, dz, range) {
+    const v = this.set.vertices;
+    let best = range;
+    let found = false;
+    this.tree.walk(ox, oy, oz, inverse(dx), inverse(dy), inverse(dz), () => best, (t) => {
+      const o = t * 9;
+      const ax = v[o], ay = v[o + 1], az = v[o + 2];
+      const e1x = v[o + 3] - ax, e1y = v[o + 4] - ay, e1z = v[o + 5] - az;
+      const e2x = v[o + 6] - ax, e2y = v[o + 7] - ay, e2z = v[o + 8] - az;
+      const px = dy * e2z - dz * e2y, py = dz * e2x - dx * e2z, pz = dx * e2y - dy * e2x;
+      const det = e1x * px + e1y * py + e1z * pz;
+      if (det === 0) return;
+      const inv = 1 / det;
+      const sx = ox - ax, sy = oy - ay, sz = oz - az;
+      const u = (sx * px + sy * py + sz * pz) * inv;
+      if (u < 0 || u > 1) return;
+      const qx = sy * e1z - sz * e1y, qy = sz * e1x - sx * e1z, qz = sx * e1y - sy * e1x;
+      const w = (dx * qx + dy * qy + dz * qz) * inv;
+      if (w < 0 || u + w > 1) return;
+      const dist = (e2x * qx + e2y * qy + e2z * qz) * inv;
+      if (dist >= 0 && dist < best) {
+        best = dist;
+        found = true;
+      }
+    });
+    return found ? best : null;
+  }
+};
+var worldTrees = /* @__PURE__ */ new WeakMap();
+function treeOfWorld(world) {
+  const known = worldTrees.get(world);
+  if (known !== void 0) return known;
+  const items = new Float64Array(world.boxes.length * 6);
+  world.boxes.forEach((b, i) => items.set(b, i * 6));
+  const tree = new BoundsTree(items, world.boxes.length);
+  worldTrees.set(world, tree);
+  return tree;
+}
+function shotRay(world, origin, dir, range = Number.POSITIVE_INFINITY) {
+  const [ox, oy, oz] = origin;
+  const [dx, dy, dz] = dir;
+  const { boxes } = world;
+  const lo = [0, 0, 0];
+  let best = range;
+  let solid = -1;
+  let axis = -1;
+  treeOfWorld(world).walk(ox, oy, oz, inverse(dx), inverse(dy), inverse(dz), () => best, (s) => {
+    const b = boxes[s];
+    let near = Number.NEGATIVE_INFINITY;
+    let far = Number.POSITIVE_INFINITY;
+    let entered = -1;
+    for (let a = 0; a < 3; a++) {
+      const d = a === 0 ? dx : a === 1 ? dy : dz;
+      lo[a] = a === 0 ? ox : a === 1 ? oy : oz;
+      if (d === 0) {
+        if (!(lo[a] > b[a] && lo[a] < b[a + 3])) return;
+        continue;
+      }
+      const inv = 1 / d;
+      const t0 = (b[a] - lo[a]) * inv;
+      const t1 = (b[a + 3] - lo[a]) * inv;
+      const enter = Math.min(t0, t1);
+      if (enter > near) {
+        near = enter;
+        entered = a;
+      }
+      far = Math.min(far, Math.max(t0, t1));
+    }
+    if (!(near < far && far > 0)) return;
+    const t = Math.max(near, 0);
+    if (t < best || t === best && (solid < 0 || s < solid)) {
+      best = t;
+      solid = s;
+      axis = near < 0 ? -1 : entered;
+    }
+  });
+  return solid < 0 ? null : { dist: best, solid, axis };
+}
+function sweepOctants(l, solid, sources) {
+  const { nx, ny, w } = l;
+  const seenAir = newLayer(l);
+  const seenSolid = newLayer(l);
+  const visited = newLayer(l);
+  for (let octant = 0; octant < 8; octant++) {
+    const sx = octant & 1 ? 1 : -1;
+    const sy = octant & 2 ? 1 : -1;
+    const up = (octant & 4) !== 0;
+    visited.fill(0);
+    for (let jStep = 0; jStep < ny; jStep++) {
+      const j = sy > 0 ? jStep : ny - 1 - jStep;
+      const fromY = jStep > 0 ? (j - sy) * nx : -1;
+      for (let iStep = 0; iStep < nx; iStep++) {
+        const i = sx > 0 ? iStep : nx - 1 - iStep;
+        const col = (j * nx + i) * w;
+        const prevX = iStep > 0 ? (j * nx + i - sx) * w : -1;
+        const prevY = fromY >= 0 ? (fromY + i) * w : -1;
+        let carry = 0;
+        for (let step = 0; step < w; step++) {
+          const a = up ? step : w - 1 - step;
+          let seed = sources[col + a] | carry;
+          if (prevX >= 0) seed |= visited[prevX + a];
+          if (prevY >= 0) seed |= visited[prevY + a];
+          const rock = solid[col + a];
+          const air = ~rock;
+          let g = seed & air;
+          let p = air;
+          if (up) {
+            g |= p & g << 1;
+            p &= p << 1;
+            g |= p & g << 2;
+            p &= p << 2;
+            g |= p & g << 4;
+            p &= p << 4;
+            g |= p & g << 8;
+            p &= p << 8;
+            g |= p & g << 16;
+            carry = g >>> 31;
+            seenSolid[col + a] |= (seed | g << 1) & rock;
+          } else {
+            g |= p & g >>> 1;
+            p &= p >>> 1;
+            g |= p & g >>> 2;
+            p &= p >>> 2;
+            g |= p & g >>> 4;
+            p &= p >>> 4;
+            g |= p & g >>> 8;
+            p &= p >>> 8;
+            g |= p & g >>> 16;
+            carry = (g & 1) << 31;
+            seenSolid[col + a] |= (seed | g >>> 1) & rock;
+          }
+          visited[col + a] = g;
+          seenAir[col + a] |= g;
+        }
+      }
+    }
+  }
+  return { seenAir, seenSolid };
+}
+function sourcesFromReach(from, body, shots) {
+  const out = newLayer(shots);
+  for (let j = 0; j < from.ny; j++) {
+    const y = from.y0 + (j + 0.5) * from.h;
+    const sj = Math.floor((y - shots.y0) / shots.h);
+    if (sj < 0 || sj >= shots.ny) continue;
+    for (let i = 0; i < from.nx; i++) {
+      const col = (j * from.nx + i) * from.w;
+      let any = false;
+      for (let a = 0; a < from.w && !any; a++) any = body[col + a] !== 0;
+      if (!any) continue;
+      const x = from.x0 + (i + 0.5) * from.h;
+      const si = Math.floor((x - shots.x0) / shots.h);
+      if (si < 0 || si >= shots.nx) continue;
+      const target = (sj * shots.nx + si) * shots.w;
+      for (let k = 0; k < from.nz; k++) {
+        if (!testBit(body, col, k)) continue;
+        const sk = Math.floor((from.z0 + (k + 0.5) * from.h - shots.z0) / shots.h);
+        if (sk >= 0 && sk < shots.nz) setBit(out, target, sk);
+      }
+    }
+  }
+  return out;
+}
+function faceGain(l, must, avoid, i0, i1, j0, j1, k0, k1) {
+  let gain = 0;
+  for (let j = j0; j <= j1; j++) {
+    for (let i = i0; i <= i1; i++) {
+      const col = (j * l.nx + i) * l.w;
+      if (anyInRun(l, avoid, col, k0, k1)) return -1;
+      gain += countInRun(l, must, col, k0, k1);
+    }
+  }
+  return gain;
+}
+function growRect(l, must, avoid, i, j, k, order) {
+  const r = { i0: i, i1: i, j0: j, j1: j, k0: k, k1: k };
+  let gained = 1;
+  for (const axis of order) {
+    for (const way of [1, -1]) {
+      for (; ; ) {
+        const size = axis === 0 ? r.i1 - r.i0 : axis === 1 ? r.j1 - r.j0 : r.k1 - r.k0;
+        if (size + 1 >= MAX_GROW_CELLS2) break;
+        let gain;
+        if (axis === 0) {
+          const x = way > 0 ? r.i1 + 1 : r.i0 - 1;
+          if (x < 0 || x >= l.nx) break;
+          gain = faceGain(l, must, avoid, x, x, r.j0, r.j1, r.k0, r.k1);
+          if (gain <= 0) break;
+          if (way > 0) r.i1 = x;
+          else r.i0 = x;
+        } else if (axis === 1) {
+          const y = way > 0 ? r.j1 + 1 : r.j0 - 1;
+          if (y < 0 || y >= l.ny) break;
+          gain = faceGain(l, must, avoid, r.i0, r.i1, y, y, r.k0, r.k1);
+          if (gain <= 0) break;
+          if (way > 0) r.j1 = y;
+          else r.j0 = y;
+        } else {
+          const z = way > 0 ? r.k1 + 1 : r.k0 - 1;
+          if (z < 0 || z >= l.nz) break;
+          gain = faceGain(l, must, avoid, r.i0, r.i1, r.j0, r.j1, z, z);
+          if (gain <= 0) break;
+          if (way > 0) r.k1 = z;
+          else r.k0 = z;
+        }
+        gained += gain;
+      }
+    }
+  }
+  return { rect: r, gained };
+}
+var GROW_ORDERS = [[0, 1, 2], [1, 0, 2]];
+function coverCells(l, must, avoid, stopAt) {
+  const rects = [];
+  for (let col = 0; col < l.nx * l.ny; col++) {
+    const offset = col * l.w;
+    let any = false;
+    for (let a = 0; a < l.w && !any; a++) any = must[offset + a] !== 0;
+    if (!any) continue;
+    const j = Math.floor(col / l.nx);
+    const i = col - j * l.nx;
+    for (let k = 0; k < l.nz; k++) {
+      if (!testBit(must, offset, k)) continue;
+      let best = null;
+      for (const order of GROW_ORDERS) {
+        const grown = growRect(l, must, avoid, i, j, k, order);
+        if (best === null || grown.gained > best.gained) best = grown;
+      }
+      const { rect } = best;
+      rects.push(rect);
+      if (rects.length >= stopAt) return rects;
+      for (let y = rect.j0; y <= rect.j1; y++) {
+        for (let x = rect.i0; x <= rect.i1; x++) clearRun(l, must, (y * l.nx + x) * l.w, rect.k0, rect.k1);
+      }
+    }
+  }
+  return rects;
+}
+var clipIn = new Float64Array(3 * 16);
+var clipOut = new Float64Array(3 * 16);
+function clippedBounds(v, o, min, max, bounds) {
+  let src = clipIn;
+  let dst = clipOut;
+  for (let n = 0; n < 9; n++) src[n] = v[o + n];
+  let count = 3;
+  for (let axis = 0; axis < 3 && count > 0; axis++) {
+    for (const side of [0, 1]) {
+      const edge = side === 0 ? min[axis] : max[axis];
+      const sign = side === 0 ? 1 : -1;
+      let out = 0;
+      for (let a = 0; a < count; a++) {
+        const b = (a + 1) % count;
+        const pa = (src[a * 3 + axis] - edge) * sign;
+        const pb = (src[b * 3 + axis] - edge) * sign;
+        if (pa >= 0) {
+          dst[out * 3] = src[a * 3];
+          dst[out * 3 + 1] = src[a * 3 + 1];
+          dst[out * 3 + 2] = src[a * 3 + 2];
+          out += 1;
+        }
+        if (pa > 0 && pb < 0 || pa < 0 && pb > 0) {
+          const t = pa / (pa - pb);
+          for (let c = 0; c < 3; c++) dst[out * 3 + c] = src[a * 3 + c] + (src[b * 3 + c] - src[a * 3 + c]) * t;
+          out += 1;
+        }
+      }
+      count = out;
+      const swap = src;
+      src = dst;
+      dst = swap;
+    }
+  }
+  if (count === 0) return false;
+  for (let p = 0; p < count; p++) {
+    for (let a = 0; a < 3; a++) {
+      const value = src[p * 3 + a];
+      if (value < bounds[a]) bounds[a] = value;
+      if (value > bounds[a + 3]) bounds[a + 3] = value;
+    }
+  }
+  return true;
+}
+var gridOf = (h) => 2 ** Math.floor(Math.log2(h * GRID_CELLS));
+function faceDown(value, grid) {
+  const on = Math.floor(value / grid) * grid;
+  const f2 = Math.fround(on);
+  return f2 > on ? Math.fround(on - grid) : f2;
+}
+function faceUp(value, grid) {
+  const on = Math.ceil(value / grid) * grid;
+  const f2 = Math.fround(on);
+  return f2 < on ? Math.fround(on + grid) : f2;
+}
+function boxRound(lo, hi, grid, seam) {
+  return [faceDown(lo[0] - seam, grid), faceDown(lo[1] - seam, grid), faceDown(lo[2] - seam, grid), faceUp(hi[0] + seam, grid), faceUp(hi[1] + seam, grid), faceUp(hi[2] + seam, grid)];
+}
+function fitOnLattice(input, h, exact, maxBoxes, log) {
+  const { scene } = input;
+  const bounds = shotBounds(input);
+  const l = makeLattice(h, bounds.min, bounds.max);
+  const half = h / 2 + h * SOLID_GROW_CELLS;
+  const solid = newLayer(l);
+  const exactLists = [];
+  const others = new TriangleSet();
+  const shell = newLayer(l);
+  const inReach = (b) => b.max[0] >= l.x0 && b.max[1] >= l.y0 && b.max[2] >= l.z0 && b.min[0] <= l.x0 + l.nx * h && b.min[1] <= l.y0 + l.ny * h && b.min[2] <= l.z0 + l.nz * h;
+  scene.actors.forEach((actor, index) => {
+    for (const surface of actor.surfaces) {
+      if (!stopsShot(actor, surface) || !inReach(surfaceBounds(surface))) continue;
+      const asBox = exact ? exactBoxBounds(surface) : null;
+      if (asBox !== null) {
+        exactLists.push({ actor: index, box: asBox });
+        rasterSurface(l, solid, half, surface);
+        continue;
+      }
+      rasterSurface(l, solid, half, surface);
+      surfaceTriangles(surface, (ax, ay, az, bx, by, bz, cx, cy, cz) => {
+        others.add(index, ax, ay, az, bx, by, bz, cx, cy, cz);
+        rasterTriangle(l, shell, half, ax, ay, az, bx, by, bz, cx, cy, cz);
+      });
+    }
+  });
+  const dilate = Math.max(0, Math.floor(input.hull.radius / h) - 1);
+  const raw = sourcesFromReach(input.reachL, input.reachBody, l);
+  const sources = dilate > 0 ? dilateXY(l, raw, dilate) : raw;
+  const { seenAir, seenSolid } = sweepOctants(l, solid, sources);
+  let airCells = 0;
+  const topBits = l.nz % 32;
+  const topMask = topBits === 0 ? 4294967295 : 2 ** topBits - 1;
+  for (let at = 0; at < seenAir.length; at++) {
+    let word = (at + 1) % l.w === 0 ? (seenAir[at] & topMask) >>> 0 : seenAir[at];
+    while (word !== 0) {
+      word &= word - 1;
+      airCells += 1;
+    }
+  }
+  const grid = gridOf(h);
+  const seam = grid * SEAM_GRIDS;
+  const boxes = [];
+  const actorBoxes = new Int32Array(scene.actors.length);
+  const actorsKept = new Uint8Array(scene.actors.length);
+  for (const { actor, box } of exactLists) {
+    const i0 = Math.max(0, cellFloor((box.min[0] - l.x0) / h - SOLID_GROW_CELLS));
+    const i1 = Math.min(l.nx - 1, cellCeil((box.max[0] - l.x0) / h + SOLID_GROW_CELLS) - 1);
+    const j0 = Math.max(0, cellFloor((box.min[1] - l.y0) / h - SOLID_GROW_CELLS));
+    const j1 = Math.min(l.ny - 1, cellCeil((box.max[1] - l.y0) / h + SOLID_GROW_CELLS) - 1);
+    const k0 = Math.max(0, cellFloor((box.min[2] - l.z0) / h));
+    const k1 = Math.min(l.nz - 1, Math.max(k0, cellCeil((box.max[2] - l.z0) / h) - 1));
+    let seen = false;
+    for (let j = j0; j <= j1 && !seen; j++) {
+      for (let i = i0; i <= i1 && !seen; i++) seen = anyInRun(l, seenSolid, (j * l.nx + i) * l.w, k0, k1);
+    }
+    if (!seen) continue;
+    boxes.push(boxRound(box.min, box.max, grid, 0));
+    actorBoxes[actor] += 1;
+    actorsKept[actor] = 1;
+  }
+  const exactBoxes = boxes.length;
+  const band = reachUp(l, reachDown(l, dilateXY(l, seenSolid, SURFACE_BAND_CELLS), SURFACE_BAND_CELLS + 1), SURFACE_BAND_CELLS + 1);
+  const must = newLayer(l);
+  for (let at = 0; at < must.length; at++) must[at] = band[at] & shell[at];
+  const left = Math.max(0, maxBoxes - exactBoxes);
+  const stopAt = Math.max(REFUSAL_COUNT_LEAST, Math.ceil(maxBoxes * REFUSAL_COUNT_FACTOR)) + 1;
+  const rects = coverCells(l, must, seenAir, stopAt);
+  const tree = others.tree();
+  const v = others.vertices;
+  let coverBoxes = 0;
+  const lo = [0, 0, 0];
+  const hi = [0, 0, 0];
+  for (const r of rects) {
+    lo[0] = l.x0 + r.i0 * h;
+    lo[1] = l.y0 + r.j0 * h;
+    lo[2] = l.z0 + r.k0 * h;
+    hi[0] = l.x0 + (r.i1 + 1) * h;
+    hi[1] = l.y0 + (r.j1 + 1) * h;
+    hi[2] = l.z0 + (r.k1 + 1) * h;
+    const tight = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+    let owner = -1;
+    tree.overlap(lo, hi, (t) => {
+      if (clippedBounds(v, t * 9, lo, hi, tight)) {
+        const actor = others.owner(t);
+        actorsKept[actor] = 1;
+        if (owner < 0) owner = actor;
+      }
+    });
+    if (owner < 0) continue;
+    boxes.push(boxRound([tight[0], tight[1], tight[2]], [tight[3], tight[4], tight[5]], grid, seam));
+    actorBoxes[owner] += 1;
+    coverBoxes += 1;
+  }
+  const over = rects.length >= stopAt || coverBoxes > left;
+  log?.(`shot lattice ${l.nx} x ${l.ny} x ${l.nz} at ${h}${exact ? "" : " (no exact boxes)"}: ${exactBoxes} exact + ${coverBoxes} cover${over ? " (over)" : ""}, air seen ${Math.round(100 * airCells / (l.nx * l.ny * l.nz))}%`);
+  return { boxes, exactBoxes, coverBoxes, actorBoxes, actorsKept, seenAirPct: Math.round(1e4 * airCells / (l.nx * l.ny * l.nz)) / 100, over };
+}
+function shotBounds(input) {
+  const { eyeBounds: eye, range, scene } = input;
+  const lo = [eye.min[0], eye.min[1], eye.min[2]];
+  const hi = [eye.max[0], eye.max[1], eye.max[2]];
+  for (const actor of scene.actors) {
+    for (const surface of actor.surfaces) {
+      if (!stopsShot(actor, surface)) continue;
+      const b = surfaceBounds(surface);
+      for (let a = 0; a < 3; a++) {
+        lo[a] = Math.min(lo[a], Math.max(b.min[a], eye.min[a] - range));
+        hi[a] = Math.max(hi[a], Math.min(b.max[a], eye.max[a] + range));
+      }
+    }
+  }
+  return { min: [lo[0], lo[1], lo[2]], max: [hi[0], hi[1], hi[2]] };
+}
+function ladder(bounds, hull, asked) {
+  if (asked !== void 0) return [asked];
+  let h = hull.radius * FINEST_CELL_RADII;
+  const cells = (c) => (bounds.max[0] - bounds.min[0]) / c * ((bounds.max[1] - bounds.min[1]) / c) * ((bounds.max[2] - bounds.min[2]) / c);
+  while (cells(h) > MAX_LATTICE_CELLS2) h *= 2;
+  return Array.from({ length: CELL_RUNGS }, (_, n) => h * 2 ** n);
+}
+function eyeBoundsOf(l, nodes, count, hull) {
+  let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (let n = 0; n < count; n++) {
+    const node = nodes[n];
+    const k = node % l.nz;
+    const col = (node - k) / l.nz;
+    const j = Math.floor(col / l.nx);
+    const i = col - j * l.nx;
+    minX = Math.min(minX, l.x0 + i * l.h);
+    maxX = Math.max(maxX, l.x0 + (i + 1) * l.h);
+    minY = Math.min(minY, l.y0 + j * l.h);
+    maxY = Math.max(maxY, l.y0 + (j + 1) * l.h);
+    minZ = Math.min(minZ, l.z0 + k * l.h);
+    maxZ = Math.max(maxZ, l.z0 + k * l.h + hull.height + hull.jump);
+  }
+  return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
+}
+function claimArithmetic(server, facing, claimed, tolerance, range, minFacing = ShotWorldCost.MIN_CLAIM_FACING) {
+  const said = claimed === null || Number.isNaN(claimed) ? Number.POSITIVE_INFINITY : Math.max(claimed, 0);
+  const stop = Math.min(said, range);
+  const slack = tolerance / Math.max(facing, minFacing);
+  if (stop > server + slack) return { dist: server, verdict: ClaimVerdict.Refused, slack };
+  if (stop < server - slack) return { dist: server - slack, verdict: ClaimVerdict.Capped, slack };
+  return { dist: stop, verdict: ClaimVerdict.Accepted, slack };
+}
+function claimedStop(world, origin, dir, claimed, tolerance, range, minFacing = ShotWorldCost.MIN_CLAIM_FACING) {
+  const big = Math.max(Math.abs(dir[0]), Math.abs(dir[1]), Math.abs(dir[2]));
+  const a = dir[0] / big;
+  const b = dir[1] / big;
+  const c = dir[2] / big;
+  const length = Math.sqrt(a * a + b * b + c * c);
+  const unit = [a / length, b / length, c / length];
+  const hit = shotRay(world, origin, unit, range);
+  const facing = hit === null || hit.axis < 0 ? 1 : Math.abs(unit[hit.axis]);
+  return { ...claimArithmetic(hit === null ? range : hit.dist, facing, claimed, tolerance, range, minFacing), server: hit === null ? null : hit.dist };
+}
+function claimMargin(record, toleranceUnits, past, range, minFacing) {
+  const { truths, stops, facings, answered } = record;
+  let off = 0;
+  let stopped = 0;
+  let passed = 0;
+  const gains = new Float64Array(answered);
+  for (let n = 0; n < answered; n++) {
+    const truth = truths[n];
+    const stop = stops[n];
+    const server = stop < 0 ? range : stop;
+    const facing = facings[n];
+    const honest = claimArithmetic(server, facing, truth < 0 ? null : truth, toleranceUnits, range, minFacing);
+    if (honest.verdict !== ClaimVerdict.Accepted) off += 1;
+    if (truth < 0) continue;
+    if (stop >= 0) gains[stopped] = Math.max(0, stop + honest.slack - truth);
+    stopped += 1;
+    if (claimArithmetic(server, facing, truth + past, toleranceUnits, range, minFacing).verdict === ClaimVerdict.Accepted) passed += 1;
+  }
+  const sorted = gains.subarray(0, stopped).sort();
+  const at = (share) => Math.round((sorted[Math.min(stopped - 1, Math.floor(share * stopped))] ?? 0) * 100) / 100;
+  return { toleranceUnits, minFacing, honestOffPct: Math.round(1e4 * off / Math.max(1, answered)) / 100, hostilePassPct: Math.round(1e4 * passed / Math.max(1, stopped)) / 100, hostileGainP50Units: at(0.5), hostileGainP99Units: at(0.99), hostileGainMaxUnits: at(1) };
+}
+function claimMargins(record, stated, hull, range) {
+  return CLAIM_MULTIPLES.map((multiple) => claimMargin(record, stated * multiple, hull.radius * HOSTILE_PAST_RADII, range, ShotWorldCost.MIN_CLAIM_FACING));
+}
+function claimGrid(record, stated, hull, range, facings) {
+  return facings.flatMap((minFacing) => CLAIM_MULTIPLES.map((multiple) => claimMargin(record, stated * multiple, hull.radius * HOSTILE_PAST_RADII, range, minFacing)));
+}
+function measureRays(input, world, rays) {
+  const { source, l, nodes, count, hull, range } = input;
+  let state = RAY_SEED >>> 0;
+  const next = () => {
+    state = Math.imul(state, 1664525) + 1013904223 >>> 0;
+    return state / 2 ** 32;
+  };
+  const errors = new Float64Array(rays);
+  const offSurface = new Float64Array(rays);
+  const truths = new Float64Array(rays);
+  const stopsOf = new Float64Array(rays);
+  const facingsOf = new Float64Array(rays);
+  let answered = 0;
+  let surfaced = 0;
+  const order = [];
+  let stopped = 0;
+  let passes = 0;
+  let stops = 0;
+  const keepWorst = (entry) => {
+    if (order.length === REPORT_WORST && entry.error <= order[order.length - 1].error) return;
+    order.push(entry);
+    order.sort((a, b) => b.error - a.error);
+    if (order.length > REPORT_WORST) order.pop();
+  };
+  for (let n = 0; n < rays; n++) {
+    const node = nodes[Math.floor(next() * count)];
+    const k = node % l.nz;
+    const col = (node - k) / l.nz;
+    const j = Math.floor(col / l.nx);
+    const i = col - j * l.nx;
+    const eyeHeight = next() < CROUCH_RAY_SHARE ? hull.crouchHeight * CROUCH_EYE_SHARE : hull.height * EYE_SHARE;
+    const ox = l.x0 + (i + 0.5) * l.h;
+    const oy = l.y0 + (j + 0.5) * l.h;
+    const oz = l.z0 + k * l.h + eyeHeight;
+    const level = next() < LEVEL_RAY_SHARE;
+    const yaw = next() * 2 * Math.PI;
+    const z = level ? (next() * 2 - 1) * LEVEL_RAY_SLOPE : next() * 2 - 1;
+    const across = Math.sqrt(Math.max(0, 1 - z * z));
+    const dx = Math.cos(yaw) * across;
+    const dy = Math.sin(yaw) * across;
+    const truth = source.ray(ox, oy, oz, dx, dy, z, range);
+    const hit = shotRay(world, [ox, oy, oz], [dx, dy, z], range);
+    if (truth === null && hit === null) continue;
+    truths[answered] = truth ?? -1;
+    stopsOf[answered] = hit === null ? -1 : hit.dist;
+    facingsOf[answered] = hit === null || hit.axis < 0 ? 1 : Math.abs(hit.axis === 0 ? dx : hit.axis === 1 ? dy : z);
+    answered += 1;
+    if (hit !== null) offSurface[surfaced++] = source.offSurface(ox + dx * hit.dist, oy + dy * hit.dist, oz + z * hit.dist, input.h);
+    if (truth === null) {
+      stops += 1;
+      keepWorst({ error: range, from: [ox, oy, oz], dir: [dx, dy, z], source: null, fit: hit?.dist ?? null });
+      continue;
+    }
+    if (hit === null) {
+      passes += 1;
+      keepWorst({ error: range, from: [ox, oy, oz], dir: [dx, dy, z], source: truth, fit: null });
+      continue;
+    }
+    const error = Math.abs(truth - hit.dist);
+    errors[stopped++] = error;
+    keepWorst({ error, from: [ox, oy, oz], dir: [dx, dy, z], source: truth, fit: hit.dist });
+  }
+  const sorted = errors.subarray(0, stopped).sort();
+  const at = (share) => Math.round((sorted[Math.min(stopped - 1, Math.floor(share * stopped))] ?? 0) * 100) / 100;
+  const pct = (v) => Math.round(1e4 * v / rays) / 100;
+  const surfaces = offSurface.subarray(0, surfaced).sort();
+  const surfaceAt = (share) => surfaces[Math.min(surfaced - 1, Math.floor(share * surfaced))] ?? 0;
+  return { accuracy: { rays, hitMissPct: pct(passes + stops), passesPct: pct(passes), stopsPct: pct(stops), stopped, p50Units: at(0.5), p95Units: at(0.95), p99Units: at(0.99), maxUnits: at(1), surfaceP50Units: surfaceAt(0.5), surfaceP99Units: surfaceAt(0.99), surfaceMaxUnits: surfaceAt(1), worst: order.map(({ from: f2, dir, source: s, fit }) => ({ from: f2, dir, source: s, fit })) }, truths, stops: stopsOf, facings: facingsOf, answered };
+}
+function sceneShotRays(scene) {
+  const triangles = new TriangleSet();
+  scene.actors.forEach((actor, index) => {
+    for (const surface of actor.surfaces) {
+      if (stopsShot(actor, surface)) surfaceTriangles(surface, (ax, ay, az, bx, by, bz, cx, cy, cz) => triangles.add(index, ax, ay, az, bx, by, bz, cx, cy, cz));
+    }
+  });
+  const source = new SourceRays(triangles);
+  return (origin, dir, range) => source.ray(origin[0], origin[1], origin[2], dir[0], dir[1], dir[2], range);
+}
+function costliest(scene, actorBoxes) {
+  return Array.from(actorBoxes, (boxes, index) => ({ name: scene.actors[index].name, boxes, index })).filter((a) => a.boxes > 0).sort((a, b) => b.boxes - a.boxes || a.index - b.index).slice(0, REPORT_ACTORS2).map(({ name, boxes }) => ({ name, boxes }));
+}
+var answersShot = (actor) => actor.surfaces.some((surface) => stopsShot(actor, surface));
+function fitShotWorld(scene, options) {
+  const started = performance.now();
+  const hull = sceneHull(scene);
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const range = options.range ?? hull.radius * DEFAULT_RANGE_RADII;
+  const rays = options.rays ?? DEFAULT_RAYS;
+  const { l: reachL, truth } = sceneReach(scene);
+  const movableActors = scene.actors.filter((a) => a.tags.includes(SceneTag.Movable)).map((a) => a.name);
+  const finish = (status, detail, rung, h, accuracy, claims, grid, tolerance, bytes) => {
+    const unseen = rung === null ? [] : scene.actors.filter((a, index) => answersShot(a) && rung.actorsKept[index] === 0).map((a) => a.name);
+    const report = {
+      status,
+      detail,
+      budget: { maxBoxes: options.maxBoxes, maxBytes },
+      boxes: rung?.boxes.length ?? 0,
+      exactBoxes: rung?.exactBoxes ?? 0,
+      coverBoxes: rung?.coverBoxes ?? 0,
+      bytes,
+      cell: h,
+      toleranceUnits: tolerance,
+      accuracy,
+      claims,
+      claimGrid: grid,
+      seenAirPct: rung?.seenAirPct ?? 0,
+      movableActors,
+      unseenActors: unseen.slice(0, REPORT_UNSEEN),
+      actors: rung === null ? [] : costliest(scene, rung.actorBoxes),
+      seconds: Math.round((performance.now() - started) / 100) / 10
+    };
+    if (status !== ShotFitStatus.Ok || rung === null) return { report, world: null };
+    return { report, world: { boxes: rung.boxes, ramps: [], tolerance } };
+  };
+  if (truth.count === 0) return finish(ShotFitStatus.NoReach, "no spawn stands anywhere in the scene: nothing to fit from", null, 0, null, [], [], 0, 0);
+  const triangles = new TriangleSet();
+  scene.actors.forEach((actor, index) => {
+    for (const surface of actor.surfaces) {
+      if (stopsShot(actor, surface)) surfaceTriangles(surface, (ax, ay, az, bx, by, bz, cx, cy, cz) => triangles.add(index, ax, ay, az, bx, by, bz, cx, cy, cz));
+    }
+  });
+  const eyeBounds = eyeBoundsOf(reachL, truth.nodes, truth.count, hull);
+  const input = { scene, hull, reachL, reachBody: truth.body, eyeBounds, triangles, exactOf: [], range };
+  const cells = ladder(shotBounds(input), hull, options.cell);
+  const source = new SourceRays(triangles);
+  const ownBudget = (rung) => JSON.stringify(rung.boxes).length;
+  let last = null;
+  for (const h of cells) {
+    let rung = fitOnLattice(input, h, true, options.maxBoxes, options.log);
+    if (rung.exactBoxes > options.maxBoxes / 2 && (rung.over || ownBudget(rung) > maxBytes)) rung = fitOnLattice(input, h, false, options.maxBoxes, options.log);
+    last = { rung, h };
+    const bytes = ownBudget(rung);
+    if (rung.over || rung.boxes.length > options.maxBoxes || bytes > maxBytes) continue;
+    const provisional = { boxes: rung.boxes, ramps: [], tolerance: 0 };
+    const record = measureRays({ source, h, l: reachL, nodes: truth.nodes, count: truth.count, hull, range }, provisional, rays);
+    const { accuracy } = record;
+    const tolerance = Math.max(gridOf(h), accuracy.surfaceP99Units);
+    const claims = claimMargins(record, tolerance, hull, range);
+    const grid = options.facings === void 0 ? [] : claimGrid(record, tolerance, hull, range, options.facings);
+    if (accuracy.hitMissPct > MAX_HIT_MISS_PCT) {
+      return finish(ShotFitStatus.Inaccurate, `at the cell the budget holds (${h} units) ${accuracy.hitMissPct}% of rays disagree with the source; a shot world may disagree on ${MAX_HIT_MISS_PCT}%: raise the budget or simplify what is named`, rung, h, accuracy, claims, grid, tolerance, bytes);
+    }
+    options.log?.(`rays ${accuracy.rays}: hit or miss ${accuracy.hitMissPct}%, off by ${accuracy.p50Units} / ${accuracy.p95Units} / ${accuracy.p99Units} / ${accuracy.maxUnits} along the ray, ${accuracy.surfaceP50Units} / ${accuracy.surfaceP99Units} / ${accuracy.surfaceMaxUnits} from a surface`);
+    return finish(ShotFitStatus.Ok, "fits", rung, h, accuracy, claims, grid, tolerance, bytes);
+  }
+  const named = last === null ? [] : costliest(scene, last.rung.actorBoxes).slice(0, 5).map((a) => `${a.name} (${a.boxes} boxes)`);
+  const need = last === null ? 0 : last.rung.boxes.length;
+  return finish(ShotFitStatus.OverBudget, `needs ${need} boxes${last?.rung.over ? " or more" : ""} or ${last === null ? 0 : ownBudget(last.rung)} bytes at the coarsest cell; the budget is ${options.maxBoxes} and ${maxBytes}. Costliest: ${named.join(", ")}. Simplify those or raise the budget`, last?.rung ?? null, last?.h ?? 0, null, [], [], 0, last === null ? 0 : ownBudget(last.rung));
+}
+
+// src/world-fit/gltf.ts
+import { createHash } from "crypto";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, realpathSync } from "fs";
+import { basename, dirname, join, sep } from "path";
+var DEFAULT_UNITS_PER_METER = 39.37;
+var GLB_MAGIC = 1179937895;
+var CHUNK_JSON = 1313821514;
+var CHUNK_BIN = 5130562;
+var GLB_HEADER_BYTES = 12;
+var CHUNK_HEADER_BYTES = 8;
+var GLTF_MAJOR = 2;
+var QUATERNION_SLACK = 0.01;
+var ComponentType = { I8: 5120, U8: 5121, I16: 5122, U16: 5123, U32: 5125, F32: 5126 };
+var COMPONENT_BYTES = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 };
+var PrimitiveMode = { Points: 0, Lines: 1, LineLoop: 2, LineStrip: 3, Triangles: 4, TriangleStrip: 5, TriangleFan: 6 };
+var Extension = {
+  Draco: "KHR_draco_mesh_compression",
+  MeshoptExt: "EXT_meshopt_compression",
+  MeshoptKhr: "KHR_meshopt_compression",
+  Quantization: "KHR_mesh_quantization",
+  Instancing: "EXT_mesh_gpu_instancing"
+};
+var READS_FINE = [Extension.Quantization, Extension.Instancing, Extension.Draco, Extension.MeshoptExt, Extension.MeshoptKhr, "KHR_lights_punctual", "KHR_materials_", "KHR_texture_", "EXT_texture_", "KHR_animation_pointer", "KHR_xmp", "KHR_node_"];
+var COMPRESSION_FIX = "re-export uncompressed (gltf-transform copy, or your exporter's compression off), or load it in three.js and use sceneFromThree, whose loader decodes it";
+var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isIndex = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+function readPlainFile(path, refuse, tooLarge) {
+  const before = lstatSync(path);
+  if (!before.isFile()) throw refuse("is not a plain file");
+  if (before.size > LEVEL_LIMITS.maxFileBytes) throw tooLarge();
+  const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+  try {
+    const now = fstatSync(fd);
+    if (!now.isFile() || now.ino !== before.ino || now.dev !== before.dev) throw refuse("changed while it was read");
+    if (now.size > LEVEL_LIMITS.maxFileBytes) throw tooLarge();
+    return readFileSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function relativeUri(uri, where) {
+  const refuse = (why) => new LevelRefusal(LevelRefusalCode.UriRefused, `${where}: the uri ${JSON.stringify(uri.slice(0, 200))} ${why}; keep the buffer beside the file, or embed it`);
+  if (uri === "") throw refuse("is empty");
+  let decoded;
+  try {
+    decoded = decodeURIComponent(uri);
+  } catch {
+    throw refuse("has a bad percent escape");
+  }
+  if (/[\0\\:?#%]/.test(decoded)) throw refuse("holds a character no plain relative path needs");
+  if (decoded.startsWith("/")) throw refuse("is absolute");
+  for (const segment of decoded.split("/")) {
+    if (segment === "" || segment.endsWith(".") || segment.endsWith(" ")) throw refuse("leaves the input folder or is one a path would collapse");
+  }
+  return decoded;
+}
+var DATA_URI = /^data:application\/(octet-stream|gltf-buffer);base64,/;
+function dataUri(uri, where) {
+  if (!uri.startsWith("data:")) return null;
+  const head = DATA_URI.exec(uri);
+  if (head === null) throw new LevelRefusal(LevelRefusalCode.UriRefused, `${where}: only a base64 data uri of application/octet-stream or application/gltf-buffer is read`);
+  const encodedChars = uri.length - head[0].length;
+  if (encodedChars * 3 / 4 > LEVEL_LIMITS.maxFileBytes) throw new LevelRefusal(LevelRefusalCode.TooLarge, `${where}: a data uri past ${LEVEL_LIMITS.maxFileBytes} bytes`);
+  return Buffer.from(uri.slice(head[0].length), "base64");
+}
+var Document = class {
+  json;
+  buffers = /* @__PURE__ */ new Map();
+  bin;
+  root;
+  readBytes = 0;
+  uriOf;
+  quantized;
+  /** POSITION and index reads, by accessor. */
+  positionsCache = /* @__PURE__ */ new Map();
+  constructor(json, bin, root) {
+    this.json = json;
+    this.bin = bin;
+    this.root = root;
+    const declared = Array.isArray(json.buffers) ? json.buffers : [];
+    this.uriOf = declared.map((b, i) => {
+      const where = `$.buffers[${i}]`;
+      if (!isObject2(b)) throw new LevelRefusal(LevelRefusalCode.BadReference, `${where} is not an object`);
+      if (b.uri === void 0) return null;
+      if (typeof b.uri !== "string") throw new LevelRefusal(LevelRefusalCode.UriRefused, `${where}: the uri is not text`);
+      if (!b.uri.startsWith("data:")) relativeUri(b.uri, where);
+      else dataUri(b.uri.slice(0, 256), where);
+      return b.uri;
+    });
+    this.quantized = Array.isArray(json.extensionsUsed) && json.extensionsUsed.includes(Extension.Quantization);
+  }
+  list(name) {
+    const v = this.json[name];
+    return Array.isArray(v) ? v : [];
+  }
+  entry(name, index, where) {
+    if (!isIndex(index)) throw new LevelRefusal(LevelRefusalCode.BadReference, `${where} is not an index`);
+    const item = this.list(name)[index];
+    if (!isObject2(item)) throw new LevelRefusal(LevelRefusalCode.BadReference, `${where} names ${name}[${index}], which is not there`);
+    return item;
+  }
+  buffer(index, where) {
+    const cached = this.buffers.get(index);
+    if (cached !== void 0) return cached;
+    const spec = this.entry("buffers", index, where);
+    const bufferWhere = `$.buffers[${index}]`;
+    const uri = this.uriOf[index] ?? null;
+    let bytes;
+    if (uri === null) {
+      if (index !== 0 || this.bin === null) throw new LevelRefusal(LevelRefusalCode.BadReference, `${bufferWhere} has no uri and the file has no binary chunk for it`);
+      bytes = this.bin;
+    } else {
+      bytes = dataUri(uri, bufferWhere) ?? this.externalBuffer(relativeUri(uri, bufferWhere), uri, bufferWhere);
+    }
+    if (!isIndex(spec.byteLength) || bytes.length < spec.byteLength) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `${bufferWhere} says ${String(spec.byteLength)} bytes and holds ${bytes.length}`);
+    this.readBytes += bytes.length;
+    if (this.readBytes > LEVEL_LIMITS.maxFileBytes) throw new LevelRefusal(LevelRefusalCode.TooLarge, `the level's buffers pass ${LEVEL_LIMITS.maxFileBytes} bytes together`);
+    this.buffers.set(index, bytes);
+    return bytes;
+  }
+  externalBuffer(relative, uri, where) {
+    const refuse = (why) => new LevelRefusal(LevelRefusalCode.UriRefused, `${where}: ${uri.slice(0, 200)} ${why}`);
+    let real;
+    try {
+      real = realpathSync(join(this.root, relative));
+    } catch {
+      throw refuse("is not there, beside the file");
+    }
+    if (!real.startsWith(this.root + sep)) throw refuse("leads outside the input folder");
+    return readPlainFile(real, refuse, () => new LevelRefusal(LevelRefusalCode.TooLarge, `${where}: ${uri.slice(0, 200)} is past ${LEVEL_LIMITS.maxFileBytes} bytes`));
+  }
+  /** An accessor's own shape: what it reads, from which view, at what stride. Nothing decoded. */
+  layout(accessorIndex, where, elementComponents) {
+    const accessor = this.entry("accessors", accessorIndex, where);
+    const at = `$.accessors[${String(accessorIndex)}]`;
+    const bad = (why) => new LevelRefusal(LevelRefusalCode.BadAccessor, `${at} ${why}`);
+    if (accessor.sparse !== void 0) throw bad("is sparse: re-export it plain");
+    if (accessor.bufferView === void 0) throw bad("has no bufferView");
+    const count = accessor.count;
+    if (!isIndex(count) || count === 0) throw bad("has no usable count");
+    const componentType = accessor.componentType;
+    const componentBytes = COMPONENT_BYTES[componentType];
+    if (componentBytes === void 0) throw bad("has an unknown componentType");
+    const viewAt = `$.bufferViews[${String(accessor.bufferView)}]`;
+    const view = this.entry("bufferViews", accessor.bufferView, `${at}.bufferView`);
+    if (isObject2(view.extensions)) {
+      for (const name of [Extension.MeshoptExt, Extension.MeshoptKhr]) {
+        if (view.extensions[name] !== void 0) throw new LevelRefusal(LevelRefusalCode.Compressed, `${viewAt} is compressed with ${name}: ${COMPRESSION_FIX}`);
+      }
+    }
+    const badView = (why) => new LevelRefusal(LevelRefusalCode.BadAccessor, `${viewAt} ${why}`);
+    if (!isIndex(view.buffer) || !isObject2(this.list("buffers")[view.buffer])) throw new LevelRefusal(LevelRefusalCode.BadReference, `${viewAt}.buffer names no buffer`);
+    const viewOffset = view.byteOffset ?? 0;
+    const viewLength = view.byteLength;
+    if (!isIndex(viewOffset) || !isIndex(viewLength)) throw badView("has no usable offset or length");
+    const spec = this.list("buffers")[view.buffer];
+    if (!isIndex(spec.byteLength) || viewOffset + viewLength > spec.byteLength) throw badView(`runs past its buffer's ${String(spec.byteLength)} bytes`);
+    const element = componentBytes * elementComponents;
+    const stride = view.byteStride ?? element;
+    if (!isIndex(stride) || stride < element) throw badView(`has a stride under its ${element}-byte element`);
+    const accessorOffset = accessor.byteOffset ?? 0;
+    if (!isIndex(accessorOffset)) throw bad("has no usable byteOffset");
+    if (accessorOffset + (count - 1) * stride + element > viewLength) throw bad(`reads ${count} elements past its view's ${viewLength} bytes`);
+    const bytes = this.buffer(view.buffer, viewAt);
+    return { bytes, offset: viewOffset + accessorOffset, stride, count, componentType, normalized: accessor.normalized === true };
+  }
+  /** An accessor's element count, checked for type, before anything is decoded. */
+  checkType(accessorIndex, where, type) {
+    const accessor = this.entry("accessors", accessorIndex, where);
+    if (accessor.type !== type) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `$.accessors[${String(accessorIndex)}] is not ${type}`);
+  }
+  /** How many elements an accessor holds. */
+  countOf(accessorIndex, where) {
+    const count = this.entry("accessors", accessorIndex, where).count;
+    if (!isIndex(count)) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `$.accessors[${String(accessorIndex)}] has no usable count`);
+    return count;
+  }
+  /** VEC3 positions, as the numbers they mean. */
+  positions(accessorIndex, where) {
+    this.checkType(accessorIndex, where, "VEC3");
+    const cached = this.positionsCache.get(accessorIndex);
+    if (cached !== void 0) return cached;
+    const out = this.numbers(accessorIndex, where, 3, true);
+    this.positionsCache.set(accessorIndex, out);
+    return out;
+  }
+  /** A float or normalized-integer accessor as numbers. `quantizable`: integers only with KHR_mesh_quantization. */
+  numbers(accessorIndex, where, components, quantizable) {
+    const layout = this.layout(accessorIndex, where, components);
+    if (layout.count > LEVEL_LIMITS.maxVertices) throw new LevelRefusal(LevelRefusalCode.TooLarge, `$.accessors[${String(accessorIndex)}] holds ${layout.count} vertices, past ${LEVEL_LIMITS.maxVertices}`);
+    const { bytes, offset, stride, count, componentType, normalized } = layout;
+    if (componentType !== ComponentType.F32 && quantizable && !this.quantized) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `$.accessors[${String(accessorIndex)}] is not float, and the file does not use ${Extension.Quantization}`);
+    const read = this.reader(bytes, componentType, normalized, accessorIndex);
+    const size = COMPONENT_BYTES[componentType];
+    const out = new Float64Array(count * components);
+    for (let i = 0; i < count; i++) {
+      for (let c = 0; c < components; c++) out[i * components + c] = read(offset + i * stride + c * size);
+    }
+    return out;
+  }
+  reader(bytes, componentType, normalized, accessorIndex) {
+    switch (componentType) {
+      case ComponentType.F32:
+        return (at) => bytes.readFloatLE(at);
+      case ComponentType.I8:
+        return normalized ? (at) => Math.max(bytes.readInt8(at) / 127, -1) : (at) => bytes.readInt8(at);
+      case ComponentType.U8:
+        return normalized ? (at) => bytes.readUInt8(at) / 255 : (at) => bytes.readUInt8(at);
+      case ComponentType.I16:
+        return normalized ? (at) => Math.max(bytes.readInt16LE(at) / 32767, -1) : (at) => bytes.readInt16LE(at);
+      case ComponentType.U16:
+        return normalized ? (at) => bytes.readUInt16LE(at) / 65535 : (at) => bytes.readUInt16LE(at);
+      default:
+        throw new LevelRefusal(LevelRefusalCode.BadAccessor, `$.accessors[${String(accessorIndex)}] has a componentType these numbers cannot be`);
+    }
+  }
+  /** A SCALAR index accessor as indices. */
+  indices(accessorIndex, where) {
+    this.checkType(accessorIndex, where, "SCALAR");
+    const { bytes, offset, stride, count, componentType, normalized } = this.layout(accessorIndex, where, 1);
+    const at = `$.accessors[${String(accessorIndex)}]`;
+    if (normalized) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `${at} is normalized and an index cannot be`);
+    const out = new Uint32Array(count);
+    if (componentType === ComponentType.U16) for (let i = 0; i < count; i++) out[i] = bytes.readUInt16LE(offset + i * stride);
+    else if (componentType === ComponentType.U32) for (let i = 0; i < count; i++) out[i] = bytes.readUInt32LE(offset + i * stride);
+    else if (componentType === ComponentType.U8) for (let i = 0; i < count; i++) out[i] = bytes.readUInt8(offset + i * stride);
+    else throw new LevelRefusal(LevelRefusalCode.BadAccessor, `${at} is not an index type`);
+    return out;
+  }
+};
+function numberList(raw, length, where) {
+  if (!Array.isArray(raw) || raw.length !== length) throw new LevelRefusal(LevelRefusalCode.BadValue, `${where} is not ${length} numbers`);
+  return raw.map((v, i) => {
+    if (typeof v !== "number") throw new LevelRefusal(LevelRefusalCode.BadValue, `${where}[${i}] is not a number`);
+    if (!Number.isFinite(v)) throw new LevelRefusal(LevelRefusalCode.NotFinite, `${where}[${i}] is ${v}`);
+    return v;
+  });
+}
+function localMatrix(node, where) {
+  const hasTrs = node.translation !== void 0 || node.rotation !== void 0 || node.scale !== void 0;
+  if (node.matrix !== void 0) {
+    if (hasTrs) throw new LevelRefusal(LevelRefusalCode.BadValue, `${where}.matrix sits beside a translation, rotation or scale: glTF allows one or the other`);
+    return numberList(node.matrix, 16, `${where}.matrix`);
+  }
+  if (!hasTrs) return IDENTITY_MATRIX;
+  const t = node.translation === void 0 ? [0, 0, 0] : numberList(node.translation, 3, `${where}.translation`);
+  const q = node.rotation === void 0 ? [0, 0, 0, 1] : numberList(node.rotation, 4, `${where}.rotation`);
+  const s = node.scale === void 0 ? [1, 1, 1] : numberList(node.scale, 3, `${where}.scale`);
+  const length = Math.hypot(q[0], q[1], q[2], q[3]);
+  if (Math.abs(length - 1) > QUATERNION_SLACK) throw new LevelRefusal(LevelRefusalCode.BadValue, `${where}.rotation is not a unit quaternion`);
+  return composeMatrix(t, q, s);
+}
+function animatedNodes(json) {
+  const out = /* @__PURE__ */ new Set();
+  if (!Array.isArray(json.animations)) return out;
+  for (const animation of json.animations) {
+    if (!isObject2(animation) || !Array.isArray(animation.channels)) continue;
+    for (const channel of animation.channels) {
+      if (!isObject2(channel) || !isObject2(channel.target)) continue;
+      const path = channel.target.path;
+      if (isIndex(channel.target.node) && (path === "translation" || path === "rotation" || path === "scale")) out.add(channel.target.node);
+    }
+  }
+  return out;
+}
+function asTriangles(mode, indices2) {
+  if (mode === PrimitiveMode.Triangles) return indices2;
+  const triangles = Math.max(0, indices2.length - 2);
+  const out = new Uint32Array(triangles * 3);
+  for (let i = 0; i < triangles; i++) {
+    if (mode === PrimitiveMode.TriangleFan) {
+      out[i * 3] = indices2[0];
+      out[i * 3 + 1] = indices2[i + 1];
+      out[i * 3 + 2] = indices2[i + 2];
+    } else if (i % 2 === 0) {
+      out[i * 3] = indices2[i];
+      out[i * 3 + 1] = indices2[i + 1];
+      out[i * 3 + 2] = indices2[i + 2];
+    } else {
+      out[i * 3] = indices2[i + 2];
+      out[i * 3 + 1] = indices2[i + 1];
+      out[i * 3 + 2] = indices2[i];
+    }
+  }
+  return out;
+}
+var Walker = class {
+  doc;
+  meshes = [];
+  spawns = [];
+  notes = [];
+  nodes;
+  visited;
+  animated;
+  primitives = /* @__PURE__ */ new Map();
+  skinned = [];
+  morphed = [];
+  triangles = 0;
+  constructor(doc) {
+    this.doc = doc;
+    this.nodes = Array.isArray(doc.json.nodes) ? doc.json.nodes : [];
+    if (this.nodes.length > LEVEL_LIMITS.maxNodes) throw new LevelRefusal(LevelRefusalCode.TooLarge, `the level holds ${this.nodes.length} nodes, past ${LEVEL_LIMITS.maxNodes}`);
+    this.visited = new Uint8Array(this.nodes.length);
+    this.animated = animatedNodes(doc.json);
+  }
+  walk(roots, rootWhere, rootMark) {
+    const stack = [];
+    for (let i = roots.length - 1; i >= 0; i--) stack.push({ index: roots[i], where: `${rootWhere}.nodes[${i}]`, parent: IDENTITY_MATRIX, mark: rootMark, path: "", depth: 0 });
+    for (let frame = stack.pop(); frame !== void 0; frame = stack.pop()) {
+      const { index, where } = frame;
+      const node = this.doc.entry("nodes", index, where);
+      const i = index;
+      const name = typeof node.name === "string" && node.name !== "" ? node.name : `node_${i}`;
+      if (this.visited[i] === 1) throw new LevelRefusal(LevelRefusalCode.NodeCycle, `${name} is reached twice: a cycle, or a node with two parents`);
+      this.visited[i] = 1;
+      if (frame.depth > LEVEL_LIMITS.maxDepth) throw new LevelRefusal(LevelRefusalCode.TooLarge, `${name} sits past a depth of ${LEVEL_LIMITS.maxDepth} nodes`);
+      const nodeWhere = `$.nodes[${i}]`;
+      const genex = isObject2(node.extras) ? node.extras.genex : void 0;
+      const own = levelMarkOf(name, genex, name);
+      const mark = inheritMark(frame.mark, this.animated.has(i) ? { ...own, movable: true } : own);
+      const world = multiplyMatrix(frame.parent, localMatrix(node, nodeWhere));
+      const path = frame.path === "" ? name : `${frame.path}/${name}`;
+      if (own.spawn === true) this.spawns.push({ name: spawnNameOf(name), at: [world[12], world[13], world[14]], tags: own.tags ?? [] });
+      else if (node.mesh !== void 0) this.addMesh(node, nodeWhere, name, path, mark, world);
+      const children = node.children;
+      if (children === void 0) continue;
+      if (!Array.isArray(children)) throw new LevelRefusal(LevelRefusalCode.BadReference, `${nodeWhere}.children is not a list`);
+      for (let c = children.length - 1; c >= 0; c--) stack.push({ index: children[c], where: `${nodeWhere}.children[${c}]`, parent: world, mark, path, depth: frame.depth + 1 });
+    }
+    this.refuseThoseThatMove();
+  }
+  refuseThoseThatMove() {
+    if (this.skinned.length > 0) throw new LevelRefusal(LevelRefusalCode.Skinned, `a room's world is static and these are skinned: ${namesInRefusal(this.skinned)}. Mark them nocol_ and collide with a static proxy, or movable_`);
+    if (this.morphed.length > 0) throw new LevelRefusal(LevelRefusalCode.Morphed, `a room's world is static and these are posed by morph targets: ${namesInRefusal(this.morphed)}. Mark them nocol_ and collide with a static proxy, or movable_`);
+  }
+  addMesh(node, nodeWhere, name, path, mark, world) {
+    const meshIndex = node.mesh;
+    const mesh = this.doc.entry("meshes", meshIndex, `${nodeWhere}.mesh`);
+    if (mark.collide === LevelCollide.None) return;
+    if (!Array.isArray(mesh.primitives)) throw new LevelRefusal(LevelRefusalCode.BadReference, `$.meshes[${String(meshIndex)}].primitives is not a list`);
+    if (mark.movable !== true) {
+      if (node.skin !== void 0) {
+        this.skinned.push(name);
+        return;
+      }
+      const weights = node.weights ?? mesh.weights;
+      const posed = Array.isArray(weights) && weights.some((w) => w !== 0);
+      const morphs = mesh.primitives.some((p) => isObject2(p) && Array.isArray(p.targets) && p.targets.length > 0);
+      if (posed && morphs) {
+        this.morphed.push(name);
+        return;
+      }
+    }
+    const instances = this.instancesOf(node, nodeWhere, world);
+    const primitives = [];
+    mesh.primitives.forEach((_raw, k) => {
+      const p = this.primitive(meshIndex, k, mesh.primitives, instances.count, name);
+      if (p !== null) primitives.push(p);
+    });
+    if (primitives.length === 0) {
+      this.notes.push(`${name}: holds no triangles (points or lines), so it is not in the scene`);
+      return;
+    }
+    this.meshes.push({ name, path, mark, instances: instances.matrices(), primitives });
+  }
+  instancesOf(node, nodeWhere, world) {
+    const spec = isObject2(node.extensions) ? node.extensions[Extension.Instancing] : void 0;
+    if (spec === void 0) return { count: 1, matrices: () => [world] };
+    const where = `${nodeWhere}.extensions.${Extension.Instancing}`;
+    if (!isObject2(spec) || !isObject2(spec.attributes)) throw new LevelRefusal(LevelRefusalCode.BadValue, `${where} holds no attributes`);
+    const { TRANSLATION: t, ROTATION: r, SCALE: s } = spec.attributes;
+    const named = [t, r, s].find((a) => a !== void 0);
+    if (named === void 0) throw new LevelRefusal(LevelRefusalCode.BadValue, `${where} holds no attributes`);
+    const count = this.doc.countOf(named, `${where}.attributes`);
+    return {
+      count,
+      matrices: () => {
+        const ts = t === void 0 ? null : this.doc.numbers(t, `${where}.attributes.TRANSLATION`, 3, false);
+        const rs = r === void 0 ? null : this.doc.numbers(r, `${where}.attributes.ROTATION`, 4, false);
+        const ss = s === void 0 ? null : this.doc.numbers(s, `${where}.attributes.SCALE`, 3, false);
+        for (const list of [[ts, 3], [rs, 4], [ss, 3]]) {
+          if (list[0] !== null && list[0].length !== count * list[1]) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `${where}: its attributes hold different counts`);
+        }
+        const out = [];
+        for (let i = 0; i < count; i++) {
+          const translation = ts === null ? [0, 0, 0] : [ts[i * 3], ts[i * 3 + 1], ts[i * 3 + 2]];
+          const rotation = rs === null ? [0, 0, 0, 1] : [rs[i * 4], rs[i * 4 + 1], rs[i * 4 + 2], rs[i * 4 + 3]];
+          const scale = ss === null ? [1, 1, 1] : [ss[i * 3], ss[i * 3 + 1], ss[i * 3 + 2]];
+          out.push(multiplyMatrix(world, composeMatrix(translation, rotation, scale)));
+        }
+        return out;
+      }
+    };
+  }
+  primitive(meshIndex, k, list, instanceCount, name) {
+    const raw = list[k];
+    const where = `$.meshes[${meshIndex}].primitives[${k}]`;
+    if (!isObject2(raw)) throw new LevelRefusal(LevelRefusalCode.BadReference, `${where} is not an object`);
+    if (isObject2(raw.extensions) && raw.extensions[Extension.Draco] !== void 0) throw new LevelRefusal(LevelRefusalCode.Compressed, `${name}: ${where} is compressed with ${Extension.Draco}: ${COMPRESSION_FIX}`);
+    const mode = raw.mode ?? PrimitiveMode.Triangles;
+    if (mode === PrimitiveMode.Points || mode === PrimitiveMode.Lines || mode === PrimitiveMode.LineLoop || mode === PrimitiveMode.LineStrip) return null;
+    if (mode !== PrimitiveMode.Triangles && mode !== PrimitiveMode.TriangleStrip && mode !== PrimitiveMode.TriangleFan) throw new LevelRefusal(LevelRefusalCode.BadValue, `${where}.mode is not a primitive mode`);
+    const attributes = raw.attributes;
+    if (!isObject2(attributes) || attributes.POSITION === void 0) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `${name}: ${where} has no POSITION`);
+    const positionsAt = `${where}.attributes.POSITION`;
+    const positionCount = this.doc.countOf(attributes.POSITION, positionsAt);
+    const indexCount = raw.indices === void 0 ? positionCount : this.doc.countOf(raw.indices, `${where}.indices`);
+    const triangleCount = mode === PrimitiveMode.Triangles ? indexCount / 3 : Math.max(0, indexCount - 2);
+    this.triangles += Math.ceil(triangleCount) * instanceCount;
+    if (this.triangles > LEVEL_LIMITS.maxTriangles) throw new LevelRefusal(LevelRefusalCode.TooLarge, `the level holds over ${LEVEL_LIMITS.maxTriangles} triangles (${name} is where it passes); give what no one walks on a nocol_ mark or a collision proxy`);
+    const key = `${meshIndex}/${k}`;
+    if (this.primitives.has(key)) return this.primitives.get(key) ?? null;
+    const positions = this.doc.positions(attributes.POSITION, positionsAt);
+    const stated = raw.indices === void 0 ? Uint32Array.from({ length: positionCount }, (_, i) => i) : this.doc.indices(raw.indices, `${where}.indices`);
+    if (mode === PrimitiveMode.Triangles && stated.length % 3 !== 0) throw new LevelRefusal(LevelRefusalCode.BadAccessor, `${name}: ${where} is not three indices per triangle`);
+    const primitive = { positions, indices: asTriangles(mode, stated) };
+    this.primitives.set(key, primitive);
+    return primitive;
+  }
+};
+function requireExtensions(json) {
+  const required = json.extensionsRequired;
+  if (required === void 0) return;
+  if (!Array.isArray(required)) throw new LevelRefusal(LevelRefusalCode.BadValue, "$.extensionsRequired is not a list");
+  for (const name of required) {
+    if (typeof name !== "string" || !READS_FINE.some((known) => name.startsWith(known))) throw new LevelRefusal(LevelRefusalCode.UnknownExtension, `the file requires ${String(name)}, which this reader cannot honour; re-export without it`);
+  }
+}
+function checkAsset(json) {
+  if (!isObject2(json.asset)) throw new LevelRefusal(LevelRefusalCode.BadVersion, "the file has no asset block, so it is no glTF 2");
+  const version = json.asset.version;
+  const major = typeof version === "string" ? Number.parseInt(version, 10) : Number.NaN;
+  if (major !== GLTF_MAJOR) throw new LevelRefusal(LevelRefusalCode.BadVersion, `asset.version is ${String(version)}; this reads glTF 2`);
+  const min = json.asset.minVersion;
+  if (typeof min === "string" && Number.parseInt(min, 10) > GLTF_MAJOR) throw new LevelRefusal(LevelRefusalCode.BadVersion, `asset.minVersion is ${min}; this reads glTF 2`);
+}
+function unpackGlb(bytes, label) {
+  if (bytes.length < GLB_HEADER_BYTES) throw new LevelRefusal(LevelRefusalCode.BadContainer, `${label}: a glb header is ${GLB_HEADER_BYTES} bytes`);
+  const version = bytes.readUInt32LE(4);
+  if (version !== GLTF_MAJOR) throw new LevelRefusal(LevelRefusalCode.BadVersion, `${label} is glb version ${version}; this reads version ${GLTF_MAJOR}`);
+  const length = bytes.readUInt32LE(8);
+  if (length > bytes.length || length < GLB_HEADER_BYTES + CHUNK_HEADER_BYTES) throw new LevelRefusal(LevelRefusalCode.BadContainer, `${label}: the header says a length of ${length} and the file has ${bytes.length}`);
+  const chunk = (at) => {
+    const size = bytes.readUInt32LE(at);
+    const type = bytes.readUInt32LE(at + 4);
+    const start = at + CHUNK_HEADER_BYTES;
+    if (start + size > length) throw new LevelRefusal(LevelRefusalCode.BadContainer, `${label}: a chunk of ${size} bytes runs past the file`);
+    return { type, body: bytes.subarray(start, start + size), next: start + size };
+  };
+  const first = chunk(GLB_HEADER_BYTES);
+  if (first.type !== CHUNK_JSON) throw new LevelRefusal(LevelRefusalCode.BadContainer, `${label}: the first chunk is not JSON`);
+  let bin = null;
+  if (first.next + CHUNK_HEADER_BYTES <= length) {
+    const second = chunk(first.next);
+    if (second.type === CHUNK_BIN) bin = second.body;
+  }
+  return { json: parseJson(first.body, label), bin };
+}
+function parseJson(bytes, label) {
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes));
+  } catch {
+    throw new LevelRefusal(LevelRefusalCode.NotGltf, `${label}: its JSON does not parse`);
+  }
+}
+function readInput(path) {
+  const label = basename(path);
+  const refuse = (why) => new LevelRefusal(LevelRefusalCode.NotGltf, `${label} ${why}`);
+  let real;
+  try {
+    real = realpathSync(path);
+  } catch {
+    throw refuse("is not there");
+  }
+  return { real, bytes: readPlainFile(real, refuse, () => new LevelRefusal(LevelRefusalCode.TooLarge, `${label} is past ${LEVEL_LIMITS.maxFileBytes} bytes`)) };
+}
+function readGltfLevel(path, options = {}) {
+  const label = basename(path);
+  const { bytes, real } = readInput(path);
+  let raw;
+  let bin = null;
+  if (bytes.length >= 4 && bytes.readUInt32LE(0) === GLB_MAGIC) ({ json: raw, bin } = unpackGlb(bytes, label));
+  else if (bytes.length > 0 && bytes.subarray(0, 16).toString("latin1").trimStart().startsWith("{")) raw = parseJson(bytes, label);
+  else throw new LevelRefusal(LevelRefusalCode.NotGltf, `${label} is neither a glb nor a glTF`);
+  if (!isObject2(raw)) throw new LevelRefusal(LevelRefusalCode.NotGltf, `${label}: its JSON is not a glTF object`);
+  checkAsset(raw);
+  requireExtensions(raw);
+  const doc = new Document(raw, bin, dirname(real));
+  if (!Array.isArray(raw.scenes) || raw.scenes.length === 0) throw new LevelRefusal(LevelRefusalCode.BadReference, `$.scene: ${label} holds no scene`);
+  const sceneIndex = raw.scene ?? 0;
+  const scene = doc.entry("scenes", sceneIndex, "$.scene");
+  const sceneWhere = `$.scenes[${String(sceneIndex)}]`;
+  if (scene.nodes !== void 0 && !Array.isArray(scene.nodes)) throw new LevelRefusal(LevelRefusalCode.BadReference, `${sceneWhere}.nodes is not a list`);
+  const sceneGenex = isObject2(scene.extras) ? scene.extras.genex : void 0;
+  const settings = levelSettingsOf(sceneGenex, `${sceneWhere}`);
+  const unitsPerMeter = options.unitsPerMeter ?? settings.unitsPerMeter ?? DEFAULT_UNITS_PER_METER;
+  const hull = options.hull ?? settings.hull;
+  const walker = new Walker(doc);
+  walker.walk(scene.nodes ?? [], sceneWhere, {});
+  const level = buildLevelScene(
+    { meshes: walker.meshes, spawns: walker.spawns, notes: walker.notes },
+    { scale: unitsPerMeter, unitsPerMeter, ...hull === void 0 ? {} : { hull }, ...options.spawns === void 0 ? {} : { spawns: options.spawns }, source: { engine: "gltf", level: label.slice(0, 200), tool: "genex world gltf" } }
+  );
+  parseWorldScene(level.scene);
+  return { ...level, sha256: createHash("sha256").update(level.json).digest("hex") };
+}
+
+// src/world-fit/gltf-command.ts
+import { lstatSync as lstatSync2, mkdtempSync, realpathSync as realpathSync2, renameSync, rmSync, writeFileSync } from "fs";
+import { basename as basename2, dirname as dirname2, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+var WorldGltfExit = { Ok: 0, Usage: 1, Refused: 3 };
+var USAGE = "usage: genex world gltf <level.glb|level.gltf> <scene.json>";
+function writeWhole(path, text2) {
+  const dir = dirname2(path);
+  const scratch = mkdtempSync(join2(dir, ".world-gltf-"));
+  try {
+    const temp = join2(scratch, basename2(path));
+    writeFileSync(temp, text2);
+    renameSync(temp, path);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+function sameFile(a, b) {
+  try {
+    return realpathSync2(a) === realpathSync2(b);
+  } catch {
+    return false;
+  }
+}
+function runWorldGltf(args, io = { print: console.log, error: console.error }) {
+  const [input, output] = args;
+  if (args.length !== 2 || input === void 0 || output === void 0 || args.some((a) => a.startsWith("-"))) {
+    io.error(USAGE);
+    return WorldGltfExit.Usage;
+  }
+  const target = resolve(output);
+  try {
+    if (sameFile(input, target)) throw new LevelRefusal(LevelRefusalCode.NotGltf, "the input and the output are one file; name another output");
+    const isLink = lstatIsLink(target);
+    if (isLink) throw new LevelRefusal(LevelRefusalCode.UriRefused, `${output} is a link; name the file itself`);
+    const level = readGltfLevel(input);
+    writeWhole(target, level.json);
+    io.print(`SCENE ${JSON.stringify({ path: output, sha256: level.sha256, ...level.stats, notes: level.notes })}`);
+    return WorldGltfExit.Ok;
+  } catch (error) {
+    if (!(error instanceof LevelRefusal)) throw error;
+    io.print(`REFUSED ${JSON.stringify({ code: error.code, message: error.message })}`);
+    io.error(error.message);
+    return WorldGltfExit.Refused;
+  }
+}
+function lstatIsLink(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+if (process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1]) {
+  process.exitCode = runWorldGltf(process.argv.slice(2));
+}
+export {
+  BOUND_ACTOR,
+  DEFAULT_UNITS_PER_METER,
+  FLOOR_MAX_RADII,
+  FLOOR_P99_RADII,
+  FitStatus,
+  HOSTILE_PAST_RADII,
+  LEVEL_LIMITS,
+  LevelCollide,
+  LevelRefusal,
+  LevelRefusalCode,
+  LevelShape,
+  SceneChannel,
+  SceneSurfaceKind,
+  SceneTag,
+  ShotFitStatus,
+  WORLD_SCENE_FORMAT,
+  WORLD_SCENE_VERSION,
+  WorldGltfExit,
+  WorldLimits,
+  WorldSceneError,
+  claimArithmetic,
+  claimedStop,
+  fitRungs,
+  fitScene,
+  fitShotWorld,
+  fitWorldHash,
+  levelMarkOf,
+  parseWorldScene,
+  readGltfLevel,
+  runWorldGltf,
+  sceneHull,
+  sceneReach,
+  sceneShotRays,
+  shotRay,
+  surfaceAnswers
+};