cajonzero 0.1.3 → 0.2.0

package/dist/bin/cj0.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { spawnSync } from 'child_process';
-import { writeFileSync, mkdirSync, existsSync, rmSync, readdirSync, readFileSync, statSync, renameSync, cpSync } from 'fs';
+import { existsSync, mkdirSync, renameSync, rmSync, cpSync, writeFileSync, readFileSync, mkdtempSync, statSync, readdirSync } from 'fs';
 import { createRequire } from 'module';
+import { tmpdir } from 'os';
 import path4 from 'path';
 import { createInterface } from 'readline/promises';
-import { gzipSync } from 'zlib';
+import { gunzipSync, gzipSync } from 'zlib';
 import { vec3, vec4, vec2, mat3 } from 'gl-matrix';
 import { fileURLToPath } from 'url';
-import { randomBytes, createHash } from 'crypto';
+import { createHash, randomBytes } from 'crypto';
 
 // src/core/maps/catalog.ts
 var MAP_CATALOG_VERSION = 1;
@@ -65,30 +66,28 @@ function normalizeRootUrl(raw) {
   }
   return url.toString();
 }
-function assertRelativeMapPath(relPath) {
-  if (relPath.length === 0 || relPath.includes("\0") || relPath.includes("\\")) {
-    fail("INVALID_PATH", `invalid map path "${relPath}"`);
+function normalizeRelativeMapRoot(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("/")) {
+    fail("INVALID_ROOT", `map root must start with "/": ${raw}`);
+  }
+  if (trimmed.includes("\\") || trimmed.includes("\0") || trimmed.includes("?") || trimmed.includes("#")) {
+    fail("INVALID_ROOT", `map root contains an unsupported character: ${raw}`);
   }
-  if (relPath.startsWith("/")) fail("INVALID_PATH", `absolute map path "${relPath}"`);
   const parts = [];
-  for (const part of relPath.split("/")) {
+  for (const part of trimmed.split("/")) {
     if (part === "" || part === ".") continue;
-    if (part === "..") fail("INVALID_PATH", `map path escapes the root: "${relPath}"`);
+    if (part === "..") fail("INVALID_ROOT", `map root escapes the site root: ${raw}`);
     parts.push(part);
   }
-  if (parts.length === 0) fail("INVALID_PATH", "empty map path");
-  return parts.join("/");
+  if (parts.length === 0) fail("INVALID_ROOT", "map root must not be the site root");
+  return `/${parts.join("/")}/`;
 }
-function mapFilePath(root, relPath) {
-  const base = new URL(normalizeRootUrl(root));
-  const relative = assertRelativeMapPath(relPath);
-  const url = new URL(relative, base);
-  if (url.origin !== base.origin || !url.pathname.startsWith(base.pathname)) {
-    fail("INVALID_PATH", `map path escapes the root: "${relPath}"`);
+function normalizeMapRoot(raw) {
+  if (typeof raw !== "string" || raw.trim().length === 0) {
+    fail("INVALID_ROOT", "map root must be a non-empty URL or path");
   }
-  if (base.search.length > 0) url.search = base.search;
-  url.hash = "";
-  return url.toString();
+  return raw.trim().startsWith("/") ? normalizeRelativeMapRoot(raw) : normalizeRootUrl(raw);
 }
 function optionalString(value, label, code = "INVALID_MAP") {
   if (value === void 0) return void 0;
@@ -107,7 +106,7 @@ function parseEntry(value, index) {
   assertMapSlug(slug);
   const rootRaw = optionalString(record.root, `maps[${index}].root`, "INVALID_ROOT");
   if (rootRaw === void 0) fail("INVALID_ROOT", `maps[${slug}].root is required`);
-  const root = normalizeRootUrl(rootRaw);
+  const root = normalizeMapRoot(rootRaw);
   const worldId = optionalString(record.worldId, `maps[${index}].worldId`);
   const assetRoot = optionalString(record.assetRoot, `maps[${index}].assetRoot`, "INVALID_ROOT");
   const name = optionalString(record.name, `maps[${index}].name`);
@@ -115,6 +114,7 @@ function parseEntry(value, index) {
   const version = optionalString(record.version, `maps[${index}].version`);
   const etag = optionalString(record.etag, `maps[${index}].etag`);
   const cover = optionalString(record.cover, `maps[${index}].cover`);
+  const scriptsFile = optionalString(record.scriptsFile, `maps[${index}].scriptsFile`);
   return {
     slug,
     root,
@@ -124,7 +124,8 @@ function parseEntry(value, index) {
     ...version !== void 0 ? { version } : {},
     ...etag !== void 0 ? { etag } : {},
     ...cover !== void 0 ? { cover } : {},
-    ...assetRoot !== void 0 ? { assetRoot: normalizeRootUrl(assetRoot) } : {}
+    ...assetRoot !== void 0 ? { assetRoot: normalizeMapRoot(assetRoot) } : {},
+    ...scriptsFile !== void 0 ? { scriptsFile } : {}
   };
 }
 function parseMapCatalog(input) {
@@ -151,6 +152,167 @@ function parseMapCatalog(input) {
 function findMap(catalog, slug) {
   return catalog.maps.find((entry) => entry.slug === slug);
 }
+var BOXPLAY_FORMAT_VERSION = 1;
+var BOXPLAY_BUNDLE_TYPE = "map-group-play-bundle";
+var DEFAULT_BOXPLAY_LIMITS = {
+  maxExpandedBytes: 2 * 1024 * 1024 * 1024,
+  maxEntries: 2e5
+};
+var BoxplayError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "BoxplayError";
+    this.code = code;
+  }
+};
+var decoder = new TextDecoder();
+function fail2(code, message) {
+  throw new BoxplayError(code, message);
+}
+function cString(block, offset, length) {
+  let end = offset;
+  const limit = Math.min(offset + length, block.length);
+  while (end < limit && block[end] !== 0) end += 1;
+  return decoder.decode(block.subarray(offset, end));
+}
+function octal(block, offset, length) {
+  const value = parseInt(cString(block, offset, length).replace(/[\0 ]/g, ""), 8);
+  return Number.isNaN(value) ? 0 : value;
+}
+function isZero(block) {
+  for (const byte of block) if (byte !== 0) return false;
+  return true;
+}
+function normalizeArchivePath(raw) {
+  if (raw.includes("\0") || raw.includes("\\")) fail2("UNSAFE_PATH", `invalid path: ${raw}`);
+  if (raw.startsWith("/") || /^[a-zA-Z]:/.test(raw)) fail2("UNSAFE_PATH", `absolute path: ${raw}`);
+  const parts = [];
+  for (const part of raw.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") fail2("UNSAFE_PATH", `path escapes the archive: ${raw}`);
+    parts.push(part);
+  }
+  if (parts.length === 0) fail2("UNSAFE_PATH", "empty archive path");
+  return parts.join("/");
+}
+function* parseTar(tar, limits = DEFAULT_BOXPLAY_LIMITS) {
+  let offset = 0;
+  let count = 0;
+  let longName = null;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (isZero(header)) break;
+    const name = cString(header, 0, 100);
+    const size = octal(header, 124, 12);
+    const typeflag = String.fromCharCode(header[156] ?? 0);
+    const prefix = cString(header, 345, 155);
+    const dataStart = offset + 512;
+    const dataEnd = dataStart + size;
+    if (dataEnd > tar.length) fail2("CORRUPT", `entry overruns archive: ${name}`);
+    count += 1;
+    if (count > limits.maxEntries) {
+      fail2("TOO_MANY_FILES", `archive exceeds ${limits.maxEntries} entries`);
+    }
+    const data = tar.subarray(dataStart, dataEnd);
+    offset = dataStart + Math.ceil(size / 512) * 512;
+    if (typeflag === "L") {
+      longName = decoder.decode(data).replace(/\0+$/, "");
+      continue;
+    }
+    const resolved = longName ?? (prefix ? `${prefix}/${name}` : name);
+    longName = null;
+    if (typeflag === "5") {
+      yield { path: normalizeArchivePath(resolved), kind: "dir" };
+    } else if (typeflag === "0" || typeflag === "\0") {
+      yield { path: normalizeArchivePath(resolved), kind: "file", data };
+    } else {
+      fail2("UNSUPPORTED_ENTRY", `unsupported tar entry ${typeflag}: ${resolved}`);
+    }
+  }
+}
+function parseBoxplayBytes(input, limits = DEFAULT_BOXPLAY_LIMITS) {
+  if (input.length < 2 || input[0] !== 31 || input[1] !== 139) {
+    fail2("NOT_GZIP", "not a gzip stream");
+  }
+  let tar;
+  try {
+    tar = gunzipSync(input);
+  } catch (error) {
+    fail2("CORRUPT", `gzip failed: ${error.message}`);
+  }
+  if (tar.length > limits.maxExpandedBytes) {
+    fail2("TOO_LARGE", `archive expands to ${tar.length} bytes`);
+  }
+  const files = [];
+  const manifests = /* @__PURE__ */ new Map();
+  const dataFiles = /* @__PURE__ */ new Map();
+  let bundleBytes = null;
+  for (const entry of parseTar(tar, limits)) {
+    if (entry.kind === "dir") continue;
+    files.push({ path: entry.path, data: entry.data, size: entry.data.length });
+    if (entry.path === "bundle.json") {
+      bundleBytes = entry.data;
+      continue;
+    }
+    const manifest = /^worlds\/([^/]+)\/manifest\.json$/.exec(entry.path);
+    if (manifest) {
+      const worldId = manifest[1];
+      const parsed = JSON.parse(decoder.decode(entry.data));
+      if (typeof parsed !== "object" || parsed === null) {
+        fail2("MISSING_WORLD", `worlds/${worldId}/manifest.json is not an object`);
+      }
+      manifests.set(worldId, parsed);
+      continue;
+    }
+    const data = /^worlds\/([^/]+)\/data\/(.+)$/.exec(entry.path);
+    if (data) {
+      const worldId = data[1];
+      const list = dataFiles.get(worldId) ?? [];
+      list.push(entry.path);
+      dataFiles.set(worldId, list);
+    }
+  }
+  if (bundleBytes === null) fail2("MISSING_BUNDLE", "archive has no bundle.json");
+  let bundle;
+  try {
+    const raw = JSON.parse(decoder.decode(bundleBytes));
+    if (typeof raw !== "object" || raw === null) throw new Error("not an object");
+    const value = raw;
+    if (value.formatVersion !== BOXPLAY_FORMAT_VERSION) throw new Error("bad formatVersion");
+    if (value.type !== BOXPLAY_BUNDLE_TYPE) throw new Error("bad type");
+    bundle = {
+      ...value,
+      formatVersion: BOXPLAY_FORMAT_VERSION,
+      type: BOXPLAY_BUNDLE_TYPE,
+      mapGroupId: String(value.mapGroupId),
+      version: String(value.version),
+      members: Array.isArray(value.members) ? value.members : []
+    };
+  } catch (error) {
+    fail2("INVALID_BUNDLE", `invalid bundle.json: ${error.message}`);
+  }
+  if (manifests.size === 0) fail2("MISSING_WORLD", "archive has no world manifest");
+  return {
+    bundle,
+    worlds: [...manifests].map(([worldId, manifest]) => ({
+      worldId,
+      manifest,
+      dataFiles: (dataFiles.get(worldId) ?? []).sort()
+    })),
+    files,
+    expandedBytes: tar.length
+  };
+}
+function readBoxplayFile(file, limits = DEFAULT_BOXPLAY_LIMITS) {
+  let bytes;
+  try {
+    bytes = readFileSync(file);
+  } catch (error) {
+    fail2("CORRUPT", `cannot read ${file}: ${error.message}`);
+  }
+  return parseBoxplayBytes(bytes, limits);
+}
 
 // src/vendor/mudb/schema/void.ts
 var MuVoid = class {
@@ -2339,631 +2501,975 @@ var MuDate = class {
   }
 };
 
-// src/vendor/mudb/box-utils/id.ts
-function compareId(a, b) {
-  return a.id - b.id;
-}
-function interpolate(objects, l, h, id) {
-  const a = objects[l].id;
-  const b = objects[h].id;
-  const t = (id - a) / (b - a);
-  return Math.max(l, Math.min(h, Math.round((1 - t) * l + t * h) | 0));
-}
-function indexEqRange(objects, id, _l, _h) {
-  let l = _l;
-  let h = _h;
-  while (l < h) {
-    const m = interpolate(objects, l, h, id);
-    const x = objects[m].id;
-    if (x === id) {
-      return m;
-    } else if (x < id) {
-      l = m + 1;
-    } else {
-      h = m - 1;
-    }
+// src/vendor/mudb/box-schema/content-server/index.ts
+var HashSchema = new MuASCII();
+
+// src/vendor/mudb/box-schema/utils/ref-schema.ts
+var _noSerialize = () => {
+  throw new Error("cannot serialize references");
+};
+var MuRefSchema = class {
+  identity = null;
+  muType = "ref";
+  muData = { type: "ref" };
+  json = { type: "ref" };
+  constructor() {
   }
-  if (l === h && objects[l].id === id) {
-    return l;
+  diff = _noSerialize;
+  patch = _noSerialize;
+  toJSON = _noSerialize;
+  fromJSON = _noSerialize;
+  alloc() {
+    return null;
   }
-  return -1;
-}
-new MuFloat32();
-var Vec2Schema = new MuVector(new MuFloat32(), 2);
-var vec3Pool = [];
-var Vec3Schema = {
-  muType: "vector",
-  identity: vec3.create(),
-  json: {
-    type: "vector",
-    data: [0, 0, 0]
-  },
-  alloc: () => {
-    return vec3Pool.pop() || vec3.create();
-  },
-  free: (v) => {
-    vec3Pool.push(v);
-  },
-  assign: (dst, src) => {
-    dst[0] = src[0];
-    dst[1] = src[1];
-    dst[2] = src[2];
-    return dst;
-  },
-  equal: (dst, src) => {
-    return dst[0] === src[0] && dst[1] === src[1] && dst[2] === src[2];
-  },
-  diff: (base, target, out) => {
-    const s0 = (base[0] !== target[0]) << 0;
-    const s1 = (base[1] !== target[1]) << 1;
-    const s2 = (base[2] !== target[2]) << 2;
-    const flags = s0 + s1 + s2;
-    if (flags === 0) {
-      return false;
-    }
-    out.grow(13);
-    out.writeUint8(flags);
-    if (s0) {
-      out.writeFloat32(target[0]);
-    }
-    if (s1) {
-      out.writeFloat32(target[1]);
-    }
-    if (s2) {
-      out.writeFloat32(target[2]);
+  free() {
+  }
+  assign(dst, src) {
+    return src;
+  }
+  clone(x) {
+    return x;
+  }
+  equal(a, b) {
+    return a === b;
+  }
+};
+
+// src/vendor/mudb/box-schema/utils/relative-array.ts
+var RelativeArray = class {
+  identity;
+  muType = "relative array";
+  muData;
+  json;
+  arraySchema;
+  alloc;
+  free;
+  clone;
+  equal;
+  assign;
+  toJSON;
+  fromJSON;
+  constructor(schema, capacity, identity2) {
+    const arraySchema = this.arraySchema = new MuArray(
+      schema,
+      capacity,
+      identity2
+    );
+    this.json = {
+      type: "relative array",
+      value: schema.json
+    };
+    this.muData = schema;
+    this.identity = arraySchema.identity;
+    this.alloc = arraySchema.alloc;
+    this.free = arraySchema.free;
+    this.clone = arraySchema.clone;
+    this.equal = arraySchema.equal;
+    this.assign = arraySchema.assign;
+    this.toJSON = arraySchema.toJSON;
+    this.fromJSON = arraySchema.fromJSON;
+  }
+  diff(base, target, stream) {
+    const prefixOffset = stream.offset;
+    const targetLength = target.length;
+    const numTrackers = Math.ceil(targetLength / 8);
+    stream.grow(4 + numTrackers);
+    stream.writeUint32(targetLength);
+    let trackerOffset = stream.offset;
+    stream.offset = trackerOffset + numTrackers;
+    let tracker = 0;
+    let numPatch = 0;
+    const baseLength = base.length;
+    const valueSchema = this.muData;
+    let prev = base.length > 0 ? base[0] : valueSchema.identity;
+    for (let i = 0; i < target.length; ++i) {
+      if (valueSchema.diff(prev, target[i], stream)) {
+        tracker |= 1 << (i & 7);
+        ++numPatch;
+      }
+      if ((i & 7) === 7) {
+        stream.writeUint8At(trackerOffset++, tracker);
+        tracker = 0;
+      }
+      prev = target[i];
     }
-    return true;
-  },
-  patch: (base, inp) => {
-    const v = vec3Pool.pop() || vec3.create();
-    const flags = inp.readUint8();
-    v[0] = flags & 1 ? inp.readFloat32() : base[0];
-    v[1] = flags & 2 ? inp.readFloat32() : base[1];
-    v[2] = flags & 4 ? inp.readFloat32() : base[2];
-    return v;
-  },
-  clone: (v) => {
-    const x = vec3Pool.pop();
-    if (x) {
-      x[0] = v[0];
-      x[1] = v[1];
-      x[2] = v[2];
-      return x;
+    if (targetLength & 7) {
+      stream.writeUint8At(trackerOffset, tracker);
     }
-    return vec3.clone(v);
-  },
-  toJSON: (v) => [v[0], v[1], v[2]],
-  fromJSON: (json) => {
-    let v = vec3Pool.pop();
-    if (Array.isArray(json)) {
-      v = v || vec3.create();
-      v[0] = +json[0] || 0;
-      v[1] = +json[1] || 0;
-      v[2] = +json[2] || 0;
-      return v;
-    } else if (v) {
-      v[0] = v[1] = v[2] = 0;
-      return v;
-    } else {
-      return vec3.create();
+    if (numPatch > 0 || baseLength !== targetLength) {
+      return true;
     }
+    stream.offset = prefixOffset;
+    return false;
   }
-};
-var vec4Pool = [];
-var Vec4Schema = {
-  muType: "vector",
-  identity: vec4.create(),
-  json: {
-    type: "vector",
-    data: [0, 0, 0, 0]
-  },
-  alloc: () => {
-    return vec4Pool.pop() || vec4.create();
-  },
-  free: (v) => {
-    vec4Pool.push(v);
-  },
-  assign: (dst, src) => {
-    dst[0] = src[0];
-    dst[1] = src[1];
-    dst[2] = src[2];
-    dst[3] = src[3];
-    return dst;
-  },
-  equal: (dst, src) => {
-    return dst[0] === src[0] && dst[1] === src[1] && dst[2] === src[2] && dst[3] === src[3];
-  },
-  diff: (base, target, out) => {
-    const s0 = (base[0] !== target[0]) << 0;
-    const s1 = (base[1] !== target[1]) << 1;
-    const s2 = (base[2] !== target[2]) << 2;
-    const s3 = (base[3] !== target[3]) << 3;
-    const flags = s0 + s1 + s2 + s3;
-    if (flags === 0) {
-      return false;
-    }
-    out.grow(17);
-    out.writeUint8(flags);
-    if (s0) {
-      out.writeFloat32(target[0]);
-    }
-    if (s1) {
-      out.writeFloat32(target[1]);
-    }
-    if (s2) {
-      out.writeFloat32(target[2]);
-    }
-    if (s3) {
-      out.writeFloat32(target[3]);
-    }
-    return true;
-  },
-  patch: (base, inp) => {
-    const v = vec4Pool.pop() || vec4.create();
-    const flags = inp.readUint8();
-    v[0] = flags & 1 ? inp.readFloat32() : base[0];
-    v[1] = flags & 2 ? inp.readFloat32() : base[1];
-    v[2] = flags & 4 ? inp.readFloat32() : base[2];
-    v[3] = flags & 8 ? inp.readFloat32() : base[3];
-    return v;
-  },
-  clone: (v) => {
-    const x = vec4Pool.pop();
-    if (x) {
-      x[0] = v[0];
-      x[1] = v[1];
-      x[2] = v[2];
-      x[3] = v[3];
-      return x;
-    }
-    return vec4.clone(v);
-  },
-  toJSON: (v) => [v[0], v[1], v[2], v[3]],
-  fromJSON: (json) => {
-    let v = vec4Pool.pop();
-    if (Array.isArray(json)) {
-      v = v || vec4.create();
-      v[0] = +json[0] || 0;
-      v[1] = +json[1] || 0;
-      v[2] = +json[2] || 0;
-      v[3] = +json[3] || 0;
-      return v;
-    } else if (v) {
-      v[0] = v[1] = v[2] = v[3] = 0;
-      return v;
-    } else {
-      return vec4.create();
+  patch(base, stream) {
+    const result = this.clone(base);
+    const targetLength = stream.readUint32();
+    result.length = targetLength;
+    let trackerOffset = stream.offset;
+    const numTrackers = Math.ceil(targetLength / 8);
+    stream.offset = trackerOffset + numTrackers;
+    let tracker = 0;
+    const valueSchema = this.muData;
+    let prev = base.length > 0 ? base[0] : valueSchema.identity;
+    for (let i = 0; i < targetLength; ++i) {
+      const mod8 = i & 7;
+      if (!mod8) {
+        tracker = stream.readUint8At(trackerOffset++);
+      }
+      if (1 << mod8 & tracker) {
+        prev = result[i] = valueSchema.patch(prev, stream);
+      } else {
+        result[i] = valueSchema.clone(prev);
+      }
     }
+    return result;
   }
 };
-var QuatSchema = Vec4Schema;
-new MuVector(new MuFloat32(), 9);
-var Mat4Schema = new MuVector(new MuFloat32(), 16);
+
+// src/vendor/mudb/box-schema/voxel/block-schema.ts
+var BlockInfoSchema = new MuStruct({
+  // voxel info
+  ids: new RelativeArray(new MuRelativeVarint(), Infinity, [0]),
+  names: new MuArray(new MuUTF8(), Infinity, ["air"]),
+  // run length encode these arrays
+  emissive: new RelativeArray(new MuVarint(), Infinity, [0]),
+  texture: new RelativeArray(
+    new MuRelativeVarint(),
+    Infinity,
+    [0, 0, 0, 0, 0, 0]
+  ),
+  animLength: new RelativeArray(new MuVarint(1), Infinity, [1, 1, 1, 1, 1, 1]),
+  friction: new RelativeArray(new MuQuantizedFloat(1 / 256, 1), Infinity, [0]),
+  restitution: new RelativeArray(new MuQuantizedFloat(1 / 256, 0), Infinity, [
+    0
+  ]),
+  velocity: new RelativeArray(new MuFloat32(0), Infinity, [0, 0, 0]),
+  // fluids
+  fluids: new MuArray(
+    new MuStruct({
+      id: new MuVarint(),
+      info: new MuUint32(),
+      mass: new MuFloat64(1)
+    }),
+    Infinity,
+    [
+      {
+        id: 0,
+        info: 0,
+        mass: 0
+      }
+    ]
+  ),
+  // category list
+  category: new MuDictionary(
+    new RelativeArray(new MuRelativeVarint(), Infinity),
+    Infinity,
+    {
+      default: [0]
+    }
+  ),
+  // texture info
+  atlasRadius: new MuVarint(16),
+  blockBumpShift: new MuVarint(6),
+  blockColorShift: new MuVarint(4),
+  // texture atlases
+  colorAtlas: new MuArray(HashSchema, Infinity),
+  materialAtlas: new MuArray(HashSchema, Infinity),
+  bumpAtlas: new MuArray(HashSchema, Infinity)
+});
 new MuStruct({
-  lo: Vec3Schema,
-  hi: Vec3Schema
+  id: new MuDictionary(new MuVarint(), Infinity, { air: 0 }),
+  valid: new MuArray(new MuBoolean(false), Infinity),
+  name: new MuArray(new MuUTF8(), Infinity, ["air"]),
+  emissive: new MuArray(new MuUint16(), Infinity, [0]),
+  texture: new MuArray(new MuUint32(), Infinity, [0, 0, 0, 0, 0, 0]),
+  mass: new MuArray(new MuFloat64(), Infinity, [0]),
+  restitution: new MuArray(new MuFloat64(), Infinity, [0]),
+  friction: new MuArray(new MuFloat64(), Infinity, [0]),
+  fluid: new MuArray(new MuVarint(), Infinity, [1]),
+  fluidInfo: new MuArray(new MuUint32(), Infinity, [0, 0]),
+  velocity: new MuArray(new MuFloat32(0), Infinity, [0, 0, 0]),
+  isFluid: new MuRefSchema()
 });
-
-// src/vendor/mudb/rda/constant.ts
-var MuRDAConstantStore = class {
-  value;
-  constructor(initial) {
-    this.value = initial;
-  }
-  state(rda, out) {
-    return rda.stateSchema.assign(out, this.value);
+var decodeUTF8;
+{
+  new TextEncoder();
+  const decoder2 = new TextDecoder();
+  decodeUTF8 = (bytes) => decoder2.decode(bytes);
+}
+var MuBuffer = class {
+  buffer;
+  dataView;
+  uint8;
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.dataView = new DataView(buffer);
+    this.uint8 = new Uint8Array(buffer);
   }
-  apply() {
-    return false;
+};
+var bufferPool = new Array(31);
+for (let i = 0; i < 31; ++i) {
+  bufferPool[i] = [];
+}
+var LITTLE_ENDIAN = true;
+var MuReadStream = class {
+  buffer;
+  offset;
+  length;
+  constructor(data) {
+    this.buffer = new MuBuffer(data.buffer);
+    this.offset = data.byteOffset;
+    this.length = data.byteLength + data.byteOffset;
   }
-  inverse() {
+  bytes() {
+    return this.buffer.uint8.subarray(this.offset, this.length);
   }
-  serialize(rda, out) {
-    return rda.storeSchema.assign(out, this.value);
+  checkBounds() {
+    if (this.offset > this.length) {
+      throw new Error("out of bounds");
+    }
   }
-  free(rda) {
-    rda.stateSchema.free(this.value);
+  readInt8() {
+    const offset = this.offset;
+    this.offset += 1;
+    this.checkBounds();
+    return this.buffer.dataView.getInt8(offset);
   }
-};
-var MuRDAConstant = class {
-  stateSchema;
-  actionSchema = new MuVoid();
-  storeSchema;
-  actionMeta = {
-    type: "table",
-    table: {}
-  };
-  action = {};
-  emptyStore;
-  constructor(stateSchema) {
-    this.stateSchema = stateSchema;
-    this.storeSchema = stateSchema;
-    this.emptyStore = new MuRDAConstantStore(stateSchema.identity);
+  readInt16() {
+    const offset = this.offset;
+    this.offset += 2;
+    this.checkBounds();
+    return this.buffer.dataView.getInt16(offset, LITTLE_ENDIAN);
   }
-  createStore(initialState) {
-    return new MuRDAConstantStore(this.stateSchema.clone(initialState));
+  readInt32() {
+    const offset = this.offset;
+    this.offset += 4;
+    this.checkBounds();
+    return this.buffer.dataView.getInt32(offset, LITTLE_ENDIAN);
   }
-  parse(store) {
-    return new MuRDAConstantStore(this.stateSchema.clone(store));
+  readUint8() {
+    const offset = this.offset;
+    this.offset += 1;
+    this.checkBounds();
+    return this.buffer.dataView.getUint8(offset);
   }
-};
-
-// src/vendor/mudb/rda/register.ts
-function identity(x) {
-  return x;
-}
-var MuRDARegisterStore = class {
-  value;
-  constructor(initial) {
-    this.value = initial;
-  }
-  state(rda, out) {
-    return rda.stateSchema.assign(out, this.value);
+  readUint16() {
+    const offset = this.offset;
+    this.offset += 2;
+    this.checkBounds();
+    return this.buffer.dataView.getUint16(offset, LITTLE_ENDIAN);
   }
-  inverse(rda) {
-    return rda.actionSchema.clone(this.value);
+  readUint32() {
+    const offset = this.offset;
+    this.offset += 4;
+    this.checkBounds();
+    return this.buffer.dataView.getUint32(offset, LITTLE_ENDIAN);
   }
-  free(rda) {
-    rda.stateSchema.free(this.value);
+  readFloat32() {
+    const offset = this.offset;
+    this.offset += 4;
+    this.checkBounds();
+    return this.buffer.dataView.getFloat32(offset, LITTLE_ENDIAN);
   }
-  apply(rda, action) {
-    this.value = rda.stateSchema.assign(this.value, rda.constrain(action));
-    return true;
+  readFloat64() {
+    const offset = this.offset;
+    this.offset += 8;
+    this.checkBounds();
+    return this.buffer.dataView.getFloat64(offset, LITTLE_ENDIAN);
   }
-  serialize(rda, out) {
-    return rda.storeSchema.assign(out, this.value);
+  readVarint() {
+    const bytes = this.buffer.uint8;
+    let offset = this.offset;
+    const x0 = bytes[offset++];
+    if (x0 < 128) {
+      this.offset = offset;
+      this.checkBounds();
+      return x0;
+    }
+    const x1 = bytes[offset++];
+    if (x1 < 128) {
+      this.offset = offset;
+      this.checkBounds();
+      return x0 & 127 | x1 << 7;
+    }
+    const x2 = bytes[offset++];
+    if (x2 < 128) {
+      this.offset = offset;
+      this.checkBounds();
+      return x0 & 127 | (x1 & 127) << 7 | x2 << 14;
+    }
+    const x3 = bytes[offset++];
+    if (x3 < 128) {
+      this.offset = offset;
+      this.checkBounds();
+      return x0 & 127 | (x1 & 127) << 7 | (x2 & 127) << 14 | x3 << 21;
+    }
+    const x4 = bytes[offset++];
+    this.offset = offset;
+    this.checkBounds();
+    return (x0 & 127) + ((x1 & 127) << 7) + ((x2 & 127) << 14) + ((x3 & 127) << 21) + x4 * (1 << 28);
   }
-};
-var MuRDARegister = class {
-  stateSchema;
-  actionSchema;
-  storeSchema;
-  actionMeta = { type: "unit" };
-  action = (value) => {
-    return this.actionSchema.clone(this.constrain(value));
-  };
-  emptyStore;
-  constrain;
-  constructor(stateSchema, constrain) {
-    this.stateSchema = this.actionSchema = this.storeSchema = stateSchema;
-    this.constrain = constrain || identity;
-    this.emptyStore = new MuRDARegisterStore(stateSchema.identity);
+  readASCII(length) {
+    const head = this.offset;
+    this.offset += length;
+    this.checkBounds();
+    let str = "";
+    for (let i = head; i < this.offset; ++i) {
+      str += String.fromCharCode(this.buffer.uint8[i]);
+    }
+    return str;
   }
-  createStore(initialState) {
-    return new MuRDARegisterStore(this.stateSchema.clone(initialState));
+  readString() {
+    const byteLength = this.readVarint();
+    const head = this.offset;
+    this.offset += byteLength;
+    this.checkBounds();
+    const bytes = this.buffer.uint8.subarray(head, this.offset);
+    return decodeUTF8(bytes);
   }
-  parse(store) {
-    return new MuRDARegisterStore(this.stateSchema.clone(store));
+  readUint8At(offset) {
+    return this.buffer.dataView.getUint8(offset);
   }
 };
 
-// src/vendor/mudb/rda/struct.ts
-var MuRDAStructStore = class {
-  stores;
-  constructor(stores) {
-    this.stores = stores;
+// src/core/maps/block-info.ts
+var BLOCK_INFO_HASH = "QmW2E9E8ipYUifsCfkMj5SULYMYbFQvP6BQxo52atXw7Zj";
+async function readBlockInfoBytes(reader, worldId, hash = BLOCK_INFO_HASH) {
+  try {
+    const bytes = await reader.read(`worlds/${worldId}/data/blobs/${hash}`);
+    if (bytes === null || bytes.length === 0) return null;
+    return bytes;
+  } catch {
+    return null;
   }
-  state(rda, out) {
-    const ids = Object.keys(this.stores);
-    for (let i = 0; i < ids.length; ++i) {
-      const id = ids[i];
-      out[id] = this.stores[id].state(rda.rdas[id], out[id]);
+}
+
+// src/vendor/mudb/box-utils/id.ts
+function compareId(a, b) {
+  return a.id - b.id;
+}
+function interpolate(objects, l, h, id) {
+  const a = objects[l].id;
+  const b = objects[h].id;
+  const t = (id - a) / (b - a);
+  return Math.max(l, Math.min(h, Math.round((1 - t) * l + t * h) | 0));
+}
+function indexEqRange(objects, id, _l, _h) {
+  let l = _l;
+  let h = _h;
+  while (l < h) {
+    const m = interpolate(objects, l, h, id);
+    const x = objects[m].id;
+    if (x === id) {
+      return m;
+    } else if (x < id) {
+      l = m + 1;
+    } else {
+      h = m - 1;
     }
-    return out;
-  }
-  apply(rda, action) {
-    return this.stores[action.type].apply(rda.rdas[action.type], action.data);
   }
-  inverse(rda, action) {
-    const result = rda.actionSchema.alloc();
-    result.type = action.type;
-    result.data = this.stores[action.type].inverse(
-      rda.rdas[action.type],
-      action.data
-    );
-    return result;
+  if (l === h && objects[l].id === id) {
+    return l;
   }
-  serialize(rda, out) {
-    const ids = Object.keys(this.stores);
-    for (let i = 0; i < ids.length; ++i) {
-      const id = ids[i];
-      out[id] = this.stores[id].serialize(rda.rdas[id], out[id]);
+  return -1;
+}
+new MuFloat32();
+var Vec2Schema = new MuVector(new MuFloat32(), 2);
+var vec3Pool = [];
+var Vec3Schema = {
+  muType: "vector",
+  identity: vec3.create(),
+  json: {
+    type: "vector",
+    data: [0, 0, 0]
+  },
+  alloc: () => {
+    return vec3Pool.pop() || vec3.create();
+  },
+  free: (v) => {
+    vec3Pool.push(v);
+  },
+  assign: (dst, src) => {
+    dst[0] = src[0];
+    dst[1] = src[1];
+    dst[2] = src[2];
+    return dst;
+  },
+  equal: (dst, src) => {
+    return dst[0] === src[0] && dst[1] === src[1] && dst[2] === src[2];
+  },
+  diff: (base, target, out) => {
+    const s0 = (base[0] !== target[0]) << 0;
+    const s1 = (base[1] !== target[1]) << 1;
+    const s2 = (base[2] !== target[2]) << 2;
+    const flags = s0 + s1 + s2;
+    if (flags === 0) {
+      return false;
     }
-    return out;
-  }
-  free(rda) {
-    const ids = Object.keys(this.stores);
-    for (let i = 0; i < ids.length; ++i) {
-      const id = ids[i];
-      this.stores[id].free(rda.rdas[id]);
+    out.grow(13);
+    out.writeUint8(flags);
+    if (s0) {
+      out.writeFloat32(target[0]);
     }
-  }
-};
-var MuRDAStruct = class {
-  rdas;
-  stateSchema;
-  actionSchema;
-  storeSchema;
-  actionMeta;
-  action;
-  emptyStore;
-  _saveStore = null;
-  _wrapDispatch(id, rda) {
-    const self = this;
-    function wrapPartial(root, dispatch) {
-      const savedPartial = { data: null };
-      function wrapPartialRec(meta, index) {
-        if (meta.type === "unit") {
-          return new Function(
-            "rda",
-            "partial",
-            `/* ${id}:${index} */ return function() { var result = rda.actionSchema.alloc(); result.type = "${id}"; result.data = partial.data${index}.apply(null, arguments); return result; }`
-          )(self, savedPartial);
-        } else if (meta.type === "table") {
-          const result = {};
-          const keys = Object.keys(meta.table);
-          for (let i = 0; i < keys.length; ++i) {
-            const key = keys[i];
-            result[key] = wrapPartialRec(meta.table[key], `${index}["${key}"]`);
-          }
-          return result;
-        } else if (meta.type === "partial") {
-          return wrapPartial(
-            meta.action,
-            new Function(
-              "partial",
-              `/* ${id}:${index} */ return function () { return partial.data${index}.apply(null, arguments); }`
-            )(savedPartial)
-          );
-        }
-        return {};
-      }
-      return new Function(
-        "dispatch",
-        "partial",
-        "wrappedDispatch",
-        `/* ${id} */ return function () { partial.data = dispatch.apply(null, arguments); return wrappedDispatch; }`
-      )(dispatch, savedPartial, wrapPartialRec(root, ""));
+    if (s1) {
+      out.writeFloat32(target[1]);
     }
-    function wrapAction(meta, dispatch) {
-      if (meta.type === "unit") {
-        return function(...args) {
-          const result = self.actionSchema.alloc();
-          result.type = id;
-          result.data = dispatch.apply(null, args);
-          return result;
-        };
-      } else if (meta.type === "table") {
-        const result = {};
-        const ids = Object.keys(meta.table);
-        for (let i = 0; i < ids.length; ++i) {
-          const key = ids[i];
-          result[key] = wrapAction(meta.table[key], dispatch);
-        }
-        return result;
-      } else if (meta.type === "partial") {
-        return wrapPartial(meta.action, dispatch);
-      }
-      return {};
+    if (s2) {
+      out.writeFloat32(target[2]);
     }
-    function wrapStore(meta, index) {
-      if (meta.type === "unit") {
-        return new Function(
-          "rda",
-          "dispatch",
-          `/* ${id}:${index} */ return function() { var result = rda.actionSchema.alloc(); result.type = "${id}"; result.data = dispatch(rda._saveStore.stores["${id}"])${index}.apply(null, arguments); return result; }`
-        )(self, rda.action);
-      } else if (meta.type === "table") {
-        const result = {};
-        const ids = Object.keys(meta.table);
-        for (let i = 0; i < ids.length; ++i) {
-          const key = ids[i];
-          result[key] = wrapStore(meta.table[key], `${index}["${key}"]`);
-        }
-        return result;
-      } else if (meta.type === "partial") {
-        return wrapPartial(
-          meta.action,
-          new Function(
-            "rda",
-            "dispatch",
-            `/* ${id}:${index} */ return function() { return dispatch(rda._saveStore.stores["${id}"])${index}.apply(null, arguments); }`
-          )(self, rda.action)
-        );
-      }
-      return {};
+    return true;
+  },
+  patch: (base, inp) => {
+    const v = vec3Pool.pop() || vec3.create();
+    const flags = inp.readUint8();
+    v[0] = flags & 1 ? inp.readFloat32() : base[0];
+    v[1] = flags & 2 ? inp.readFloat32() : base[1];
+    v[2] = flags & 4 ? inp.readFloat32() : base[2];
+    return v;
+  },
+  clone: (v) => {
+    const x = vec3Pool.pop();
+    if (x) {
+      x[0] = v[0];
+      x[1] = v[1];
+      x[2] = v[2];
+      return x;
     }
-    if (rda.actionMeta.type !== "store") {
-      this.actionMeta.action.table[id] = rda.actionMeta;
-      return wrapAction(rda.actionMeta, rda.action);
+    return vec3.clone(v);
+  },
+  toJSON: (v) => [v[0], v[1], v[2]],
+  fromJSON: (json) => {
+    let v = vec3Pool.pop();
+    if (Array.isArray(json)) {
+      v = v || vec3.create();
+      v[0] = +json[0] || 0;
+      v[1] = +json[1] || 0;
+      v[2] = +json[2] || 0;
+      return v;
+    } else if (v) {
+      v[0] = v[1] = v[2] = 0;
+      return v;
     } else {
-      this.actionMeta.action.table[id] = rda.actionMeta.action;
-      return wrapStore(rda.actionMeta.action, "");
+      return vec3.create();
     }
   }
-  constructor(spec) {
-    this.rdas = spec;
-    const stateSpec = {};
-    const actionSpec = {};
-    const storeSpec = {};
-    const emptyStores = {};
-    const props = Object.keys(spec);
-    for (let i = 0; i < props.length; ++i) {
-      const prop = props[i];
-      const rda = spec[prop];
-      stateSpec[prop] = rda.stateSchema;
-      actionSpec[prop] = rda.actionSchema;
-      storeSpec[prop] = rda.storeSchema;
-      emptyStores[prop] = rda.emptyStore;
+};
+var vec4Pool = [];
+var Vec4Schema = {
+  muType: "vector",
+  identity: vec4.create(),
+  json: {
+    type: "vector",
+    data: [0, 0, 0, 0]
+  },
+  alloc: () => {
+    return vec4Pool.pop() || vec4.create();
+  },
+  free: (v) => {
+    vec4Pool.push(v);
+  },
+  assign: (dst, src) => {
+    dst[0] = src[0];
+    dst[1] = src[1];
+    dst[2] = src[2];
+    dst[3] = src[3];
+    return dst;
+  },
+  equal: (dst, src) => {
+    return dst[0] === src[0] && dst[1] === src[1] && dst[2] === src[2] && dst[3] === src[3];
+  },
+  diff: (base, target, out) => {
+    const s0 = (base[0] !== target[0]) << 0;
+    const s1 = (base[1] !== target[1]) << 1;
+    const s2 = (base[2] !== target[2]) << 2;
+    const s3 = (base[3] !== target[3]) << 3;
+    const flags = s0 + s1 + s2 + s3;
+    if (flags === 0) {
+      return false;
     }
-    this.stateSchema = new MuStruct(stateSpec);
-    this.actionSchema = new MuUnion(actionSpec);
-    this.storeSchema = new MuStruct(storeSpec);
-    this.emptyStore = new MuRDAStructStore(emptyStores);
-    this.actionMeta = {
-      type: "store",
-      action: {
-        type: "table",
-        table: {}
-      }
-    };
-    const storeDispatch = {};
-    for (let i = 0; i < props.length; ++i) {
-      const prop = props[i];
-      storeDispatch[prop] = this._wrapDispatch(prop, spec[prop]);
+    out.grow(17);
+    out.writeUint8(flags);
+    if (s0) {
+      out.writeFloat32(target[0]);
     }
-    this.action = ((store) => {
-      this._saveStore = store;
-      return storeDispatch;
-    });
-  }
-  createStore(state) {
-    const stores = {};
-    const ids = Object.keys(this.rdas);
-    for (let i = 0; i < ids.length; ++i) {
-      const id = ids[i];
-      stores[id] = this.rdas[id].createStore(state[id]);
+    if (s1) {
+      out.writeFloat32(target[1]);
     }
-    return new MuRDAStructStore(stores);
-  }
-  parse(store) {
-    const stores = {};
-    const ids = Object.keys(this.rdas);
-    for (let i = 0; i < ids.length; ++i) {
-      const id = ids[i];
-      stores[id] = this.rdas[id].parse(store[id]);
+    if (s2) {
+      out.writeFloat32(target[2]);
+    }
+    if (s3) {
+      out.writeFloat32(target[3]);
+    }
+    return true;
+  },
+  patch: (base, inp) => {
+    const v = vec4Pool.pop() || vec4.create();
+    const flags = inp.readUint8();
+    v[0] = flags & 1 ? inp.readFloat32() : base[0];
+    v[1] = flags & 2 ? inp.readFloat32() : base[1];
+    v[2] = flags & 4 ? inp.readFloat32() : base[2];
+    v[3] = flags & 8 ? inp.readFloat32() : base[3];
+    return v;
+  },
+  clone: (v) => {
+    const x = vec4Pool.pop();
+    if (x) {
+      x[0] = v[0];
+      x[1] = v[1];
+      x[2] = v[2];
+      x[3] = v[3];
+      return x;
+    }
+    return vec4.clone(v);
+  },
+  toJSON: (v) => [v[0], v[1], v[2], v[3]],
+  fromJSON: (json) => {
+    let v = vec4Pool.pop();
+    if (Array.isArray(json)) {
+      v = v || vec4.create();
+      v[0] = +json[0] || 0;
+      v[1] = +json[1] || 0;
+      v[2] = +json[2] || 0;
+      v[3] = +json[3] || 0;
+      return v;
+    } else if (v) {
+      v[0] = v[1] = v[2] = v[3] = 0;
+      return v;
+    } else {
+      return vec4.create();
     }
-    return new MuRDAStructStore(stores);
   }
 };
+var QuatSchema = Vec4Schema;
+new MuVector(new MuFloat32(), 9);
+var Mat4Schema = new MuVector(new MuFloat32(), 16);
+new MuStruct({
+  lo: Vec3Schema,
+  hi: Vec3Schema
+});
 
-// src/vendor/mudb/rda/map.ts
-function compareKey(a, b) {
-  return a < b ? -1 : b < a ? 1 : 0;
-}
-function compareStoreElements(a, b) {
-  return a.sequence - b.sequence || a.id - b.id;
-}
-function compareNum(a, b) {
-  return a - b;
-}
-var MuRDAMapStoreElement = class {
-  constructor(id, sequence, deleted, key, value) {
-    this.id = id;
-    this.sequence = sequence;
-    this.deleted = deleted;
-    this.key = key;
-    this.value = value;
-  }
-  id;
-  sequence;
-  deleted;
-  key;
+// src/vendor/mudb/rda/constant.ts
+var MuRDAConstantStore = class {
   value;
-  // currently a linked list, though this should probably be replaced by a pairing heap to prevent adversarial attacks
-  next = null;
-  prev = null;
+  constructor(initial) {
+    this.value = initial;
+  }
+  state(rda, out) {
+    return rda.stateSchema.assign(out, this.value);
+  }
+  apply() {
+    return false;
+  }
+  inverse() {
+  }
+  serialize(rda, out) {
+    return rda.storeSchema.assign(out, this.value);
+  }
+  free(rda) {
+    rda.stateSchema.free(this.value);
+  }
 };
-var MuRDAMapStore = class {
-  keyIndex = {};
-  idIndex = {};
-  constructor(elements) {
-    const { idIndex } = this;
-    for (let i = 0; i < elements.length; ++i) {
-      const element = elements[i];
-      const id = element.id;
-      idIndex[id] = element;
-      this._insertElement(element);
-    }
+var MuRDAConstant = class {
+  stateSchema;
+  actionSchema = new MuVoid();
+  storeSchema;
+  actionMeta = {
+    type: "table",
+    table: {}
+  };
+  action = {};
+  emptyStore;
+  constructor(stateSchema) {
+    this.stateSchema = stateSchema;
+    this.storeSchema = stateSchema;
+    this.emptyStore = new MuRDAConstantStore(stateSchema.identity);
+  }
+  createStore(initialState) {
+    return new MuRDAConstantStore(this.stateSchema.clone(initialState));
+  }
+  parse(store) {
+    return new MuRDAConstantStore(this.stateSchema.clone(store));
+  }
+};
+
+// src/vendor/mudb/rda/register.ts
+function identity(x) {
+  return x;
+}
+var MuRDARegisterStore = class {
+  value;
+  constructor(initial) {
+    this.value = initial;
   }
   state(rda, out) {
-    const keyIndex = this.keyIndex;
-    const outKeys = Object.keys(out);
-    for (let i = 0; i < outKeys.length; ++i) {
-      const key = outKeys[i];
-      const cur = keyIndex[key];
-      if (!cur || cur.deleted) {
-        rda.valueRDA.stateSchema.free(out[key]);
-        delete out[key];
-      }
-    }
-    const keys = Object.keys(keyIndex);
-    const valueRDA = rda.valueRDA;
-    const valueSchema = valueRDA.stateSchema;
-    for (let i = 0; i < keys.length; ++i) {
-      const key = keys[i];
-      const final = keyIndex[key];
-      if (!final.deleted) {
-        out[key] = final.value.state(valueRDA, out[key] || valueSchema.alloc());
-      }
+    return rda.stateSchema.assign(out, this.value);
+  }
+  inverse(rda) {
+    return rda.actionSchema.clone(this.value);
+  }
+  free(rda) {
+    rda.stateSchema.free(this.value);
+  }
+  apply(rda, action) {
+    this.value = rda.stateSchema.assign(this.value, rda.constrain(action));
+    return true;
+  }
+  serialize(rda, out) {
+    return rda.storeSchema.assign(out, this.value);
+  }
+};
+var MuRDARegister = class {
+  stateSchema;
+  actionSchema;
+  storeSchema;
+  actionMeta = { type: "unit" };
+  action = (value) => {
+    return this.actionSchema.clone(this.constrain(value));
+  };
+  emptyStore;
+  constrain;
+  constructor(stateSchema, constrain) {
+    this.stateSchema = this.actionSchema = this.storeSchema = stateSchema;
+    this.constrain = constrain || identity;
+    this.emptyStore = new MuRDARegisterStore(stateSchema.identity);
+  }
+  createStore(initialState) {
+    return new MuRDARegisterStore(this.stateSchema.clone(initialState));
+  }
+  parse(store) {
+    return new MuRDARegisterStore(this.stateSchema.clone(store));
+  }
+};
+
+// src/vendor/mudb/rda/struct.ts
+var MuRDAStructStore = class {
+  stores;
+  constructor(stores) {
+    this.stores = stores;
+  }
+  state(rda, out) {
+    const ids = Object.keys(this.stores);
+    for (let i = 0; i < ids.length; ++i) {
+      const id = ids[i];
+      out[id] = this.stores[id].state(rda.rdas[id], out[id]);
     }
     return out;
   }
-  _moveElement(element, key) {
-    if (key === element.key) {
-      return;
-    }
-    const { next, prev, sequence } = element;
-    if (this.keyIndex[element.key] === element) {
-      if (next) {
-        this.keyIndex[element.key] = next;
-        if (next.sequence >= sequence) {
-          next.deleted = false;
-        }
-      } else {
-        delete this.keyIndex[element.key];
-      }
-    }
-    if (next) {
-      next.prev = prev;
+  apply(rda, action) {
+    return this.stores[action.type].apply(rda.rdas[action.type], action.data);
+  }
+  inverse(rda, action) {
+    const result = rda.actionSchema.alloc();
+    result.type = action.type;
+    result.data = this.stores[action.type].inverse(
+      rda.rdas[action.type],
+      action.data
+    );
+    return result;
+  }
+  serialize(rda, out) {
+    const ids = Object.keys(this.stores);
+    for (let i = 0; i < ids.length; ++i) {
+      const id = ids[i];
+      out[id] = this.stores[id].serialize(rda.rdas[id], out[id]);
     }
-    if (prev) {
-      prev.next = next;
+    return out;
+  }
+  free(rda) {
+    const ids = Object.keys(this.stores);
+    for (let i = 0; i < ids.length; ++i) {
+      const id = ids[i];
+      this.stores[id].free(rda.rdas[id]);
     }
-    element.next = element.prev = null;
-    element.key = key;
-    this._insertElement(element);
   }
-  _insertElement(element) {
-    const key = element.key;
-    const head = this.keyIndex[key];
-    if (head) {
-      if (compareStoreElements(head, element) < 0) {
-        element.next = head;
-        head.prev = element;
-        head.deleted = true;
-        this.keyIndex[key] = element;
-      } else {
-        let prev = head;
-        while (prev) {
-          const next = prev.next;
-          if (!next) {
-            prev.next = element;
-            element.prev = prev;
-            break;
-          } else if (compareStoreElements(next, element) < 0) {
-            prev.next = element;
-            next.prev = element;
-            element.next = next;
-            element.prev = prev;
-            break;
+};
+var MuRDAStruct = class {
+  rdas;
+  stateSchema;
+  actionSchema;
+  storeSchema;
+  actionMeta;
+  action;
+  emptyStore;
+  _saveStore = null;
+  _wrapDispatch(id, rda) {
+    const self = this;
+    function wrapPartial(root, dispatch) {
+      const savedPartial = { data: null };
+      function wrapPartialRec(meta, index) {
+        if (meta.type === "unit") {
+          return new Function(
+            "rda",
+            "partial",
+            `/* ${id}:${index} */ return function() { var result = rda.actionSchema.alloc(); result.type = "${id}"; result.data = partial.data${index}.apply(null, arguments); return result; }`
+          )(self, savedPartial);
+        } else if (meta.type === "table") {
+          const result = {};
+          const keys = Object.keys(meta.table);
+          for (let i = 0; i < keys.length; ++i) {
+            const key = keys[i];
+            result[key] = wrapPartialRec(meta.table[key], `${index}["${key}"]`);
           }
-          prev = next;
+          return result;
+        } else if (meta.type === "partial") {
+          return wrapPartial(
+            meta.action,
+            new Function(
+              "partial",
+              `/* ${id}:${index} */ return function () { return partial.data${index}.apply(null, arguments); }`
+            )(savedPartial)
+          );
         }
+        return {};
       }
-    } else {
-      this.keyIndex[key] = element;
+      return new Function(
+        "dispatch",
+        "partial",
+        "wrappedDispatch",
+        `/* ${id} */ return function () { partial.data = dispatch.apply(null, arguments); return wrappedDispatch; }`
+      )(dispatch, savedPartial, wrapPartialRec(root, ""));
     }
-  }
-  _applyUpsert(valueRDA, upsertAction) {
-    const prev = this.idIndex[upsertAction.id];
-    if (prev) {
-      prev.id = upsertAction.id;
-      prev.deleted = upsertAction.deleted;
-      prev.sequence = upsertAction.sequence;
-      prev.value.free(valueRDA);
-      prev.value = valueRDA.parse(upsertAction.value);
-      this._moveElement(prev, upsertAction.key);
+    function wrapAction(meta, dispatch) {
+      if (meta.type === "unit") {
+        return function(...args) {
+          const result = self.actionSchema.alloc();
+          result.type = id;
+          result.data = dispatch.apply(null, args);
+          return result;
+        };
+      } else if (meta.type === "table") {
+        const result = {};
+        const ids = Object.keys(meta.table);
+        for (let i = 0; i < ids.length; ++i) {
+          const key = ids[i];
+          result[key] = wrapAction(meta.table[key], dispatch);
+        }
+        return result;
+      } else if (meta.type === "partial") {
+        return wrapPartial(meta.action, dispatch);
+      }
+      return {};
+    }
+    function wrapStore(meta, index) {
+      if (meta.type === "unit") {
+        return new Function(
+          "rda",
+          "dispatch",
+          `/* ${id}:${index} */ return function() { var result = rda.actionSchema.alloc(); result.type = "${id}"; result.data = dispatch(rda._saveStore.stores["${id}"])${index}.apply(null, arguments); return result; }`
+        )(self, rda.action);
+      } else if (meta.type === "table") {
+        const result = {};
+        const ids = Object.keys(meta.table);
+        for (let i = 0; i < ids.length; ++i) {
+          const key = ids[i];
+          result[key] = wrapStore(meta.table[key], `${index}["${key}"]`);
+        }
+        return result;
+      } else if (meta.type === "partial") {
+        return wrapPartial(
+          meta.action,
+          new Function(
+            "rda",
+            "dispatch",
+            `/* ${id}:${index} */ return function() { return dispatch(rda._saveStore.stores["${id}"])${index}.apply(null, arguments); }`
+          )(self, rda.action)
+        );
+      }
+      return {};
+    }
+    if (rda.actionMeta.type !== "store") {
+      this.actionMeta.action.table[id] = rda.actionMeta;
+      return wrapAction(rda.actionMeta, rda.action);
+    } else {
+      this.actionMeta.action.table[id] = rda.actionMeta.action;
+      return wrapStore(rda.actionMeta.action, "");
+    }
+  }
+  constructor(spec) {
+    this.rdas = spec;
+    const stateSpec = {};
+    const actionSpec = {};
+    const storeSpec = {};
+    const emptyStores = {};
+    const props = Object.keys(spec);
+    for (let i = 0; i < props.length; ++i) {
+      const prop = props[i];
+      const rda = spec[prop];
+      stateSpec[prop] = rda.stateSchema;
+      actionSpec[prop] = rda.actionSchema;
+      storeSpec[prop] = rda.storeSchema;
+      emptyStores[prop] = rda.emptyStore;
+    }
+    this.stateSchema = new MuStruct(stateSpec);
+    this.actionSchema = new MuUnion(actionSpec);
+    this.storeSchema = new MuStruct(storeSpec);
+    this.emptyStore = new MuRDAStructStore(emptyStores);
+    this.actionMeta = {
+      type: "store",
+      action: {
+        type: "table",
+        table: {}
+      }
+    };
+    const storeDispatch = {};
+    for (let i = 0; i < props.length; ++i) {
+      const prop = props[i];
+      storeDispatch[prop] = this._wrapDispatch(prop, spec[prop]);
+    }
+    this.action = ((store) => {
+      this._saveStore = store;
+      return storeDispatch;
+    });
+  }
+  createStore(state) {
+    const stores = {};
+    const ids = Object.keys(this.rdas);
+    for (let i = 0; i < ids.length; ++i) {
+      const id = ids[i];
+      stores[id] = this.rdas[id].createStore(state[id]);
+    }
+    return new MuRDAStructStore(stores);
+  }
+  parse(store) {
+    const stores = {};
+    const ids = Object.keys(this.rdas);
+    for (let i = 0; i < ids.length; ++i) {
+      const id = ids[i];
+      stores[id] = this.rdas[id].parse(store[id]);
+    }
+    return new MuRDAStructStore(stores);
+  }
+};
+
+// src/vendor/mudb/rda/map.ts
+function compareKey(a, b) {
+  return a < b ? -1 : b < a ? 1 : 0;
+}
+function compareStoreElements(a, b) {
+  return a.sequence - b.sequence || a.id - b.id;
+}
+function compareNum(a, b) {
+  return a - b;
+}
+var MuRDAMapStoreElement = class {
+  constructor(id, sequence, deleted, key, value) {
+    this.id = id;
+    this.sequence = sequence;
+    this.deleted = deleted;
+    this.key = key;
+    this.value = value;
+  }
+  id;
+  sequence;
+  deleted;
+  key;
+  value;
+  // currently a linked list, though this should probably be replaced by a pairing heap to prevent adversarial attacks
+  next = null;
+  prev = null;
+};
+var MuRDAMapStore = class {
+  keyIndex = {};
+  idIndex = {};
+  constructor(elements) {
+    const { idIndex } = this;
+    for (let i = 0; i < elements.length; ++i) {
+      const element = elements[i];
+      const id = element.id;
+      idIndex[id] = element;
+      this._insertElement(element);
+    }
+  }
+  state(rda, out) {
+    const keyIndex = this.keyIndex;
+    const outKeys = Object.keys(out);
+    for (let i = 0; i < outKeys.length; ++i) {
+      const key = outKeys[i];
+      const cur = keyIndex[key];
+      if (!cur || cur.deleted) {
+        rda.valueRDA.stateSchema.free(out[key]);
+        delete out[key];
+      }
+    }
+    const keys = Object.keys(keyIndex);
+    const valueRDA = rda.valueRDA;
+    const valueSchema = valueRDA.stateSchema;
+    for (let i = 0; i < keys.length; ++i) {
+      const key = keys[i];
+      const final = keyIndex[key];
+      if (!final.deleted) {
+        out[key] = final.value.state(valueRDA, out[key] || valueSchema.alloc());
+      }
+    }
+    return out;
+  }
+  _moveElement(element, key) {
+    if (key === element.key) {
+      return;
+    }
+    const { next, prev, sequence } = element;
+    if (this.keyIndex[element.key] === element) {
+      if (next) {
+        this.keyIndex[element.key] = next;
+        if (next.sequence >= sequence) {
+          next.deleted = false;
+        }
+      } else {
+        delete this.keyIndex[element.key];
+      }
+    }
+    if (next) {
+      next.prev = prev;
+    }
+    if (prev) {
+      prev.next = next;
+    }
+    element.next = element.prev = null;
+    element.key = key;
+    this._insertElement(element);
+  }
+  _insertElement(element) {
+    const key = element.key;
+    const head = this.keyIndex[key];
+    if (head) {
+      if (compareStoreElements(head, element) < 0) {
+        element.next = head;
+        head.prev = element;
+        head.deleted = true;
+        this.keyIndex[key] = element;
+      } else {
+        let prev = head;
+        while (prev) {
+          const next = prev.next;
+          if (!next) {
+            prev.next = element;
+            element.prev = prev;
+            break;
+          } else if (compareStoreElements(next, element) < 0) {
+            prev.next = element;
+            next.prev = element;
+            element.next = next;
+            element.prev = prev;
+            break;
+          }
+          prev = next;
+        }
+      }
+    } else {
+      this.keyIndex[key] = element;
+    }
+  }
+  _applyUpsert(valueRDA, upsertAction) {
+    const prev = this.idIndex[upsertAction.id];
+    if (prev) {
+      prev.id = upsertAction.id;
+      prev.deleted = upsertAction.deleted;
+      prev.sequence = upsertAction.sequence;
+      prev.value.free(valueRDA);
+      prev.value = valueRDA.parse(upsertAction.value);
+      this._moveElement(prev, upsertAction.key);
     } else {
       const element = new MuRDAMapStoreElement(
         upsertAction.id,
@@ -4240,9 +4746,6 @@ var MuRDAList = class {
     return new MuRDAListStore(nodes);
   }
 };
-
-// src/vendor/mudb/box-schema/content-server/index.ts
-var HashSchema = new MuASCII();
 var SCHROEPPEL23 = 2863311530;
 function readShroeppel(stream) {
   const x = stream.readVarint();
@@ -8139,284 +8642,95 @@ var DamageEventSchema = new MuStruct({
   die: new MuArray(new MuVarint(), Infinity)
 });
 
-// src/vendor/mudb/box-schema/events/script-events.ts
-new MuStruct({
-  damage: DamageEventSchema
-});
-
-// src/vendor/mudb/box-schema/physics/collision-filter-schema.ts
-var CollisionGroupSchema = new MuSortedArray(
-  new MuVarint(),
-  Infinity,
-  (a, b) => a - b
-);
-var CollisionFilterSchema = new MuArray(
-  CollisionGroupSchema,
-  Infinity
-);
-
-// src/vendor/mudb/box-schema/zone/zone-schema.ts
-var ZoneSchema = new MuStruct({
-  id: new MuVarint(),
-  // bounds
-  minX: new MuQuantizedFloat(1 / 16, 0),
-  minY: new MuQuantizedFloat(1 / 16, 0),
-  minZ: new MuQuantizedFloat(1 / 16, 0),
-  maxX: new MuQuantizedFloat(1 / 16, 0),
-  maxY: new MuQuantizedFloat(1 / 16, 0),
-  maxZ: new MuQuantizedFloat(1 / 16, 0)
-});
-var ZoneSelectorGroupSchema = new MuStruct({
-  id: new MuVarint(),
-  groupBits: new MuSortedArray(new MuVarint(), Infinity, (a, b) => a - b)
-});
-var ZoneSelectorGroupSetSchema = new MuSortedArray(
-  ZoneSelectorGroupSchema,
-  Infinity,
-  compareId
-);
-var PhysicsZoneSchema = new MuStruct({
-  // selector group for this zone
-  selectorGroup: new MuVarint(0),
-  // physics effects
-  massScale: new MuQuantizedFloat(1 / 256, 0),
-  fx: new MuQuantizedFloat(1 / 1024, 0),
-  fy: new MuQuantizedFloat(1 / 1024, 0),
-  fz: new MuQuantizedFloat(1 / 1024, 0),
-  ...ZoneSchema.muData
-});
-var PhysicsZoneSetSchema = new MuSortedArray(
-  PhysicsZoneSchema,
-  Infinity,
-  compareId
-);
-var EnvironmentZoneSchema = new MuStruct({
-  // weather effects
-  overrideFog: new MuBoolean(false),
-  fog: FogRDA.stateSchema,
-  overrideSky: new MuBoolean(false),
-  sky: SkyRDA.stateSchema,
-  overrideSnow: new MuBoolean(false),
-  snow: SnowRDA.stateSchema,
-  overrideRain: new MuBoolean(false),
-  rain: RainRDA.stateSchema,
-  ...ZoneSchema.muData
-});
-var EnvironmentZoneSetSchema = new MuSortedArray(
-  EnvironmentZoneSchema,
-  Infinity,
-  compareId
-);
-
-// src/vendor/mudb/box-schema/environment/environment-schema.ts
-var EnvironmentParamSchema = EnvironmentRDA.stateSchema;
-new MuStruct({
-  timeOfDay: new MuFloat64(0),
-  sunUp: new MuBoolean(false),
-  globalLight: new MuFloat64(0),
-  gamma: new MuFloat32(1.3),
-  drawDistance: new MuFloat32(512),
-  freezeDrawDistance: new MuBoolean(false),
-  sunDirection: Vec3Schema,
-  sunColor: Vec3Schema,
-  skyLeft: Vec3Schema,
-  skyRight: Vec3Schema,
-  skyTop: Vec3Schema,
-  skyBottom: Vec3Schema,
-  skyFront: Vec3Schema,
-  skyBack: Vec3Schema,
-  fogParams: Vec4Schema,
-  fogParams2: Vec4Schema,
-  fogParams3: Vec4Schema
-});
-
-// src/vendor/mudb/box-schema/utils/ref-schema.ts
-var _noSerialize = () => {
-  throw new Error("cannot serialize references");
-};
-var MuRefSchema = class {
-  identity = null;
-  muType = "ref";
-  muData = { type: "ref" };
-  json = { type: "ref" };
-  constructor() {
-  }
-  diff = _noSerialize;
-  patch = _noSerialize;
-  toJSON = _noSerialize;
-  fromJSON = _noSerialize;
-  alloc() {
-    return null;
-  }
-  free() {
-  }
-  assign(dst, src) {
-    return src;
-  }
-  clone(x) {
-    return x;
-  }
-  equal(a, b) {
-    return a === b;
-  }
-};
-
-// src/vendor/mudb/box-schema/utils/relative-array.ts
-var RelativeArray = class {
-  identity;
-  muType = "relative array";
-  muData;
-  json;
-  arraySchema;
-  alloc;
-  free;
-  clone;
-  equal;
-  assign;
-  toJSON;
-  fromJSON;
-  constructor(schema, capacity, identity2) {
-    const arraySchema = this.arraySchema = new MuArray(
-      schema,
-      capacity,
-      identity2
-    );
-    this.json = {
-      type: "relative array",
-      value: schema.json
-    };
-    this.muData = schema;
-    this.identity = arraySchema.identity;
-    this.alloc = arraySchema.alloc;
-    this.free = arraySchema.free;
-    this.clone = arraySchema.clone;
-    this.equal = arraySchema.equal;
-    this.assign = arraySchema.assign;
-    this.toJSON = arraySchema.toJSON;
-    this.fromJSON = arraySchema.fromJSON;
-  }
-  diff(base, target, stream) {
-    const prefixOffset = stream.offset;
-    const targetLength = target.length;
-    const numTrackers = Math.ceil(targetLength / 8);
-    stream.grow(4 + numTrackers);
-    stream.writeUint32(targetLength);
-    let trackerOffset = stream.offset;
-    stream.offset = trackerOffset + numTrackers;
-    let tracker = 0;
-    let numPatch = 0;
-    const baseLength = base.length;
-    const valueSchema = this.muData;
-    let prev = base.length > 0 ? base[0] : valueSchema.identity;
-    for (let i = 0; i < target.length; ++i) {
-      if (valueSchema.diff(prev, target[i], stream)) {
-        tracker |= 1 << (i & 7);
-        ++numPatch;
-      }
-      if ((i & 7) === 7) {
-        stream.writeUint8At(trackerOffset++, tracker);
-        tracker = 0;
-      }
-      prev = target[i];
-    }
-    if (targetLength & 7) {
-      stream.writeUint8At(trackerOffset, tracker);
-    }
-    if (numPatch > 0 || baseLength !== targetLength) {
-      return true;
-    }
-    stream.offset = prefixOffset;
-    return false;
-  }
-  patch(base, stream) {
-    const result = this.clone(base);
-    const targetLength = stream.readUint32();
-    result.length = targetLength;
-    let trackerOffset = stream.offset;
-    const numTrackers = Math.ceil(targetLength / 8);
-    stream.offset = trackerOffset + numTrackers;
-    let tracker = 0;
-    const valueSchema = this.muData;
-    let prev = base.length > 0 ? base[0] : valueSchema.identity;
-    for (let i = 0; i < targetLength; ++i) {
-      const mod8 = i & 7;
-      if (!mod8) {
-        tracker = stream.readUint8At(trackerOffset++);
-      }
-      if (1 << mod8 & tracker) {
-        prev = result[i] = valueSchema.patch(prev, stream);
-      } else {
-        result[i] = valueSchema.clone(prev);
-      }
-    }
-    return result;
-  }
-};
-
-// src/vendor/mudb/box-schema/voxel/block-schema.ts
-var BlockInfoSchema = new MuStruct({
-  // voxel info
-  ids: new RelativeArray(new MuRelativeVarint(), Infinity, [0]),
-  names: new MuArray(new MuUTF8(), Infinity, ["air"]),
-  // run length encode these arrays
-  emissive: new RelativeArray(new MuVarint(), Infinity, [0]),
-  texture: new RelativeArray(
-    new MuRelativeVarint(),
-    Infinity,
-    [0, 0, 0, 0, 0, 0]
-  ),
-  animLength: new RelativeArray(new MuVarint(1), Infinity, [1, 1, 1, 1, 1, 1]),
-  friction: new RelativeArray(new MuQuantizedFloat(1 / 256, 1), Infinity, [0]),
-  restitution: new RelativeArray(new MuQuantizedFloat(1 / 256, 0), Infinity, [
-    0
-  ]),
-  velocity: new RelativeArray(new MuFloat32(0), Infinity, [0, 0, 0]),
-  // fluids
-  fluids: new MuArray(
-    new MuStruct({
-      id: new MuVarint(),
-      info: new MuUint32(),
-      mass: new MuFloat64(1)
-    }),
-    Infinity,
-    [
-      {
-        id: 0,
-        info: 0,
-        mass: 0
-      }
-    ]
-  ),
-  // category list
-  category: new MuDictionary(
-    new RelativeArray(new MuRelativeVarint(), Infinity),
-    Infinity,
-    {
-      default: [0]
-    }
-  ),
-  // texture info
-  atlasRadius: new MuVarint(16),
-  blockBumpShift: new MuVarint(6),
-  blockColorShift: new MuVarint(4),
-  // texture atlases
-  colorAtlas: new MuArray(HashSchema, Infinity),
-  materialAtlas: new MuArray(HashSchema, Infinity),
-  bumpAtlas: new MuArray(HashSchema, Infinity)
+// src/vendor/mudb/box-schema/events/script-events.ts
+new MuStruct({
+  damage: DamageEventSchema
+});
+
+// src/vendor/mudb/box-schema/physics/collision-filter-schema.ts
+var CollisionGroupSchema = new MuSortedArray(
+  new MuVarint(),
+  Infinity,
+  (a, b) => a - b
+);
+var CollisionFilterSchema = new MuArray(
+  CollisionGroupSchema,
+  Infinity
+);
+
+// src/vendor/mudb/box-schema/zone/zone-schema.ts
+var ZoneSchema = new MuStruct({
+  id: new MuVarint(),
+  // bounds
+  minX: new MuQuantizedFloat(1 / 16, 0),
+  minY: new MuQuantizedFloat(1 / 16, 0),
+  minZ: new MuQuantizedFloat(1 / 16, 0),
+  maxX: new MuQuantizedFloat(1 / 16, 0),
+  maxY: new MuQuantizedFloat(1 / 16, 0),
+  maxZ: new MuQuantizedFloat(1 / 16, 0)
+});
+var ZoneSelectorGroupSchema = new MuStruct({
+  id: new MuVarint(),
+  groupBits: new MuSortedArray(new MuVarint(), Infinity, (a, b) => a - b)
+});
+var ZoneSelectorGroupSetSchema = new MuSortedArray(
+  ZoneSelectorGroupSchema,
+  Infinity,
+  compareId
+);
+var PhysicsZoneSchema = new MuStruct({
+  // selector group for this zone
+  selectorGroup: new MuVarint(0),
+  // physics effects
+  massScale: new MuQuantizedFloat(1 / 256, 0),
+  fx: new MuQuantizedFloat(1 / 1024, 0),
+  fy: new MuQuantizedFloat(1 / 1024, 0),
+  fz: new MuQuantizedFloat(1 / 1024, 0),
+  ...ZoneSchema.muData
+});
+var PhysicsZoneSetSchema = new MuSortedArray(
+  PhysicsZoneSchema,
+  Infinity,
+  compareId
+);
+var EnvironmentZoneSchema = new MuStruct({
+  // weather effects
+  overrideFog: new MuBoolean(false),
+  fog: FogRDA.stateSchema,
+  overrideSky: new MuBoolean(false),
+  sky: SkyRDA.stateSchema,
+  overrideSnow: new MuBoolean(false),
+  snow: SnowRDA.stateSchema,
+  overrideRain: new MuBoolean(false),
+  rain: RainRDA.stateSchema,
+  ...ZoneSchema.muData
 });
+var EnvironmentZoneSetSchema = new MuSortedArray(
+  EnvironmentZoneSchema,
+  Infinity,
+  compareId
+);
+
+// src/vendor/mudb/box-schema/environment/environment-schema.ts
+var EnvironmentParamSchema = EnvironmentRDA.stateSchema;
 new MuStruct({
-  id: new MuDictionary(new MuVarint(), Infinity, { air: 0 }),
-  valid: new MuArray(new MuBoolean(false), Infinity),
-  name: new MuArray(new MuUTF8(), Infinity, ["air"]),
-  emissive: new MuArray(new MuUint16(), Infinity, [0]),
-  texture: new MuArray(new MuUint32(), Infinity, [0, 0, 0, 0, 0, 0]),
-  mass: new MuArray(new MuFloat64(), Infinity, [0]),
-  restitution: new MuArray(new MuFloat64(), Infinity, [0]),
-  friction: new MuArray(new MuFloat64(), Infinity, [0]),
-  fluid: new MuArray(new MuVarint(), Infinity, [1]),
-  fluidInfo: new MuArray(new MuUint32(), Infinity, [0, 0]),
-  velocity: new MuArray(new MuFloat32(0), Infinity, [0, 0, 0]),
-  isFluid: new MuRefSchema()
+  timeOfDay: new MuFloat64(0),
+  sunUp: new MuBoolean(false),
+  globalLight: new MuFloat64(0),
+  gamma: new MuFloat32(1.3),
+  drawDistance: new MuFloat32(512),
+  freezeDrawDistance: new MuBoolean(false),
+  sunDirection: Vec3Schema,
+  sunColor: Vec3Schema,
+  skyLeft: Vec3Schema,
+  skyRight: Vec3Schema,
+  skyTop: Vec3Schema,
+  skyBottom: Vec3Schema,
+  skyFront: Vec3Schema,
+  skyBack: Vec3Schema,
+  fogParams: Vec4Schema,
+  fogParams2: Vec4Schema,
+  fogParams3: Vec4Schema
 });
 
 // src/vendor/mudb/box-schema/script/script-protocol.ts
@@ -12906,146 +13220,6 @@ new MuSortedArray(
   Infinity,
   compareNetPublic
 );
-var decodeUTF8;
-{
-  new TextEncoder();
-  const decoder = new TextDecoder();
-  decodeUTF8 = (bytes) => decoder.decode(bytes);
-}
-var MuBuffer = class {
-  buffer;
-  dataView;
-  uint8;
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.dataView = new DataView(buffer);
-    this.uint8 = new Uint8Array(buffer);
-  }
-};
-var bufferPool = new Array(31);
-for (let i = 0; i < 31; ++i) {
-  bufferPool[i] = [];
-}
-var LITTLE_ENDIAN = true;
-var MuReadStream = class {
-  buffer;
-  offset;
-  length;
-  constructor(data) {
-    this.buffer = new MuBuffer(data.buffer);
-    this.offset = data.byteOffset;
-    this.length = data.byteLength + data.byteOffset;
-  }
-  bytes() {
-    return this.buffer.uint8.subarray(this.offset, this.length);
-  }
-  checkBounds() {
-    if (this.offset > this.length) {
-      throw new Error("out of bounds");
-    }
-  }
-  readInt8() {
-    const offset = this.offset;
-    this.offset += 1;
-    this.checkBounds();
-    return this.buffer.dataView.getInt8(offset);
-  }
-  readInt16() {
-    const offset = this.offset;
-    this.offset += 2;
-    this.checkBounds();
-    return this.buffer.dataView.getInt16(offset, LITTLE_ENDIAN);
-  }
-  readInt32() {
-    const offset = this.offset;
-    this.offset += 4;
-    this.checkBounds();
-    return this.buffer.dataView.getInt32(offset, LITTLE_ENDIAN);
-  }
-  readUint8() {
-    const offset = this.offset;
-    this.offset += 1;
-    this.checkBounds();
-    return this.buffer.dataView.getUint8(offset);
-  }
-  readUint16() {
-    const offset = this.offset;
-    this.offset += 2;
-    this.checkBounds();
-    return this.buffer.dataView.getUint16(offset, LITTLE_ENDIAN);
-  }
-  readUint32() {
-    const offset = this.offset;
-    this.offset += 4;
-    this.checkBounds();
-    return this.buffer.dataView.getUint32(offset, LITTLE_ENDIAN);
-  }
-  readFloat32() {
-    const offset = this.offset;
-    this.offset += 4;
-    this.checkBounds();
-    return this.buffer.dataView.getFloat32(offset, LITTLE_ENDIAN);
-  }
-  readFloat64() {
-    const offset = this.offset;
-    this.offset += 8;
-    this.checkBounds();
-    return this.buffer.dataView.getFloat64(offset, LITTLE_ENDIAN);
-  }
-  readVarint() {
-    const bytes = this.buffer.uint8;
-    let offset = this.offset;
-    const x0 = bytes[offset++];
-    if (x0 < 128) {
-      this.offset = offset;
-      this.checkBounds();
-      return x0;
-    }
-    const x1 = bytes[offset++];
-    if (x1 < 128) {
-      this.offset = offset;
-      this.checkBounds();
-      return x0 & 127 | x1 << 7;
-    }
-    const x2 = bytes[offset++];
-    if (x2 < 128) {
-      this.offset = offset;
-      this.checkBounds();
-      return x0 & 127 | (x1 & 127) << 7 | x2 << 14;
-    }
-    const x3 = bytes[offset++];
-    if (x3 < 128) {
-      this.offset = offset;
-      this.checkBounds();
-      return x0 & 127 | (x1 & 127) << 7 | (x2 & 127) << 14 | x3 << 21;
-    }
-    const x4 = bytes[offset++];
-    this.offset = offset;
-    this.checkBounds();
-    return (x0 & 127) + ((x1 & 127) << 7) + ((x2 & 127) << 14) + ((x3 & 127) << 21) + x4 * (1 << 28);
-  }
-  readASCII(length) {
-    const head = this.offset;
-    this.offset += length;
-    this.checkBounds();
-    let str = "";
-    for (let i = head; i < this.offset; ++i) {
-      str += String.fromCharCode(this.buffer.uint8[i]);
-    }
-    return str;
-  }
-  readString() {
-    const byteLength = this.readVarint();
-    const head = this.offset;
-    this.offset += byteLength;
-    this.checkBounds();
-    const bytes = this.buffer.uint8.subarray(head, this.offset);
-    return decodeUTF8(bytes);
-  }
-  readUint8At(offset) {
-    return this.buffer.dataView.getUint8(offset);
-  }
-};
 
 // src/core/engine/world-seed.ts
 var WORLD_SEED_VERSION = 2;
@@ -13074,6 +13248,21 @@ function asQuat(value) {
     asNumber(w, 1)
   ];
 }
+function archiveToWorldSeedSource(archive) {
+  const world = archive.worlds[0];
+  if (!world) {
+    throw new Error("cajonzero: boxplay archive contains no world to seed");
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const file of archive.files) {
+    files.set(file.path, file.data);
+  }
+  return {
+    worldId: world.worldId,
+    manifest: world.manifest,
+    reader: { read: (relPath) => files.get(relPath) ?? null }
+  };
+}
 async function readJsonFile(source, relPath) {
   const bytes = await source.reader.read(`worlds/${source.worldId}/${relPath}`);
   if (!bytes) return null;
@@ -13129,6 +13318,45 @@ function entityToSeedBody(entity) {
   const bounds = asVec3(value.bounds) ?? [1, 1, 1];
   const scale = asVec3(value.scale) ?? [1, 1, 1];
   const orientation = asQuat(value.orientation);
+  const [qx, qy, qz, qw] = orientation;
+  const x2 = qx + qx;
+  const y2 = qy + qy;
+  const z2 = qz + qz;
+  const xx = qx * x2;
+  const yx = qy * x2;
+  const yy = qy * y2;
+  const zx = qz * x2;
+  const zy = qz * y2;
+  const zz = qz * z2;
+  const wx = qw * x2;
+  const wy = qw * y2;
+  const wz = qw * z2;
+  const m0 = 1 - yy - zz;
+  const m1 = yx + wz;
+  const m2 = zx - wy;
+  const m3 = yx - wz;
+  const m4 = 1 - xx - zz;
+  const m5 = zy + wx;
+  const m6 = zx + wy;
+  const m7 = zy - wx;
+  const m8 = 1 - xx - yy;
+  const sx = scale[0];
+  const sy = scale[1];
+  const sz = scale[2];
+  const bx = bounds[0];
+  const by = bounds[1];
+  const bz = bounds[2];
+  let rx = 0;
+  let ry = 0;
+  let rz = 0;
+  for (let i = 0; i < 8; i += 1) {
+    const x = 0.5 * (i & 1 ? sx : -sx) * bx;
+    const y = 0.5 * (i & 2 ? sy : -sy) * by;
+    const z = 0.5 * (i & 4 ? sz : -sz) * bz;
+    rx = Math.max(rx, Math.abs(x * m0 + y * m3 + z * m6));
+    ry = Math.max(ry, Math.abs(x * m1 + y * m4 + z * m7));
+    rz = Math.max(rz, Math.abs(x * m2 + y * m5 + z * m8));
+  }
   let flags = 0;
   if (value.collision === true) flags |= 2 /* COLLIDES */;
   if (value.gravity === true) flags |= 4 /* GRAVITY */;
@@ -13139,9 +13367,9 @@ function entityToSeedBody(entity) {
       px: position[0],
       py: position[1],
       pz: position[2],
-      rx: bounds[0] * scale[0],
-      ry: bounds[1] * scale[1],
-      rz: bounds[2] * scale[2],
+      rx,
+      ry,
+      rz,
       qx: orientation[0],
       qy: orientation[1],
       qz: orientation[2],
@@ -13173,6 +13401,40 @@ async function mapLimit(items, limit, fn) {
   await Promise.all(workers);
   return results;
 }
+async function resolveScripts(source, head, warnings) {
+  const assetsRef = await resolveRef(source, head.scriptAssets);
+  if (!isRecord(assetsRef)) return void 0;
+  const rawIndex = typeof head.scriptIndex === "string" ? head.scriptIndex : "";
+  const modules = {};
+  for (const [path6, raw] of Object.entries(assetsRef)) {
+    if (!isRecord(raw)) continue;
+    if (raw.isClient === true || raw.type === 7) continue;
+    const hash = typeof raw.hash === "string" ? raw.hash : "";
+    if (hash.length === 0) {
+      warnings.push(`script module "${path6}" has no hash`);
+      continue;
+    }
+    const bytes = await source.reader.read(
+      `worlds/${source.worldId}/data/blobs/${hash}`
+    );
+    if (!bytes) {
+      warnings.push(`script module "${path6}" is missing (${hash.slice(0, 12)}\u2026)`);
+      continue;
+    }
+    modules[path6] = {
+      hash,
+      source: textDecoder.decode(bytes),
+      order: asNumber(raw.order, 0),
+      ...typeof raw.name === "string" && raw.name.length > 0 ? { name: raw.name } : {}
+    };
+  }
+  if (Object.keys(modules).length === 0) return void 0;
+  const index = /^_+migrated_index\.js$/.test(rawIndex) && modules["index.js"] !== void 0 ? "index.js" : rawIndex;
+  if (index.length > 0 && modules[index] === void 0) {
+    warnings.push(`scriptIndex "${index}" does not exist in scriptAssets`);
+  }
+  return { index, modules };
+}
 async function resolveRenderAssets(source, entities, projectState, warnings) {
   const extraProjectHash = typeof projectState.extraProjectHash === "string" && projectState.extraProjectHash.length > 0 ? projectState.extraProjectHash : void 0;
   if (extraProjectHash === void 0) {
@@ -13235,22 +13497,22 @@ async function resolveRenderAssets(source, entities, projectState, warnings) {
   }
   const meshes = [];
   const paths = [...referenced.keys()].sort();
-  await mapLimit(paths, 8, async (path5) => {
-    const asset = referenced.get(path5);
+  await mapLimit(paths, 8, async (path6) => {
+    const asset = referenced.get(path6);
     if (!asset) return;
     const metadataHash = typeof asset.hash === "string" ? asset.hash : "";
     if (metadataHash.length === 0) {
-      warnings.push(`mesh ${path5} has no metadata hash`);
+      warnings.push(`mesh ${path6} has no metadata hash`);
       return;
     }
     const metadata = await readBlobJson(source, metadataHash);
     if (!isRecord(metadata)) {
-      warnings.push(`mesh ${path5} metadata ${metadataHash} is missing/undecodable`);
+      warnings.push(`mesh ${path6} metadata ${metadataHash} is missing/undecodable`);
       return;
     }
     const dataHash = typeof metadata.dataHash === "string" ? metadata.dataHash : "";
     if (dataHash.length === 0) {
-      warnings.push(`mesh ${path5} metadata has no dataHash`);
+      warnings.push(`mesh ${path6} metadata has no dataHash`);
       return;
     }
     const bounds = asVec3(metadata.bounds) ?? [1, 1, 1];
@@ -13261,13 +13523,14 @@ async function resolveRenderAssets(source, entities, projectState, warnings) {
     })) : [];
     const renderBoxOffset = asVec3(metadata.renderBoxOffset);
     meshes.push({
-      path: path5,
+      path: path6,
       modelId: asNumber(asset.modelId, 0),
       metadataHash,
       dataHash,
       bounds,
       motionList,
-      ...renderBoxOffset ? { renderBoxOffset } : {}
+      ...renderBoxOffset ? { renderBoxOffset } : {},
+      ...typeof metadata.hashType === "string" ? { hashType: metadata.hashType } : typeof asset.hashType === "string" ? { hashType: asset.hashType } : {}
     });
   });
   meshes.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -13338,6 +13601,19 @@ async function resolveWorldSeed(source, options = {}) {
   for (const [reason, count] of skipReasons) {
     warnings.push(`skipped ${count} entit${count === 1 ? "y" : "ies"}: ${reason}`);
   }
+  const seedInfo = [];
+  for (const raw of entities) {
+    if (!isRecord(raw)) continue;
+    const value = isRecord(raw.value) ? raw.value : void 0;
+    if (value === void 0) continue;
+    const rawId = raw.id;
+    const id = typeof rawId === "string" ? Number(rawId) : typeof rawId === "number" ? rawId : NaN;
+    if (!Number.isFinite(id) || id <= 0) continue;
+    const name = typeof value.name === "string" ? value.name : typeof raw.name === "string" ? raw.name : "";
+    const tags = Array.isArray(value.tags) ? value.tags.filter((tag) => typeof tag === "string") : [];
+    seedInfo.push({ id, name, tags });
+  }
+  seedInfo.sort((a, b) => a.id - b.id);
   const voxelsRef = await resolveRef(source, head.voxels);
   let voxels = null;
   if (isRecord(voxelsRef)) {
@@ -13370,6 +13646,15 @@ async function resolveWorldSeed(source, options = {}) {
     }
   }
   const render = await resolveRenderAssets(source, entities, stateRecord, warnings);
+  const scripts = await resolveScripts(source, head, warnings);
+  const audioRef = await resolveRef(source, head.audioAssets);
+  const audioAssets = [];
+  if (isRecord(audioRef)) {
+    for (const [path6, raw] of Object.entries(audioRef)) {
+      if (!isRecord(raw) || typeof raw.hash !== "string" || raw.hash.length === 0) continue;
+      audioAssets.push({ path: path6, hash: raw.hash });
+    }
+  }
   return {
     version: WORLD_SEED_VERSION,
     mapId: source.worldId,
@@ -13382,30 +13667,14 @@ async function resolveWorldSeed(source, options = {}) {
     bodies,
     voxels,
     render,
+    ...scripts !== void 0 ? { scripts } : {},
+    ...seedInfo.length > 0 ? { seedInfo } : {},
+    ...audioAssets.length > 0 ? { audioAssets } : {},
     entityCount: entities.length,
     warnings
   };
 }
 
-// src/core/maps/block-info.ts
-var BLOCK_INFO_HASH = "QmW2E9E8ipYUifsCfkMj5SULYMYbFQvP6BQxo52atXw7Zj";
-function decodeBlockInfo(bytes) {
-  try {
-    return BlockInfoSchema.patch(BlockInfoSchema.identity, new MuReadStream(bytes));
-  } catch {
-    return null;
-  }
-}
-async function readBlockInfoBytes(reader, worldId, hash = BLOCK_INFO_HASH) {
-  try {
-    const bytes = await reader.read(`worlds/${worldId}/data/blobs/${hash}`);
-    if (bytes === null || bytes.length === 0) return null;
-    return bytes;
-  } catch {
-    return null;
-  }
-}
-
 // src/core/maps/seed-pack.ts
 var SEED_PACK_VERSION = 1;
 var SEED_PACK_FORMAT = "cajonzero-seed";
@@ -13417,14 +13686,35 @@ function bytesToBase64(bytes) {
   }
   return btoa(binary);
 }
-function encodeSeedPack(seed, blockInfoBytes) {
-  const { blockInfo: _decodedPalette, ...jsonSeed } = seed;
+var SCRIPT_PACK_FORMAT = "cajonzero-scripts";
+var SCRIPT_PACK_VERSION = 1;
+function encodeScriptsPack(seed, slug) {
+  const scripts = seed.scripts;
+  if (scripts === void 0) throw new Error("seed has no scripts");
+  const document = {
+    format: SCRIPT_PACK_FORMAT,
+    version: SCRIPT_PACK_VERSION,
+    slug,
+    mapId: seed.mapId,
+    index: scripts.index,
+    modules: scripts.modules,
+    ...scripts.revision !== void 0 && scripts.revision.length > 0 ? { revision: scripts.revision } : {}
+  };
+  return new TextEncoder().encode(JSON.stringify(document));
+}
+function encodeSeedPack(seed, blockInfoBytes, options = {}) {
+  const {
+    blockInfo: _decodedPalette,
+    scripts: _privateScripts,
+    ...jsonSeed
+  } = seed;
   const document = {
     format: SEED_PACK_FORMAT,
     version: SEED_PACK_VERSION,
     mapId: seed.mapId,
     seed: {
       ...jsonSeed,
+      ...options.includeScripts === true && seed.scripts !== void 0 ? { scripts: seed.scripts } : {},
       voxels: seed.voxels === null || seed.voxels === void 0 ? null : {
         shape: seed.voxels.shape,
         chunkCount: seed.voxels.chunkCount,
@@ -13437,143 +13727,330 @@ function encodeSeedPack(seed, blockInfoBytes) {
   return new TextEncoder().encode(JSON.stringify(document));
 }
 
-// src/core/maps/http.ts
-var MapSourceError = class extends Error {
+// src/maps/import.ts
+var DEFAULT_MAPS_FILE = "cajonzero/maps.json";
+var DEFAULT_PUBLIC_DIR = "public";
+var DEFAULT_SCRIPTS_DIR = path4.join("cajonzero", "private");
+var MapImportError = class extends Error {
   code;
   constructor(code, message) {
     super(message);
-    this.name = "MapSourceError";
+    this.name = "MapImportError";
     this.code = code;
   }
 };
-var DEFAULT_TIMEOUT_MS = 15e3;
-var DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
-var DEFAULT_CONCURRENCY = 8;
-function fail2(code, message) {
-  throw new MapSourceError(code, message);
-}
-function describeError(error) {
-  return error instanceof Error ? error.message : String(error);
+function resolveOptions(options) {
+  const cwd = options.cwd ?? process.cwd();
+  return {
+    cwd,
+    mapsPath: path4.resolve(cwd, options.maps ?? DEFAULT_MAPS_FILE),
+    publicDir: path4.resolve(cwd, options.publicDir ?? DEFAULT_PUBLIC_DIR),
+    scriptsDir: path4.resolve(cwd, options.scriptsDir ?? DEFAULT_SCRIPTS_DIR),
+    gzip: options.gzip ?? true,
+    resetRoot: options.resetRoot ?? false
+  };
 }
-var HttpMapSource = class {
-  /** Normalized root URL. */
-  root;
-  fetchImpl;
-  timeoutMs;
-  maxBytes;
-  cache = /* @__PURE__ */ new Map();
-  inflight = /* @__PURE__ */ new Map();
-  constructor(root, options = {}) {
-    this.root = normalizeRootUrl(root);
-    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
-    this.timeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.maxBytes = options.maxDownloadBytes ?? DEFAULT_MAX_BYTES;
-  }
-  /** Read one archive-relative file; `null` when it does not exist (404). */
-  async read(relPath) {
-    const relative = assertRelativeMapPath(relPath);
-    if (this.cache.has(relative)) return this.cache.get(relative) ?? null;
-    let pending = this.inflight.get(relative);
-    if (pending === void 0) {
-      pending = this.fetchFile(relative);
-      this.inflight.set(relative, pending);
-    }
-    let bytes;
-    try {
-      bytes = await pending;
-    } finally {
-      this.inflight.delete(relative);
+function readMapCatalogFile(mapsPath) {
+  if (!existsSync(mapsPath)) return EMPTY_MAP_CATALOG;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(mapsPath, "utf8").replace(/^\uFEFF/, ""));
+  } catch (error) {
+    throw new MapImportError(
+      "INVALID_CATALOG",
+      `${mapsPath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    return parseMapCatalog(parsed);
+  } catch (error) {
+    if (error instanceof MapCatalogError) {
+      throw new MapImportError("INVALID_CATALOG", `${mapsPath}: ${error.message}`);
     }
-    this.cache.set(relative, bytes);
-    return bytes;
+    throw error;
   }
-  /** Read + parse a JSON file; `null` when absent or not JSON. */
-  async readJson(relPath) {
-    const bytes = await this.read(relPath);
-    if (bytes === null) return null;
+}
+function writeFileAtomic(filePath, data) {
+  mkdirSync(path4.dirname(filePath), { recursive: true });
+  const temp = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  writeFileSync(temp, data);
+  renameSync(temp, filePath);
+}
+function writeCatalog(mapsPath, catalog) {
+  const document = {
+    version: catalog.version,
+    maps: catalog.maps
+  };
+  writeFileAtomic(mapsPath, `${JSON.stringify(document, null, 2)}
+`);
+}
+function deriveMapSlug(archive, override) {
+  if (override !== void 0) {
     try {
-      return JSON.parse(new TextDecoder().decode(bytes));
+      return assertMapSlug(override);
     } catch {
-      return null;
+      throw new MapImportError("INVALID_SLUG", `invalid map slug "${override}"`);
     }
   }
-  async fetchFile(relPath) {
-    let url;
-    try {
-      url = mapFilePath(this.root, relPath);
-    } catch (error) {
-      fail2("MAP_INVALID_FILE", `${relPath}: ${describeError(error)}`);
-    }
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-    let response;
-    try {
-      response = await this.fetchImpl(url, {
-        method: "GET",
-        signal: controller.signal,
-        redirect: "follow",
-        headers: { accept: "application/octet-stream, application/json;q=0.9, */*;q=0.8" }
-      });
-    } catch (error) {
-      clearTimeout(timer);
-      const reason = controller.signal.aborted ? `timed out after ${this.timeoutMs}ms` : describeError(error);
-      fail2("MAP_FETCH_FAILED", `${relPath}: ${reason}`);
-    } finally {
-      clearTimeout(timer);
-    }
-    if (response.status === 404) return null;
-    if (!response.ok) {
-      fail2("MAP_FETCH_FAILED", `${relPath}: HTTP ${response.status}`);
-    }
-    const declared = Number(response.headers.get("content-length") ?? "");
-    if (Number.isFinite(declared) && declared > this.maxBytes) {
-      fail2("MAP_TOO_LARGE", `${relPath}: ${declared} bytes exceeds the ${this.maxBytes}-byte cap`);
-    }
-    const buffer = await response.arrayBuffer();
-    if (buffer.byteLength > this.maxBytes) {
-      fail2(
-        "MAP_TOO_LARGE",
-        `${relPath}: ${buffer.byteLength} bytes exceeds the ${this.maxBytes}-byte cap`
+  const world = archive.worlds[0];
+  const candidates = [
+    archive.bundle.permanentMapGroupId,
+    archive.bundle.mapGroupId,
+    world?.worldId
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string") continue;
+    const slug = toMapSlug(candidate);
+    if (slug.length > 0) return slug;
+  }
+  throw new MapImportError(
+    "INVALID_SLUG",
+    "cannot derive a slug from the archive; pass --slug <slug>"
+  );
+}
+function toMapSlug(raw) {
+  const slug = raw.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^[-_]+/, "").replace(/[-_]+$/, "").slice(0, 63);
+  return isMapSlug(slug) ? slug : "";
+}
+function mapPublicDir(publicDir, slug) {
+  return path4.join(publicDir, "maps", slug);
+}
+function seedPackName(gzip) {
+  return gzip ? "seed.json.gz" : "seed.json";
+}
+function scriptsPackPath(scriptsDir, slug, gzip) {
+  return path4.join(scriptsDir, `${slug}.json${gzip ? ".gz" : ""}`);
+}
+function publicRoot(slug) {
+  return `/maps/${slug}/`;
+}
+function readArchive(archivePath) {
+  if (!existsSync(archivePath) || !statSync(archivePath).isFile()) {
+    throw new MapImportError("ARCHIVE_NOT_FOUND", `archive not found: ${archivePath}`);
+  }
+  try {
+    return readBoxplayFile(archivePath);
+  } catch (error) {
+    throw new MapImportError(
+      "INVALID_ARCHIVE",
+      `cannot read ${path4.basename(archivePath)}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function importMap(action, archivePath, options, slugOverride) {
+  const resolved = resolveOptions(options);
+  const archive = readArchive(path4.resolve(resolved.cwd, archivePath));
+  const slug = deriveMapSlug(archive, slugOverride ?? options.slug);
+  const catalog = readMapCatalogFile(resolved.mapsPath);
+  const existing = findMap(catalog, slug);
+  const targetDir = mapPublicDir(resolved.publicDir, slug);
+  const targetExists = existsSync(targetDir);
+  if (action === "add") {
+    if (existing !== void 0 || targetExists) {
+      throw new MapImportError(
+        "SLUG_EXISTS",
+        `map "${slug}" already exists; use: cj0 update ${slug} <file.boxplay>`
       );
     }
-    return new Uint8Array(buffer);
+  } else if (existing === void 0) {
+    throw new MapImportError(
+      "MAP_NOT_FOUND",
+      `map "${slug}" is not in ${path4.relative(resolved.cwd, resolved.mapsPath)}; use: cj0 add <file.boxplay> --slug ${slug}`
+    );
   }
-};
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-async function resolveWorldId(source) {
-  const bundle = await source.readJson("bundle.json");
-  if (bundle === null) fail2("MAP_NO_WORLD", "bundle.json is missing or not JSON");
-  const members = Array.isArray(bundle.members) ? bundle.members : [];
-  const records = members.filter(isRecord2);
-  const main2 = records.find((member) => member.mapRole === "main") ?? records[0];
-  const candidate = (main2 !== void 0 && typeof main2.id === "string" ? main2.id : void 0) ?? (typeof bundle.mainProjectId === "string" ? bundle.mainProjectId : void 0);
-  if (candidate === void 0) {
-    fail2("MAP_NO_WORLD", "bundle.json does not name a world (no member id, no mainProjectId)");
-  }
-  return assertWorldId(candidate);
-}
-async function loadWorldSeedGraphFromHttp(entry, options = {}) {
-  const source = new HttpMapSource(entry.root, options);
-  const worldId = entry.worldId ?? await resolveWorldId(source);
-  const manifest = await source.readJson(
-    `worlds/${worldId}/manifest.json`
-  );
-  if (manifest === null) {
-    fail2("MAP_NO_WORLD", `worlds/${worldId}/manifest.json is missing or not JSON`);
+  const world = archive.worlds[0];
+  if (world === void 0) {
+    throw new MapImportError("INVALID_ARCHIVE", "archive contains no world");
+  }
+  const worldId = world.worldId;
+  const source = archiveToWorldSeedSource(archive);
+  let seed;
+  try {
+    seed = await resolveWorldSeed(source);
+  } catch (error) {
+    throw new MapImportError(
+      "INVALID_ARCHIVE",
+      `cannot resolve the map seed: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  const seed = await resolveWorldSeed(
-    { worldId, manifest, reader: source },
-    { concurrency: options.concurrency ?? DEFAULT_CONCURRENCY }
+  const blockInfoBytes = await readBlockInfoBytes(source.reader, seed.mapId) ?? void 0;
+  const scriptBlobs = new Set(
+    Object.values(seed.scripts?.modules ?? {}).map(
+      (module) => `worlds/${seed.mapId}/data/blobs/${module.hash}`
+    )
   );
-  const blockInfoBytes = await readBlockInfoBytes(source, worldId) ?? void 0;
-  const blockInfo = blockInfoBytes === void 0 ? null : decodeBlockInfo(blockInfoBytes);
+  const seedPack = encodeSeedPack(seed, blockInfoBytes);
+  const seedData = resolved.gzip ? gzipSync(seedPack, { level: 9 }) : seedPack;
+  const scriptPack = seed.scripts !== void 0 ? (() => {
+    seed.scripts.revision = versionOf(archive, existing) ?? "";
+    const packed = encodeScriptsPack(seed, slug);
+    return resolved.gzip ? gzipSync(packed, { level: 9 }) : packed;
+  })() : void 0;
+  const mapsDir = path4.join(resolved.publicDir, "maps");
+  mkdirSync(mapsDir, { recursive: true });
+  const tempDir = path4.join(mapsDir, `.tmp-${slug}-${process.pid}-${Date.now().toString(36)}`);
+  let files = 0;
+  let bytes = 0;
+  try {
+    mkdirSync(tempDir, { recursive: true });
+    for (const file of archive.files) {
+      if (scriptBlobs.has(file.path)) continue;
+      const destination = path4.join(tempDir, ...file.path.split("/"));
+      mkdirSync(path4.dirname(destination), { recursive: true });
+      writeFileSync(destination, file.data);
+      files += 1;
+      bytes += file.data.length;
+    }
+    const seedName = seedPackName(resolved.gzip);
+    writeFileSync(path4.join(tempDir, seedName), seedData);
+    files += 1;
+    bytes += seedData.length;
+    installPublicDir(tempDir, targetDir);
+  } catch (error) {
+    rmSync(tempDir, { recursive: true, force: true });
+    throw error;
+  }
+  const scriptsPath = scriptsPackPath(resolved.scriptsDir, slug, resolved.gzip);
+  if (scriptPack !== void 0) {
+    writeFileAtomic(scriptsPath, scriptPack);
+    rmSync(scriptsPackPath(resolved.scriptsDir, slug, !resolved.gzip), { force: true });
+  } else {
+    rmSync(scriptsPackPath(resolved.scriptsDir, slug, true), { force: true });
+    rmSync(scriptsPackPath(resolved.scriptsDir, slug, false), { force: true });
+  }
+  const name = seed.projectName ?? existing?.name;
+  const author = seed.author ?? existing?.author;
+  const version = versionOf(archive, existing);
+  const root = action === "update" && !resolved.resetRoot && existing !== void 0 ? existing.root : publicRoot(slug);
+  const entry = {
+    slug,
+    root,
+    worldId,
+    ...name !== void 0 ? { name } : {},
+    ...author !== void 0 ? { author } : {},
+    ...version !== void 0 ? { version } : {},
+    ...action === "update" && !resolved.resetRoot && existing?.assetRoot !== void 0 ? { assetRoot: existing.assetRoot } : {},
+    ...action === "update" && !resolved.resetRoot && existing?.cover !== void 0 ? { cover: existing.cover } : {},
+    ...scriptPack !== void 0 ? { scriptsFile: projectRelative(resolved.cwd, scriptsPath) } : {}
+  };
+  const maps = [...catalog.maps.filter((map) => map.slug !== slug), entry];
+  writeCatalog(resolved.mapsPath, { version: catalog.version, maps });
+  return {
+    action,
+    slug,
+    root,
+    worldId,
+    mapId: seed.mapId,
+    ...name !== void 0 ? { name } : {},
+    ...version !== void 0 ? { version } : {},
+    publicDir: targetDir,
+    seedPack: path4.join(targetDir, seedPackName(resolved.gzip)),
+    ...scriptPack !== void 0 ? {
+      scriptsPack: scriptsPath,
+      scriptsFile: projectRelative(resolved.cwd, scriptsPath)
+    } : {},
+    files,
+    bytes,
+    seedPackBytes: seedData.length,
+    scriptModules: Object.keys(seed.scripts?.modules ?? {}).length,
+    warnings: seed.warnings
+  };
+}
+function projectRelative(cwd, dir) {
+  return path4.relative(cwd, dir).split(path4.sep).join("/") || ".";
+}
+function defaultScriptPackFile(entry, scriptsDir) {
+  const gz = scriptsPackPath(scriptsDir, entry.slug, true);
+  return existsSync(gz) ? gz : scriptsPackPath(scriptsDir, entry.slug, false);
+}
+function mapScriptsFile(entry, options = {}) {
+  const resolved = resolveOptions(options);
+  return entry.scriptsFile !== void 0 ? path4.resolve(resolved.cwd, entry.scriptsFile) : defaultScriptPackFile(entry, resolved.scriptsDir);
+}
+function listScriptPackLocations(options = {}) {
+  return readMapCatalogFile(resolveOptions(options).mapsPath).maps.flatMap((entry) => {
+    const file = mapScriptsFile(entry, options);
+    return existsSync(file) ? [{ slug: entry.slug, file }] : [];
+  });
+}
+function versionOf(archive, existing) {
+  const value = archive.bundle.version;
+  if (typeof value === "string" && value.length > 0) return value;
+  return existing?.version;
+}
+function installPublicDir(tempDir, targetDir) {
+  const backup = `${targetDir}.bak-${process.pid}-${Date.now().toString(36)}`;
+  const hadTarget = existsSync(targetDir);
+  if (hadTarget) renameSync(targetDir, backup);
+  try {
+    renameSync(tempDir, targetDir);
+    if (hadTarget) rmSync(backup, { recursive: true, force: true });
+  } catch (error) {
+    rmSync(targetDir, { recursive: true, force: true });
+    if (hadTarget && existsSync(backup)) renameSync(backup, targetDir);
+    throw error;
+  }
+}
+function addMap(archivePath, options = {}) {
+  return importMap("add", archivePath, options);
+}
+function updateMap(slug, archivePath, options = {}) {
+  return importMap("update", archivePath, options, slug);
+}
+function listMaps(options = {}) {
+  const resolved = resolveOptions(options);
+  const catalog = readMapCatalogFile(resolved.mapsPath);
+  return catalog.maps.map((entry) => {
+    const dir = mapPublicDir(resolved.publicDir, entry.slug);
+    const imported = existsSync(dir);
+    const seeded = existsSync(path4.join(dir, seedPackName(true))) || existsSync(path4.join(dir, seedPackName(false)));
+    const hasScripts = existsSync(mapScriptsFile(entry, options));
+    return {
+      slug: entry.slug,
+      root: entry.root,
+      ...entry.worldId !== void 0 ? { worldId: entry.worldId } : {},
+      ...entry.name !== void 0 ? { name: entry.name } : {},
+      ...entry.version !== void 0 ? { version: entry.version } : {},
+      imported,
+      seeded,
+      hasScripts
+    };
+  });
+}
+function removeMap(slug, options = {}) {
+  const resolved = resolveOptions(options);
+  const catalog = readMapCatalogFile(resolved.mapsPath);
+  const existing = findMap(catalog, slug);
+  if (existing === void 0) {
+    throw new MapImportError("MAP_NOT_FOUND", `map "${slug}" is not in the catalog`);
+  }
+  const dir = mapPublicDir(resolved.publicDir, slug);
+  const removedDir = existsSync(dir) ? dir : void 0;
+  rmSync(dir, { recursive: true, force: true });
+  const removedScripts = [];
+  const scriptFiles = /* @__PURE__ */ new Set([
+    mapScriptsFile(existing, options),
+    scriptsPackPath(resolved.scriptsDir, slug, true),
+    scriptsPackPath(resolved.scriptsDir, slug, false)
+  ]);
+  for (const file of scriptFiles) {
+    if (!existsSync(file)) continue;
+    rmSync(file, { force: true });
+    removedScripts.push(file);
+  }
+  const maps = catalog.maps.filter((map) => map.slug !== slug);
+  writeCatalog(resolved.mapsPath, { version: catalog.version, maps });
   return {
-    seed: blockInfo === null ? seed : { ...seed, blockInfo },
-    ...blockInfoBytes !== void 0 ? { blockInfoBytes } : {}
+    slug,
+    ...removedDir !== void 0 ? { removedDir } : {},
+    removedScripts
   };
 }
+function readScriptsPackText(file) {
+  if (!existsSync(file)) return void 0;
+  const raw = readFileSync(file);
+  return file.endsWith(".gz") ? gunzipSync(raw).toString("utf8") : raw.toString("utf8");
+}
 
 // src/scaffold/templates.ts
 var SCAFFOLD_ENTRY_PATH = "src/index.ts";
@@ -13643,7 +14120,7 @@ var SCAFFOLD_CONFIG_CONTENT = `${JSON.stringify(
 `;
 var SCAFFOLD_MAPS_CONTENT = `${JSON.stringify({ version: 1, maps: [] }, null, 2)}
 `;
-var PREPARE_ASSETS = "cj0 worker prepare";
+var SCAFFOLD_PUBLIC_KEEP_PATH = "public/.gitkeep";
 function packageJson(options) {
   const manifest = {
     name: options.packageName,
@@ -13651,14 +14128,12 @@ function packageJson(options) {
     private: true,
     type: "module",
     scripts: {
-      dev: `${PREPARE_ASSETS} && wrangler dev`,
-      build: `${PREPARE_ASSETS} && cj0 worker build-seed && wrangler deploy --dry-run`,
-      // Deploy always rebuilds: map content can change without `version` being
-      // bumped, and the room prefers the pack over the live CDN graph.
-      deploy: `${PREPARE_ASSETS} && cj0 worker build-seed --force && wrangler deploy`,
-      // `prepare` also runs after `npm install`, so a plain install leaves a
-      // ready-to-deploy project. Seed packs are network work and stay out of it.
-      prepare: PREPARE_ASSETS
+      dev: "wrangler dev",
+      // `cj0 deploy` syncs the packaged UI, uploads the private map-script
+      // packs, then runs `wrangler deploy` — one command, no build chain.
+      deploy: "cj0 deploy",
+      sync: "cj0 sync",
+      maps: "cj0 list"
     },
     dependencies: {
       cajonzero: options.cajonzeroRange,
@@ -13683,11 +14158,16 @@ function wranglerConfig(options) {
     `  "compatibility_date": ${JSON.stringify(options.compatibilityDate)},`,
     "  // Deliberately NO `nodejs_compat`: cajonzero's worker path is Node-free.",
     '  "compatibility_flags": [],',
-    "  // Static UI (play lobby + owner admin console) served by the worker.",
-    "  // cajonzero ships the built assets into this directory.",
+    "  // QuickJS is a build-time-compiled WASM module; workerd forbids runtime",
+    "  // WebAssembly codegen. Keep this rule when editing the config.",
+    '  "rules": [',
+    '    { "type": "CompiledWasm", "globs": ["**/*.wasm"], "fallthrough": true }',
+    "  ],",
+    "  // Static UI + imported maps (play lobby + owner admin console).",
+    "  // `cj0 sync` writes the packaged UI here; `cj0 add` writes public/maps/.",
     '  "assets": {',
-    '    "directory": "dist/ui",',
-    "    // Binding so the room can read seed packs bundled at deploy time.",
+    '    "directory": "public",',
+    "    // Binding so the room can read imported maps + seed packs at runtime.",
     '    "binding": "ASSETS",',
     "    // History routing: deep links (/play/x, /admin/bans) boot index.html.",
     '    "not_found_handling": "single-page-application",',
@@ -13774,24 +14254,25 @@ function readme(options) {
     "",
     "## \u5730\u56FE",
     "",
-    "\u5730\u56FE\u4E0D\u968F worker \u4E0A\u4F20\u3002\u628A\u89E3\u5305\u540E\u7684 `.boxplay` \u76EE\u5F55\u4F20\u5230 OSS/S3/CDN\uFF08\u9700\u5141\u8BB8 CORS\uFF09\uFF0C",
-    "\u518D\u5728 `cajonzero/maps.json` \u767B\u8BB0\uFF1A",
+    "\u5730\u56FE\u5728\u672C\u5730\u5BFC\u5165\uFF0C\u968F worker \u4E00\u6B21\u90E8\u7F72\uFF08\u9759\u6001\u8D44\u6E90 `public/`\uFF09\uFF1A",
     "",
-    "```json",
-    "{",
-    '  "version": 1,',
-    '  "maps": [',
-    "    {",
-    '      "slug": "omega",',
-    '      "root": "https://cdn.example.com/cajonzero/omega/",',
-    '      "worldId": "project-omega",',
-    '      "name": "Omega City Reloaded"',
-    "    }",
-    "  ]",
-    "}",
+    "```bash",
+    "npx cj0 add ./race.boxplay                 # \u89E3\u5305\u5230 public/maps/race/ \u5E76\u751F\u6210 seed",
+    "npx cj0 update race ./race-v2.boxplay      # \u8986\u76D6\u5DF2\u6709 slug",
+    "npx cj0 list                               # \u67E5\u770B catalog + \u672C\u5730\u5BFC\u5165\u72B6\u6001",
+    "npx cj0 remove race                        # \u5220\u9664\u5730\u56FE\u3001\u79C1\u6709\u811A\u672C\u4E0E catalog \u6761\u76EE",
     "```",
     "",
-    "`root` \u5FC5\u987B\u4EE5 `/` \u7ED3\u5C3E\uFF1B\u66F4\u65B0\u5730\u56FE\u540E\u5237\u65B0 CDN \u7F13\u5B58\u6216\u6362\u8DEF\u5F84\u3002",
+    "`add/update` \u4F1A\uFF1A",
+    "",
+    "1. \u628A\u516C\u5F00\u5730\u56FE\u8D44\u6E90\u89E3\u5305\u5230 `public/maps/<slug>/`\uFF1B",
+    "2. \u5728\u672C\u5730\u89E3\u6790\u4E16\u754C\u56FE\u5E76\u5199\u5165 `public/maps/<slug>/seed.json.gz`\uFF1B",
+    "3. \u628A**\u670D\u52A1\u7AEF\u811A\u672C**\u5199\u5230 `cajonzero/private/<slug>.json.gz`\uFF0C\u4E0D\u8FDB\u5165 `public/`\uFF1B",
+    '4. \u5728 `cajonzero/maps.json` \u5199\u5165 `"root": "/maps/<slug>/"`\uFF0C\u5E76\u628A\u670D\u52A1\u7AEF\u811A\u672C\u6587\u4EF6\u8BB0\u5F55\u4E3A',
+    '   `"scriptsFile": "cajonzero/private/<slug>.json.gz"`\uFF08\u8BE5\u76EE\u5F55\u4F1A\u63D0\u4EA4\uFF0CCF \u6784\u5EFA\u65F6 `cj0 deploy` \u53EF\u4E0A\u4F20\uFF09\u3002',
+    "",
+    "\u9700\u8981\u72EC\u7ACB CDN \u65F6\uFF0C\u624B\u52A8\u628A\u8BE5\u6761\u76EE\u7684 `root` \u6539\u6210 `https://cdn.example.com/.../` \u5373\u53EF\uFF1B",
+    "`cj0 update` \u9ED8\u8BA4\u4FDD\u7559\u4F60\u6539\u8FC7\u7684 `root`\uFF08`--reset-root` \u53EF\u6062\u590D\uFF09\u3002",
     "",
     "## \u90E8\u7F72",
     "",
@@ -13799,6 +14280,9 @@ function readme(options) {
     "npm run deploy",
     "```",
     "",
+    "`cj0 deploy` \u4F1A\u540C\u6B65\u6253\u5305\u7684 UI \u5230 `public/`\u3001\u4E0A\u4F20\u79C1\u6709\u811A\u672C\uFF0C\u7136\u540E\u6267\u884C",
+    "`wrangler deploy`\u3002\u9996\u6B21\u90E8\u7F72\u524D\u5148\u8FD0\u884C `npx cj0 setup`\u3002",
+    "",
     "\u5927\u5385\u5728 `/`\uFF0C\u7BA1\u7406\u540E\u53F0\u5728 `/admin`\u3002",
     ""
   ].join("\n");
@@ -13813,6 +14297,7 @@ function buildScaffoldFiles(options) {
       content: SCAFFOLD_CONFIG_CONTENT.replace("<project-name>", options.packageName)
     },
     { path: "cajonzero/maps.json", content: SCAFFOLD_MAPS_CONTENT },
+    { path: SCAFFOLD_PUBLIC_KEEP_PATH, content: "" },
     { path: ".gitignore", content: gitignore() },
     { path: "README.md", content: readme(options) }
   ];
@@ -14254,7 +14739,8 @@ function applySetup(options) {
   return { configPath, devVarsPath, vars, secrets, ...kvId !== void 0 ? { kvId } : {} };
 }
 var ASSETS_STAMP_FILE = ".cajonzero-assets.json";
-var ASSETS_SEED_DIR = "seed";
+var ASSETS_MAPS_DIR = "maps";
+var ASSETS_KEEP_FILE = ".gitkeep";
 var DEFAULT_CONFIG = "wrangler.jsonc";
 function resolvePackageRoot() {
   try {
@@ -14334,7 +14820,7 @@ function assertSafeTarget(targetDir, sourceDir, configDir) {
     throw new Error(`assets \u76EE\u5F55\u4E0D\u80FD\u5305\u542B\u9879\u76EE\u914D\u7F6E/cajonzero \u8D44\u6E90\u76EE\u5F55\uFF1A${targetDir}`);
   }
 }
-async function prepareWorkerAssets(options = {}) {
+async function syncPublicAssets(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const configPath = path4.resolve(cwd, options.configPath ?? DEFAULT_CONFIG);
   const configDir = path4.dirname(configPath);
@@ -14365,17 +14851,25 @@ async function prepareWorkerAssets(options = {}) {
       bytes: source.bytes
     };
   }
-  const seedDir = path4.join(targetDir, ASSETS_SEED_DIR);
-  const seedBackup = `${targetDir}.${ASSETS_SEED_DIR}-backup`;
-  if (!existsSync(seedDir) && existsSync(seedBackup)) {
-    mkdirSync(path4.dirname(seedDir), { recursive: true });
-    renameSync(seedBackup, seedDir);
-  }
-  let hasSeed = false;
-  if (existsSync(seedDir)) {
-    rmSync(seedBackup, { recursive: true, force: true });
-    renameSync(seedDir, seedBackup);
-    hasSeed = true;
+  const mapsDir = path4.join(targetDir, ASSETS_MAPS_DIR);
+  const mapsBackup = path4.join(configDir, `.cajonzero-maps-backup-${process.pid}`);
+  const keepFile = path4.join(targetDir, ASSETS_KEEP_FILE);
+  const keepBackup = path4.join(configDir, `.cajonzero-keep-backup-${process.pid}`);
+  if (!existsSync(mapsDir) && existsSync(mapsBackup)) {
+    mkdirSync(path4.dirname(mapsDir), { recursive: true });
+    renameSync(mapsBackup, mapsDir);
+  }
+  let hasMaps = false;
+  if (existsSync(mapsDir)) {
+    rmSync(mapsBackup, { recursive: true, force: true });
+    renameSync(mapsDir, mapsBackup);
+    hasMaps = true;
+  }
+  let hasKeep = false;
+  if (existsSync(keepFile)) {
+    rmSync(keepBackup, { force: true });
+    renameSync(keepFile, keepBackup);
+    hasKeep = true;
   }
   try {
     rmSync(targetDir, { recursive: true, force: true });
@@ -14386,10 +14880,15 @@ async function prepareWorkerAssets(options = {}) {
       filter: (from) => path4.basename(from) !== ASSETS_STAMP_FILE
     });
   } finally {
-    if (hasSeed && existsSync(seedBackup)) {
+    if (hasMaps && existsSync(mapsBackup)) {
+      mkdirSync(targetDir, { recursive: true });
+      rmSync(mapsDir, { recursive: true, force: true });
+      renameSync(mapsBackup, mapsDir);
+    }
+    if (hasKeep && existsSync(keepBackup)) {
       mkdirSync(targetDir, { recursive: true });
-      rmSync(seedDir, { recursive: true, force: true });
-      renameSync(seedBackup, seedDir);
+      rmSync(keepFile, { force: true });
+      renameSync(keepBackup, keepFile);
     }
   }
   const next = {
@@ -14416,41 +14915,37 @@ Usage:
   cj0 <command> [options]
 
 Commands:
-  create <folder>                         Scaffold a deployable project
-  setup [--config <file>]                 Configure ENV values + KV namespace
-  serve [--port <port>] [--host <host>]   Run the cajonzero server locally (workerd)
-  worker prepare [--config <file>]        Sync the packaged UI into assets.directory
-  maps pack <slug>                        Precompute a seed pack (1 request/room)
-  worker build-seed [slug...]             Build seed packs into worker assets
-
-Worker prepare options:
-  --config <file>  Wrangler config (default: wrangler.jsonc; JSON/JSONC)
-  --assets <dir>   Override assets.directory (relative to the config file)
-  --force          Re-copy even when the fingerprint already matches
-  -h, --help       Show this help
+  create <folder>                          Scaffold a deployable project
+  setup [--config <file>]                  Configure ENV values + KV namespace
+  add <file.boxplay> [--slug <slug>]       Import a map (public/maps + seed)
+  update <slug> <file.boxplay>             Replace an existing map
+  list [--json]                            Show the map catalog
+  remove <slug>                            Delete a map from the catalog
+  sync [--config <file>]                   Copy the packaged UI into public/
+  deploy [--config <file>]                 Sync UI, upload scripts, wrangler deploy
+  serve [--port <port>] [--host <host>]    Run the cajonzero server locally (workerd)
 
-Worker build-seed options:
-  --config <file>  Wrangler config (default: wrangler.jsonc)
-  --maps <file>    Catalog to read (default: cajonzero/maps.json)
-  --assets <dir>   Override assets.directory (default: from the config)
-  --force          Rebuild even when the pack is up to date
-  --no-gzip        Write plain JSON (lower CPU, larger asset)
-  -h, --help       Show this help
+Map options (add/update/list/remove):
+  --maps <file>       Catalog path (default: cajonzero/maps.json)
+  --public <dir>      Static-asset dir (default: public)
+  --scripts <dir>     Private scripts dir (default: cajonzero/private)
+  --slug <slug>       Override the slug (add only)
+  --no-gzip           Write plain JSON instead of gzip packs
+  --reset-root        update: reset a custom root back to /maps/<slug>/
+  --json              Machine-readable summary (add/update/list/remove)
+  -h, --help          Show this help
 
-Maps pack options:
-  --maps <file>    Catalog to read (default: cajonzero/maps.json)
-  --out <file>     Output path (default: <slug>.seed.json[.gz])
-  --no-gzip        Write plain JSON instead of gzip (lower CPU, larger file)
-  -h, --help       Show this help
+Sync/deploy options:
+  --config <file>     Wrangler config (default: wrangler.jsonc)
+  --no-ui             deploy: do not copy the packaged UI
+  --no-scripts        deploy: do not upload private map scripts
+  -h, --help          Show this help
 
 Serve options:
-  --port <port>    Listener port (default: 8787)
-  --host <host>    Listener host (default: 127.0.0.1)
-  --config <file>  Wrangler config (default: wrangler.jsonc)
-  -h, --help       Show this help
-
-Maps: unpack the .boxplay, upload the directory to OSS/CDN, and list its root
-in cajonzero/maps.json. The CLI does not import map archives.
+  --port <port>       Listener port (default: 8787)
+  --host <host>       Listener host (default: 127.0.0.1)
+  --config <file>     Wrangler config (default: wrangler.jsonc)
+  -h, --help          Show this help
 `;
 var DEFAULT_SERVE_PORT = 8787;
 var DEFAULT_SERVE_HOST = "127.0.0.1";
@@ -14466,33 +14961,389 @@ function localDevVars() {
   }
   return Object.keys(vars).length > 0 ? vars : void 0;
 }
-function printUsage() {
-  process.stdout.write(USAGE);
+function printUsage() {
+  process.stdout.write(USAGE);
+}
+function fail3(message) {
+  process.stderr.write(`cajonzero: ${message}
+`);
+  process.exitCode = 1;
+}
+function errorLabel(error) {
+  if (error instanceof ScaffoldError) {
+    return `${error.code}: ${error.message}`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function readFlagValue(args, index, flag) {
+  const inline = args[index];
+  if (inline !== void 0 && inline.startsWith(`${flag}=`)) {
+    return inline.slice(flag.length + 1);
+  }
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("-")) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+async function runCreate(args) {
+  const [folder] = args;
+  if (folder === void 0) {
+    fail3("create requires: cj0 create <folder>");
+    return;
+  }
+  const result = createProject(folder);
+  process.stdout.write(
+    `created project in ${result.target} (${result.files.length} files)
+  ${result.files.join(", ")}
+`
+  );
+  try {
+    const sync = await syncPublicAssets({ cwd: result.target });
+    process.stdout.write(
+      `  UI: ${sync.files} assets (${formatBytes(sync.bytes)}) -> ${path4.relative(
+        result.target,
+        sync.targetDir
+      ) || "."}
+`
+    );
+  } catch (error) {
+    process.stdout.write(
+      `  UI: \u672A\u540C\u6B65\uFF08${error instanceof Error ? error.message : String(error)}\uFF09\uFF1B\u7A0D\u540E\u8FD0\u884C cj0 sync
+`
+    );
+  }
+  process.stdout.write(
+    `  next: cd ${folder} && npm install && npx cj0 setup && npm run dev
+`
+  );
+}
+function parseSyncFlags(args, allowDeployFlags) {
+  let config = DEFAULT_CONFIG2;
+  let noUi = false;
+  let noScripts = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--config" || arg.startsWith("--config=")) {
+      config = readFlagValue(args, i, "--config");
+      if (!arg.includes("=")) i += 1;
+    } else if (allowDeployFlags && arg === "--no-ui") {
+      noUi = true;
+    } else if (allowDeployFlags && arg === "--no-scripts") {
+      noScripts = true;
+    } else {
+      throw new Error(`unexpected ${allowDeployFlags ? "deploy" : "sync"} option "${arg}"`);
+    }
+  }
+  return { config, noUi, noScripts };
+}
+async function runSync(args) {
+  const flags = parseSyncFlags(args, false);
+  const result = await syncPublicAssets({ configPath: flags.config });
+  const target = path4.relative(process.cwd(), result.targetDir) || ".";
+  process.stdout.write(
+    `${result.copied ? "synced" : "up to date"}: ${result.files} assets, ${formatBytes(result.bytes)} -> ${target}
+`
+  );
+}
+function parseMapFlags(args, command) {
+  let maps = DEFAULT_MAPS_FILE;
+  let publicDir = DEFAULT_PUBLIC_DIR;
+  let scriptsDir = DEFAULT_SCRIPTS_DIR;
+  let slug;
+  let gzip = true;
+  let resetRoot = false;
+  let json = false;
+  const positional = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--maps" || arg.startsWith("--maps=")) {
+      maps = readFlagValue(args, i, "--maps");
+      if (!arg.includes("=")) i += 1;
+    } else if (arg === "--public" || arg.startsWith("--public=")) {
+      publicDir = readFlagValue(args, i, "--public");
+      if (!arg.includes("=")) i += 1;
+    } else if (arg === "--scripts" || arg.startsWith("--scripts=")) {
+      scriptsDir = readFlagValue(args, i, "--scripts");
+      if (!arg.includes("=")) i += 1;
+    } else if (arg === "--slug" || arg.startsWith("--slug=")) {
+      slug = readFlagValue(args, i, "--slug");
+      if (!arg.includes("=")) i += 1;
+    } else if (arg === "--no-gzip") {
+      gzip = false;
+    } else if (arg === "--reset-root") {
+      resetRoot = true;
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`unexpected ${command} option "${arg}"`);
+    } else {
+      positional.push(arg);
+    }
+  }
+  return {
+    maps,
+    publicDir,
+    scriptsDir,
+    ...slug !== void 0 ? { slug } : {},
+    gzip,
+    resetRoot,
+    json,
+    positional
+  };
+}
+function mapOptions(flags) {
+  return {
+    maps: flags.maps,
+    publicDir: flags.publicDir,
+    scriptsDir: flags.scriptsDir,
+    ...flags.slug !== void 0 ? { slug: flags.slug } : {},
+    gzip: flags.gzip,
+    resetRoot: flags.resetRoot
+  };
+}
+function printImportResult(result) {
+  process.stdout.write(
+    `${result.action === "add" ? "added" : "updated"} "${result.slug}" (${result.worldId}) -> ${result.root}
+  map: ${result.files} files, ${formatBytes(result.bytes)} (seed ${formatBytes(result.seedPackBytes)})
+  seed: ${path4.relative(process.cwd(), result.seedPack)}
+`
+  );
+  if (result.scriptsPack !== void 0) {
+    process.stdout.write(
+      `  scripts: ${result.scriptModules} modules -> ${path4.relative(
+        process.cwd(),
+        result.scriptsPack
+      )}
+`
+    );
+  }
+  for (const warning of result.warnings) process.stdout.write(`  warning: ${warning}
+`);
+}
+async function runAdd(args) {
+  const flags = parseMapFlags(args, "add");
+  const archive = flags.positional[0];
+  if (archive === void 0) {
+    throw new Error("add requires: cj0 add <file.boxplay> [--slug <slug>]");
+  }
+  if (flags.positional.length > 1) {
+    throw new Error(`unexpected argument "${flags.positional[1]}"`);
+  }
+  const result = await addMap(archive, mapOptions(flags));
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  printImportResult(result);
+}
+async function runUpdate(args) {
+  const flags = parseMapFlags(args, "update");
+  const [slug, archive] = flags.positional;
+  if (slug === void 0 || archive === void 0) {
+    throw new Error("update requires: cj0 update <slug> <file.boxplay>");
+  }
+  if (flags.positional.length > 2) {
+    throw new Error(`unexpected argument "${flags.positional[2]}"`);
+  }
+  const result = await updateMap(slug, archive, mapOptions(flags));
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  printImportResult(result);
+}
+function runList(args) {
+  const flags = parseMapFlags(args, "list");
+  if (flags.positional.length > 0) {
+    throw new Error(`unexpected argument "${flags.positional[0]}"`);
+  }
+  const entries = listMaps({
+    maps: flags.maps,
+    publicDir: flags.publicDir,
+    scriptsDir: flags.scriptsDir
+  });
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify(entries, null, 2)}
+`);
+    return;
+  }
+  if (entries.length === 0) {
+    process.stdout.write("no maps; import one with: cj0 add <file.boxplay>\n");
+    return;
+  }
+  for (const entry of entries) {
+    const state = [
+      entry.imported ? "imported" : "catalog-only",
+      entry.seeded ? "seeded" : "no-seed",
+      entry.hasScripts ? "scripts" : "no-scripts"
+    ].join(", ");
+    process.stdout.write(
+      `${entry.slug.padEnd(16)} ${entry.root}
+  ${entry.name ?? "(unnamed)"}${entry.version !== void 0 ? ` v${entry.version}` : ""}  [${state}]
+`
+    );
+  }
 }
-function fail3(message) {
-  process.stderr.write(`cajonzero: ${message}
+function runRemove(args) {
+  const flags = parseMapFlags(args, "remove");
+  const slug = flags.positional[0];
+  if (slug === void 0) {
+    throw new Error("remove requires: cj0 remove <slug>");
+  }
+  if (flags.positional.length > 1) {
+    throw new Error(`unexpected argument "${flags.positional[1]}"`);
+  }
+  const result = removeMap(slug, {
+    maps: flags.maps,
+    publicDir: flags.publicDir,
+    scriptsDir: flags.scriptsDir
+  });
+  if (flags.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
-  process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`removed "${result.slug}"
+`);
+  if (result.removedDir !== void 0) {
+    process.stdout.write(`  dir: ${path4.relative(process.cwd(), result.removedDir)}
+`);
+  }
+  for (const file of result.removedScripts) {
+    process.stdout.write(`  scripts: ${path4.relative(process.cwd(), file)}
+`);
+  }
 }
-function errorLabel(error) {
-  if (error instanceof ScaffoldError) {
-    return `${error.code}: ${error.message}`;
+function resolveWranglerBin() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packagePath = require2.resolve("wrangler/package.json");
+    const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["wrangler"];
+    return bin !== void 0 ? path4.resolve(path4.dirname(packagePath), bin) : void 0;
+  } catch {
+    return void 0;
   }
-  return error instanceof Error ? error.message : String(error);
 }
-function runCreate(args) {
-  const [folder] = args;
-  if (folder === void 0) {
-    fail3("create requires: cj0 create <folder>");
-    return;
+function scriptsKvBinding(configPath) {
+  if (!existsSync(configPath)) return void 0;
+  const parsed = parseJsoncObject(readFileSync(configPath, "utf8"));
+  const namespaces = Array.isArray(parsed["kv_namespaces"]) ? parsed["kv_namespaces"] : [];
+  const bindings = namespaces.map(
+    (entry) => typeof entry === "object" && entry !== null ? entry["binding"] : void 0
+  ).filter((binding) => typeof binding === "string");
+  return bindings.includes("CAJONZERO_SCRIPTS") ? "CAJONZERO_SCRIPTS" : bindings.includes("CAJONZERO_KV") ? "CAJONZERO_KV" : void 0;
+}
+function uploadScriptPacks(cwd, configPath, locations, binding, target) {
+  const wrangler = resolveWranglerBin();
+  if (wrangler === void 0) {
+    throw new Error("wrangler is not installed; cannot upload map scripts");
+  }
+  if (locations.length === 0) return 0;
+  const temp = mkdtempSync(path4.join(tmpdir(), "cajonzero-scripts-"));
+  let uploaded = 0;
+  try {
+    for (const { slug, file: source } of locations) {
+      const text = readScriptsPackText(source);
+      if (text === void 0) continue;
+      const parsed = JSON.parse(text);
+      const revision = typeof parsed.revision === "string" && parsed.revision.length > 0 ? parsed.revision : void 0;
+      const file = path4.join(temp, `${slug}.json`);
+      writeFileSync(file, text, "utf8");
+      const keys = [
+        ...revision !== void 0 ? [`scripts:${slug}:${revision}`] : [],
+        `scripts:${slug}`
+      ];
+      for (const key of keys) {
+        const args = [
+          wrangler,
+          "kv",
+          "key",
+          "put",
+          key,
+          "--binding",
+          binding,
+          "--path",
+          file,
+          "--config",
+          configPath
+        ];
+        if (target.remote) {
+          args.push("--remote");
+        } else {
+          args.push("--local");
+          if (target.persistTo !== void 0) args.push("--persist-to", target.persistTo);
+        }
+        const result = spawnSync(process.execPath, args, { cwd, stdio: "inherit" });
+        if (result.error !== void 0 || result.status !== 0) {
+          throw new Error(`failed to upload ${key}`);
+        }
+        uploaded += 1;
+      }
+    }
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
   }
-  const result = createProject(folder);
-  process.stdout.write(
-    `created project in ${result.target} (${result.files.length} files)
-  ${result.files.join(", ")}
-  next: cd ${folder} && npm install && npx cj0 setup && npm run dev
+  return uploaded;
+}
+async function runDeploy(args) {
+  const flags = parseSyncFlags(args, true);
+  const cwd = process.cwd();
+  const configPath = path4.resolve(cwd, flags.config);
+  if (!flags.noUi) {
+    try {
+      const sync = await syncPublicAssets({ cwd, configPath: flags.config });
+      process.stdout.write(
+        `UI ${sync.copied ? "synced" : "up to date"}: ${sync.files} assets
+`
+      );
+    } catch (error) {
+      throw new Error(
+        `cannot sync the packaged UI: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (!flags.noScripts) {
+    const binding = scriptsKvBinding(configPath);
+    const locations = listScriptPackLocations({ cwd, scriptsDir: DEFAULT_SCRIPTS_DIR });
+    if (binding !== void 0) {
+      const uploaded = uploadScriptPacks(cwd, configPath, locations, binding, {
+        remote: true
+      });
+      if (uploaded > 0) {
+        process.stdout.write(`map scripts: ${uploaded} KV key(s) -> ${binding}
+`);
+      }
+    } else if (locations.length > 0) {
+      process.stdout.write(
+        `map scripts: no CAJONZERO_SCRIPTS/CAJONZERO_KV binding in ${flags.config}; skipping upload
 `
+      );
+    }
+  }
+  const wrangler = resolveWranglerBin();
+  if (wrangler === void 0) {
+    throw new Error("wrangler is not installed; run npm install first");
+  }
+  const result = spawnSync(
+    process.execPath,
+    [wrangler, "deploy", "--config", flags.config],
+    { cwd, stdio: "inherit" }
   );
+  if (result.error !== void 0) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`wrangler deploy exited with status ${result.status ?? "unknown"}`);
+  }
 }
 function parseSetupFlags(args) {
   let config = DEFAULT_CONFIG2;
@@ -14508,17 +15359,6 @@ function parseSetupFlags(args) {
   }
   return { config };
 }
-function resolveWranglerBin() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const packagePath = require2.resolve("wrangler/package.json");
-    const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
-    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.["wrangler"];
-    return bin !== void 0 ? path4.resolve(path4.dirname(packagePath), bin) : void 0;
-  } catch {
-    return void 0;
-  }
-}
 function createKvNamespace(cwd, configPath) {
   const bin = resolveWranglerBin();
   if (bin === void 0) return void 0;
@@ -14636,17 +15476,6 @@ async function runSetup(args) {
     }
   }
 }
-function readFlagValue(args, index, flag) {
-  const inline = args[index];
-  if (inline !== void 0 && inline.startsWith(`${flag}=`)) {
-    return inline.slice(flag.length + 1);
-  }
-  const value = args[index + 1];
-  if (value === void 0 || value.startsWith("-")) {
-    throw new Error(`${flag} requires a value`);
-  }
-  return value;
-}
 function parseServeFlags(args) {
   let port = DEFAULT_SERVE_PORT;
   let host = DEFAULT_SERVE_HOST;
@@ -14674,286 +15503,6 @@ function parseServeFlags(args) {
   }
   return { port, host, config };
 }
-function parseMapsPackFlags(args) {
-  let slug;
-  let maps = "cajonzero/maps.json";
-  let out;
-  let gzip = true;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === void 0) continue;
-    if (arg === "--maps" || arg.startsWith("--maps=")) {
-      maps = readFlagValue(args, i, "--maps");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--out" || arg.startsWith("--out=")) {
-      out = readFlagValue(args, i, "--out");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--no-gzip") {
-      gzip = false;
-    } else if (arg.startsWith("-")) {
-      throw new Error(`unexpected maps pack option "${arg}"`);
-    } else if (slug === void 0) {
-      slug = arg;
-    } else {
-      throw new Error(`unexpected argument "${arg}"`);
-    }
-  }
-  if (slug === void 0) throw new Error("maps pack requires a map slug");
-  return { slug, maps, ...out !== void 0 ? { out } : {}, gzip };
-}
-function readMapCatalogFile(mapsPath, label) {
-  if (!existsSync(mapsPath)) {
-    throw new Error(`\u627E\u4E0D\u5230\u5730\u56FE\u76EE\u5F55 ${label}\uFF0C\u8BF7\u5728\u9879\u76EE\u76EE\u5F55\u4E2D\u8FD0\u884C`);
-  }
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(mapsPath, "utf8").replace(/^\uFEFF/, ""));
-  } catch (error) {
-    throw new Error(
-      `${label} \u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  return parseMapCatalog(raw);
-}
-async function runMapsPack(args) {
-  const flags = parseMapsPackFlags(args);
-  const cwd = process.cwd();
-  const catalog = readMapCatalogFile(path4.resolve(cwd, flags.maps), flags.maps);
-  const entry = findMap(catalog, flags.slug);
-  if (entry === void 0) {
-    throw new Error(`${flags.maps} \u4E2D\u6CA1\u6709 slug "${flags.slug}"`);
-  }
-  process.stdout.write(`resolving ${entry.slug} from ${entry.root}
-`);
-  const { seed, blockInfoBytes } = await loadWorldSeedGraphFromHttp(entry);
-  for (const warning of seed.warnings) process.stdout.write(`  warning: ${warning}
-`);
-  const pack = encodeSeedPack(seed, blockInfoBytes);
-  const data = flags.gzip ? gzipSync(pack, { level: 9 }) : pack;
-  const fileName = `seed.json${flags.gzip ? ".gz" : ""}`;
-  const outPath = path4.resolve(cwd, flags.out ?? `${entry.slug}.${fileName}`);
-  writeFileSync(outPath, data);
-  const chunks = seed.voxels?.chunkCount ?? 0;
-  process.stdout.write(
-    `packed ${seed.bodies.length} bodies, ${chunks} voxel chunks, ${seed.render?.meshes.length ?? 0} meshes
-wrote ${path4.relative(cwd, outPath)} (${formatBytes(data.length)}${flags.gzip ? ", gzip" : ""})
-upload it to: ${entry.root}${fileName}
-room startup becomes 1 request instead of one per blob.
-`
-  );
-}
-async function runMaps(args) {
-  const [subcommand, ...rest] = args;
-  if (subcommand === void 0 || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
-    printUsage();
-    return;
-  }
-  if (subcommand === "pack") {
-    if (rest.includes("-h") || rest.includes("--help")) {
-      printUsage();
-      return;
-    }
-    await runMapsPack(rest);
-    return;
-  }
-  throw new Error(`unknown maps command "${subcommand}"`);
-}
-function parseBuildSeedFlags(args) {
-  const slugs = [];
-  let config = DEFAULT_CONFIG2;
-  let maps = "cajonzero/maps.json";
-  let assets;
-  let force = false;
-  let gzip = true;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === void 0) continue;
-    if (arg === "--config" || arg.startsWith("--config=")) {
-      config = readFlagValue(args, i, "--config");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--maps" || arg.startsWith("--maps=")) {
-      maps = readFlagValue(args, i, "--maps");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--assets" || arg.startsWith("--assets=")) {
-      assets = readFlagValue(args, i, "--assets");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--force") {
-      force = true;
-    } else if (arg === "--no-gzip") {
-      gzip = false;
-    } else if (arg.startsWith("-")) {
-      throw new Error(`unexpected worker build-seed option "${arg}"`);
-    } else {
-      slugs.push(arg);
-    }
-  }
-  return { slugs, config, maps, ...assets !== void 0 ? { assets } : {}, force, gzip };
-}
-function readSeedMeta(metaPath) {
-  try {
-    return JSON.parse(readFileSync(metaPath, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-async function runWorkerBuildSeed(args) {
-  const flags = parseBuildSeedFlags(args);
-  const cwd = process.cwd();
-  const configPath = path4.resolve(cwd, flags.config);
-  const configDir = path4.dirname(configPath);
-  const assetsRel = flags.assets ?? readWranglerAssetsDirectory(configPath);
-  if (assetsRel === void 0) {
-    throw new Error(
-      `${path4.basename(configPath)} \u672A\u914D\u7F6E assets.directory\uFF1B\u7528 --assets <dir> \u6307\u5B9A\u8F93\u51FA\u76EE\u5F55`
-    );
-  }
-  const assetsDir = path4.resolve(configDir, assetsRel);
-  const seedDir = path4.join(assetsDir, ASSETS_SEED_DIR);
-  mkdirSync(seedDir, { recursive: true });
-  const catalog = readMapCatalogFile(path4.resolve(cwd, flags.maps), flags.maps);
-  const selected = flags.slugs.length > 0 ? flags.slugs.map((slug) => {
-    const entry = findMap(catalog, slug);
-    if (entry === void 0) throw new Error(`${flags.maps} \u4E2D\u6CA1\u6709 slug "${slug}"`);
-    return entry;
-  }) : [...catalog.maps];
-  if (selected.length === 0) {
-    process.stdout.write(`no maps in ${flags.maps}; nothing to build
-`);
-    return;
-  }
-  let failures = 0;
-  for (const entry of selected) {
-    const suffix = flags.gzip ? ".json.gz" : ".json";
-    const packPath = path4.join(seedDir, `${entry.slug}${suffix}`);
-    const staleSuffix = flags.gzip ? ".json" : ".json.gz";
-    const meta = {
-      root: entry.root,
-      ...entry.worldId !== void 0 ? { worldId: entry.worldId } : {},
-      ...entry.version !== void 0 ? { version: entry.version } : {},
-      ...entry.etag !== void 0 ? { etag: entry.etag } : {},
-      gzip: flags.gzip
-    };
-    if (!flags.force && existsSync(packPath)) {
-      const previous = readSeedMeta(path4.join(seedDir, `${entry.slug}.meta.json`));
-      if (previous !== void 0 && JSON.stringify(previous) === JSON.stringify(meta)) {
-        process.stdout.write(`up to date: ${path4.relative(cwd, packPath)}
-`);
-        continue;
-      }
-    }
-    try {
-      process.stdout.write(`resolving ${entry.slug} from ${entry.root}
-`);
-      const { seed, blockInfoBytes } = await loadWorldSeedGraphFromHttp(entry);
-      for (const warning of seed.warnings) process.stdout.write(`  warning: ${warning}
-`);
-      const pack = encodeSeedPack(seed, blockInfoBytes);
-      const data = flags.gzip ? gzipSync(pack, { level: 9 }) : pack;
-      writeFileSync(packPath, data);
-      writeFileSync(
-        path4.join(seedDir, `${entry.slug}.meta.json`),
-        `${JSON.stringify(meta, null, 2)}
-`,
-        "utf8"
-      );
-      rmSync(path4.join(seedDir, `${entry.slug}${staleSuffix}`), { force: true });
-      process.stdout.write(
-        `seeded ${entry.slug}: ${seed.bodies.length} bodies, ${seed.voxels?.chunkCount ?? 0} voxel chunks, ${seed.render?.meshes.length ?? 0} meshes -> ${path4.relative(cwd, packPath)} (${formatBytes(data.length)})
-`
-      );
-    } catch (error) {
-      failures += 1;
-      process.stderr.write(
-        `cajonzero: build-seed failed for "${entry.slug}": ${errorLabel(error)}
-`
-      );
-    }
-  }
-  if (failures > 0) {
-    throw new Error(`${failures} map(s) failed to build; refusing to deploy without a seed`);
-  }
-  const known = new Set(catalog.maps.map((map) => map.slug));
-  let pruned = 0;
-  for (const name of readdirSync(seedDir)) {
-    const match = /^(.+?)(?:\.meta)?\.json(?:\.gz)?$/.exec(name);
-    const slug = match?.[1];
-    if (slug === void 0 || known.has(slug)) continue;
-    rmSync(path4.join(seedDir, name), { force: true });
-    pruned += 1;
-  }
-  if (pruned > 0) {
-    process.stdout.write(`pruned ${pruned} stale seed asset(s)
-`);
-  }
-  process.stdout.write(
-    `seed assets: ${path4.relative(cwd, seedDir)} (served at /seed/<slug>.json[.gz])
-`
-  );
-}
-function parseWorkerPrepareFlags(args) {
-  let config = DEFAULT_CONFIG2;
-  let assets;
-  let force = false;
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === void 0) continue;
-    if (arg === "--config" || arg.startsWith("--config=")) {
-      config = readFlagValue(args, i, "--config");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--assets" || arg.startsWith("--assets=")) {
-      assets = readFlagValue(args, i, "--assets");
-      if (!arg.includes("=")) i += 1;
-    } else if (arg === "--force") {
-      force = true;
-    } else {
-      throw new Error(`unexpected worker prepare option "${arg}"`);
-    }
-  }
-  return { config, ...assets !== void 0 ? { assets } : {}, force };
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-}
-async function runWorkerPrepare(args) {
-  const flags = parseWorkerPrepareFlags(args);
-  const result = await prepareWorkerAssets({
-    cwd: process.cwd(),
-    configPath: flags.config,
-    ...flags.assets !== void 0 ? { assetsDir: flags.assets } : {},
-    force: flags.force
-  });
-  const target = path4.relative(process.cwd(), result.targetDir) || ".";
-  process.stdout.write(
-    `${result.copied ? "synced" : "up to date"}: ${result.files} assets, ${formatBytes(result.bytes)} -> ${target}
-`
-  );
-}
-async function runWorker(args) {
-  const [subcommand, ...rest] = args;
-  if (subcommand === void 0 || subcommand === "--help" || subcommand === "-h" || subcommand === "help") {
-    printUsage();
-    return;
-  }
-  if (subcommand === "prepare") {
-    if (rest.includes("-h") || rest.includes("--help")) {
-      printUsage();
-      return;
-    }
-    await runWorkerPrepare(rest);
-    return;
-  }
-  if (subcommand === "build-seed") {
-    if (rest.includes("-h") || rest.includes("--help")) {
-      printUsage();
-      return;
-    }
-    await runWorkerBuildSeed(rest);
-    return;
-  }
-  throw new Error(`unknown worker command "${subcommand}"`);
-}
 async function runServe(args) {
   const flags = parseServeFlags(args);
   const { unstable_dev, unstable_readConfig } = await import('wrangler');
@@ -14964,14 +15513,41 @@ async function runServe(args) {
   }
   const assetsDir = config.assets?.directory;
   if (typeof assetsDir === "string" && assetsDir.length > 0) {
-    await prepareWorkerAssets({ cwd: process.cwd(), configPath: flags.config, assetsDir });
+    try {
+      await syncPublicAssets({ cwd: process.cwd(), configPath: flags.config, assetsDir });
+    } catch (error) {
+      process.stdout.write(
+        `cajonzero: UI sync skipped (${error instanceof Error ? error.message : String(error)})
+`
+      );
+    }
   }
   const secrets = localDevVars();
+  const persistTo = path4.resolve(
+    path4.dirname(path4.resolve(flags.config)),
+    ".wrangler",
+    "state"
+  );
+  const scriptsBinding = scriptsKvBinding(path4.resolve(flags.config));
+  if (scriptsBinding !== void 0) {
+    const uploaded = uploadScriptPacks(
+      process.cwd(),
+      flags.config,
+      path4.resolve(process.cwd(), DEFAULT_SCRIPTS_DIR),
+      scriptsBinding,
+      { remote: false, persistTo }
+    );
+    if (uploaded > 0) {
+      process.stdout.write(`map scripts: ${uploaded} local KV key(s) -> ${scriptsBinding}
+`);
+    }
+  }
   const worker = await unstable_dev(entry, {
     config: flags.config,
     ip: flags.host,
     port: flags.port,
     local: true,
+    persistTo,
     logLevel: "info",
     // Inject local-dev secrets (from the environment) on top of the config
     // `vars` so auth/session work locally without `wrangler secret put`.
@@ -15015,22 +15591,38 @@ async function main(argv) {
     printUsage();
     return;
   }
+  if (rest.includes("-h") || rest.includes("--help")) {
+    printUsage();
+    return;
+  }
   try {
     switch (command) {
       case "serve":
         await runServe(rest);
         return;
       case "create":
-        runCreate(rest);
+        await runCreate(rest);
         return;
       case "setup":
         await runSetup(rest);
         return;
-      case "worker":
-        await runWorker(rest);
+      case "add":
+        await runAdd(rest);
+        return;
+      case "update":
+        await runUpdate(rest);
+        return;
+      case "list":
+        runList(rest);
+        return;
+      case "remove":
+        runRemove(rest);
+        return;
+      case "sync":
+        await runSync(rest);
         return;
-      case "maps":
-        await runMaps(rest);
+      case "deploy":
+        await runDeploy(rest);
         return;
       default:
         process.stderr.write(`cajonzero: unknown command "${command}"