@pixelvibing/cli 0.8.0 → 0.10.0

package/dist/pixel-vibing-cli.js

@@ -5,7 +5,7 @@ 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 { inflate, deflateSync, inflateSync } from "node:zlib";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { hostname, homedir } from "node:os";
@@ -339,11 +339,12 @@ class SignedOut extends Error {
   }
 }
 class ApiError extends Error {
-  constructor(status, message, body = {}) {
+  constructor(status, message, body = {}, retryAfter = null) {
     super(message);
     this.name = "ApiError";
     this.status = status;
     this.body = body;
+    this.retryAfter = retryAfter;
   }
 }
 async function refusalOf(response) {
@@ -383,7 +384,8 @@ function createCaller(fetcher = (input, init2) => fetch(input, init2), base = AP
     }
     if (!response.ok) {
       const refused = await refusalOf(response);
-      throw new ApiError(response.status, refused.message, refused.body);
+      const wait = Number(response.headers.get("retry-after") ?? Number.NaN);
+      throw new ApiError(response.status, refused.message, refused.body, Number.isFinite(wait) ? wait : null);
     }
     return response;
   };
@@ -1303,6 +1305,174 @@ const editor = {
     answer(context, { opened: local.root, app: found.command }, `Opening ${local.root} in PixelVibing.`);
   }
 };
+const SECTOR_SIDE = 128;
+const SECTOR_CELLS = SECTOR_SIDE * SECTOR_SIDE;
+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);
+const SECTOR_FORMAT = 1;
+const MAGIC = [80, 86, 67];
+const PRESENT = 1;
+const AUDIO = 2;
+const INTERACT = 4;
+const EXTRA = 8;
+const NAMED = /* @__PURE__ */ new Set(["x", "y", "z", "layers", "blocking", "zone", "audioZone", "interact"]);
+class SectorError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SectorError";
+  }
+}
+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.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;
+}
+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 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 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`;
+}
+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 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`);
+  }
+  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 >= index.size.width || cy * SECTOR_SIDE >= 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);
+  }
+  return index;
+}
+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 {
+      cells = decodeSector(await inflate2(await read(path)));
+    } catch (error) {
+      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 + at % SECTOR_SIDE;
+      const y = cy * SECTOR_SIDE + Math.floor(at / SECTOR_SIDE);
+      if (x >= index.size.width || y >= index.size.height) continue;
+      tiles.push(tileOfCell(cell, x, y, z));
+    }
+  }
+  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 };
+}
 const TILE_SIZE = 256;
 const EAI_MAGIC = 1229018181;
 const EAI_VERSION = 1;
@@ -2204,6 +2374,23 @@ async function readProjectMap(boundary, artDirectory) {
   await sized(boundary, path, MAX_TEXT_BYTES, shown(artDirectory, "map.json"));
   return boundary.readText(path);
 }
+const MAX_MIRRORED_SECTOR_BYTES = 256 * 1024;
+const inflated = 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(bytes, { maxOutputLength: SECTOR_BYTES }))
+  );
+}
 async function sealProject(boundary, artDirectory) {
   try {
     const sealed = sealProjectArt(await readProjectArt(boundary, artDirectory));
@@ -2738,14 +2925,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;
@@ -2790,14 +2977,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;
@@ -2947,7 +3134,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`);
@@ -2965,7 +3153,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,
@@ -2973,7 +3161,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;
     }
@@ -3760,7 +3948,7 @@ const seal = {
     answer(context, { sealed: true, output: result.output }, result.output);
   }
 };
-const version = "0.8.0";
+const version = "0.10.0";
 const manifest = {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixelvibing/cli",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "PixelVibing: pixel art game assets from the command line, and the Skills that teach coding assistants to make them.",
   "license": "MIT",
   "homepage": "https://pixelvibing.com",