@pixelvibing/cli 0.9.0 → 0.11.0

package/dist/pixel-vibing-cli.js

@@ -4,8 +4,8 @@ import { realpath, promises } from "node:fs";
 import { promisify, parseArgs } from "node:util";
 import { randomBytes, createHash } from "node:crypto";
 import { createServer } from "node:http";
-import { stat, readFile, writeFile, mkdir, readdir, lstat, rm, rename, realpath as realpath$1 } from "node:fs/promises";
-import { deflateSync, inflateSync } from "node:zlib";
+import { stat, readFile, writeFile, mkdir, readdir, rename, lstat, rm, realpath as realpath$1 } from "node:fs/promises";
+import { inflate, deflate, deflateSync, inflateSync } from "node:zlib";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { hostname, homedir } from "node:os";
@@ -623,7 +623,7 @@ function bearerFetch(fetcher, apiUrl, token) {
 }
 function platformWith(fetcher, apiUrl, token) {
   const carrying = bearerFetch(fetcher, apiUrl, token);
-  return { apiUrl, web: createWebApi(carrying, apiUrl), account: createAccountApi(carrying, apiUrl) };
+  return { apiUrl, web: createWebApi(carrying, apiUrl), account: createAccountApi(carrying, apiUrl), call: createCaller(carrying, apiUrl) };
 }
 async function signedIn(context) {
   const apiUrl = apiUrlOf(context);
@@ -1016,66 +1016,6 @@ function nameProblem(name) {
   }
   return null;
 }
-const PULLED_FILE = `${PROJECT_DIRECTORY}/pulled.json`;
-const PULLED_FORMAT = 1;
-const HEX64 = /^[0-9a-f]{64}$/;
-const UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
-const EMPTY_PULLED = { guide: null, assets: {} };
-class PulledError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PulledError";
-  }
-}
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function isPulledPath(path) {
-  if (!path.startsWith("out/") || !path.endsWith(".png")) return false;
-  const name = path.slice("out/".length, -".png".length);
-  return !name.includes("\\") && nameProblem(name) === null;
-}
-function assetOf(id2, raw) {
-  if (!UUID.test(id2)) throw new PulledError(`${PULLED_FILE}: ${id2} is not an asset's id`);
-  if (!isRecord$2(raw)) throw new PulledError(`${PULLED_FILE}: the asset ${id2} is not an object`);
-  const { kind, name, hash, files } = raw;
-  if (typeof kind !== "string" || kind === "") throw new PulledError(`${PULLED_FILE}: the asset ${id2} names no kind`);
-  if (typeof name !== "string" || name === "") throw new PulledError(`${PULLED_FILE}: the asset ${id2} names no name`);
-  if (typeof hash !== "string" || !HEX64.test(hash)) throw new PulledError(`${PULLED_FILE}: the asset ${id2} has no hash`);
-  if (!Array.isArray(files) || files.length === 0 || !files.every((file) => typeof file === "string" && isPulledPath(file))) {
-    throw new PulledError(`${PULLED_FILE}: the asset ${id2} names a file that is not a picture under out/`);
-  }
-  return { kind, name, hash, files };
-}
-function guideOf(raw) {
-  if (raw === void 0 || raw === null) return null;
-  if (!isRecord$2(raw) || !Number.isInteger(raw.version) || raw.version < 1 || typeof raw.sha256 !== "string" || !HEX64.test(raw.sha256)) {
-    throw new PulledError(`${PULLED_FILE}: the style guide's entry is not a version and a digest`);
-  }
-  return { version: raw.version, sha256: raw.sha256 };
-}
-function readPulled(text2) {
-  let parsed2;
-  try {
-    parsed2 = JSON.parse(text2);
-  } catch (error) {
-    throw new PulledError(`${PULLED_FILE} is not valid JSON: ${error.message}`);
-  }
-  if (!isRecord$2(parsed2)) throw new PulledError(`${PULLED_FILE} is not an object`);
-  if (parsed2.format !== PULLED_FORMAT) throw new PulledError(`${PULLED_FILE} names no format this CLI reads: expected "format": ${PULLED_FORMAT}`);
-  const assets = {};
-  if (parsed2.assets !== void 0) {
-    if (!isRecord$2(parsed2.assets)) throw new PulledError(`${PULLED_FILE}: "assets" is not an object`);
-    for (const [id2, raw] of Object.entries(parsed2.assets)) assets[id2] = assetOf(id2, raw);
-  }
-  return { guide: guideOf(parsed2.guide), assets };
-}
-function writePulled(record) {
-  return `${JSON.stringify({ format: PULLED_FORMAT, ...record.guide === null ? {} : { guide: record.guide }, assets: record.assets }, null, 2)}
-`;
-}
-function ownerOf(record, file) {
-  for (const [id2, asset] of Object.entries(record.assets)) if (asset.files.includes(file)) return id2;
-  return null;
-}
 const HUD_PIECE_NAMES = ["health-bar", "mana-bar", "button", "inventory-slot", "panel-frame", "minimap-frame"];
 const ICON_SIZES = [16, 32, 64];
 const DEFAULT_ICON_SIZE = 32;
@@ -1105,206 +1045,362 @@ function describedInterface(manifest2, kept, earlier) {
     next[name] = { meta: { kind: "ui", ...piece.nineGrid === void 0 ? {} : { nineGrid: piece.nineGrid, scale: "stretch" } } };
   return next;
 }
-const SIGNATURE$1 = [137, 80, 78, 71, 13, 10, 26, 10];
-function isPng(bytes) {
-  return bytes.length >= 24 && SIGNATURE$1.every((byte, index) => bytes[index] === byte);
+const SECTOR_SIDE$1 = 128;
+const SECTOR_CELLS = SECTOR_SIDE$1 * SECTOR_SIDE$1;
+const SECTOR_BYTES = 512 * 1024;
+const MAP_LEVELS = { first: 0, last: 14 };
+const LARGEST_MAP_SIDE = 1e4;
+const OUTLINE_ACROSS = Math.ceil(LARGEST_MAP_SIDE / SECTOR_SIDE$1);
+const SECTOR_FORMAT = 1;
+const MAGIC = [80, 86, 67];
+const PRESENT = 1;
+const AUDIO = 2;
+const INTERACT = 4;
+const EXTRA = 8;
+const U16 = 65535;
+const MAX_LAYERS = 255;
+const NAMED$1 = /* @__PURE__ */ new Set(["x", "y", "z", "layers", "blocking", "zone", "audioZone", "interact"]);
+class SectorError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SectorError";
+  }
 }
-function pngSize(bytes) {
-  if (!isPng(bytes)) throw new RangeError("those bytes are not a PNG");
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  return { width: view.getUint32(16), height: view.getUint32(20) };
+function u16(value, what) {
+  if (!Number.isInteger(value) || value < 0 || value > U16) throw new SectorError(`${what} is ${value}, and a sector holds a whole number from 0 to 65,535`);
+  return value;
 }
-const MAX_RECORD_BYTES = 4 * 1024 * 1024;
-const artBoundary = (local) => new Boundary([artOf(local)]);
-const recordPath = (local) => join(local.root, ...PULLED_FILE.split("/"));
-async function readRecord(local) {
-  const boundary = artBoundary(local);
-  const path = recordPath(local);
-  if (!await boundary.exists(path)) return EMPTY_PULLED;
-  const { size } = await stat(await boundary.resolve(path));
-  if (size > MAX_RECORD_BYTES) throw new CliError(`${PULLED_FILE} is ${size} bytes, and is read at most ${MAX_RECORD_BYTES}`);
-  try {
-    return readPulled(await boundary.readText(path));
-  } catch (error) {
-    if (error instanceof PulledError) throw new CliError(error.message);
-    throw error;
+function encodeSector(cells) {
+  if (cells.length !== SECTOR_CELLS) throw new SectorError(`a sector is ${SECTOR_CELLS} cells, not ${cells.length}`);
+  const encoder2 = new TextEncoder();
+  const bytes = [...MAGIC, SECTOR_FORMAT];
+  const push16 = (value) => bytes.push(value & 255, value >> 8);
+  for (const cell of cells) {
+    if (cell === void 0) {
+      bytes.push(0);
+      continue;
+    }
+    const extra = cell.extra === void 0 ? null : encoder2.encode(JSON.stringify(cell.extra));
+    if (extra !== null && extra.length > U16) throw new SectorError("a tile's extra fields are past 65,535 bytes");
+    if (cell.layers.length > MAX_LAYERS) throw new SectorError(`a tile has ${cell.layers.length} layers, and a sector holds at most ${MAX_LAYERS}`);
+    bytes.push(PRESENT | (cell.audioZone === void 0 ? 0 : AUDIO) | (cell.interact === void 0 ? 0 : INTERACT) | (extra === null ? 0 : EXTRA));
+    bytes.push(cell.layers.length);
+    for (const layer of cell.layers) push16(u16(layer, "a layer id"));
+    push16(u16(cell.blocking, "blocking"));
+    push16(u16(cell.zone, "a zone"));
+    if (cell.audioZone !== void 0) push16(u16(cell.audioZone, "an audio zone"));
+    if (cell.interact !== void 0) push16(u16(cell.interact, "interact"));
+    if (extra !== null) {
+      push16(extra.length);
+      for (const byte of extra) bytes.push(byte);
+    }
   }
+  return Uint8Array.from(bytes);
 }
-async function writeRecord(local, record) {
-  await artBoundary(local).writeFileReplacing(recordPath(local), writePulled(record));
+function decodeSector(bytes) {
+  if (bytes.length < 4 || MAGIC.some((byte, index) => bytes[index] !== byte)) throw new SectorError("these bytes are not a map sector");
+  if (bytes[3] !== SECTOR_FORMAT) throw new SectorError(`a map sector of format ${bytes[3]} is not one this version reads`);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let at = 4;
+  const need = (count) => {
+    if (at + count > bytes.length) throw new SectorError("the sector's bytes end before its last cell");
+  };
+  const read8 = () => {
+    need(1);
+    return bytes[at++];
+  };
+  const read16 = () => {
+    need(2);
+    const value = bytes[at] | bytes[at + 1] << 8;
+    at += 2;
+    return value;
+  };
+  const cells = [];
+  for (let index = 0; index < SECTOR_CELLS; index += 1) {
+    const flags = read8();
+    if ((flags & PRESENT) === 0) {
+      cells.push(void 0);
+      continue;
+    }
+    const count = read8();
+    const layers = [];
+    for (let layer = 0; layer < count; layer += 1) layers.push(read16());
+    const blocking = read16();
+    const zone = read16();
+    const audioZone = (flags & AUDIO) === 0 ? void 0 : read16();
+    const interact = (flags & INTERACT) === 0 ? void 0 : read16();
+    let extra;
+    if ((flags & EXTRA) !== 0) {
+      const length = read16();
+      need(length);
+      let parsed2;
+      try {
+        parsed2 = JSON.parse(decoder.decode(bytes.subarray(at, at + length)));
+      } catch {
+        throw new SectorError("a tile's extra fields are not JSON");
+      }
+      if (typeof parsed2 !== "object" || parsed2 === null || Array.isArray(parsed2)) throw new SectorError("a tile's extra fields are not an object");
+      const named = Object.keys(parsed2).find((key) => NAMED$1.has(key));
+      if (named !== void 0) throw new SectorError(`a tile's extra fields name ${named}, which the sector holds itself`);
+      extra = parsed2;
+      at += length;
+    }
+    cells.push({
+      layers,
+      blocking,
+      zone,
+      ...audioZone === void 0 ? {} : { audioZone },
+      ...interact === void 0 ? {} : { interact },
+      ...extra === void 0 ? {} : { extra }
+    });
+  }
+  if (at !== bytes.length) throw new SectorError("the sector's bytes go on past its last cell");
+  return cells;
 }
-const INTERFACE_MANIFEST = "manifest/interface.json";
-function setPieces(asset) {
-  return setPiecesOf(asset.kind, asset.images.length, asset.data);
+const NAMED = /* @__PURE__ */ new Set(["x", "y", "z", "layers", "blocking", "zone", "audioZone", "interact"]);
+function cellOfTile(tile) {
+  const extra = Object.fromEntries(Object.entries(tile).filter(([key]) => !NAMED.has(key)));
+  return {
+    layers: tile.layers,
+    blocking: tile.blocking,
+    zone: tile.zone,
+    ...tile.audioZone === void 0 ? {} : { audioZone: tile.audioZone },
+    ...tile.interact === void 0 ? {} : { interact: tile.interact },
+    ...Object.keys(extra).length === 0 ? {} : { extra }
+  };
 }
-function pieceFiles(name, pieces) {
-  return pieceNames(name, pieces).map((piece) => `out/${piece}.png`);
+function tileOfCell(cell, x, y, z) {
+  return {
+    ...cell.extra ?? {},
+    x,
+    y,
+    z,
+    layers: [...cell.layers],
+    blocking: cell.blocking,
+    zone: cell.zone,
+    ...cell.audioZone === void 0 ? {} : { audioZone: cell.audioZone },
+    ...cell.interact === void 0 ? {} : { interact: cell.interact }
+  };
 }
-const pictureName = (file) => file.replace(/^out\//, "").replace(/\.png$/, "");
-function filesOf(name, count) {
-  return count === 1 ? [`out/${name}.png`] : Array.from({ length: count }, (_, index) => `out/${name}/${index}.png`);
+const MIRROR_MAP_DIRECTORY = "map";
+const MIRROR_INDEX_FILE = `${MIRROR_MAP_DIRECTORY}/index.json`;
+const MIRROR_FORMAT = 1;
+class MirrorError extends Error {
+  // Assigned in the body: Node's strip-only TypeScript mode rejects parameter
+  // properties (docs/notes.md n-0023).
+  constructor(message) {
+    super(message);
+    this.name = "MirrorError";
+  }
 }
-function nameFor(asset, record, given) {
-  const name = given ?? record.assets[asset.id]?.name ?? asset.name ?? SET_NAMES[asset.kind] ?? `${asset.kind}-${asset.id.slice(0, 8)}`;
-  const problem = nameProblem(name);
-  if (problem !== null) throw new CliError(`${name} is not a name a picture can be written under (${problem}): give one with --as`);
-  return name;
+function mirrorSectorPath(z, cx, cy) {
+  if (!isPlace(z, cx, cy)) throw new MirrorError(`no sector of a map is at level ${z}, column ${cx}, row ${cy}`);
+  return `${MIRROR_MAP_DIRECTORY}/${z}/${cx}-${cy}.bin`;
 }
-async function pullAsset(platform, local, ref, given) {
-  const project = linkedOf(local);
-  const asset = await platform.web.asset(project, ref);
-  if (asset.images.length === 0) throw new CliError(`the asset ${asset.id} has no image the platform still keeps`);
-  const record = await readRecord(local);
-  const boundary = artBoundary(local);
-  const art = artOf(local);
-  const name = nameFor(asset, record, given);
-  const pieces = setPieces(asset);
-  const files = pieces === null ? filesOf(name, asset.images.length) : pieceFiles(name, pieces);
-  const pulled = { id: asset.id, kind: asset.kind, name, hash: asset.hash, files, data: asset.data };
-  const before = record.assets[asset.id];
-  const onDisk = async (file) => boundary.exists(join(art, ...file.split("/")));
-  if (before !== void 0 && before.hash === asset.hash && before.name === name && (await Promise.all(before.files.map(onDisk))).every(Boolean)) {
-    return { ...pulled, files: before.files, current: true };
+function isPlace(z, cx, cy) {
+  const within = (value, last) => Number.isInteger(value) && value >= 0 && value <= last;
+  return within(z, MAP_LEVELS.last) && z >= MAP_LEVELS.first && within(cx, OUTLINE_ACROSS - 1) && within(cy, OUTLINE_ACROSS - 1);
+}
+function isSize(value) {
+  const side = (n) => Number.isInteger(n) && n >= 1 && n <= LARGEST_MAP_SIDE;
+  return typeof value === "object" && value !== null && side(value.width) && side(value.height);
+}
+function mirrorIndexText(index) {
+  return `${JSON.stringify(index, null, 2)}
+`;
+}
+function parseMirrorIndex(text2) {
+  let value;
+  try {
+    value = JSON.parse(text2);
+  } catch {
+    throw new MirrorError(`${MIRROR_INDEX_FILE} is not JSON`);
+  }
+  const index = value;
+  if (typeof index !== "object" || index === null) throw new MirrorError(`${MIRROR_INDEX_FILE} is not an object`);
+  if (index.format !== MIRROR_FORMAT)
+    throw new MirrorError(`${MIRROR_INDEX_FILE} is in format ${String(index.format)}, and this reads format ${MIRROR_FORMAT}`);
+  if (!Number.isInteger(index.revision) || index.revision < 0) throw new MirrorError(`${MIRROR_INDEX_FILE} names no revision`);
+  if (!isSize(index.size) || !isSize(index.limit)) throw new MirrorError(`${MIRROR_INDEX_FILE} names no size or limit a map may have`);
+  if (!Array.isArray(index.names) || !Array.isArray(index.sectors)) throw new MirrorError(`${MIRROR_INDEX_FILE} lists no levels or sectors`);
+  for (const named of index.names) {
+    if (typeof named?.name !== "string" || !isPlace(named.z, 0, 0)) throw new MirrorError(`${MIRROR_INDEX_FILE} names a level that is none`);
   }
-  for (const file of files) {
-    const owner = ownerOf(record, file);
-    if (owner !== asset.id && await onDisk(file)) {
-      throw new CliError(
-        `pixelvibing/${file} is already there, ${owner === null ? "written by the editor or by hand" : `pulled for the asset ${owner}`}: nothing was written. Give this one another name with --as`
-      );
+  const seen = /* @__PURE__ */ new Set();
+  for (const sector of index.sectors) {
+    const [z, cx, cy, version2] = Array.isArray(sector) ? sector : [];
+    if (!isPlace(z, cx, cy) || !Number.isInteger(version2) || version2 < 1) {
+      throw new MirrorError(`${MIRROR_INDEX_FILE} lists a sector that is none: ${JSON.stringify(sector)}`);
     }
+    const key = `${z}:${cx}:${cy}`;
+    if (cx * SECTOR_SIDE$1 >= index.size.width || cy * SECTOR_SIDE$1 >= index.size.height) {
+      throw new MirrorError(`${MIRROR_INDEX_FILE} lists the sector ${key}, outside the map's size`);
+    }
+    if (seen.has(key)) throw new MirrorError(`${MIRROR_INDEX_FILE} lists the sector ${key} twice`);
+    seen.add(key);
   }
-  const images = [];
-  for (const image of asset.images) {
-    const bytes = await platform.web.imageBytes(image.id);
-    if (!isPng(bytes)) throw new CliError(`the platform answered something that is not a PNG for the image ${image.id}: nothing was written`);
-    images.push(bytes);
-  }
-  for (const [index, file] of files.entries()) await boundary.writeFileReplacing(join(art, ...file.split("/")), images[index]);
-  for (const stale of before?.files ?? []) {
-    if (!files.includes(stale)) await boundary.removeFile(join(art, ...stale.split("/")));
-  }
-  if (pieces !== null || before?.files.some((file) => file.startsWith("out/ui/"))) {
-    await describeInterface(boundary, art, pieces === null ? [] : files.map((file, index) => [file, pieces[index]]), before?.files ?? []);
-  }
-  await writeRecord(local, { ...record, assets: { ...record.assets, [asset.id]: { kind: asset.kind, name, hash: asset.hash, files } } });
-  return { ...pulled, current: false };
+  return index;
 }
-async function describeInterface(boundary, art, written, earlier) {
-  const path = join(art, ...INTERFACE_MANIFEST.split("/"));
-  let manifest2 = {};
-  if (await boundary.exists(path)) {
+async function readMirroredMap(index, read, inflate2) {
+  const tiles = [];
+  for (const [z, cx, cy] of index.sectors) {
+    const path = mirrorSectorPath(z, cx, cy);
+    let cells;
     try {
-      const parsed2 = JSON.parse(await boundary.readText(path));
-      if (typeof parsed2 === "object" && parsed2 !== null && !Array.isArray(parsed2)) manifest2 = parsed2;
-      else throw new Error("not an object");
+      cells = decodeSector(await inflate2(await read(path)));
     } catch (error) {
-      throw new CliError(`pixelvibing/${INTERFACE_MANIFEST} is not a manifest (${error.message}): the pieces were written, and not described`);
+      throw new MirrorError(`${path} is not a sector the map can read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    for (const [at, cell] of cells.entries()) {
+      if (cell === void 0) continue;
+      const x = cx * SECTOR_SIDE$1 + at % SECTOR_SIDE$1;
+      const y = cy * SECTOR_SIDE$1 + Math.floor(at / SECTOR_SIDE$1);
+      if (x >= index.size.width || y >= index.size.height) continue;
+      tiles.push(tileOfCell(cell, x, y, z));
     }
   }
-  manifest2 = describedInterface(
-    manifest2,
-    written.map(([file, piece]) => [pictureName(file), piece]),
-    earlier.map(pictureName)
-  );
-  await boundary.writeFileReplacing(path, new TextEncoder().encode(`${JSON.stringify(manifest2, null, 2)}
-`));
+  tiles.sort((a, b) => a.z - b.z || a.y - b.y || a.x - b.x);
+  return { width: index.size.width, height: index.size.height, tiles };
 }
-function pulledWords(pulled) {
-  const where = pulled.files.length === 1 ? `pixelvibing/${pulled.files[0]}` : `pixelvibing/out/${pulled.name}/ (${pulled.files.length} images)`;
-  return pulled.current ? `${pulled.name} is current: ${where} is what the platform has.` : `Pulled ${pulled.name}, ${pulled.kind}, into ${where}.`;
-}
-const date = (at) => at.slice(0, 10);
-function listed(assets) {
-  if (assets.length === 0) return "No assets.";
-  return assets.map(
-    (asset) => `${asset.id}  ${asset.kind.padEnd(12)}  ${(asset.name ?? "—").padEnd(28)}  ${asset.images} image${asset.images === 1 ? "" : "s"}  ${date(asset.createdAt)}`
-  ).join("\n");
+function sectorsOfMap(map) {
+  const sectors = /* @__PURE__ */ new Map();
+  for (const tile of map.tiles) {
+    const { x, y, z } = tile;
+    if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= LARGEST_MAP_SIDE || y >= LARGEST_MAP_SIDE || !isPlace(z, 0, 0)) {
+      throw new MirrorError(`the tile at (${x}, ${y}) on level ${z} is at no place a map has`);
+    }
+    const cx = Math.floor(x / SECTOR_SIDE$1);
+    const cy = Math.floor(y / SECTOR_SIDE$1);
+    const key = `${z}:${cx}:${cy}`;
+    let sector = sectors.get(key);
+    if (sector === void 0) {
+      sector = { z, cx, cy, cells: new Array(SECTOR_CELLS) };
+      sectors.set(key, sector);
+    }
+    sector.cells[y % SECTOR_SIDE$1 * SECTOR_SIDE$1 + x % SECTOR_SIDE$1] = cellOfTile(tile);
+  }
+  return [...sectors.values()].sort((a, b) => a.z - b.z || a.cy - b.cy || a.cx - b.cx);
 }
-const list = {
-  name: "list",
-  summary: "List the platform project's assets, of one kind when given, newest first",
-  usage: "[<kind>] [--before <id>]",
-  options: { before: { type: "string", value: "<id>", description: "the page after the asset with this id, as the last page said" } },
-  positionals: [0, 1],
-  run: async (context, args) => {
-    const local = await projectHere(context.io.cwd);
-    const project = linkedOf(local);
-    const platform = await signedIn(context);
-    const [kind] = args.positionals;
-    const page = await platform.web.assets(project, kind ?? null, stringOf(args, "before") ?? null);
-    const more = page.next === null ? "" : `
-More: pixel-vibing-cli list${kind === void 0 ? "" : ` ${kind}`} --before ${page.next}`;
-    answer(context, page, `${listed(page.assets)}${more}`);
+class MapTextError extends Error {
+  // Assigned in the body: the suites run under Node's strip-only TypeScript
+  // mode, which rejects parameter properties (docs/notes.md n-0023).
+  constructor(message) {
+    super(message);
+    this.name = "MapTextError";
   }
-};
-const pull = {
-  name: "pull",
-  summary: "Pull one asset, by its id or its name, into the local project",
-  usage: "<id|name> [--as <name>]",
-  options: { as: { type: "string", value: "<name>", description: "write it under this name instead of the platform's" } },
-  positionals: [1, 1],
-  run: async (context, args) => {
-    const local = await projectHere(context.io.cwd);
-    linkedOf(local);
-    const platform = await signedIn(context);
-    const pulled = await pullAsset(platform, local, args.positionals[0], stringOf(args, "as"));
-    answer(context, pulled, pulledWords(pulled));
+}
+function tileKey(x, y, z) {
+  return `${x}:${y}:${z}`;
+}
+function scanTileSources(text2) {
+  const key = '"tiles"';
+  let at = text2.indexOf(key);
+  if (at === -1) return [];
+  at = text2.indexOf("[", at + key.length);
+  if (at === -1) return [];
+  const sources = [];
+  let depth = 0;
+  let inString = false;
+  let start = -1;
+  for (let index = at + 1; index < text2.length; index += 1) {
+    const char = text2[index];
+    if (inString) {
+      if (char === "\\") index += 1;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+    } else if (char === "{") {
+      if (depth === 0) start = index;
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0 && start !== -1) {
+        sources.push(text2.slice(start, index + 1));
+        start = -1;
+      }
+    } else if (char === "]" && depth === 0) {
+      break;
+    }
   }
-};
-const DOWNLOAD_URL = "https://github.com/Pixel-Vibing/pixel-vibing/releases/latest";
-const EDITOR_VARIABLE = "PIXELVIBING_EDITOR";
-async function exists$1(path) {
+  return sources;
+}
+function isTile(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.x === "number" && typeof record.y === "number" && typeof record.z === "number" && Array.isArray(record.layers);
+}
+function parseMapText(text2, path = "the map") {
+  let parsed2;
   try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
+    parsed2 = JSON.parse(text2);
+  } catch (error) {
+    throw new MapTextError(`${path} is not valid JSON: ${error.message}`);
   }
-}
-async function findEditor(platform, env, home) {
-  const named = env[EDITOR_VARIABLE]?.trim();
-  if (named !== void 0 && named !== "") {
-    if (!await exists$1(named)) throw new CliError(`${EDITOR_VARIABLE} names ${named}, which is not there`);
-    return platform === "darwin" && named.endsWith(".app") ? { command: "open", args: ["-a", named, "--args"] } : { command: named, args: [] };
+  if (typeof parsed2 !== "object" || parsed2 === null || !Array.isArray(parsed2.tiles)) {
+    throw new MapTextError(`${path} holds no tiles array`);
   }
-  if (platform === "win32") {
-    const places = [env.LOCALAPPDATA && join(env.LOCALAPPDATA, "Programs", "PixelVibing"), env.ProgramFiles && join(env.ProgramFiles, "PixelVibing")];
-    for (const place of places) {
-      if (typeof place === "string" && await exists$1(join(place, "PixelVibing.exe"))) return { command: join(place, "PixelVibing.exe"), args: [] };
-    }
-    return null;
+  const document = parsed2;
+  const sources = scanTileSources(text2);
+  if (sources.length !== document.tiles.length) {
+    throw new MapTextError(`${path}: the scanner found ${sources.length} tile sources for ${document.tiles.length} tiles`);
   }
-  if (platform === "darwin") {
-    for (const app of ["/Applications/PixelVibing.app", join(home, "Applications", "PixelVibing.app")]) {
-      if (await exists$1(app)) return { command: "open", args: ["-a", app, "--args"] };
-    }
-    return null;
+  const byKey = /* @__PURE__ */ new Map();
+  document.tiles.forEach((tile, index) => {
+    if (!isTile(tile)) throw new MapTextError(`${path}: tile ${index} lacks x, y, z or layers`);
+    byKey.set(tileKey(tile.x, tile.y, tile.z), { tile, source: sources[index] });
+  });
+  return { document, sources: byKey };
+}
+const TILE_KEYS = ["x", "y", "z", "layers", "blocking", "zone", "audioZone", "interact"];
+function serializeTile(tile) {
+  const ordered = {};
+  for (const key of TILE_KEYS) {
+    if (tile[key] !== void 0) ordered[key] = tile[key];
   }
-  const applications = join(home, "Applications");
-  let found = [];
-  try {
-    found = (await readdir(applications)).filter((name) => /^PixelVibing.*\.AppImage$/i.test(name)).sort();
-  } catch {
-    return null;
+  for (const key of Object.keys(tile)) {
+    if (!(key in ordered) && tile[key] !== void 0) ordered[key] = tile[key];
   }
-  const newest = found.at(-1);
-  return newest === void 0 ? null : { command: join(applications, newest), args: [] };
+  return JSON.stringify(ordered);
 }
-const editor = {
-  name: "editor",
-  summary: "Open the PixelVibing desktop app on this local project",
-  run: async (context) => {
-    const local = await projectHere(context.io.cwd);
-    const { platform, home } = context.services;
-    const found = await findEditor(platform, context.io.env, home);
-    if (found === null) {
-      throw new CliError(`the PixelVibing desktop app is not installed here: download it from ${DOWNLOAD_URL}, or set ${EDITOR_VARIABLE} to where it is`);
+function formatMap(next, previous) {
+  const lines = [];
+  let changed = 0;
+  for (const tile of next.tiles) {
+    {
+      lines.push(serializeTile(tile));
+      changed += 1;
     }
-    await context.services.launch(found.command, [...found.args, "--project", local.root]);
-    answer(context, { opened: local.root, app: found.command }, `Opening ${local.root} in PixelVibing.`);
   }
-};
+  const rest = {};
+  for (const key of Object.keys(next)) {
+    if (key !== "width" && key !== "height" && key !== "tiles") rest[key] = next[key];
+  }
+  const trailer = Object.keys(rest).length === 0 ? "" : `,${JSON.stringify(rest).slice(1, -1)}`;
+  const head = `{"width":${JSON.stringify(next.width)},"height":${JSON.stringify(next.height)},"tiles":[`;
+  const body = lines.length === 0 ? "" : `
+${lines.join(",\n")}
+`;
+  return { text: `${head}${body}]${trailer}}
+`, changed };
+}
+const SIGNATURE$1 = [137, 80, 78, 71, 13, 10, 26, 10];
+function isPng(bytes) {
+  return bytes.length >= 24 && SIGNATURE$1.every((byte, index) => bytes[index] === byte);
+}
+function pngSize(bytes) {
+  if (!isPng(bytes)) throw new RangeError("those bytes are not a PNG");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+const GROUND_KINDS = /* @__PURE__ */ new Set(["ground", "floor", "wall", "cliff", "interior", "grass-stone"]);
+function isGroundName(name) {
+  const { inner } = splitTileset(name);
+  const kind = inner.split("/")[1] ?? "";
+  return GROUND_KINDS.has(kind) || inner.includes("/wang-");
+}
+const MAX_ASSEMBLED_PX = 4096;
 const TILE_SIZE = 256;
 const EAI_MAGIC = 1229018181;
 const EAI_VERSION = 1;
@@ -1559,7 +1655,7 @@ class AssetMetadataError extends Error {
     this.name = "AssetMetadataError";
   }
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 const MAX_ANIMATION_FRAMES = 64;
@@ -1571,7 +1667,7 @@ function readFrames(value, asset, animation) {
     throw new AssetMetadataError(`${asset}: animation ${animation} has ${value.length} frames, and an animation holds at most ${MAX_ANIMATION_FRAMES}`);
   }
   return value.map((raw, index) => {
-    if (!isRecord$1(raw)) {
+    if (!isRecord$2(raw)) {
       throw new AssetMetadataError(`${asset}: animation ${animation} frame ${index} is not a frame`);
     }
     const name = raw.asset;
@@ -1590,7 +1686,7 @@ function readFrames(value, asset, animation) {
 function readAnimations(value, asset, kind) {
   const animations = /* @__PURE__ */ new Map();
   if (value === void 0) return animations;
-  if (!isRecord$1(value)) {
+  if (!isRecord$2(value)) {
     throw new AssetMetadataError(`${asset}: animations is not a map of name to frames`);
   }
   for (const [name, frames] of Object.entries(value)) {
@@ -1607,10 +1703,10 @@ function readAnimations(value, asset, kind) {
 function readPlays(value, asset, animations, kind) {
   const plays = /* @__PURE__ */ new Map();
   if (value === void 0) return plays;
-  if (!isRecord$1(value)) throw new AssetMetadataError(`${asset}: plays is not a map of animation to how it plays`);
+  if (!isRecord$2(value)) throw new AssetMetadataError(`${asset}: plays is not a map of animation to how it plays`);
   for (const [name, play] of Object.entries(value)) {
     if (!animations.has(name)) throw new AssetMetadataError(`${asset}: plays names ${name}, and there is no such animation`);
-    if (!isRecord$1(play)) throw new AssetMetadataError(`${asset}: how ${name} plays is not an object`);
+    if (!isRecord$2(play)) throw new AssetMetadataError(`${asset}: how ${name} plays is not an object`);
     if (kind === "outfit" && play.mode !== "loop")
       throw new AssetMetadataError(`${asset}: ${name} is an outfit's animation, which plays as the game drives it, in a loop`);
     if (play.mode === "loop" || play.mode === "change") {
@@ -1633,7 +1729,7 @@ function readPlays(value, asset, animations, kind) {
 }
 function readNineGrid(value, asset) {
   if (value === void 0) return void 0;
-  if (!isRecord$1(value)) {
+  if (!isRecord$2(value)) {
     throw new AssetMetadataError(`${asset}: nineGrid is not an object of four insets`);
   }
   const insets = {};
@@ -1658,7 +1754,7 @@ function readScale(value, asset) {
 }
 function readCollide(value, asset) {
   if (value === void 0) return void 0;
-  if (!isRecord$1(value)) {
+  if (!isRecord$2(value)) {
     throw new AssetMetadataError(`${asset}: collide is not a box of x, y, w and h in cells`);
   }
   const box = {};
@@ -1679,7 +1775,7 @@ const MIN_DRAW_SCALE = 0.05;
 const MAX_DRAW_SCALE = 8;
 function readOffset(value, asset) {
   if (value === void 0) return void 0;
-  if (!isRecord$1(value) || typeof value.x !== "number" || typeof value.y !== "number" || !Number.isFinite(value.x) || !Number.isFinite(value.y)) {
+  if (!isRecord$2(value) || typeof value.x !== "number" || typeof value.y !== "number" || !Number.isFinite(value.x) || !Number.isFinite(value.y)) {
     throw new AssetMetadataError(`${asset}: offset is not an x and a y in pixels`);
   }
   for (const axis of ["x", "y"]) {
@@ -1701,7 +1797,7 @@ function readDrawScale(value, asset) {
   return value;
 }
 function readEntry(value, asset) {
-  if (!isRecord$1(value)) {
+  if (!isRecord$2(value)) {
     throw new AssetMetadataError(`${asset}: not an entry`);
   }
   const kind = value.kind;
@@ -1746,7 +1842,7 @@ function parseAssetMetadata(text2) {
   } catch (error) {
     throw new AssetMetadataError(`not JSON: ${error.message}`);
   }
-  if (!isRecord$1(parsed2)) {
+  if (!isRecord$2(parsed2)) {
     throw new AssetMetadataError("not an object");
   }
   const version2 = parsed2.version;
@@ -1754,7 +1850,7 @@ function parseAssetMetadata(text2) {
     throw new AssetMetadataError(`unsupported version ${String(version2)}, reader speaks v${METADATA_VERSION}`);
   }
   const rawAssets = parsed2.assets;
-  if (rawAssets !== void 0 && !isRecord$1(rawAssets)) {
+  if (rawAssets !== void 0 && !isRecord$2(rawAssets)) {
     throw new AssetMetadataError("assets is not a map of name to entry");
   }
   const assets = /* @__PURE__ */ new Map();
@@ -1949,117 +2045,67 @@ function placeTileSprite(tx, ty, width, height, options = {}) {
     height: scaledHeight
   };
 }
-class MapTextError extends Error {
-  // Assigned in the body: the suites run under Node's strip-only TypeScript
-  // mode, which rejects parameter properties (docs/notes.md n-0023).
-  constructor(message) {
-    super(message);
-    this.name = "MapTextError";
-  }
-}
-function tileKey(x, y, z) {
-  return `${x}:${y}:${z}`;
-}
-function scanTileSources(text2) {
-  const key = '"tiles"';
-  let at = text2.indexOf(key);
-  if (at === -1) return [];
-  at = text2.indexOf("[", at + key.length);
-  if (at === -1) return [];
-  const sources = [];
-  let depth = 0;
-  let inString = false;
-  let start = -1;
-  for (let index = at + 1; index < text2.length; index += 1) {
-    const char = text2[index];
-    if (inString) {
-      if (char === "\\") index += 1;
-      else if (char === '"') inString = false;
-      continue;
-    }
-    if (char === '"') {
-      inString = true;
-    } else if (char === "{") {
-      if (depth === 0) start = index;
-      depth += 1;
-    } else if (char === "}") {
-      depth -= 1;
-      if (depth === 0 && start !== -1) {
-        sources.push(text2.slice(start, index + 1));
-        start = -1;
-      }
-    } else if (char === "]" && depth === 0) {
-      break;
-    }
-  }
-  return sources;
-}
-function isTile(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const record = value;
-  return typeof record.x === "number" && typeof record.y === "number" && typeof record.z === "number" && Array.isArray(record.layers);
-}
-function parseMapText(text2, path = "the map") {
-  let parsed2;
-  try {
-    parsed2 = JSON.parse(text2);
-  } catch (error) {
-    throw new MapTextError(`${path} is not valid JSON: ${error.message}`);
-  }
-  if (typeof parsed2 !== "object" || parsed2 === null || !Array.isArray(parsed2.tiles)) {
-    throw new MapTextError(`${path} holds no tiles array`);
-  }
-  const document = parsed2;
-  const sources = scanTileSources(text2);
-  if (sources.length !== document.tiles.length) {
-    throw new MapTextError(`${path}: the scanner found ${sources.length} tile sources for ${document.tiles.length} tiles`);
+const WINDOW_PX = { width: 1536, height: 1024 };
+const SCALES = [TILE_SIZE, TILE_SIZE / 2, TILE_SIZE / 4, TILE_SIZE / 8, TILE_SIZE / 16];
+function scaleFor(tilesWide, tilesHigh) {
+  if (tilesWide <= 0 || tilesHigh <= 0) return null;
+  for (const scale of SCALES) {
+    if (tilesWide * scale <= WINDOW_PX.width && tilesHigh * scale <= WINDOW_PX.height) return scale;
   }
-  const byKey = /* @__PURE__ */ new Map();
-  document.tiles.forEach((tile, index) => {
-    if (!isTile(tile)) throw new MapTextError(`${path}: tile ${index} lacks x, y, z or layers`);
-    byKey.set(tileKey(tile.x, tile.y, tile.z), { tile, source: sources[index] });
-  });
-  return { document, sources: byKey };
+  return null;
 }
-const TILE_KEYS = ["x", "y", "z", "layers", "blocking", "zone", "audioZone", "interact"];
-function serializeTile(tile) {
-  const ordered = {};
-  for (const key of TILE_KEYS) {
-    if (tile[key] !== void 0) ordered[key] = tile[key];
-  }
-  for (const key of Object.keys(tile)) {
-    if (!(key in ordered) && tile[key] !== void 0) ordered[key] = tile[key];
+({
+  width: Math.floor(WINDOW_PX.width / SCALES.at(-1)),
+  height: Math.floor(WINDOW_PX.height / SCALES.at(-1))
+});
+Array.from({ length: 16 }, (_value, index) => index);
+const REFERENCE_FILE = /^[A-Za-z0-9_-][A-Za-z0-9._-]*(?:\/[A-Za-z0-9_-][A-Za-z0-9._-]*)*\.png$/i;
+class ArtError extends Error {
+  // Assigned in the body: Node's strip-only TypeScript mode rejects parameter
+  // properties (docs/notes.md n-0023).
+  constructor(message) {
+    super(message);
+    this.name = "ArtError";
   }
-  return JSON.stringify(ordered);
 }
-function formatMap(next, previous) {
-  const lines = [];
-  let changed = 0;
-  for (const tile of next.tiles) {
-    {
-      lines.push(serializeTile(tile));
-      changed += 1;
+const CONTAINER_FILE = join("build", "assets.eac");
+const STYLE_GUIDE_FILE$1 = "style-guide.md";
+const REFERENCE_DIRECTORY = "ref";
+async function listReferences(boundary, artDirectory) {
+  const root = join(artDirectory, REFERENCE_DIRECTORY);
+  const names = [];
+  const walk = async (directory, prefix) => {
+    let entries;
+    try {
+      entries = await readdir(await boundary.resolve(directory), { withFileTypes: true });
+    } catch {
+      return;
     }
+    for (const entry of entries) {
+      const relative2 = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) await walk(join(directory, entry.name), relative2);
+      else if (entry.name.toLowerCase().endsWith(".png")) names.push(relative2);
+    }
+  };
+  await walk(root, "");
+  return names.sort();
+}
+async function readReference(boundary, artDirectory, name) {
+  if (!REFERENCE_FILE.test(name) || name.split("/").includes("..")) {
+    throw new ArtError(`${name} is not a reference under ${REFERENCE_DIRECTORY}/`);
   }
-  const rest = {};
-  for (const key of Object.keys(next)) {
-    if (key !== "width" && key !== "height" && key !== "tiles") rest[key] = next[key];
-  }
-  const trailer = Object.keys(rest).length === 0 ? "" : `,${JSON.stringify(rest).slice(1, -1)}`;
-  const head = `{"width":${JSON.stringify(next.width)},"height":${JSON.stringify(next.height)},"tiles":[`;
-  const body = lines.length === 0 ? "" : `
-${lines.join(",\n")}
-`;
-  return { text: `${head}${body}]${trailer}}
-`, changed };
+  return boundary.readBytes(join(artDirectory, REFERENCE_DIRECTORY, name));
 }
+const MANIFEST_DIRECTORY = "manifest";
+const OUT_DIRECTORY = "out";
+const ID_MAP_FILE = "id-map.json";
 const MAX_SIDE$1 = 65535;
 const encoder$1 = new TextEncoder();
-function isRecord(value) {
+function isRecord$1(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function metadataOf(entry) {
-  const raw = isRecord(entry.meta) && entry.meta.kind === void 0 ? { kind: "tile", ...entry.meta } : entry.meta;
+  const raw = isRecord$1(entry.meta) && entry.meta.kind === void 0 ? { kind: "tile", ...entry.meta } : entry.meta;
   try {
     const parsed2 = parseAssetMetadata(JSON.stringify({ version: METADATA_VERSION, assets: { [entry.name]: raw } }));
     return parsed2.assets.get(entry.name);
@@ -2109,115 +2155,737 @@ function sealProjectArt(art) {
   }
   return { container: sealContainer([...entries, ...pages]), pictures: pictures.length, described: described.size };
 }
-const GROUND_KINDS = /* @__PURE__ */ new Set(["ground", "floor", "wall", "cliff", "interior", "grass-stone"]);
-function isGroundName(name) {
-  const { inner } = splitTileset(name);
-  const kind = inner.split("/")[1] ?? "";
-  return GROUND_KINDS.has(kind) || inner.includes("/wang-");
+const PROJECT_SEAL_STEP = "project:seal";
+const MAX_PICTURE_BYTES = 64 * 1024 * 1024;
+const MAX_TEXT_BYTES = 16 * 1024 * 1024;
+const MAX_PICTURES = 2e4;
+function shown(artDirectory, relative2) {
+  return [basename(artDirectory), ...relative2.split(/[\\/]/)].join("/");
+}
+async function sized(boundary, path, most, what) {
+  const { size } = await stat(await boundary.resolve(path));
+  if (size > most) throw new ProjectError(`${what} is ${size} bytes, and one is read at most ${most}`);
+}
+async function readPictures(boundary, artDirectory) {
+  const pictures = [];
+  const walk = async (directory, prefix) => {
+    let entries;
+    try {
+      entries = await readdir(await boundary.resolve(directory), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const name = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) await walk(join(directory, entry.name), name);
+      else if (entry.isFile() && entry.name.endsWith(".png")) {
+        if (pictures.length >= MAX_PICTURES) throw new ProjectError(`${shown(artDirectory, OUT_DIRECTORY)} holds more than ${MAX_PICTURES} pictures`);
+        const path = join(directory, entry.name);
+        await sized(boundary, path, MAX_PICTURE_BYTES, `${shown(artDirectory, OUT_DIRECTORY)}/${name}`);
+        pictures.push({ name: name.slice(0, -".png".length), bytes: await boundary.readBytes(path) });
+      }
+    }
+  };
+  await walk(join(artDirectory, OUT_DIRECTORY), "");
+  return pictures;
+}
+async function readEntries(boundary, artDirectory) {
+  const directory = join(artDirectory, MANIFEST_DIRECTORY);
+  const entries = [];
+  for (const file of (await boundary.list(directory)).filter((name) => name.endsWith(".json")).sort()) {
+    let manifest2;
+    await sized(boundary, join(directory, file), MAX_TEXT_BYTES, `${MANIFEST_DIRECTORY}/${file}`);
+    try {
+      manifest2 = JSON.parse(await boundary.readText(join(directory, file)));
+    } catch (error) {
+      throw new ProjectError(`${MANIFEST_DIRECTORY}/${file} is not valid JSON: ${error.message}`);
+    }
+    if (typeof manifest2 !== "object" || manifest2 === null || Array.isArray(manifest2)) throw new ProjectError(`${MANIFEST_DIRECTORY}/${file} is not an object`);
+    for (const [name, entry] of Object.entries(manifest2)) {
+      if (name.startsWith("$")) continue;
+      entries.push({ name, meta: entry?.meta });
+    }
+  }
+  return entries;
+}
+async function readIdMap(boundary, artDirectory) {
+  const path = join(artDirectory, ID_MAP_FILE);
+  if (!await boundary.exists(path)) return null;
+  await sized(boundary, path, MAX_TEXT_BYTES, shown(artDirectory, ID_MAP_FILE));
+  return boundary.readText(path);
+}
+async function readProjectArt(boundary, artDirectory) {
+  return {
+    pictures: await readPictures(boundary, artDirectory),
+    entries: await readEntries(boundary, artDirectory),
+    idMap: await readIdMap(boundary, artDirectory)
+  };
+}
+async function readProjectMap(boundary, artDirectory) {
+  const path = join(artDirectory, "map.json");
+  if (!await boundary.exists(path)) return null;
+  await sized(boundary, path, MAX_TEXT_BYTES, shown(artDirectory, "map.json"));
+  return boundary.readText(path);
+}
+const MAX_MIRRORED_SECTOR_BYTES = 256 * 1024;
+const inflated$1 = promisify(inflate);
+async function readMirroredProjectMap(boundary, artDirectory) {
+  const indexPath = join(artDirectory, MIRROR_INDEX_FILE);
+  if (!await boundary.exists(indexPath)) return null;
+  await sized(boundary, indexPath, MAX_TEXT_BYTES, shown(artDirectory, MIRROR_INDEX_FILE));
+  const index = parseMirrorIndex(await boundary.readText(indexPath));
+  return readMirroredMap(
+    index,
+    async (relative2) => {
+      const path = join(artDirectory, relative2);
+      await sized(boundary, path, MAX_MIRRORED_SECTOR_BYTES, shown(artDirectory, relative2));
+      return boundary.readBytes(path);
+    },
+    async (bytes) => new Uint8Array(await inflated$1(bytes, { maxOutputLength: SECTOR_BYTES }))
+  );
+}
+async function sealProject(boundary, artDirectory) {
+  try {
+    const sealed = sealProjectArt(await readProjectArt(boundary, artDirectory));
+    await boundary.writeFileReplacing(join(artDirectory, CONTAINER_FILE), sealed.container);
+    const pictures = `${sealed.pictures} ${sealed.pictures === 1 ? "picture" : "pictures"}`;
+    const described = `${sealed.described} ${sealed.described === 1 ? "asset" : "assets"} described`;
+    return [{ step: PROJECT_SEAL_STEP, code: 0, output: `sealed ${pictures} into ${shown(artDirectory, CONTAINER_FILE)}, ${described}` }];
+  } catch (error) {
+    if (!(error instanceof ProjectError)) throw error;
+    return [{ step: PROJECT_SEAL_STEP, code: 1, output: `the container was not rebuilt: ${error.message}` }];
+  }
+}
+const MIRROR_FILE = ".mirror.json";
+const MOVING_FILE = ".moving";
+const ASIDE_DIRECTORY = "before-platform";
+const OWN = ["map.json", OUT_DIRECTORY, MANIFEST_DIRECTORY, ID_MAP_FILE, REFERENCE_DIRECTORY, STYLE_GUIDE_FILE$1];
+const MAX_SECTOR_FILE_BYTES = 256 * 1024;
+const MANIFEST_NAME = /^[a-z][a-z0-9-]{0,39}$/;
+const IMAGE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const MAX_RECORD_BYTES$1 = MAX_TEXT_BYTES;
+const MAX_FOLDER_BYTES = 1024 * 1024 * 1024;
+class MirrorRefused extends Error {
+  // Assigned in the body: Node's strip-only TypeScript mode rejects parameter
+  // properties (docs/notes.md n-0023).
+  constructor(message) {
+    super(message);
+    this.name = "MirrorRefused";
+  }
+}
+async function readMirrorFile(boundary, art) {
+  const path = join(art, MIRROR_FILE);
+  if (!await boundary.exists(path)) return { format: MIRROR_FORMAT, art: null };
+  let read = null;
+  await sized(boundary, path, MAX_RECORD_BYTES$1, MIRROR_FILE);
+  try {
+    read = JSON.parse(await boundary.readText(path));
+  } catch {
+    throw new MirrorRefused(`${MIRROR_FILE} is not JSON: remove it and the mirror is written again`);
+  }
+  if (read === null || read.format !== MIRROR_FORMAT) throw new MirrorRefused(`${MIRROR_FILE} is not a mirror's record this editor reads`);
+  const index = read.art ?? null;
+  const record = (value) => typeof value === "object" && value !== null && Object.values(value).every((id2) => typeof id2 === "string");
+  if (index !== null && (!record(index.pictures) || !record(index.references) || !Array.isArray(index.manifests))) {
+    throw new MirrorRefused(`${MIRROR_FILE} does not say what the mirror holds: remove it and the mirror is written again`);
+  }
+  if (index !== null) {
+    const named = [...Object.keys(index.pictures), ...Object.keys(index.references)];
+    const bad = named.find((name) => nameProblem(name) !== null) ?? index.manifests.find((manifest2) => typeof manifest2 !== "string" || !MANIFEST_NAME.test(manifest2));
+    if (bad !== void 0)
+      throw new MirrorRefused(`${MIRROR_FILE} names ${String(bad)}, which the mirror never writes: remove it and the mirror is written again`);
+  }
+  return { format: MIRROR_FORMAT, art: index };
+}
+async function writeMirrorFile(boundary, art, file) {
+  await boundary.writeFileReplacing(join(art, MIRROR_FILE), `${JSON.stringify(file, null, 2)}
+`);
+}
+async function isMirrored(boundary, art) {
+  return await boundary.exists(join(art, MIRROR_FILE)) || await boundary.exists(join(art, MIRROR_INDEX_FILE));
+}
+async function holdsAny(boundary, directory) {
+  if (!await boundary.exists(directory)) return false;
+  for (const entry of await readdir(await boundary.resolve(directory), { withFileTypes: true })) {
+    if (!entry.isDirectory() || await holdsAny(boundary, join(directory, entry.name))) return true;
+  }
+  return false;
+}
+async function paintsAny(boundary, path) {
+  if (!await boundary.exists(path)) return false;
+  await sized(boundary, path, MAX_TEXT_BYTES, "map.json");
+  try {
+    const map = parseMapText(await boundary.readText(path), "pixelvibing/map.json").document;
+    const SCAFFOLD_TILE = /* @__PURE__ */ new Set(["x", "y", "z", "layers", "blocking", "zone"]);
+    if (Object.keys(map).some((key) => key !== "width" && key !== "height" && key !== "tiles")) return true;
+    return map.tiles.some(
+      (tile) => tile.layers.length > 0 || tile.blocking !== 0 || tile.zone !== 0 || Object.keys(tile).some((key) => !SCAFFOLD_TILE.has(key))
+    );
+  } catch {
+    return true;
+  }
+}
+async function mirrorState(boundary, art) {
+  const file = await readMirrorFile(boundary, art);
+  const indexPath = join(art, MIRROR_INDEX_FILE);
+  const mirrored2 = await isMirrored(boundary, art);
+  const movingPath = join(art, MOVING_FILE);
+  const readSized = async (path, what) => {
+    await sized(boundary, path, MAX_RECORD_BYTES$1, what);
+    return boundary.readText(path);
+  };
+  const moving = await boundary.exists(movingPath) ? (await readSized(movingPath, MOVING_FILE)).trim() : "";
+  return {
+    map: await boundary.exists(indexPath) ? parseMirrorIndex(await readSized(indexPath, MIRROR_INDEX_FILE)) : null,
+    art: file.art,
+    moving: moving === "" ? null : moving,
+    mirrored: mirrored2,
+    own: mirrored2 ? { map: false, art: false } : {
+      map: await paintsAny(boundary, join(art, "map.json")),
+      art: await holdsAny(boundary, join(art, OUT_DIRECTORY)) || await holdsAny(boundary, join(art, REFERENCE_DIRECTORY))
+    }
+  };
+}
+async function markMoving(boundary, art, project) {
+  if (project === null) return boundary.removeFile(join(art, MOVING_FILE));
+  if (!IMAGE_ID.test(project)) throw new MirrorRefused("a folder is moved onto a platform project named by its id");
+  await boundary.writeFileReplacing(join(art, MOVING_FILE), `${project}
+`);
+}
+async function setAside(boundary, art) {
+  if (await isMirrored(boundary, art)) return;
+  const held = [];
+  for (const name of OWN) if (await boundary.exists(join(art, name))) held.push(name);
+  if (held.length > 0) {
+    let aside = join(art, ASIDE_DIRECTORY);
+    for (let second = 2; await boundary.exists(aside); second += 1) aside = join(art, `${ASIDE_DIRECTORY}-${second}`);
+    await boundary.writeFileReplacing(join(aside, ".kept"), "the folder's own, before it was a mirror of its platform project\n");
+    for (const name of held) await rename(await boundary.resolve(join(art, name)), await boundary.resolve(join(aside, name)));
+  }
+  await writeMirrorFile(boundary, art, { format: MIRROR_FORMAT, art: null });
+}
+const MOST_MANIFEST_BYTES = MAX_TEXT_BYTES;
+async function readFolder(boundary, art) {
+  if (await isMirrored(boundary, art)) throw new MirrorRefused("this folder is already a mirror: it holds nothing of its own to move");
+  const read = await readProjectArt(boundary, art);
+  const assets = [];
+  const directory = join(art, MANIFEST_DIRECTORY);
+  const files = await boundary.exists(directory) ? (await boundary.list(directory)).filter((name) => name.endsWith(".json")).sort() : [];
+  for (const file of files) {
+    const manifest2 = file.slice(0, -".json".length);
+    if (!MANIFEST_NAME.test(manifest2)) throw new MirrorRefused(`${MANIFEST_DIRECTORY}/${file} is not a manifest the platform keeps: rename it`);
+    const text2 = await boundary.readText(join(directory, file));
+    if (text2.length > MOST_MANIFEST_BYTES) throw new MirrorRefused(`${MANIFEST_DIRECTORY}/${file} is past what a manifest may weigh`);
+    let entries;
+    try {
+      entries = JSON.parse(text2);
+    } catch {
+      throw new MirrorRefused(`${MANIFEST_DIRECTORY}/${file} is not JSON`);
+    }
+    if (typeof entries !== "object" || entries === null || Array.isArray(entries)) throw new MirrorRefused(`${MANIFEST_DIRECTORY}/${file} is not a manifest`);
+    for (const [name, entry] of Object.entries(entries)) {
+      if (typeof entry === "object" && entry !== null) assets.push({ name: checkedName(name, "the asset"), manifest: manifest2, entry });
+    }
+  }
+  const idMap = {};
+  if (read.idMap !== null) {
+    let parsed2 = {};
+    try {
+      parsed2 = JSON.parse(read.idMap);
+    } catch {
+      throw new MirrorRefused(`${ID_MAP_FILE} is not JSON`);
+    }
+    for (const [id2, name] of Object.entries(parsed2.looktypes ?? {})) if (typeof name === "string") idMap[id2] = name;
+  }
+  let total = read.pictures.reduce((sum, picture) => sum + picture.bytes.length, 0);
+  if (total > MAX_FOLDER_BYTES) throw new MirrorRefused(`this folder's pictures weigh past ${MAX_FOLDER_BYTES / 1024 / 1024} MB, more than one move sends`);
+  const references = [];
+  for (const file of await listReferences(boundary, art)) {
+    await sized(boundary, join(art, REFERENCE_DIRECTORY, file), MAX_PICTURE_BYTES, `${REFERENCE_DIRECTORY}/${file}`);
+    const bytes = await readReference(boundary, art, file);
+    total += bytes.length;
+    if (total > MAX_FOLDER_BYTES) throw new MirrorRefused(`this folder's pictures weigh past ${MAX_FOLDER_BYTES / 1024 / 1024} MB, more than one move sends`);
+    references.push({ name: file.replace(/\.png$/i, ""), bytes });
+  }
+  return { map: await readProjectMap(boundary, art), assets, pictures: read.pictures.map(({ name, bytes }) => ({ name, bytes })), idMap, references };
+}
+function checkedName(name, what) {
+  const problem = typeof name === "string" ? nameProblem(name) : "it is not text";
+  if (problem !== null) throw new MirrorRefused(`${what} ${String(name)} cannot be written to the folder: ${problem}`);
+  return name;
+}
+async function writeMapMirror(boundary, art, mirror) {
+  await setAside(boundary, art);
+  const current = await mirrorState(boundary, art);
+  const versions = new Map(
+    (current.map?.sectors ?? []).map((sector) => [sector.slice(0, 3).join(":"), sector])
+  );
+  for (const sector of mirror.write) {
+    const path = mirrorSectorPath(sector.z, sector.cx, sector.cy);
+    if (!(sector.data instanceof Uint8Array) || sector.data.length > MAX_SECTOR_FILE_BYTES) throw new MirrorRefused(`${path} is past what a sector is kept in`);
+    if (!Number.isInteger(sector.version) || sector.version < 1) throw new MirrorRefused(`${path} names no version`);
+    await boundary.writeFileReplacing(join(art, path), sector.data);
+    versions.set(`${sector.z}:${sector.cx}:${sector.cy}`, [sector.z, sector.cx, sector.cy, sector.version]);
+  }
+  const dropped = mirror.drop.map((place) => mirrorSectorPath(place.z, place.cx, place.cy));
+  for (const place of mirror.drop) versions.delete(`${place.z}:${place.cx}:${place.cy}`);
+  const index = parseMirrorIndex(
+    mirrorIndexText({
+      format: MIRROR_FORMAT,
+      revision: mirror.revision,
+      size: mirror.size,
+      limit: mirror.limit,
+      names: mirror.names,
+      sectors: [...versions.values()]
+    })
+  );
+  await boundary.writeFileReplacing(join(art, MIRROR_INDEX_FILE), mirrorIndexText(index));
+  for (const path of dropped) await boundary.removeFile(join(art, path)).catch(() => void 0);
+  return index;
+}
+function checkedPictures(pictures, held, what) {
+  const names = Object.keys(pictures);
+  if (names.length > MAX_PICTURES) throw new MirrorRefused(`the mirror holds at most ${MAX_PICTURES} ${what}s`);
+  for (const name of names) {
+    checkedName(name, `the ${what}`);
+    const picture = pictures[name];
+    if (typeof picture.image !== "string" || !IMAGE_ID.test(picture.image)) throw new MirrorRefused(`the ${what} ${name} names no image`);
+    if (picture.bytes === void 0) {
+      if (held[name] !== picture.image) throw new MirrorRefused(`the ${what} ${name} comes with no bytes, and the folder does not hold its image`);
+      continue;
+    }
+    if (!(picture.bytes instanceof Uint8Array) || picture.bytes.length > MAX_PICTURE_BYTES || !isPng(picture.bytes)) {
+      throw new MirrorRefused(`the ${what} ${name} is not a PNG the folder can keep`);
+    }
+  }
+}
+async function writeArtMirror(boundary, art, mirror) {
+  await setAside(boundary, art);
+  const file = await readMirrorFile(boundary, art);
+  const before = file.art ?? { pictures: {}, references: {}, manifests: [] };
+  checkedPictures(mirror.pictures, before.pictures, "picture");
+  checkedPictures(mirror.references, before.references, "reference");
+  const manifests = /* @__PURE__ */ new Map();
+  for (const asset of mirror.assets) {
+    checkedName(asset.name, "the asset");
+    if (typeof asset.manifest !== "string" || !MANIFEST_NAME.test(asset.manifest)) throw new MirrorRefused(`${asset.name} names no manifest the folder keeps`);
+    const entries = manifests.get(asset.manifest) ?? {};
+    entries[asset.name] = asset.entry;
+    manifests.set(asset.manifest, entries);
+  }
+  const looktypes = {};
+  for (const [id2, name] of Object.entries(mirror.idMap)) {
+    if (!/^[0-9]+$/.test(id2)) throw new MirrorRefused(`the id map names an id that is none: ${id2}`);
+    looktypes[id2] = checkedName(name, "the id map's asset");
+  }
+  if (mirror.styleGuide !== null && (typeof mirror.styleGuide !== "string" || mirror.styleGuide.length > MAX_TEXT_BYTES)) {
+    throw new MirrorRefused("the style guide is not text the folder can keep");
+  }
+  for (const [name, picture] of Object.entries(mirror.pictures)) {
+    if (picture.bytes !== void 0) await boundary.writeFileReplacing(join(art, OUT_DIRECTORY, `${name}.png`), picture.bytes);
+  }
+  for (const [name, picture] of Object.entries(mirror.references)) {
+    if (picture.bytes !== void 0) await boundary.writeFileReplacing(join(art, REFERENCE_DIRECTORY, `${name}.png`), picture.bytes);
+  }
+  for (const [manifest2, entries] of manifests) {
+    await boundary.writeFileReplacing(join(art, MANIFEST_DIRECTORY, `${manifest2}.json`), `${JSON.stringify(entries, null, 2)}
+`);
+  }
+  await boundary.writeFileReplacing(join(art, ID_MAP_FILE), `${JSON.stringify({ looktypes }, null, 2)}
+`);
+  if (mirror.styleGuide !== null) await boundary.writeFileReplacing(join(art, STYLE_GUIDE_FILE$1), mirror.styleGuide);
+  const index = {
+    revision: mirror.revision,
+    pictures: Object.fromEntries(Object.entries(mirror.pictures).map(([name, picture]) => [name, picture.image])),
+    references: Object.fromEntries(Object.entries(mirror.references).map(([name, picture]) => [name, picture.image])),
+    manifests: [...manifests.keys()].sort()
+  };
+  await writeMirrorFile(boundary, art, { ...file, art: index });
+  const gone = async (relative2) => boundary.removeFile(join(art, relative2)).catch(() => void 0);
+  for (const name of Object.keys(before.pictures)) if (index.pictures[name] === void 0) await gone(join(OUT_DIRECTORY, `${name}.png`));
+  for (const name of Object.keys(before.references)) if (index.references[name] === void 0) await gone(join(REFERENCE_DIRECTORY, `${name}.png`));
+  for (const manifest2 of before.manifests) if (!index.manifests.includes(manifest2)) await gone(join(MANIFEST_DIRECTORY, `${manifest2}.json`));
+  return index;
+}
+const SECTOR_SIDE = 128;
+const MOST_READ = 32;
+const MOST_WAIT_SECONDS$1 = 60;
+const WRITTEN_AT_ONCE = 64;
+const pause = (seconds) => new Promise((done) => setTimeout(done, seconds * 1e3));
+async function patiently(deps, attempt, most = MOST_WAIT_SECONDS$1) {
+  let waited = 0;
+  for (; ; ) {
+    try {
+      return await attempt();
+    } catch (error) {
+      const wait = error instanceof ApiError && error.status === 429 ? Math.max(1, Math.min(error.retryAfter ?? 1, 30)) : null;
+      if (wait === null || waited + wait > most) throw error;
+      waited += wait;
+      await (deps.wait ?? pause)(wait);
+    }
+  }
+}
+function fromBase64(text2) {
+  const binary = atob(text2);
+  const bytes = new Uint8Array(binary.length);
+  for (let at = 0; at < binary.length; at += 1) bytes[at] = binary.charCodeAt(at);
+  return bytes;
+}
+function readsOf(places) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const [cx, cy] of places) rows.set(cy, [...rows.get(cy) ?? [], cx]);
+  const reads = [];
+  for (const [cy, columns] of [...rows.entries()].sort((a, b) => a[0] - b[0])) {
+    const sorted = [...columns].sort((a, b) => a - b);
+    let from = sorted[0];
+    let to = from;
+    for (const cx of sorted.slice(1)) {
+      if (cx - from + 1 > MOST_READ) {
+        reads.push({ cy, from, to });
+        from = cx;
+      }
+      to = cx;
+    }
+    reads.push({ cy, from, to });
+  }
+  return reads;
+}
+async function syncMap(deps) {
+  const base = `/projects/${encodeURIComponent(deps.project)}/map`;
+  const get = (path) => patiently(deps, async () => (await deps.call(path)).json());
+  const outline = await get(base);
+  const held = (await deps.mirror.state()).map;
+  const holds = new Map((held?.sectors ?? []).map(([z, cx, cy, version2]) => [`${z}:${cx}:${cy}`, version2]));
+  const names = outline.levels.flatMap((level) => level.name === null ? [] : [{ z: level.z, name: level.name }]);
+  const meta = { revision: outline.revision, size: outline.size, limit: outline.limit, names };
+  const kept = /* @__PURE__ */ new Set();
+  let index = null;
+  let pending = [];
+  const flush = async () => {
+    if (pending.length === 0) return;
+    index = await deps.mirror.map({ ...meta, write: pending, drop: [] });
+    pending = [];
+  };
+  for (const { z } of outline.levels) {
+    const versions = await get(`${base}/versions?z=${z}`);
+    const changed = [];
+    const wanted = /* @__PURE__ */ new Map();
+    for (const [cx, cy, version2] of versions.sectors) {
+      kept.add(`${z}:${cx}:${cy}`);
+      if (holds.get(`${z}:${cx}:${cy}`) !== version2) {
+        changed.push([cx, cy]);
+        wanted.set(`${cx}:${cy}`, version2);
+      }
+    }
+    for (const read of readsOf(changed)) {
+      const area = {
+        z,
+        left: read.from * SECTOR_SIDE,
+        top: read.cy * SECTOR_SIDE,
+        right: Math.min(read.to * SECTOR_SIDE + SECTOR_SIDE - 1, outline.size.width - 1),
+        bottom: Math.min(read.cy * SECTOR_SIDE + SECTOR_SIDE - 1, outline.size.height - 1)
+      };
+      const query = `z=${area.z}&left=${area.left}&top=${area.top}&right=${area.right}&bottom=${area.bottom}`;
+      const found = await get(`${base}/sectors?${query}`);
+      for (const sector of found.sectors) {
+        if (!wanted.has(`${sector.cx}:${sector.cy}`)) continue;
+        pending.push({ z, cx: sector.cx, cy: sector.cy, version: sector.version, data: fromBase64(sector.data) });
+        if (pending.length >= WRITTEN_AT_ONCE) await flush();
+      }
+    }
+  }
+  await flush();
+  const drop = [...holds.keys()].filter((key) => !kept.has(key)).map((key) => {
+    const [z, cx, cy] = key.split(":").map(Number);
+    return { z, cx, cy };
+  });
+  if (drop.length > 0 || index === null) index = await deps.mirror.map({ ...meta, write: [], drop });
+  return index;
+}
+async function syncArt(deps) {
+  const base = `/projects/${encodeURIComponent(deps.project)}`;
+  const get = (path) => patiently(deps, async () => (await deps.call(path)).json());
+  const bytes = (image) => patiently(deps, async () => new Uint8Array(await (await deps.call(`/images/${encodeURIComponent(image)}`)).arrayBuffer()));
+  const art = await get(`${base}/art`);
+  const references = await get(`${base}/art/references`);
+  let styleGuide = null;
+  try {
+    styleGuide = (await get(`${base}/style-guide`)).text;
+  } catch (error) {
+    if (!(error instanceof ApiError && error.status === 404)) throw error;
+  }
+  const held = (await deps.mirror.state()).art;
+  const pictureOf = async (name, image, holds) => holds?.[name] === image ? { image } : { image, bytes: await bytes(image) };
+  const pictures = {};
+  for (const [name, image] of Object.entries(art.pictures)) pictures[name] = await pictureOf(name, image, held?.pictures);
+  const referenced = {};
+  for (const { name, image } of references) referenced[name] = await pictureOf(name, image, held?.references);
+  await deps.mirror.art({ revision: art.revision, assets: art.assets, pictures, idMap: art.idMap, references: referenced, styleGuide });
+}
+function mirrorOf(local) {
+  const art = artOf(local);
+  const boundary = new Boundary([art]);
+  return {
+    state: () => mirrorState(boundary, art),
+    map: (each) => writeMapMirror(boundary, art, each),
+    art: (each) => writeArtMirror(boundary, art, each),
+    folder: () => readFolder(boundary, art),
+    moving: (project) => markMoving(boundary, art, project)
+  };
+}
+const deflated = promisify(deflate);
+const inflated = promisify(inflate);
+const nodeZlib = {
+  deflate: async (bytes) => new Uint8Array(await deflated(bytes)),
+  inflate: async (bytes) => new Uint8Array(await inflated(bytes, { maxOutputLength: SECTOR_BYTES }))
+};
+const HOLDS_ITS_OWN = "this folder holds a map or art of its own, written before it was its platform project's: move it onto the platform with `pixel-vibing-cli move`, or pass --aside to keep its own files under pixelvibing/before-platform/";
+async function checkFolder(local, aside) {
+  const state = await mirrorOf(local).state();
+  if (state.moving !== null) throw new CliError("a move of this folder onto the platform stopped before it was done: run `pixel-vibing-cli move` again");
+  if (!aside && !state.mirrored && (state.own.map || state.own.art)) throw new CliError(HOLDS_ITS_OWN);
+}
+async function bringFolder(platform, local, options) {
+  await checkFolder(local, options.aside);
+  const deps = { project: linkedOf(local), call: platform.call, mirror: mirrorOf(local) };
+  if (options.map) await syncMap(deps);
+  await syncArt(deps);
+}
+const PULLED_FILE = `${PROJECT_DIRECTORY}/pulled.json`;
+const PULLED_FORMAT = 1;
+const HEX64 = /^[0-9a-f]{64}$/;
+const UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const EMPTY_PULLED = { guide: null, assets: {} };
+class PulledError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PulledError";
+  }
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isPulledPath(path) {
+  const directory = path.startsWith("out/") ? "out/" : path.startsWith("ref/") ? "ref/" : null;
+  if (directory === null || !path.endsWith(".png")) return false;
+  const name = path.slice(directory.length, -".png".length);
+  return !name.includes("\\") && nameProblem(name) === null;
+}
+function assetOf(id2, raw) {
+  if (!UUID.test(id2)) throw new PulledError(`${PULLED_FILE}: ${id2} is not an asset's id`);
+  if (!isRecord(raw)) throw new PulledError(`${PULLED_FILE}: the asset ${id2} is not an object`);
+  const { kind, name, hash, files } = raw;
+  if (typeof kind !== "string" || kind === "") throw new PulledError(`${PULLED_FILE}: the asset ${id2} names no kind`);
+  if (typeof name !== "string" || name === "") throw new PulledError(`${PULLED_FILE}: the asset ${id2} names no name`);
+  if (typeof hash !== "string" || !HEX64.test(hash)) throw new PulledError(`${PULLED_FILE}: the asset ${id2} has no hash`);
+  if (!Array.isArray(files) || files.length === 0 || !files.every((file) => typeof file === "string" && isPulledPath(file))) {
+    throw new PulledError(`${PULLED_FILE}: the asset ${id2} names a file that is not a picture under out/ or ref/`);
+  }
+  return { kind, name, hash, files };
+}
+function guideOf(raw) {
+  if (raw === void 0 || raw === null) return null;
+  if (!isRecord(raw) || !Number.isInteger(raw.version) || raw.version < 1 || typeof raw.sha256 !== "string" || !HEX64.test(raw.sha256)) {
+    throw new PulledError(`${PULLED_FILE}: the style guide's entry is not a version and a digest`);
+  }
+  return { version: raw.version, sha256: raw.sha256 };
+}
+function readPulled(text2) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(text2);
+  } catch (error) {
+    throw new PulledError(`${PULLED_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (!isRecord(parsed2)) throw new PulledError(`${PULLED_FILE} is not an object`);
+  if (parsed2.format !== PULLED_FORMAT) throw new PulledError(`${PULLED_FILE} names no format this CLI reads: expected "format": ${PULLED_FORMAT}`);
+  const assets = {};
+  if (parsed2.assets !== void 0) {
+    if (!isRecord(parsed2.assets)) throw new PulledError(`${PULLED_FILE}: "assets" is not an object`);
+    for (const [id2, raw] of Object.entries(parsed2.assets)) assets[id2] = assetOf(id2, raw);
+  }
+  return { guide: guideOf(parsed2.guide), assets };
+}
+function writePulled(record) {
+  return `${JSON.stringify({ format: PULLED_FORMAT, ...record.guide === null ? {} : { guide: record.guide }, assets: record.assets }, null, 2)}
+`;
 }
-const MAX_ASSEMBLED_PX = 4096;
-const WINDOW_PX = { width: 1536, height: 1024 };
-const SCALES = [TILE_SIZE, TILE_SIZE / 2, TILE_SIZE / 4, TILE_SIZE / 8, TILE_SIZE / 16];
-function scaleFor(tilesWide, tilesHigh) {
-  if (tilesWide <= 0 || tilesHigh <= 0) return null;
-  for (const scale of SCALES) {
-    if (tilesWide * scale <= WINDOW_PX.width && tilesHigh * scale <= WINDOW_PX.height) return scale;
+const MAX_RECORD_BYTES = 4 * 1024 * 1024;
+const artBoundary = (local) => new Boundary([artOf(local)]);
+const recordPath = (local) => join(local.root, ...PULLED_FILE.split("/"));
+async function readRecord(local) {
+  const boundary = artBoundary(local);
+  const path = recordPath(local);
+  if (!await boundary.exists(path)) return EMPTY_PULLED;
+  const { size } = await stat(await boundary.resolve(path));
+  if (size > MAX_RECORD_BYTES) throw new CliError(`${PULLED_FILE} is ${size} bytes, and is read at most ${MAX_RECORD_BYTES}`);
+  try {
+    return readPulled(await boundary.readText(path));
+  } catch (error) {
+    if (error instanceof PulledError) throw new CliError(error.message);
+    throw error;
   }
-  return null;
 }
-({
-  width: Math.floor(WINDOW_PX.width / SCALES.at(-1)),
-  height: Math.floor(WINDOW_PX.height / SCALES.at(-1))
-});
-Array.from({ length: 16 }, (_value, index) => index);
-const CONTAINER_FILE = join("build", "assets.eac");
-const MANIFEST_DIRECTORY = "manifest";
-const OUT_DIRECTORY = "out";
-const ID_MAP_FILE = "id-map.json";
-const PROJECT_SEAL_STEP = "project:seal";
-const MAX_PICTURE_BYTES = 64 * 1024 * 1024;
-const MAX_TEXT_BYTES = 16 * 1024 * 1024;
-const MAX_PICTURES = 2e4;
-function shown(artDirectory, relative2) {
-  return [basename(artDirectory), ...relative2.split(/[\\/]/)].join("/");
+async function writeRecord(local, record) {
+  await artBoundary(local).writeFileReplacing(recordPath(local), writePulled(record));
 }
-async function sized(boundary, path, most, what) {
-  const { size } = await stat(await boundary.resolve(path));
-  if (size > most) throw new ProjectError(`${what} is ${size} bytes, and one is read at most ${most}`);
+const REFERENCE_KINDS = /* @__PURE__ */ new Set(["level-design", "hud-mockup"]);
+function setPieces(asset) {
+  return setPiecesOf(asset.kind, asset.images.length, asset.data);
 }
-async function readPictures(boundary, artDirectory) {
-  const pictures = [];
-  const walk = async (directory, prefix) => {
-    let entries;
-    try {
-      entries = await readdir(await boundary.resolve(directory), { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const name = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-      if (entry.isDirectory()) await walk(join(directory, entry.name), name);
-      else if (entry.isFile() && entry.name.endsWith(".png")) {
-        if (pictures.length >= MAX_PICTURES) throw new ProjectError(`${shown(artDirectory, OUT_DIRECTORY)} holds more than ${MAX_PICTURES} pictures`);
-        const path = join(directory, entry.name);
-        await sized(boundary, path, MAX_PICTURE_BYTES, `${shown(artDirectory, OUT_DIRECTORY)}/${name}`);
-        pictures.push({ name: name.slice(0, -".png".length), bytes: await boundary.readBytes(path) });
-      }
-    }
-  };
-  await walk(join(artDirectory, OUT_DIRECTORY), "");
-  return pictures;
+function namesOf(name, count) {
+  return count === 1 ? [name] : Array.from({ length: count }, (_, index) => `${name}/${index}`);
 }
-async function readEntries(boundary, artDirectory) {
-  const directory = join(artDirectory, MANIFEST_DIRECTORY);
-  const entries = [];
-  for (const file of (await boundary.list(directory)).filter((name) => name.endsWith(".json")).sort()) {
-    let manifest2;
-    await sized(boundary, join(directory, file), MAX_TEXT_BYTES, `${MANIFEST_DIRECTORY}/${file}`);
-    try {
-      manifest2 = JSON.parse(await boundary.readText(join(directory, file)));
-    } catch (error) {
-      throw new ProjectError(`${MANIFEST_DIRECTORY}/${file} is not valid JSON: ${error.message}`);
+function nameFor(asset, record, given) {
+  const name = given ?? record.assets[asset.id]?.name ?? asset.name ?? SET_NAMES[asset.kind] ?? `${asset.kind}-${asset.id.slice(0, 8)}`;
+  const problem = nameProblem(name);
+  if (problem !== null) throw new CliError(`${name} is not a name a picture can be landed under (${problem}): give one with --as`);
+  return name;
+}
+async function pullAsset(platform, local, ref, given, options = {}) {
+  const project = linkedOf(local);
+  await checkFolder(local, options.aside === true);
+  const asset = await platform.web.asset(project, ref);
+  if (asset.images.length === 0) throw new CliError(`the asset ${asset.id} has no image the platform still keeps`);
+  if (asset.kind === "terrain") {
+    throw new CliError(`${asset.id} is a terrain set: land it from the editor's Library, which cuts a set into the cells its brush paints. Nothing was landed`);
+  }
+  const record = await readRecord(local);
+  const name = nameFor(asset, record, given);
+  const pieces = setPieces(asset);
+  const reference = REFERENCE_KINDS.has(asset.kind);
+  const names = pieces === null ? namesOf(name, asset.images.length) : pieceNames(name, pieces);
+  const files = names.map((each) => `${reference ? "ref" : "out"}/${each}.png`);
+  const pulled = { id: asset.id, kind: asset.kind, name, hash: asset.hash, files, data: asset.data };
+  const base = `/projects/${encodeURIComponent(project)}`;
+  const json2 = async (path, init2) => (await platform.call(path, init2)).json();
+  const art = await json2(`${base}/art`);
+  const references = new Map((await json2(`${base}/art/references`)).map((each) => [each.name, each.image]));
+  const held = (each) => reference ? references.get(each) : art.pictures[each];
+  const landing = [];
+  for (const [index, each] of names.entries()) {
+    const image = asset.images[index].id;
+    const holds = held(each);
+    if (holds === image) continue;
+    if (holds !== void 0) {
+      throw new CliError(
+        `the project's art already holds ${reference ? "a reference" : "a picture"} named ${each}, of something else: nothing was landed. Give this one another name with --as`
+      );
     }
-    if (typeof manifest2 !== "object" || manifest2 === null || Array.isArray(manifest2)) throw new ProjectError(`${MANIFEST_DIRECTORY}/${file} is not an object`);
-    for (const [name, entry] of Object.entries(manifest2)) {
-      if (name.startsWith("$")) continue;
-      entries.push({ name, meta: entry?.meta });
+    landing.push({ name: each, image, piece: pieces?.[index] ?? null });
+  }
+  if (landing.length > 0) {
+    if (reference) {
+      let revision = art.revision;
+      for (const each of landing)
+        revision = (await json2(`${base}/art/references`, { method: "POST", body: { revision, name: each.name, image: each.image } })).revision;
+    } else {
+      const assets = landing.map(
+        (each) => each.piece === null ? { name: each.name, manifest: "editor", entry: { command: ["cli", asset.kind, asset.id] }, image: each.image } : { name: each.name, manifest: "interface", entry: describedInterface({}, [[each.name, each.piece]], [])[each.name], image: each.image }
+      );
+      await json2(`${base}/art/land`, { method: "POST", body: { revision: art.revision, assets } });
     }
   }
-  return entries;
+  await writeRecord(local, { ...record, assets: { ...record.assets, [asset.id]: { kind: asset.kind, name, hash: asset.hash, files } } });
+  await bringFolder(platform, local, { map: false, aside: options.aside === true });
+  return { ...pulled, current: landing.length === 0 };
 }
-async function readIdMap(boundary, artDirectory) {
-  const path = join(artDirectory, ID_MAP_FILE);
-  if (!await boundary.exists(path)) return null;
-  await sized(boundary, path, MAX_TEXT_BYTES, shown(artDirectory, ID_MAP_FILE));
-  return boundary.readText(path);
+function pulledWords(pulled) {
+  const where = pulled.files.length === 1 ? `pixelvibing/${pulled.files[0]}` : `${pulled.files.length} pictures under pixelvibing/`;
+  return pulled.current ? `${pulled.name} is current: the project's art holds it, and ${where} is what the platform has.` : `Pulled ${pulled.name}, ${pulled.kind}, into the project's art, and wrote ${where}.`;
 }
-async function readProjectArt(boundary, artDirectory) {
-  return {
-    pictures: await readPictures(boundary, artDirectory),
-    entries: await readEntries(boundary, artDirectory),
-    idMap: await readIdMap(boundary, artDirectory)
-  };
+const date = (at) => at.slice(0, 10);
+function listed(assets) {
+  if (assets.length === 0) return "No assets.";
+  return assets.map(
+    (asset) => `${asset.id}  ${asset.kind.padEnd(12)}  ${(asset.name ?? "—").padEnd(28)}  ${asset.images} image${asset.images === 1 ? "" : "s"}  ${date(asset.createdAt)}`
+  ).join("\n");
 }
-async function readProjectMap(boundary, artDirectory) {
-  const path = join(artDirectory, "map.json");
-  if (!await boundary.exists(path)) return null;
-  await sized(boundary, path, MAX_TEXT_BYTES, shown(artDirectory, "map.json"));
-  return boundary.readText(path);
+const list = {
+  name: "list",
+  summary: "List the platform project's assets, of one kind when given, newest first",
+  usage: "[<kind>] [--before <id>]",
+  options: { before: { type: "string", value: "<id>", description: "the page after the asset with this id, as the last page said" } },
+  positionals: [0, 1],
+  run: async (context, args) => {
+    const local = await projectHere(context.io.cwd);
+    const project = linkedOf(local);
+    const platform = await signedIn(context);
+    const [kind] = args.positionals;
+    const page = await platform.web.assets(project, kind ?? null, stringOf(args, "before") ?? null);
+    const more = page.next === null ? "" : `
+More: pixel-vibing-cli list${kind === void 0 ? "" : ` ${kind}`} --before ${page.next}`;
+    answer(context, page, `${listed(page.assets)}${more}`);
+  }
+};
+const pull = {
+  name: "pull",
+  summary: "Land one asset, by its id or its name, in the project's art, and write it into the local project",
+  usage: "<id|name> [--as <name>] [--aside]",
+  options: {
+    as: { type: "string", value: "<name>", description: "land it under this name instead of the platform's" },
+    aside: { type: "boolean", description: "keep a folder's own map and art under pixelvibing/before-platform/, and write it from the platform" }
+  },
+  positionals: [1, 1],
+  run: async (context, args) => {
+    const local = await projectHere(context.io.cwd);
+    linkedOf(local);
+    const platform = await signedIn(context);
+    const pulled = await pullAsset(platform, local, args.positionals[0], stringOf(args, "as"), { aside: flagOf(args, "aside") });
+    answer(context, pulled, pulledWords(pulled));
+  }
+};
+const DOWNLOAD_URL = "https://github.com/Pixel-Vibing/pixel-vibing/releases/latest";
+const EDITOR_VARIABLE = "PIXELVIBING_EDITOR";
+async function exists$1(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
 }
-async function sealProject(boundary, artDirectory) {
+async function findEditor(platform, env, home) {
+  const named = env[EDITOR_VARIABLE]?.trim();
+  if (named !== void 0 && named !== "") {
+    if (!await exists$1(named)) throw new CliError(`${EDITOR_VARIABLE} names ${named}, which is not there`);
+    return platform === "darwin" && named.endsWith(".app") ? { command: "open", args: ["-a", named, "--args"] } : { command: named, args: [] };
+  }
+  if (platform === "win32") {
+    const places = [env.LOCALAPPDATA && join(env.LOCALAPPDATA, "Programs", "PixelVibing"), env.ProgramFiles && join(env.ProgramFiles, "PixelVibing")];
+    for (const place of places) {
+      if (typeof place === "string" && await exists$1(join(place, "PixelVibing.exe"))) return { command: join(place, "PixelVibing.exe"), args: [] };
+    }
+    return null;
+  }
+  if (platform === "darwin") {
+    for (const app of ["/Applications/PixelVibing.app", join(home, "Applications", "PixelVibing.app")]) {
+      if (await exists$1(app)) return { command: "open", args: ["-a", app, "--args"] };
+    }
+    return null;
+  }
+  const applications = join(home, "Applications");
+  let found = [];
   try {
-    const sealed = sealProjectArt(await readProjectArt(boundary, artDirectory));
-    await boundary.writeFileReplacing(join(artDirectory, CONTAINER_FILE), sealed.container);
-    const pictures = `${sealed.pictures} ${sealed.pictures === 1 ? "picture" : "pictures"}`;
-    const described = `${sealed.described} ${sealed.described === 1 ? "asset" : "assets"} described`;
-    return [{ step: PROJECT_SEAL_STEP, code: 0, output: `sealed ${pictures} into ${shown(artDirectory, CONTAINER_FILE)}, ${described}` }];
-  } catch (error) {
-    if (!(error instanceof ProjectError)) throw error;
-    return [{ step: PROJECT_SEAL_STEP, code: 1, output: `the container was not rebuilt: ${error.message}` }];
+    found = (await readdir(applications)).filter((name) => /^PixelVibing.*\.AppImage$/i.test(name)).sort();
+  } catch {
+    return null;
   }
+  const newest = found.at(-1);
+  return newest === void 0 ? null : { command: join(applications, newest), args: [] };
 }
+const editor = {
+  name: "editor",
+  summary: "Open the PixelVibing desktop app on this local project",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    const { platform, home } = context.services;
+    const found = await findEditor(platform, context.io.env, home);
+    if (found === null) {
+      throw new CliError(`the PixelVibing desktop app is not installed here: download it from ${DOWNLOAD_URL}, or set ${EDITOR_VARIABLE} to where it is`);
+    }
+    await context.services.launch(found.command, [...found.args, "--project", local.root]);
+    answer(context, { opened: local.root, app: found.command }, `Opening ${local.root} in PixelVibing.`);
+  }
+};
 const DRAW_LAYERS = ["ground", "object", "foreground"];
 function bandOfAsset(facts) {
   if (facts.name === null) return "ground";
@@ -2740,14 +3408,14 @@ const paeth = (a, b, c) => {
   const pc = Math.abs(p - c);
   return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
 };
-function unfilter(inflated, header) {
+function unfilter(inflated2, header) {
   const bpp = CHANNELS[header.colorType] * (header.depth / 8);
   const stride = header.width * bpp;
   const out = new Uint8Array(header.height * stride);
   for (let y = 0; y < header.height; y += 1) {
-    const filter = inflated[y * (stride + 1)];
+    const filter = inflated2[y * (stride + 1)];
     if (filter > 4) throw new PngError(`a row has filter type ${filter}, which PNG does not define`);
-    const row = inflated.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+    const row = inflated2.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
     const at = y * stride;
     for (let x = 0; x < stride; x += 1) {
       const a = x >= bpp ? out[at + x - bpp] : 0;
@@ -2792,14 +3460,14 @@ function decodeWith(zlib, bytes) {
   if (header === null) throw new PngError("the PNG has no IHDR chunk");
   const bpp = CHANNELS[header.colorType] * (header.depth / 8);
   const expected = header.height * (1 + header.width * bpp);
-  let inflated;
+  let inflated2;
   try {
-    inflated = zlib.inflate(concat(data), expected);
+    inflated2 = zlib.inflate(concat(data), expected);
   } catch {
     throw new PngError("the PNG's image data could not be inflated to the size its header promises");
   }
-  if (inflated.length !== expected) throw new PngError("the PNG's image data is not the size its header promises");
-  return toRgba(unfilter(inflated, header), header, palette, transparency);
+  if (inflated2.length !== expected) throw new PngError("the PNG's image data is not the size its header promises");
+  return toRgba(unfilter(inflated2, header), header, palette, transparency);
 }
 function toRgba(samples, header, palette, transparency) {
   const { width, height, depth, colorType } = header;
@@ -2928,10 +3596,12 @@ async function writeWhole(out, files, engine) {
 const exportCommand = {
   name: "export",
   summary: "Export the local project's art and map for an engine: default, pixi, phaser or godot",
-  usage: "<default|pixi|phaser|godot> [--out <dir>] [--godot-root <res://…>]",
+  usage: "<default|pixi|phaser|godot> [--out <dir>] [--godot-root <res://…>] [--offline] [--aside]",
   options: {
     out: { type: "string", value: "<dir>", description: "where to write it; pixelvibing/export/<engine>/ unless given" },
-    "godot-root": { type: "string", value: "<res://…>", description: `the Godot project folder the files go in, ${DEFAULT_GODOT_ROOT} unless given` }
+    "godot-root": { type: "string", value: "<res://…>", description: `the Godot project folder the files go in, ${DEFAULT_GODOT_ROOT} unless given` },
+    offline: { type: "boolean", description: "read the folder as it is, without bringing it to the platform's state first" },
+    aside: { type: "boolean", description: "keep a folder's own map and art under pixelvibing/before-platform/, and write it from the platform" }
   },
   positionals: [1, 1],
   run: async (context, args) => {
@@ -2942,6 +3612,7 @@ const exportCommand = {
       throw new CliError("--godot-root is a res:// path of letters, digits and . _ - /, with no ..");
     }
     const local = await projectHere(context.io.cwd);
+    if (!flagOf(args, "offline")) await bringFolder(await signedIn(context), local, { map: true, aside: flagOf(args, "aside") });
     const art = artOf(local);
     const out = resolve(context.io.cwd, stringOf(args, "out") ?? join(art, "export", engine));
     if (!await replaceable(out)) throw new CliError(`${out} holds files that are not an export's: nothing was written. Name an empty directory with --out`);
@@ -2949,7 +3620,8 @@ const exportCommand = {
     try {
       const boundary = new Boundary([art]);
       const read = await readProjectArt(boundary, art);
-      const mapText = await readProjectMap(boundary, art);
+      const mirrored2 = await readMirroredProjectMap(boundary, art);
+      const mapText = mirrored2 === null ? await readProjectMap(boundary, art) : null;
       checkExportable(
         read.pictures.map((picture) => {
           if (!isPng(picture.bytes)) throw new CliError(`the picture ${picture.name} cannot be read: it is not a PNG`);
@@ -2967,7 +3639,7 @@ const exportCommand = {
         {
           pictures,
           entries: read.entries,
-          map: mapText === null ? null : parseMapText(mapText, "pixelvibing/map.json").document,
+          map: mirrored2 ?? (mapText === null ? null : parseMapText(mapText, "pixelvibing/map.json").document),
           idMap: read.idMap === null ? null : parseIdMap(JSON.parse(read.idMap))
         },
         engine,
@@ -2975,7 +3647,7 @@ const exportCommand = {
         godotRoot === void 0 ? {} : { godotRoot }
       );
     } catch (error) {
-      const refusals = [ProjectError, PackError, PngError, MapTextError, IdMapError, SyntaxError, CliError];
+      const refusals = [ProjectError, PackError, PngError, MapTextError, MirrorError, IdMapError, SyntaxError, CliError];
       if (refusals.some((kind) => error instanceof kind)) throw new CliError(`nothing was exported: ${error.message}`);
       throw error;
     }
@@ -3430,7 +4102,8 @@ const generate = {
     reference: { type: "string", multiple: true, value: "<png>", description: "an image to draw from" },
     quality: { type: "string", value: "<quality>", description: `${EDIT_QUALITIES.join(", ")}; ${DEFAULT_QUALITY} unless given` },
     yes: { type: "boolean", short: "y", description: "start it without asking, once the cost is said" },
-    as: { type: "string", value: "<name>", description: "pull it under this name instead of the platform's" }
+    as: { type: "string", value: "<name>", description: "land it under this name instead of the platform's" },
+    aside: { type: "boolean", description: "keep a folder's own map and art under pixelvibing/before-platform/, and write it from the platform" }
   },
   positionals: [1, 1],
   run: async (context, args) => {
@@ -3438,6 +4111,7 @@ const generate = {
     const project = linkedOf(local);
     const kind = args.positionals[0];
     const request = await requestOf(context, kind, args);
+    await checkFolder(local, flagOf(args, "aside"));
     const platform = await signedIn(context);
     const cost = costOf(await platform.web.prices(), request);
     await confirmed(context, platform, request.words, cost, flagOf(args, "yes"));
@@ -3446,7 +4120,7 @@ const generate = {
 `);
     const job = await followed(context, platform, jobId);
     if (job.state === "failed") throw new CliError(`the generation failed: ${job.reason ?? "the platform gave no reason"}`);
-    const pulled = await pullAsset(platform, local, jobId, stringOf(args, "as"));
+    const pulled = await pullAsset(platform, local, jobId, stringOf(args, "as"), { aside: flagOf(args, "aside") });
     answer(context, { job: jobId, cost, ...pulled }, pulledWords(pulled));
   }
 };
@@ -3754,15 +4428,156 @@ const link = {
 const seal = {
   name: "seal",
   summary: "Seal the local project's art into its container, as the editor does",
-  run: async (context) => {
+  usage: "[--offline] [--aside]",
+  options: {
+    offline: { type: "boolean", description: "read the folder as it is, without bringing it to the platform's state first" },
+    aside: { type: "boolean", description: "keep a folder's own map and art under pixelvibing/before-platform/, and write it from the platform" }
+  },
+  run: async (context, args) => {
     const local = await projectHere(context.io.cwd);
+    if (!flagOf(args, "offline")) await bringFolder(await signedIn(context), local, { map: false, aside: flagOf(args, "aside") });
     const art = artOf(local);
     const [result] = await sealProject(new Boundary([art]), art);
     if (result === void 0 || result.code !== 0) throw new CliError(result?.output ?? "the container was not rebuilt");
     answer(context, { sealed: true, output: result.output }, result.output);
   }
 };
-const version = "0.9.0";
+const SECTORS_A_WRITE = 64;
+const BYTES_A_WRITE = 11 * 1024 * 1024;
+const MOST_WAIT_SECONDS = 30 * 60;
+class MoveRefused extends Error {
+  // Assigned in the body: Node's strip-only TypeScript mode rejects parameter
+  // properties (docs/notes.md n-0023).
+  constructor(message) {
+    super(message);
+    this.name = "MoveRefused";
+  }
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (let at = 0; at < bytes.length; at += 32768) binary += String.fromCharCode(...bytes.subarray(at, at + 32768));
+  return btoa(binary);
+}
+function marksAny(outline) {
+  const bits = atob(outline);
+  for (let at = 0; at < bits.length; at += 1) if (bits.charCodeAt(at) !== 0) return true;
+  return false;
+}
+async function platformIsEmpty(deps) {
+  const base = `/projects/${encodeURIComponent(deps.project)}`;
+  const outline = await (await deps.call(`${base}/map`)).json();
+  if (outline.levels.some((level) => marksAny(level.sectors))) return false;
+  const art = await (await deps.call(`${base}/art`)).json();
+  if (art.assets.length > 0) return false;
+  const references = await (await deps.call(`${base}/art/references`)).json();
+  return references.length === 0;
+}
+async function moveFolder(deps) {
+  const base = `/projects/${encodeURIComponent(deps.project)}`;
+  const call = (path, init2) => patiently(deps, async () => (await deps.call(path, init2)).json(), MOST_WAIT_SECONDS);
+  const folder = await deps.mirror.folder();
+  const pictured = new Set(folder.pictures.map((picture) => picture.name));
+  const drawn = folder.assets.filter((asset) => pictured.has(asset.name));
+  const named = new Set(drawn.map((asset) => asset.name));
+  const idMap = Object.fromEntries(Object.entries(folder.idMap).filter(([, name]) => named.has(name)));
+  try {
+    sealProjectArt({
+      pictures: folder.pictures,
+      entries: drawn.map((asset) => ({ name: asset.name, meta: asset.entry.meta })),
+      idMap: Object.keys(idMap).length === 0 ? null : JSON.stringify({ looktypes: idMap })
+    });
+  } catch (error) {
+    throw new MoveRefused(
+      `this folder's art cannot be read as the editor reads it, and nothing was sent: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  let map;
+  try {
+    map = folder.map === null ? null : parseMapText(folder.map, "pixelvibing/map.json").document;
+  } catch (error) {
+    throw new MoveRefused(`this folder's map cannot be read, and nothing was sent: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const outline = await call(`${base}/map`);
+  if (map !== null && (map.width > outline.limit.width || map.height > outline.limit.height)) {
+    throw new MoveRefused(
+      `this folder's map is ${map.width} × ${map.height} tiles, and the project's map grows to at most ${outline.limit.width} × ${outline.limit.height}: nothing was sent`
+    );
+  }
+  const sectors = map === null ? [] : sectorsOfMap(map);
+  await deps.mirror.moving(deps.project);
+  const keep2 = (bytes2) => call("/images", { method: "POST", bytes: { data: bytes2, type: "image/png" } }).then((kept) => kept.id);
+  const pictures = {};
+  for (const [index, picture] of folder.pictures.entries()) {
+    deps.progress?.(`sending the pictures: ${index + 1} of ${folder.pictures.length}`);
+    pictures[picture.name] = await keep2(picture.bytes);
+  }
+  const references = [];
+  for (const reference of folder.references) references.push({ name: reference.name, image: await keep2(reference.bytes) });
+  const assets = drawn.map((asset) => ({ ...asset, image: pictures[asset.name] }));
+  const art = await call(`${base}/art`);
+  deps.progress?.("sending the art");
+  await call(`${base}/art/import`, { method: "POST", body: { revision: art.revision, assets, pictures, idMap, references } });
+  let revision = outline.revision;
+  if (map !== null && (map.width > outline.size.width || map.height > outline.size.height)) {
+    const size = { width: Math.max(map.width, outline.size.width), height: Math.max(map.height, outline.size.height) };
+    revision = (await call(`${base}/map/size`, { method: "PUT", body: { revision, ...size } })).revision;
+  }
+  let batch = [];
+  let bytes = 0;
+  let sent = 0;
+  const send = async () => {
+    if (batch.length === 0) return;
+    revision = (await call(`${base}/map/sectors`, { method: "PUT", body: { revision, sectors: batch } })).revision;
+    sent += batch.length;
+    deps.progress?.(`sending the map: ${sent} of ${sectors.length} parts`);
+    batch = [];
+    bytes = 0;
+  };
+  for (const sector of sectors) {
+    const data = toBase64(await deps.zlib.deflate(encodeSector(sector.cells)));
+    if (batch.length >= SECTORS_A_WRITE || bytes + data.length > BYTES_A_WRITE) await send();
+    batch.push({ z: sector.z, cx: sector.cx, cy: sector.cy, data });
+    bytes += data.length;
+  }
+  await send();
+  await deps.mirror.moving(null);
+}
+const move = {
+  name: "move",
+  summary: "Move this folder's own map and art onto its platform project, once, when that project holds none",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    const project = linkedOf(local);
+    const platform = await signedIn(context);
+    const mirror = mirrorOf(local);
+    const state = await mirror.state();
+    const again = state.moving === project;
+    if (!again) {
+      if (state.mirrored || !(state.own.map || state.own.art)) {
+        throw new CliError("this folder holds no map or art of its own to move: it is written from its platform project already");
+      }
+      if (!await platformIsEmpty({ project, call: platform.call })) {
+        throw new CliError(
+          "the platform project already holds a map, art or a reference, and a folder is moved only onto one holding none: nothing was sent. Pass --aside to a pull, a seal or an export to keep this folder's own files aside instead"
+        );
+      }
+    }
+    try {
+      await moveFolder({ project, call: platform.call, mirror, zlib: nodeZlib, progress: (words) => context.io.warn(`${words}
+`) });
+    } catch (error) {
+      if (error instanceof MoveRefused) throw new CliError(error.message);
+      throw new CliError(`the move stopped, and is sent whole again by \`pixel-vibing-cli move\`: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    await bringFolder(platform, local, { map: true, aside: true });
+    answer(
+      context,
+      { moved: true, project },
+      `Moved this folder onto its platform project${again ? ", sent whole again" : ""}: its own files are kept under pixelvibing/before-platform/, and the folder is written from the platform.`
+    );
+  }
+};
+const version = "0.11.0";
 const manifest = {
   version
 };
@@ -4209,6 +5024,7 @@ const COMMANDS = [
   whoami,
   init,
   link,
+  move,
   generate,
   list,
   pull,