@pixelvibing/cli 0.0.1 → 0.1.0

package/dist/pixel-vibing-cli.js

@@ -0,0 +1,4036 @@
+#!/usr/bin/env node
+import { resolve, dirname, join, relative, sep, basename } from "node:path";
+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 { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { hostname, homedir } from "node:os";
+import { createInterface } from "node:readline";
+const CASE_INSENSITIVE = process.platform === "win32" || process.platform === "darwin";
+class BoundaryError 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 = "BoundaryError";
+  }
+}
+function fold(path) {
+  return CASE_INSENSITIVE ? path.toLowerCase() : path;
+}
+function isInside(root, target) {
+  const r = fold(root);
+  const t = fold(target);
+  return t === r || t.startsWith(r.endsWith(sep) ? r : r + sep);
+}
+const realpathNative = promisify(realpath.native);
+async function realPathOfNearest(target) {
+  let existing = target;
+  const tail = [];
+  for (; ; ) {
+    try {
+      const real = await realpathNative(existing);
+      return tail.length === 0 ? real : join(real, ...tail.reverse());
+    } catch {
+      const parent = dirname(existing);
+      if (parent === existing) {
+        return target;
+      }
+      tail.push(relative(parent, existing));
+      existing = parent;
+    }
+  }
+}
+class Boundary {
+  constructor(roots, options = {}) {
+    this.realRoots = null;
+    if (roots.length === 0) throw new BoundaryError("a boundary needs at least one root");
+    this.roots = roots.map((root) => resolve(root));
+    this.tempName = options.tempName ?? ((base) => `${base}.${process.pid}.${Date.now().toString(36)}.tmp`);
+  }
+  resolvedRoots() {
+    this.realRoots ??= Promise.all(this.roots.map((root) => realPathOfNearest(root)));
+    return this.realRoots;
+  }
+  /**
+   * The absolute path for `target`, or a refusal naming it (R2.1, R2.3).
+   *
+   * What comes back is the path as given and resolved, not the real path: the
+   * caller reads and writes through the spelling it asked for, and the real
+   * path served only to judge it.
+   */
+  async resolve(target) {
+    const resolved = resolve(target);
+    const real = await realPathOfNearest(resolved);
+    const roots = await this.resolvedRoots();
+    if (roots.some((root) => isInside(root, real))) return resolved;
+    throw new BoundaryError(`refused: ${target} is outside every allowed root (resolves to ${real})`);
+  }
+  async exists(target) {
+    const path = await this.resolve(target);
+    try {
+      await promises.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readText(target) {
+    return promises.readFile(await this.resolve(target), "utf8");
+  }
+  async readBytes(target) {
+    const buffer = await promises.readFile(await this.resolve(target));
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  /**
+   * Replace `target` whole (R2.5).
+   *
+   * The content goes to a sibling in the same directory first and is renamed
+   * over the target, which the filesystem does atomically; a crash between the
+   * two leaves the previous file and a stray sibling, never half of a new file.
+   * The directory is created when it is missing, inside the root only.
+   */
+  async writeFileReplacing(target, content) {
+    const path = await this.resolve(target);
+    const directory = dirname(path);
+    const temporary = join(directory, this.tempName(path.slice(directory.length + 1)));
+    await promises.mkdir(directory, { recursive: true });
+    try {
+      await promises.writeFile(temporary, content);
+      await promises.rename(temporary, path);
+    } catch (error) {
+      await promises.rm(temporary, { force: true }).catch(() => void 0);
+      throw error;
+    }
+    return path;
+  }
+  /**
+   * Write a file that must not exist yet (specs/reference-uploads/ R1.4): the
+   * content goes to a sibling first, and is linked in under the target's name,
+   * which the filesystem refuses when that name is taken — so two writers racing
+   * for one name leave the first one's file, never a mix, and never a
+   * replaced one. Refuses with `EEXIST` when the target is already there.
+   */
+  async writeFileNew(target, content) {
+    const path = await this.resolve(target);
+    const directory = dirname(path);
+    const temporary = join(directory, this.tempName(path.slice(directory.length + 1)));
+    await promises.mkdir(directory, { recursive: true });
+    try {
+      await promises.writeFile(temporary, content);
+      await promises.link(temporary, path);
+    } finally {
+      await promises.rm(temporary, { force: true }).catch(() => void 0);
+    }
+    return path;
+  }
+  /**
+   * Remove one file (specs/asset-library/ R2.4, R4.6), judged like a write.
+   * A file already gone is not an error; a directory is refused, since
+   * nothing here removes a tree.
+   */
+  async removeFile(target) {
+    const path = await this.resolve(target);
+    const stat2 = await promises.lstat(path).catch(() => null);
+    if (stat2 === null) return;
+    if (stat2.isDirectory()) throw new BoundaryError(`refused: ${target} is a directory, and only a file is removed`);
+    await promises.rm(path);
+  }
+  /** Remove a directory that is already empty; one that still holds anything is left and refused. */
+  async removeEmptyDirectory(target) {
+    const path = await this.resolve(target);
+    await promises.rmdir(path);
+  }
+  /** The names in a directory, or none when it does not exist. */
+  async list(target) {
+    const path = await this.resolve(target);
+    return promises.readdir(path).catch(() => []);
+  }
+}
+const SESSION_FILE = "session";
+const WAIT_MS = 10 * 60 * 1e3;
+const RENEW_EARLY_MS = 60 * 1e3;
+const PAGE = (words) => `<!doctype html><meta charset="utf-8"><title>PixelVibing</title><body style="font:16px system-ui;margin:48px auto;max-width:28em;text-align:center"><p>${words}</p></body>`;
+const PAGES = {
+  "signed-in": PAGE("You are signed in to PixelVibing. You can close this tab."),
+  denied: PAGE("The sign-in was cancelled. You can close this tab and try again from PixelVibing."),
+  failed: PAGE("The sign-in did not finish. You can close this tab and try again from PixelVibing.")
+};
+async function json$1(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+class DesktopSession {
+  constructor(options) {
+    this.secret = null;
+    this.access = null;
+    this.loaded = null;
+    this.renewing = null;
+    this.options = options;
+    this.fetch = options.fetch ?? globalThis.fetch;
+    this.now = options.now ?? Date.now;
+  }
+  get path() {
+    return join(this.options.configDir, SESSION_FILE);
+  }
+  /** The secret kept by a previous run, read once; one that no longer opens is dropped. */
+  load() {
+    this.loaded ??= (async () => {
+      const { vault, boundary } = this.options;
+      if (vault === null || !await boundary.exists(this.path)) return;
+      try {
+        this.secret ??= vault.decrypt(await boundary.readBytes(this.path));
+      } catch {
+        await boundary.removeFile(this.path).catch(() => {
+        });
+      }
+    })();
+    return this.loaded;
+  }
+  async keep(secret) {
+    this.secret = secret;
+    const { vault, boundary } = this.options;
+    if (vault !== null) await boundary.writeFileReplacing(this.path, vault.encrypt(secret));
+  }
+  async forget() {
+    this.secret = null;
+    this.access = null;
+    if (await this.options.boundary.exists(this.path)) await this.options.boundary.removeFile(this.path);
+  }
+  async status() {
+    await this.load();
+    return { signedIn: this.secret !== null, remembered: this.options.vault !== null };
+  }
+  /**
+   * Sign in with `provider` in the system's browser, and wait for it to come back
+   * to this process's loopback port (R1.1).
+   */
+  async signIn(provider) {
+    const verifier = randomBytes(32).toString("base64url");
+    const challenge = createHash("sha256").update(verifier).digest("base64url");
+    const back = await this.awaitCallback(
+      (port) => this.options.openExternal(
+        `${this.options.apiUrl}/auth/${encodeURIComponent(provider)}/start?desktop=${port}&challenge=${challenge}${this.options.app === "cli" ? "&app=cli" : ""}`
+      )
+    );
+    const outcome = back.code === null ? back.outcome : await this.exchange(back.code, verifier).catch(() => "failed");
+    back.answer(outcome);
+    return outcome;
+  }
+  async exchange(code, verifier) {
+    const exchanged = await this.fetch(`${this.options.apiUrl}/auth/desktop/token`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ code, verifier })
+    });
+    const body = exchanged.ok ? await json$1(exchanged) : null;
+    if (body === null || typeof body.access !== "string" || typeof body.session !== "string" || typeof body.expiresIn !== "number") return "failed";
+    await this.keep(body.session);
+    this.access = { jwt: body.access, expiresAt: this.now() + body.expiresIn * 1e3 };
+    return "signed-in";
+  }
+  /**
+   * Listen on a port of this computer's own, start the sign-in there, and read what
+   * the browser brings back. The browser's page is answered once the sign-in has
+   * ended, so it says how it really ended.
+   */
+  awaitCallback(start) {
+    return new Promise((resolve2, reject) => {
+      let finished = false;
+      const server = createServer((request, response) => {
+        const url = new URL(request.url ?? "/", "http://127.0.0.1");
+        if (request.method !== "GET" || url.pathname !== "/callback" || finished) {
+          response.writeHead(404, { "content-type": "text/plain; charset=utf-8", connection: "close" }).end("not here");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const outcome = code !== null ? "signed-in" : url.searchParams.get("outcome") === "denied" ? "denied" : "failed";
+        finish(code, outcome, (final) => {
+          response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", connection: "close" }).end(PAGES[final]);
+        });
+      });
+      const timer = setTimeout(() => finish(null, "failed", () => {
+      }), this.options.waitMs ?? WAIT_MS);
+      const finish = (code, outcome, page) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        resolve2({
+          code,
+          outcome,
+          answer: (final) => {
+            page(final);
+            server.close();
+          }
+        });
+      };
+      server.on("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+      server.listen(0, "127.0.0.1", () => {
+        start(server.address().port).catch((error) => {
+          clearTimeout(timer);
+          finished = true;
+          server.close();
+          reject(error);
+        });
+      });
+    });
+  }
+  /** The JWT for a call, renewed first when it is about to lapse; `null` when signed out. */
+  async jwt() {
+    await this.load();
+    if (this.access !== null && this.access.expiresAt - RENEW_EARLY_MS > this.now()) return this.access.jwt;
+    return this.renew();
+  }
+  /** A new JWT from the session secret, one renewal at a time; `null`, and the session forgotten, when the API ended it (R1.5). */
+  renew() {
+    this.renewing ??= (async () => {
+      try {
+        await this.load();
+        const secret = this.secret;
+        if (secret === null) return null;
+        const answer2 = await this.fetch(`${this.options.apiUrl}/auth/desktop/refresh`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ session: secret })
+        });
+        if (answer2.status === 401) {
+          await this.forget();
+          return null;
+        }
+        const body = answer2.ok ? await json$1(answer2) : null;
+        if (body === null || typeof body.access !== "string") throw new Error("the API could not renew the sign-in just now");
+        this.access = { jwt: body.access, expiresAt: this.now() + body.expiresIn * 1e3 };
+        return body.access;
+      } finally {
+        this.renewing = null;
+      }
+    })();
+    return this.renewing;
+  }
+  /** Sign out: the API deletes the session, and this computer forgets it, even when the API cannot be reached. */
+  async signOut() {
+    await this.load();
+    const secret = this.secret;
+    await this.forget();
+    if (secret === null) return;
+    await this.fetch(`${this.options.apiUrl}/auth/desktop/sign-out`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ session: secret })
+    }).catch(() => {
+    });
+  }
+}
+const API_BASE = typeof __PIXELVIBING_API__ === "string" && __PIXELVIBING_API__ !== "" ? __PIXELVIBING_API__ : "/api";
+class SignedOut extends Error {
+  constructor() {
+    super("signed out");
+    this.name = "SignedOut";
+  }
+}
+class ApiError extends Error {
+  constructor(status, message, body = {}) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+async function refusalOf(response) {
+  try {
+    const body = await response.json();
+    if (typeof body === "object" && body !== null) {
+      return { message: typeof body.error === "string" ? body.error : `the API answered ${response.status}`, body };
+    }
+  } catch {
+  }
+  return { message: `the API answered ${response.status}`, body: {} };
+}
+function createCaller(fetcher = (input, init2) => fetch(input, init2), base = API_BASE) {
+  let renewing = null;
+  const renew = () => {
+    renewing ??= fetcher(`${base}/auth/refresh`, { method: "POST", credentials: "include" }).then((response) => response.ok).catch(() => false).finally(() => {
+      renewing = null;
+    });
+    return renewing;
+  };
+  return async (path, init2 = {}) => {
+    const headers = { accept: "application/json" };
+    let body;
+    if (init2.bytes !== void 0) {
+      headers["content-type"] = init2.bytes.type;
+      body = init2.bytes.data;
+    } else if (init2.body !== void 0) {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(init2.body);
+    }
+    const send = () => fetcher(`${base}${path}`, { method: init2.method ?? "GET", credentials: "include", headers, body });
+    let response = await send();
+    if (response.status === 401) {
+      if (!await renew()) throw new SignedOut();
+      response = await send();
+      if (response.status === 401) throw new SignedOut();
+    }
+    if (!response.ok) {
+      const refused = await refusalOf(response);
+      throw new ApiError(response.status, refused.message, refused.body);
+    }
+    return response;
+  };
+}
+function createAccountApi(fetcher = (input, init2) => fetch(input, init2), base = API_BASE) {
+  const call = createCaller(fetcher, base);
+  return {
+    providers: async () => (await (await call("/auth/providers")).json()).providers,
+    me: async () => (await call("/me")).json(),
+    tokens: async () => (await (await call("/tokens")).json()).tokens,
+    createToken: async (name) => (await call("/tokens", { method: "POST", body: { name } })).json(),
+    revokeToken: async (id2) => {
+      await call(`/tokens/${encodeURIComponent(id2)}`, { method: "DELETE" });
+    },
+    unlink: async (provider) => {
+      await call(`/me/identities/${encodeURIComponent(provider)}`, { method: "DELETE" });
+    },
+    deleteAccount: async () => {
+      await call("/me", { method: "DELETE" });
+    },
+    signOut: async () => {
+      await fetcher(`${base}/auth/sign-out`, { method: "POST", credentials: "include" });
+    },
+    signInUrl: (provider, link2 = false) => `${base}/auth/${encodeURIComponent(provider)}/start${link2 ? "?link=1" : ""}`
+  };
+}
+class CliError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliError";
+  }
+}
+function stringOf(args, name) {
+  const value = args.values[name];
+  return typeof value === "string" ? value : void 0;
+}
+function stringsOf(args, name) {
+  const value = args.values[name];
+  if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
+  return typeof value === "string" ? [value] : [];
+}
+function flagOf(args, name) {
+  return args.values[name] === true;
+}
+function answer(context, value, text2) {
+  context.io.write(context.json ? `${JSON.stringify(value, null, 2)}
+` : text2.endsWith("\n") || text2 === "" ? text2 : `${text2}
+`);
+}
+const SERVICE = "pixelvibing";
+const TOKEN_VARIABLE = "PIXELVIBING_TOKEN";
+class StoreUnavailable extends Error {
+  constructor(cause) {
+    super(
+      `this system has no credential store the CLI can use (${cause instanceof Error ? cause.message : String(cause)}): set ${TOKEN_VARIABLE} to an account token instead`
+    );
+    this.name = "StoreUnavailable";
+  }
+}
+const loadKeyring = () => import("@napi-rs/keyring");
+function systemStore(load = loadKeyring) {
+  const entry = async (origin) => {
+    try {
+      const { AsyncEntry } = await load();
+      return new AsyncEntry(SERVICE, origin);
+    } catch (error) {
+      throw new StoreUnavailable(error);
+    }
+  };
+  const guarded = async (run) => {
+    try {
+      return await run();
+    } catch (error) {
+      throw error instanceof StoreUnavailable ? error : new StoreUnavailable(error);
+    }
+  };
+  return {
+    get: (origin) => guarded(async () => await (await entry(origin)).getPassword() ?? null),
+    set: (origin, token) => guarded(async () => (await entry(origin)).setPassword(token)),
+    remove: (origin) => guarded(async () => (await entry(origin)).deletePassword())
+  };
+}
+async function tokenFor(store, origin, env) {
+  const given = env[TOKEN_VARIABLE]?.trim();
+  if (given !== void 0 && given !== "") return given;
+  try {
+    return await store.get(origin);
+  } catch (error) {
+    if (error instanceof StoreUnavailable) return null;
+    throw error;
+  }
+}
+const DEFAULT_API_URL = "https://api.pixelvibing.com";
+const DEFAULT_MCP_URL = "https://mcp.pixelvibing.com";
+const DEFAULT_WEB_URL = "https://app.pixelvibing.com/";
+const LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+const PLAIN_PATH = /^[A-Za-z0-9._~/-]*$/;
+class ApiAddressError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApiAddressError";
+  }
+}
+function apiAddress(environment = process.env) {
+  const given = (environment.PIXELVIBING_API_URL ?? "").trim();
+  if (given === "") return DEFAULT_API_URL;
+  let url;
+  try {
+    url = new URL(given);
+  } catch {
+    throw new ApiAddressError("PIXELVIBING_API_URL is not an address");
+  }
+  const secure = url.protocol === "https:" || url.protocol === "http:" && LOOPBACK.has(url.hostname);
+  if (!secure || url.search !== "" || url.hash !== "" || url.username !== "" || url.password !== "") {
+    throw new ApiAddressError("PIXELVIBING_API_URL must be an HTTPS address, or HTTP on this computer");
+  }
+  if (!PLAIN_PATH.test(url.pathname)) throw new ApiAddressError("PIXELVIBING_API_URL's path may hold only letters, digits, and . _ ~ - /");
+  return url.href.replace(/\/+$/, "");
+}
+class GuideConflict extends Error {
+  constructor(current) {
+    super(`the style guide is now at version ${current}`);
+    this.name = "GuideConflict";
+    this.current = current;
+  }
+}
+class TooFewCredits extends Error {
+  constructor(message, cost, credits) {
+    super(message);
+    this.name = "TooFewCredits";
+    this.cost = cost;
+    this.credits = credits;
+  }
+}
+function costIn(prices, kind, quality) {
+  const price = prices.kinds[kind];
+  if (price === void 0) return null;
+  if ("credits" in price) return price.credits;
+  return price.byQuality[quality ?? "high"] ?? null;
+}
+const id = (value) => encodeURIComponent(value);
+function createWebApi(fetcher = (input, init2) => fetch(input, init2), base = API_BASE) {
+  const call = createCaller(fetcher, base);
+  const json2 = async (path, init2) => await (await call(path, init2)).json();
+  const paying2 = async (run) => {
+    try {
+      return await run();
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 402) {
+        throw new TooFewCredits(error.message, Number(error.body.cost ?? 0), Number(error.body.credits ?? 0));
+      }
+      throw error;
+    }
+  };
+  return {
+    projects: (before = null) => json2(`/projects${before === null ? "" : `?before=${id(before)}`}`),
+    createProject: (name, idea) => paying2(() => json2("/projects", { method: "POST", body: { name, idea } })),
+    project: (projectId) => json2(`/projects/${id(projectId)}`),
+    renameProject: (projectId, name) => json2(`/projects/${id(projectId)}`, { method: "PATCH", body: { name } }),
+    deleteProject: async (projectId) => {
+      await call(`/projects/${id(projectId)}`, { method: "DELETE" });
+    },
+    /** The current style guide, or `null` while the project has none (R2.3). */
+    guide: async (projectId) => {
+      try {
+        return await json2(`/projects/${id(projectId)}/style-guide`);
+      } catch (error) {
+        if (error instanceof ApiError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    /** Write the guide on top of `base`, the version the person edited: its new version, or `GuideConflict` (R2.4, R2.5). */
+    saveGuide: async (projectId, text2, base2) => {
+      try {
+        return (await json2(`/projects/${id(projectId)}/style-guide`, { method: "PUT", body: { text: text2, base: base2 } })).version;
+      } catch (error) {
+        if (error instanceof ApiError && error.status === 409) throw new GuideConflict(Number(error.body.version ?? 0));
+        throw error;
+      }
+    },
+    /** Every version of the guide, newest first, with how and when each was made (specs/platform-projects/ R2.10). */
+    guideVersions: async (projectId) => (await json2(`/projects/${id(projectId)}/style-guide/versions`)).versions,
+    reviseGuide: (projectId, instruction) => paying2(async () => (await json2(`/projects/${id(projectId)}/style-guide/revisions`, { method: "POST", body: { instruction } })).job),
+    /** A page of a project's assets, of one kind when one is named. */
+    assets: (projectId, kind = null, before = null) => {
+      const query = new URLSearchParams();
+      if (kind !== null) query.set("kind", kind);
+      if (before !== null) query.set("before", before);
+      const search = query.toString();
+      return json2(`/projects/${id(projectId)}/assets${search === "" ? "" : `?${search}`}`);
+    },
+    /** One of a project's assets, by its id or its name. */
+    asset: (projectId, ref) => json2(`/projects/${id(projectId)}/assets/${id(ref)}`),
+    /** Keep a PNG for the account, answering its id. */
+    uploadImage: async (png) => (await json2("/images", { method: "POST", bytes: { data: png, type: "image/png" } })).id,
+    /** Where the page shows a kept image from; the cookie carries the account. */
+    imageUrl: (imageId) => `${base}/images/${id(imageId)}`,
+    /** A kept image's PNG bytes, for the editor to land (specs/desktop-app/ R3.1). */
+    imageBytes: async (imageId) => new Uint8Array(await (await call(`/images/${id(imageId)}`)).arrayBuffer()),
+    /** Start a generation for a project, answering its job's id, or `TooFewCredits` (R3.2, R3.4). */
+    generate: (kind, body) => paying2(async () => (await json2(`/generations/${id(kind)}`, { method: "POST", body })).id),
+    job: (jobId) => json2(`/jobs/${id(jobId)}`),
+    jobs: (projectId, before = null) => json2(`/jobs?project=${id(projectId)}${before === null ? "" : `&before=${id(before)}`}`),
+    feedback: async (jobId, verdict, reason) => {
+      await call(`/jobs/${id(jobId)}/feedback`, { method: "PUT", body: reason.trim().length > 0 ? { verdict, reason: reason.trim() } : { verdict } });
+    },
+    billing: (before = null) => json2(`/billing${before === null ? "" : `?before=${id(before)}`}`),
+    prices: () => json2("/billing/prices"),
+    checkoutPack: async (packId) => (await json2(`/billing/packs/${id(packId)}/checkout`, { method: "POST" })).url,
+    checkoutPlan: async (planId) => (await json2(`/billing/plans/${id(planId)}/checkout`, { method: "POST" })).url,
+    portal: async () => (await json2("/billing/portal", { method: "POST" })).url
+  };
+}
+const PROGRAM_LOGIN = "pixel-vibing-cli login";
+function apiUrlOf(context) {
+  try {
+    return apiAddress(context.io.env);
+  } catch (error) {
+    if (error instanceof ApiAddressError) throw new CliError(error.message);
+    throw error;
+  }
+}
+const originOf = (apiUrl) => new URL(apiUrl).origin;
+const urlOf = (input) => typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+function bearerFetch(fetcher, apiUrl, token) {
+  return async (input, init2) => {
+    const url = urlOf(input);
+    if (url !== apiUrl && !url.startsWith(`${apiUrl}/`)) throw new CliError(`the CLI sends its token only to ${apiUrl}, not to ${new URL(url).origin}`);
+    if (url === `${apiUrl}/auth/refresh`) return new Response(null, { status: 401 });
+    const headers = new Headers(init2?.headers);
+    headers.set("authorization", `Bearer ${token}`);
+    return fetcher(url, { ...init2, headers, credentials: "omit", redirect: "manual" });
+  };
+}
+function platformWith(fetcher, apiUrl, token) {
+  const carrying = bearerFetch(fetcher, apiUrl, token);
+  return { apiUrl, web: createWebApi(carrying, apiUrl), account: createAccountApi(carrying, apiUrl) };
+}
+async function signedIn(context) {
+  const apiUrl = apiUrlOf(context);
+  const token = await tokenFor(context.services.store, originOf(apiUrl), context.io.env);
+  if (token === null) throw new CliError(`not signed in: run \`${PROGRAM_LOGIN}\`, or set ${TOKEN_VARIABLE} to an account token`);
+  return platformWith(context.services.fetch, apiUrl, token);
+}
+const creditsPage = (apiUrl) => apiUrl === DEFAULT_API_URL ? `${DEFAULT_WEB_URL}#/credits` : `${originOf(apiUrl)}/app/#/credits`;
+async function paying(platform, run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (error instanceof TooFewCredits) {
+      throw new CliError(
+        `this costs ${error.cost} credits and the account has ${error.credits}: nothing was started. Buy credits at ${creditsPage(platform.apiUrl)}`
+      );
+    }
+    throw error;
+  }
+}
+function explain(error) {
+  if (error instanceof SignedOut) return `the platform refused the account token: run \`${PROGRAM_LOGIN}\` again`;
+  if (error instanceof ApiError || error instanceof StoreUnavailable || error instanceof ApiAddressError) return error.message;
+  if (error instanceof TypeError && error.message === "fetch failed") return "the platform cannot be reached just now";
+  return null;
+}
+const PROJECT_FILE = "pixelvibing.json";
+const PROJECT_FORMAT = 1;
+const PROJECT_DIRECTORY = "pixelvibing";
+const MAP_FILE = `${PROJECT_DIRECTORY}/map.json`;
+const MAX_PROJECT_NAME = 80;
+const PROJECT_ID = /^[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}$/;
+function isProjectId(id2) {
+  return typeof id2 === "string" && PROJECT_ID.test(id2);
+}
+class ProjectError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectError";
+  }
+}
+function projectNameProblem(name) {
+  const trimmed = name.trim();
+  if (trimmed === "") return "a project needs a name";
+  if (trimmed.length > MAX_PROJECT_NAME) return `a project's name is at most ${MAX_PROJECT_NAME} characters`;
+  return null;
+}
+function readProjectManifest(text2) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(text2);
+  } catch (error) {
+    throw new ProjectError(`${PROJECT_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (typeof parsed2 !== "object" || parsed2 === null || Array.isArray(parsed2)) throw new ProjectError(`${PROJECT_FILE} is not an object`);
+  const { format, name, project } = parsed2;
+  if (format !== PROJECT_FORMAT) {
+    throw new ProjectError(
+      typeof format === "number" && Number.isInteger(format) && format > PROJECT_FORMAT ? `${PROJECT_FILE} is format ${format}, newer than this editor reads (${PROJECT_FORMAT}): update PixelVibing to open it` : `${PROJECT_FILE} names no format this editor reads: expected "format": ${PROJECT_FORMAT}`
+    );
+  }
+  if (typeof name !== "string") throw new ProjectError(`${PROJECT_FILE} names no project: expected a "name"`);
+  const problem = projectNameProblem(name);
+  if (problem !== null) throw new ProjectError(`${PROJECT_FILE}: ${problem}`);
+  if (project !== void 0 && !isProjectId(project)) throw new ProjectError(`${PROJECT_FILE}: "project" is not a platform project's id`);
+  return project === void 0 ? { format, name: name.trim() } : { format, name: name.trim(), project };
+}
+function writeProjectManifest(manifest2) {
+  const fields = { format: manifest2.format, name: manifest2.name, ...manifest2.project === void 0 ? {} : { project: manifest2.project } };
+  return `${JSON.stringify(fields, null, 2)}
+`;
+}
+const MAX_MANIFEST_BYTES = 64 * 1024;
+const artOf = (project) => join(project.root, PROJECT_DIRECTORY);
+async function isFile(path) {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function readManifestAt(root) {
+  const path = join(root, PROJECT_FILE);
+  const { size } = await stat(path);
+  if (size > MAX_MANIFEST_BYTES) throw new CliError(`${path} is ${size} bytes, and a ${PROJECT_FILE} is at most ${MAX_MANIFEST_BYTES}`);
+  try {
+    return readProjectManifest(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error instanceof ProjectError) throw new CliError(`${path}: ${error.message}`);
+    throw error;
+  }
+}
+async function findProject(cwd) {
+  let directory = cwd;
+  for (; ; ) {
+    if (await isFile(join(directory, PROJECT_FILE))) return { root: directory, manifest: await readManifestAt(directory) };
+    const parent = dirname(directory);
+    if (parent === directory) return null;
+    directory = parent;
+  }
+}
+async function projectHere(cwd) {
+  const found = await findProject(cwd);
+  if (found === null) throw new CliError(`no ${PROJECT_FILE} here or in any directory above: run \`pixel-vibing-cli init\` to make this one a local project`);
+  return found;
+}
+function linkedOf(project) {
+  if (project.manifest.project === void 0) {
+    throw new CliError(`${join(project.root, PROJECT_FILE)} names no platform project: run \`pixel-vibing-cli link\` with one of your projects`);
+  }
+  return project.manifest.project;
+}
+async function writeLink(local, project) {
+  const manifest2 = { ...local.manifest, project };
+  await writeFile(join(local.root, PROJECT_FILE), writeProjectManifest(manifest2));
+  return { root: local.root, manifest: manifest2 };
+}
+const EMPTY = { tokens: {} };
+function settingsPath(platform, env, home) {
+  if (platform === "win32") return join(env.APPDATA ?? join(home, "AppData", "Roaming"), "pixelvibing", "cli.json");
+  if (platform === "darwin") return join(home, "Library", "Application Support", "pixelvibing", "cli.json");
+  const config = env.XDG_CONFIG_HOME?.trim();
+  return join(config !== void 0 && config !== "" ? config : join(home, ".config"), "pixelvibing", "cli.json");
+}
+const isCame = (value) => value === "login" || value === "given";
+async function readSettings(path) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return EMPTY;
+  }
+  const tokens = {};
+  const given = parsed2?.tokens;
+  if (typeof given === "object" && given !== null) {
+    for (const [origin, entry] of Object.entries(given)) {
+      const came = entry?.came;
+      if (isCame(came)) tokens[origin] = { came };
+    }
+  }
+  return { tokens };
+}
+async function recordToken(path, origin, came) {
+  const { tokens } = await readSettings(path);
+  const next = { ...tokens };
+  if (came === null) delete next[origin];
+  else next[origin] = { came };
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify({ tokens: next }, null, 2)}
+`);
+}
+const TOKEN_NAME_CHARS = 64;
+function tokenName(host) {
+  const name = `pixel-vibing-cli on ${host.trim() === "" ? "this machine" : host.trim()}`;
+  return name.slice(0, TOKEN_NAME_CHARS);
+}
+async function storeReady(context, origin) {
+  try {
+    return await context.services.store.get(origin);
+  } catch (error) {
+    if (error instanceof StoreUnavailable) throw new CliError(error.message);
+    throw error;
+  }
+}
+async function keep(context, origin, token, came) {
+  try {
+    await context.services.store.set(origin, token);
+  } catch (error) {
+    if (error instanceof StoreUnavailable) throw new CliError(error.message);
+    throw error;
+  }
+  await recordToken(context.services.settingsFile, origin, came);
+}
+async function providerOf(context, apiUrl, named) {
+  const offered = await createAccountApi(context.services.fetch, apiUrl).providers();
+  if (named !== void 0) {
+    if (!offered.includes(named)) throw new CliError(`the platform offers no sign-in with ${named}: ${offered.join(", ") || "none"}`);
+    return named;
+  }
+  if (offered.length === 0) throw new CliError("the platform offers no sign-in just now");
+  if (offered.length === 1) return offered[0];
+  if (!context.io.interactive) throw new CliError(`name the provider to sign in with, with --provider: ${offered.join(", ")}`);
+  const chosen = (await context.io.ask(`Sign in with (${offered.join(", ")}): `)).trim().toLowerCase();
+  if (!offered.includes(chosen)) throw new CliError(`the platform offers no sign-in with ${chosen}: ${offered.join(", ")}`);
+  return chosen;
+}
+async function givenToken(context, args) {
+  const [value] = args.positionals;
+  if (value === "-") return (await context.io.readInput()).trim();
+  if (value !== void 0) return value.trim();
+  if (!context.io.interactive) throw new CliError("give the token after --token, or - to read it from standard input");
+  return (await context.io.ask("Account token: ", true)).trim();
+}
+async function revoke(context, apiUrl, token) {
+  try {
+    await platformWith(context.services.fetch, apiUrl, token).account.revokeToken("current");
+  } catch (error) {
+    if (error instanceof SignedOut) return;
+    throw new CliError(
+      `the token could not be revoked on the platform (${error instanceof Error ? error.message : String(error)}): nothing was removed; run \`pixel-vibing-cli logout\` again, or revoke it in the dashboard`
+    );
+  }
+}
+async function loginWithToken(context, args, apiUrl, origin) {
+  const token = await givenToken(context, args);
+  if (token === "") throw new CliError("that token is empty");
+  await storeReady(context, origin);
+  let name;
+  try {
+    name = (await platformWith(context.services.fetch, apiUrl, token).account.me()).name;
+  } catch (error) {
+    if (error instanceof SignedOut) throw new CliError("the platform refused that token: nothing was kept");
+    throw error;
+  }
+  await keep(context, origin, token, "given");
+  answer(context, { signedIn: true, account: name, came: "given" }, `Signed in as ${name}. The token is kept in this system's credential store.`);
+}
+async function signInInBrowser(context, named) {
+  const apiUrl = apiUrlOf(context);
+  const origin = originOf(apiUrl);
+  const before = await storeReady(context, origin);
+  const provider = await providerOf(context, apiUrl, named);
+  const configDir = dirname(context.services.settingsFile);
+  const session = new DesktopSession({
+    apiUrl,
+    boundary: new Boundary([configDir]),
+    configDir,
+    vault: null,
+    fetch: context.services.fetch,
+    app: "cli",
+    openExternal: async (url) => {
+      context.io.warn(`Signing in with ${provider} in your browser. If it did not open, go to:
+  ${url}
+`);
+      await context.services.openExternal(url).catch(() => {
+      });
+    }
+  });
+  const outcome = await session.signIn(provider);
+  if (outcome === "denied") throw new CliError("the sign-in was cancelled: nothing was kept");
+  if (outcome === "failed") throw new CliError("the sign-in did not finish: nothing was kept");
+  const jwt = await session.jwt();
+  if (jwt === null) throw new CliError("the sign-in did not finish: nothing was kept");
+  let made;
+  let account;
+  try {
+    const signed = platformWith(context.services.fetch, apiUrl, jwt).account;
+    account = (await signed.me()).name;
+    made = await signed.createToken(tokenName(context.services.hostname()));
+  } finally {
+    await session.signOut();
+  }
+  const previous = (await readSettings(context.services.settingsFile)).tokens[origin]?.came;
+  await keep(context, origin, made.token, "login");
+  if (before !== null && before !== made.token && previous === "login") await revoke(context, apiUrl, before).catch(() => {
+  });
+  return { account, token: made.name };
+}
+const login = {
+  name: "login",
+  summary: "Sign in in the browser, and keep an account token for this machine",
+  usage: "[--provider <name>] | --token [<token> | -]",
+  options: {
+    provider: { type: "string", value: "<name>", description: "the provider to sign in with, such as github" },
+    token: { type: "boolean", description: "keep a token made in the dashboard: after it, the token, or - to read it from standard input" }
+  },
+  positionals: [0, 1],
+  run: async (context, args) => {
+    if (!flagOf(args, "token") && args.positionals.length > 0) throw new CliError("a token is given after --token");
+    const apiUrl = apiUrlOf(context);
+    const origin = originOf(apiUrl);
+    if (flagOf(args, "token")) await loginWithToken(context, args, apiUrl, origin);
+    else {
+      const { account, token } = await signInInBrowser(context, stringOf(args, "provider"));
+      answer(
+        context,
+        { signedIn: true, account, came: "login", token },
+        `Signed in as ${account}. This machine's token, "${token}", is kept in this system's credential store.`
+      );
+    }
+    if (context.io.env[TOKEN_VARIABLE] !== void 0) context.io.warn(`${TOKEN_VARIABLE} is set, and is used before the kept token while it is.
+`);
+  }
+};
+const logout = {
+  name: "logout",
+  summary: "Remove this machine's account token, revoking it when login issued it",
+  run: async (context) => {
+    const apiUrl = apiUrlOf(context);
+    const origin = originOf(apiUrl);
+    const token = await storeReady(context, origin);
+    if (token === null) {
+      answer(context, { signedOut: true, revoked: false }, "No token is kept here.");
+      return;
+    }
+    const came = (await readSettings(context.services.settingsFile)).tokens[origin]?.came;
+    if (came === "login") await revoke(context, apiUrl, token);
+    await context.services.store.remove(origin);
+    await recordToken(context.services.settingsFile, origin, null);
+    answer(
+      context,
+      { signedOut: true, revoked: came === "login" },
+      came === "login" ? "Signed out: the token was revoked and removed from this machine." : "Signed out: the token was removed from this machine. It was given with --token, so it still works wherever else it is kept: revoke it in the dashboard if it should not."
+    );
+    if (context.io.env[TOKEN_VARIABLE] !== void 0) context.io.warn(`${TOKEN_VARIABLE} is still set, and this shell still signs in with it.
+`);
+  }
+};
+const whoami = {
+  name: "whoami",
+  summary: "Show the account the token signs in as, and the local project's platform project",
+  run: async (context) => {
+    const platform = await signedIn(context);
+    const me = await platform.account.me();
+    const local = await findProject(context.io.cwd);
+    const linked = local?.manifest.project;
+    let project = null;
+    if (linked !== void 0) {
+      try {
+        project = await platform.web.project(linked);
+      } catch (error) {
+        if (!(error instanceof ApiError && error.status === 404)) throw error;
+      }
+    }
+    const lines = [`Signed in as ${me.name}${me.email === null ? "" : ` (${me.email})`} at ${platform.apiUrl}.`];
+    if (local === null) lines.push("No local project here: `pixel-vibing-cli init` makes one.");
+    else if (linked === void 0)
+      lines.push(`The local project ${local.manifest.name} is linked to no platform project: \`pixel-vibing-cli link\` links one.`);
+    else if (project === null)
+      lines.push(
+        `The local project ${local.manifest.name} is linked to ${linked}, which this account has no project by: \`pixel-vibing-cli link\` links another.`
+      );
+    else lines.push(`The local project ${local.manifest.name} generates for ${project.name} (${project.id}).`);
+    answer(
+      context,
+      {
+        account: { id: me.id, name: me.name, email: me.email },
+        apiUrl: platform.apiUrl,
+        project: local === null ? null : { root: local.root, name: local.manifest.name, platform: project === null ? null : { id: project.id, name: project.name } }
+      },
+      lines.join("\n")
+    );
+  }
+};
+const TILESET_ROOT = "tileset";
+const TILESET = /^(tileset\/[a-z0-9]+(?:-[a-z0-9]+)*-\d+)(?:\/(.+))?$/;
+function splitTileset(name) {
+  const match = TILESET.exec(name);
+  if (match === null) return { tileset: null, inner: name };
+  return { tileset: match[1], inner: match[2] ?? "" };
+}
+function scopedTerrain(tileset, terrain) {
+  return tileset === null ? terrain : `${tileset.slice(TILESET_ROOT.length + 1)}/${terrain}`;
+}
+const OUT_PREFIX = "art/out";
+const RESERVED = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const DEVICE = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
+const SEGMENT = /^[A-Za-z0-9_-][A-Za-z0-9._-]*$/;
+function joinedUnderOut(name) {
+  if (name.length === 0) return null;
+  if (/^[A-Za-z]:/.test(name)) return null;
+  const raw = name.split(/[\\/]/);
+  if (raw[0] === "") return null;
+  const segments = [];
+  for (const segment of raw) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      if (segments.length === 0) return null;
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  if (segments.length === 0) return null;
+  return `${OUT_PREFIX}/${segments.join("/")}.png`;
+}
+function nameProblem(name) {
+  if (name.length === 0) return "the name is empty";
+  if (joinedUnderOut(name) === null) return `${name} would leave ${OUT_PREFIX} when joined to it`;
+  const segments = name.split("/");
+  for (const segment of segments) {
+    if (segment.length === 0) return `${name} has an empty segment`;
+    if (segment.startsWith(".")) return `${segment} starts with a dot`;
+    if (RESERVED.has(segment)) return `${segment} is not a key an object can hold`;
+    if (DEVICE.test(segment)) return `${segment} is a device name on Windows, not a file`;
+    if (!SEGMENT.test(segment)) {
+      const bad = [...segment].find((character) => !/[A-Za-z0-9._-]/.test(character)) ?? segment;
+      return `${name} holds "${bad}", and a name is letters, digits, - and _ in segments joined by /`;
+    }
+  }
+  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;
+const MAX_ICONS = 16;
+const SET_NAMES = { hud: "ui/hud", icons: "ui/icon" };
+function setPiecesOf(kind, count, data) {
+  if (SET_NAMES[kind] === void 0) return null;
+  const pieces = data.pieces;
+  if (!Array.isArray(pieces) || pieces.length !== count) return null;
+  if (!pieces.every((piece) => typeof piece === "object" && piece !== null && typeof piece.name === "string")) return null;
+  return pieces;
+}
+function pieceNames(set, pieces) {
+  const taken = /* @__PURE__ */ new Set();
+  return pieces.map((piece) => {
+    const base = piece.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "piece";
+    let slug = base;
+    for (let again = 2; taken.has(slug); again += 1) slug = `${base}-${again}`;
+    taken.add(slug);
+    return `${set}/${slug}`;
+  });
+}
+function describedInterface(manifest2, kept, earlier) {
+  const next = { ...manifest2 };
+  for (const name of earlier) delete next[name];
+  for (const [name, piece] of kept)
+    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);
+}
+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 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;
+  }
+}
+async function writeRecord(local, record) {
+  await artBoundary(local).writeFileReplacing(recordPath(local), writePulled(record));
+}
+const INTERFACE_MANIFEST = "manifest/interface.json";
+function setPieces(asset) {
+  return setPiecesOf(asset.kind, asset.images.length, asset.data);
+}
+function pieceFiles(name, pieces) {
+  return pieceNames(name, pieces).map((piece) => `out/${piece}.png`);
+}
+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`);
+}
+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;
+}
+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 };
+  }
+  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 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 };
+}
+async function describeInterface(boundary, art, written, earlier) {
+  const path = join(art, ...INTERFACE_MANIFEST.split("/"));
+  let manifest2 = {};
+  if (await boundary.exists(path)) {
+    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");
+    } catch (error) {
+      throw new CliError(`pixelvibing/${INTERFACE_MANIFEST} is not a manifest (${error.message}): the pieces were written, and not described`);
+    }
+  }
+  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)}
+`));
+}
+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");
+}
+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: "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));
+  }
+};
+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 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 {
+    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 TILE_SIZE = 256;
+const EAI_MAGIC = 1229018181;
+const EAI_VERSION = 1;
+const HEADER_SIZE$1 = 32;
+const ASSET_SIZE = 24;
+const ATLAS_SIZE = 12;
+class AssetIndexError 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 = "AssetIndexError";
+  }
+}
+function parseAssetIndex(buffer) {
+  if (buffer.byteLength < HEADER_SIZE$1) {
+    throw new AssetIndexError(`buffer too small: ${buffer.byteLength} < ${HEADER_SIZE$1}`);
+  }
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, true);
+  if (magic !== EAI_MAGIC) {
+    throw new AssetIndexError(`bad magic 0x${magic.toString(16)} (expected 0x${EAI_MAGIC.toString(16)})`);
+  }
+  const version2 = view.getUint32(4, true);
+  if (version2 !== EAI_VERSION) {
+    throw new AssetIndexError(`unsupported version ${version2}, reader speaks v${EAI_VERSION}`);
+  }
+  const assetCount = view.getUint32(8, true);
+  const atlasCount = view.getUint32(12, true);
+  const assetsOffset = view.getUint32(16, true);
+  const atlasesOffset = view.getUint32(20, true);
+  const stringsOffset = view.getUint32(24, true);
+  const stringsLength = view.getUint32(28, true);
+  if (buffer.byteLength !== stringsOffset + stringsLength) {
+    throw new AssetIndexError(`file size ${buffer.byteLength} ≠ header-declared ${stringsOffset + stringsLength}`);
+  }
+  if (assetsOffset < HEADER_SIZE$1) {
+    throw new AssetIndexError(`assetsOffset ${assetsOffset} is inside the ${HEADER_SIZE$1}-byte header`);
+  }
+  if (assetsOffset + assetCount * ASSET_SIZE > atlasesOffset) {
+    throw new AssetIndexError("asset section overlaps atlas section");
+  }
+  if (atlasesOffset + atlasCount * ATLAS_SIZE > stringsOffset) {
+    throw new AssetIndexError("atlas section overlaps string pool");
+  }
+  const pool = new Pool(buffer, stringsOffset, stringsLength);
+  const atlases = readAtlases(view, pool, atlasCount, atlasesOffset);
+  const assets = readAssets(view, pool, assetCount, assetsOffset, atlases);
+  return { version: version2, assets, atlases };
+}
+class Pool {
+  buffer;
+  offset;
+  length;
+  decoder = new TextDecoder("utf-8", { fatal: true });
+  constructor(buffer, offset, length) {
+    this.buffer = buffer;
+    this.offset = offset;
+    this.length = length;
+  }
+  read(what, nameOffset, nameLength) {
+    if (nameOffset < this.offset || nameOffset + nameLength > this.offset + this.length) {
+      throw new AssetIndexError(`${what}: name range [${nameOffset}, +${nameLength}] outside the string pool`);
+    }
+    try {
+      return this.decoder.decode(new Uint8Array(this.buffer, nameOffset, nameLength));
+    } catch (error) {
+      throw new AssetIndexError(`${what}: bad UTF-8 name (${error.message})`);
+    }
+  }
+}
+function readAtlases(view, pool, atlasCount, atlasesOffset) {
+  const atlases = new Array(atlasCount);
+  for (let index = 0; index < atlasCount; index += 1) {
+    const base = atlasesOffset + index * ATLAS_SIZE;
+    atlases[index] = {
+      index,
+      width: view.getUint16(base, true),
+      height: view.getUint16(base + 2, true),
+      name: pool.read(`atlas ${index}`, view.getUint32(base + 4, true), view.getUint32(base + 8, true))
+    };
+  }
+  return atlases;
+}
+function readAssets(view, pool, assetCount, assetsOffset, atlases) {
+  const assets = /* @__PURE__ */ new Map();
+  for (let index = 0; index < assetCount; index += 1) {
+    const base = assetsOffset + index * ASSET_SIZE;
+    const name = pool.read(`asset ${index}`, view.getUint32(base, true), view.getUint16(base + 4, true));
+    if (assets.has(name)) {
+      throw new AssetIndexError(`duplicate asset name ${name}`);
+    }
+    const atlasIndex = view.getUint16(base + 6, true);
+    const atlas = atlases[atlasIndex];
+    if (atlas === void 0) {
+      throw new AssetIndexError(`asset ${name}: atlasIndex ${atlasIndex} ≥ atlasCount ${atlases.length}`);
+    }
+    const entry = {
+      name,
+      atlasIndex,
+      x: view.getUint16(base + 8, true),
+      y: view.getUint16(base + 10, true),
+      width: view.getUint16(base + 12, true),
+      height: view.getUint16(base + 14, true),
+      offsetX: view.getInt16(base + 16, true),
+      offsetY: view.getInt16(base + 18, true),
+      flags: view.getUint16(base + 20, true)
+    };
+    if (entry.x + entry.width > atlas.width || entry.y + entry.height > atlas.height) {
+      throw new AssetIndexError(
+        `asset ${name}: rectangle ${entry.x},${entry.y} ${entry.width}x${entry.height} leaves atlas ${atlas.name} (${atlas.width}x${atlas.height})`
+      );
+    }
+    assets.set(name, entry);
+  }
+  return assets;
+}
+const U16_MAX = 65535;
+const I16_MIN = -32768;
+const I16_MAX = 32767;
+function writeAssetIndex(atlases, assets) {
+  const encoder2 = new TextEncoder();
+  const ordered = [...assets].sort((left, right) => compareBytes(encoder2, left.name, right.name));
+  const seen = /* @__PURE__ */ new Set();
+  for (const asset of ordered) {
+    if (seen.has(asset.name)) throw new AssetIndexError(`duplicate asset name ${asset.name}`);
+    seen.add(asset.name);
+    if (asset.atlasIndex >= atlases.length) {
+      throw new AssetIndexError(`asset ${asset.name}: atlasIndex ${asset.atlasIndex} ≥ atlasCount ${atlases.length}`);
+    }
+    checkU16(asset.name, { x: asset.x, y: asset.y, width: asset.width, height: asset.height, flags: asset.flags });
+    checkI16(asset.name, { offsetX: asset.offsetX, offsetY: asset.offsetY });
+    const atlas = atlases[asset.atlasIndex];
+    if (asset.x + asset.width > atlas.width || asset.y + asset.height > atlas.height) {
+      throw new AssetIndexError(`asset ${asset.name}: rectangle leaves atlas ${atlas.name} (${atlas.width}x${atlas.height})`);
+    }
+  }
+  for (const atlas of atlases) {
+    checkU16(atlas.name, { width: atlas.width, height: atlas.height });
+  }
+  const pool = [];
+  const ranges = /* @__PURE__ */ new Map();
+  const intern = (text2) => {
+    const found = ranges.get(text2);
+    if (found !== void 0) return found;
+    const bytes = encoder2.encode(text2);
+    const range = { offset: pool.length, length: bytes.length };
+    if (range.length > U16_MAX) throw new AssetIndexError(`name too long: ${text2}`);
+    pool.push(...bytes);
+    ranges.set(text2, range);
+    return range;
+  };
+  for (const asset of ordered) intern(asset.name);
+  for (const atlas of atlases) intern(atlas.name);
+  const assetsOffset = HEADER_SIZE$1;
+  const atlasesOffset = assetsOffset + ordered.length * ASSET_SIZE;
+  const stringsOffset = atlasesOffset + atlases.length * ATLAS_SIZE;
+  const buffer = new ArrayBuffer(stringsOffset + pool.length);
+  const view = new DataView(buffer);
+  view.setUint32(0, EAI_MAGIC, true);
+  view.setUint32(4, EAI_VERSION, true);
+  view.setUint32(8, ordered.length, true);
+  view.setUint32(12, atlases.length, true);
+  view.setUint32(16, assetsOffset, true);
+  view.setUint32(20, atlasesOffset, true);
+  view.setUint32(24, stringsOffset, true);
+  view.setUint32(28, pool.length, true);
+  ordered.forEach((asset, index) => {
+    const base = assetsOffset + index * ASSET_SIZE;
+    const range = ranges.get(asset.name);
+    view.setUint32(base, stringsOffset + range.offset, true);
+    view.setUint16(base + 4, range.length, true);
+    view.setUint16(base + 6, asset.atlasIndex, true);
+    view.setUint16(base + 8, asset.x, true);
+    view.setUint16(base + 10, asset.y, true);
+    view.setUint16(base + 12, asset.width, true);
+    view.setUint16(base + 14, asset.height, true);
+    view.setInt16(base + 16, asset.offsetX, true);
+    view.setInt16(base + 18, asset.offsetY, true);
+    view.setUint16(base + 20, asset.flags, true);
+  });
+  atlases.forEach((atlas, index) => {
+    const base = atlasesOffset + index * ATLAS_SIZE;
+    const range = ranges.get(atlas.name);
+    view.setUint16(base, atlas.width, true);
+    view.setUint16(base + 2, atlas.height, true);
+    view.setUint32(base + 4, stringsOffset + range.offset, true);
+    view.setUint32(base + 8, range.length, true);
+  });
+  new Uint8Array(buffer).set(new Uint8Array(pool), stringsOffset);
+  return buffer;
+}
+function compareBytes(encoder2, left, right) {
+  const a = encoder2.encode(left);
+  const b = encoder2.encode(right);
+  for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return a.length - b.length;
+}
+function checkU16(what, fields) {
+  for (const [field, value] of Object.entries(fields)) {
+    if (!Number.isInteger(value) || value < 0 || value > U16_MAX) {
+      throw new AssetIndexError(`${what}: ${field} ${value} does not fit in a u16`);
+    }
+  }
+}
+function checkI16(what, fields) {
+  for (const [field, value] of Object.entries(fields)) {
+    if (!Number.isInteger(value) || value < I16_MIN || value > I16_MAX) {
+      throw new AssetIndexError(`${what}: ${field} ${value} does not fit in an i16`);
+    }
+  }
+}
+const METADATA_ENTRY = "meta.json";
+const METADATA_VERSION = 1;
+const ANIMATION_KEYS = [
+  "idle",
+  "stand-north",
+  "stand-south",
+  "stand-west",
+  "stand-east",
+  "walk-north",
+  "walk-south",
+  "walk-west",
+  "walk-east",
+  "attack-north",
+  "attack-south",
+  "attack-west",
+  "attack-east",
+  "icon"
+];
+const ANIMATION_KEY_SET = new Set(ANIMATION_KEYS);
+function isAnimationKey(key) {
+  return ANIMATION_KEY_SET.has(key);
+}
+const ASSET_KINDS = ["outfit", "tile", "item", "effect", "ui"];
+const UI_SCALES = ["stretch", "repeat", "round"];
+const PLAY_EVERY_MIN_MS = 250;
+const PLAY_EVERY_MAX_MS = 6e5;
+const MAX_ANIMATION_NAME = 48;
+const ANIMATION_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isAnimationName(name) {
+  return name.length <= MAX_ANIMATION_NAME && ANIMATION_NAME.test(name);
+}
+class AssetMetadataError 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 = "AssetMetadataError";
+  }
+}
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const MAX_ANIMATION_FRAMES = 64;
+function readFrames(value, asset, animation) {
+  if (!Array.isArray(value)) {
+    throw new AssetMetadataError(`${asset}: animation ${animation} is not a list of frames`);
+  }
+  if (value.length > MAX_ANIMATION_FRAMES) {
+    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)) {
+      throw new AssetMetadataError(`${asset}: animation ${animation} frame ${index} is not a frame`);
+    }
+    const name = raw.asset;
+    if (typeof name !== "string" || name === "") {
+      throw new AssetMetadataError(`${asset}: animation ${animation} frame ${index} names no asset`);
+    }
+    const ms = raw.ms;
+    if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 0) {
+      throw new AssetMetadataError(
+        `${asset}: animation ${animation} frame ${index} has duration ${String(ms)}, which is not a whole number of milliseconds at or above zero`
+      );
+    }
+    return { asset: name, ms, flip: raw.flip === true };
+  });
+}
+function readAnimations(value, asset, kind) {
+  const animations = /* @__PURE__ */ new Map();
+  if (value === void 0) return animations;
+  if (!isRecord$1(value)) {
+    throw new AssetMetadataError(`${asset}: animations is not a map of name to frames`);
+  }
+  for (const [name, frames] of Object.entries(value)) {
+    if (kind === "outfit" && !isAnimationKey(name)) {
+      throw new AssetMetadataError(`${asset}: unknown animation ${name} (expected one of ${ANIMATION_KEYS.join(", ")})`);
+    }
+    if (kind !== "outfit" && !isAnimationName(name)) {
+      throw new AssetMetadataError(`${asset}: animation ${name} is not a kebab-case name of at most ${MAX_ANIMATION_NAME} characters`);
+    }
+    animations.set(name, readFrames(frames, asset, name));
+  }
+  return animations;
+}
+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`);
+  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 (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") {
+      plays.set(name, { mode: play.mode });
+      continue;
+    }
+    if (play.mode === "every") {
+      const ms = play.ms;
+      if (typeof ms !== "number" || !Number.isInteger(ms) || ms < PLAY_EVERY_MIN_MS || ms > PLAY_EVERY_MAX_MS) {
+        throw new AssetMetadataError(
+          `${asset}: ${name} plays every ${String(ms)} ms, and an interval is a whole ${PLAY_EVERY_MIN_MS} to ${PLAY_EVERY_MAX_MS} ms`
+        );
+      }
+      plays.set(name, { mode: "every", ms });
+      continue;
+    }
+    throw new AssetMetadataError(`${asset}: ${name} plays as ${String(play.mode)}, and an animation plays as loop, every or change`);
+  }
+  return plays;
+}
+function readNineGrid(value, asset) {
+  if (value === void 0) return void 0;
+  if (!isRecord$1(value)) {
+    throw new AssetMetadataError(`${asset}: nineGrid is not an object of four insets`);
+  }
+  const insets = {};
+  for (const edge of ["top", "right", "bottom", "left"]) {
+    const inset = value[edge];
+    if (inset === void 0) {
+      throw new AssetMetadataError(`${asset}: nineGrid declares no ${edge} inset`);
+    }
+    if (typeof inset !== "number" || !Number.isInteger(inset) || inset < 0) {
+      throw new AssetMetadataError(`${asset}: nineGrid ${edge} is ${String(inset)}, which is not a whole number of pixels at or above zero`);
+    }
+    insets[edge] = inset;
+  }
+  return { top: insets.top, right: insets.right, bottom: insets.bottom, left: insets.left };
+}
+function readScale(value, asset) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !UI_SCALES.includes(value)) {
+    throw new AssetMetadataError(`${asset}: scale ${String(value)} is not one of ${UI_SCALES.join(", ")}`);
+  }
+  return value;
+}
+function readCollide(value, asset) {
+  if (value === void 0) return void 0;
+  if (!isRecord$1(value)) {
+    throw new AssetMetadataError(`${asset}: collide is not a box of x, y, w and h in cells`);
+  }
+  const box = {};
+  for (const side of ["x", "y", "w", "h"]) {
+    const cells = value[side];
+    if (typeof cells !== "number" || !Number.isInteger(cells)) {
+      throw new AssetMetadataError(`${asset}: collide ${side} is ${String(cells)}, which is not a whole number of cells`);
+    }
+    box[side] = cells;
+  }
+  if (box.w < 1 || box.h < 1) {
+    throw new AssetMetadataError(`${asset}: collide is ${box.w}x${box.h} cells, and a box is at least one by one`);
+  }
+  return { x: box.x, y: box.y, w: box.w, h: box.h };
+}
+const MAX_DRAW_OFFSET = TILE_SIZE * 8;
+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)) {
+    throw new AssetMetadataError(`${asset}: offset is not an x and a y in pixels`);
+  }
+  for (const axis of ["x", "y"]) {
+    const px = value[axis];
+    if (Math.abs(px) > MAX_DRAW_OFFSET) {
+      throw new AssetMetadataError(`${asset}: offset ${axis} is ${px} px, and an offset is within ${MAX_DRAW_OFFSET} px of the tile`);
+    }
+  }
+  return { x: value.x, y: value.y };
+}
+function readDrawScale(value, asset) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new AssetMetadataError(`${asset}: drawScale is ${String(value)}, and a scale is a number above zero`);
+  }
+  if (value < MIN_DRAW_SCALE || value > MAX_DRAW_SCALE) {
+    throw new AssetMetadataError(`${asset}: drawScale is ${value}, and a scale is between ${MIN_DRAW_SCALE} and ${MAX_DRAW_SCALE}`);
+  }
+  return value;
+}
+function readEntry(value, asset) {
+  if (!isRecord$1(value)) {
+    throw new AssetMetadataError(`${asset}: not an entry`);
+  }
+  const kind = value.kind;
+  if (typeof kind !== "string") {
+    throw new AssetMetadataError(`${asset}: declares no kind`);
+  }
+  if (!ASSET_KINDS.includes(kind)) {
+    throw new AssetMetadataError(`${asset}: unknown kind ${kind} (expected ${ASSET_KINDS.join(", ")})`);
+  }
+  const minimap = value.minimap;
+  if (minimap !== void 0 && (typeof minimap !== "number" || !Number.isInteger(minimap))) {
+    throw new AssetMetadataError(`${asset}: minimap category is not a whole number`);
+  }
+  if (kind !== "ui" && (value.nineGrid !== void 0 || value.scale !== void 0)) {
+    throw new AssetMetadataError(`${asset}: nineGrid and scale are interface fields, and this is a ${kind}`);
+  }
+  if (kind !== "tile" && (value.collide !== void 0 || value.offset !== void 0 || value.drawScale !== void 0)) {
+    throw new AssetMetadataError(`${asset}: collide, offset and drawScale are tile fields, and this is a ${kind}`);
+  }
+  const animations = readAnimations(value.animations, asset, kind);
+  return {
+    kind,
+    animations,
+    plays: readPlays(value.plays, asset, animations, kind),
+    blocking: value.blocking === true,
+    foreground: value.foreground === true,
+    roof: value.roof === true,
+    door: value.door === true,
+    water: value.water === true,
+    minimap: minimap ?? 0,
+    collide: readCollide(value.collide, asset),
+    offset: readOffset(value.offset, asset),
+    drawScale: readDrawScale(value.drawScale, asset),
+    nineGrid: readNineGrid(value.nineGrid, asset),
+    scale: readScale(value.scale, asset)
+  };
+}
+function parseAssetMetadata(text2) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(text2);
+  } catch (error) {
+    throw new AssetMetadataError(`not JSON: ${error.message}`);
+  }
+  if (!isRecord$1(parsed2)) {
+    throw new AssetMetadataError("not an object");
+  }
+  const version2 = parsed2.version;
+  if (version2 !== METADATA_VERSION) {
+    throw new AssetMetadataError(`unsupported version ${String(version2)}, reader speaks v${METADATA_VERSION}`);
+  }
+  const rawAssets = parsed2.assets;
+  if (rawAssets !== void 0 && !isRecord$1(rawAssets)) {
+    throw new AssetMetadataError("assets is not a map of name to entry");
+  }
+  const assets = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(rawAssets ?? {})) {
+    assets.set(name, readEntry(entry, name));
+  }
+  return { version: version2, assets };
+}
+function writeAssetMetadata(metadata) {
+  const assets = {};
+  for (const [name, entry] of [...metadata.assets].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    const out = { kind: entry.kind };
+    if (entry.blocking) out.blocking = true;
+    if (entry.foreground) out.foreground = true;
+    if (entry.roof) out.roof = true;
+    if (entry.door) out.door = true;
+    if (entry.water) out.water = true;
+    if (entry.minimap !== 0) out.minimap = entry.minimap;
+    if (entry.collide !== void 0) out.collide = entry.collide;
+    if (entry.offset !== void 0) out.offset = entry.offset;
+    if (entry.drawScale !== void 0) out.drawScale = entry.drawScale;
+    if (entry.nineGrid !== void 0) out.nineGrid = entry.nineGrid;
+    if (entry.scale !== void 0) out.scale = entry.scale;
+    if (entry.animations.size > 0) {
+      const animations = {};
+      const ordered = [...entry.animations].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+      for (const [animation, frames] of ordered) {
+        animations[animation] = frames.map((frame) => frame.flip ? { asset: frame.asset, ms: frame.ms, flip: true } : { asset: frame.asset, ms: frame.ms });
+      }
+      out.animations = animations;
+    }
+    if (entry.plays.size > 0) {
+      const plays = {};
+      for (const [animation, play] of [...entry.plays].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) plays[animation] = play;
+      out.plays = plays;
+    }
+    assets[name] = out;
+  }
+  return `${JSON.stringify({ version: metadata.version, assets }, null, 2)}
+`;
+}
+class IdMapError 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 = "IdMapError";
+  }
+}
+const SECTIONS = ["looktypes", "frames"];
+const WHOLE_NUMBER = /^(0|[1-9][0-9]*)$/;
+const FRAME_KEY = /^(0|[1-9][0-9]*):(0|[1-9][0-9]*)$/;
+function parseIdMap(raw) {
+  const record = asObject(raw, "the id map");
+  for (const section2 of Object.keys(record)) {
+    if (!SECTIONS.includes(section2)) {
+      throw new IdMapError(`unknown section ${section2}: the map has looktypes and frames`);
+    }
+  }
+  const looktypes = /* @__PURE__ */ new Map();
+  const frames = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(section(record, "looktypes"))) {
+    if (!WHOLE_NUMBER.test(key)) {
+      throw new IdMapError(`looktype key ${key} is not a whole number`);
+    }
+    const name = assetName(value, `looktype ${key}`);
+    looktypes.set(Number(key), name);
+    names.add(name);
+  }
+  for (const [key, value] of Object.entries(section(record, "frames"))) {
+    if (!FRAME_KEY.test(key)) {
+      throw new IdMapError(`frame key ${key} is not packId:frameId`);
+    }
+    const name = assetName(value, `frame ${key}`);
+    frames.set(key, name);
+    names.add(name);
+  }
+  return {
+    nameForLooktype: (looktype) => looktypes.get(looktype) ?? null,
+    nameForFrame: (packId, frameId) => frames.get(`${packId}:${frameId}`) ?? null,
+    names,
+    looktypeCount: looktypes.size,
+    frameCount: frames.size
+  };
+}
+function checkNamesAgainstIndex(map, index, declared = /* @__PURE__ */ new Set()) {
+  const absent = [...map.names].filter((name) => !index.assets.has(name) && !declared.has(name)).sort();
+  if (absent.length > 0) {
+    throw new IdMapError(`the id map names assets the index does not hold: ${absent.join(", ")}`);
+  }
+}
+function asObject(value, what) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new IdMapError(`${what} must be a JSON object`);
+  }
+  return value;
+}
+function section(record, name) {
+  const value = record[name];
+  return value === void 0 ? {} : asObject(value, `${name}`);
+}
+function assetName(value, what) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new IdMapError(`${what}: the asset name must be a non-empty string`);
+  }
+  return value;
+}
+const EAC_MAGIC = 826491205;
+const EAC_VERSION = 1;
+const INDEX_ENTRY = "assets.eai";
+const ID_MAP_ENTRY = "id-map.json";
+const HEADER_SIZE = 32;
+const FLAG_MASKED = 1;
+const MASK_KEY = Uint8Array.from([69, 116, 101, 114, 110, 105, 116, 121, 77, 69, 45, 115, 101, 97, 108, 33]);
+class ContainerError 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 = "ContainerError";
+  }
+}
+function maskByte(value, offset) {
+  const key = MASK_KEY[offset % MASK_KEY.length];
+  const drift = Math.imul(offset, 31) + (offset >>> 5) & 255;
+  return (value ^ key ^ drift) & 255;
+}
+function maskInto(target, start, source) {
+  for (let index = 0; index < source.length; index += 1) {
+    target[start + index] = maskByte(source[index], start + index);
+  }
+}
+function sealContainer(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.name)) throw new ContainerError(`duplicate entry name ${entry.name}`);
+    seen.add(entry.name);
+  }
+  const encoder2 = new TextEncoder();
+  const ordered = [...entries].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  const names = ordered.map((entry) => encoder2.encode(entry.name));
+  const tocLength = names.reduce((total, name) => total + 2 + name.length + 8, 0);
+  const tocOffset = HEADER_SIZE;
+  const payloadOffset = tocOffset + tocLength;
+  const payloadLength = ordered.reduce((total, entry) => total + entry.bytes.length, 0);
+  const out = new Uint8Array(payloadOffset + payloadLength);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, EAC_MAGIC, true);
+  view.setUint32(4, EAC_VERSION, true);
+  view.setUint32(8, ordered.length, true);
+  view.setUint32(12, tocOffset, true);
+  view.setUint32(16, tocLength, true);
+  view.setUint32(20, payloadOffset, true);
+  view.setUint32(24, FLAG_MASKED, true);
+  view.setUint32(28, 0, true);
+  const toc = new Uint8Array(tocLength);
+  const tocView = new DataView(toc.buffer);
+  let cursor = 0;
+  let entryOffset = payloadOffset;
+  ordered.forEach((entry, index) => {
+    const name = names[index];
+    tocView.setUint16(cursor, name.length, true);
+    cursor += 2;
+    toc.set(name, cursor);
+    cursor += name.length;
+    tocView.setUint32(cursor, entryOffset, true);
+    cursor += 4;
+    tocView.setUint32(cursor, entry.bytes.length, true);
+    cursor += 4;
+    maskInto(out, entryOffset, entry.bytes);
+    entryOffset += entry.bytes.length;
+  });
+  maskInto(out, tocOffset, toc);
+  return out;
+}
+function tileSpritePlacement(tx, ty, width, height, tileSize = TILE_SIZE) {
+  const overhangX = (width - tileSize) / 2;
+  const overhangY = (height - tileSize) / 2;
+  return { x: tx * tileSize - overhangX, y: ty * tileSize - overhangY };
+}
+function placeTileSprite(tx, ty, width, height, options = {}) {
+  const tileSize = options.tileSize ?? TILE_SIZE;
+  const scale = options.drawScale ?? 1;
+  const scaledWidth = width * scale;
+  const scaledHeight = height * scale;
+  const centred = tileSpritePlacement(tx, ty, scaledWidth, scaledHeight, tileSize);
+  return {
+    x: centred.x + (options.offset?.x ?? 0),
+    y: centred.y + (options.offset?.y ?? 0),
+    width: scaledWidth,
+    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 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];
+  }
+  for (const key of Object.keys(tile)) {
+    if (!(key in ordered) && tile[key] !== void 0) ordered[key] = tile[key];
+  }
+  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 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 MAX_SIDE$1 = 65535;
+const encoder$1 = new TextEncoder();
+function isRecord(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;
+  try {
+    const parsed2 = parseAssetMetadata(JSON.stringify({ version: METADATA_VERSION, assets: { [entry.name]: raw } }));
+    return parsed2.assets.get(entry.name);
+  } catch (error) {
+    throw new ProjectError(`the manifest entry ${entry.name} does not describe its asset: ${error.message}`);
+  }
+}
+function describedAssets(entries) {
+  const described = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.meta === void 0) continue;
+    described.set(entry.name, metadataOf(entry));
+  }
+  return described;
+}
+function sealProjectArt(art) {
+  const pictures = [...art.pictures].sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  const atlases = [];
+  const assets = [];
+  const pages = [];
+  for (const [index, picture] of pictures.entries()) {
+    if (index > 0 && pictures[index - 1]?.name === picture.name) throw new ProjectError(`two pictures are named ${picture.name}`);
+    if (!isPng(picture.bytes)) throw new ProjectError(`the picture ${picture.name} is not a PNG`);
+    const { width, height } = pngSize(picture.bytes);
+    if (width < 1 || height < 1 || width > MAX_SIDE$1 || height > MAX_SIDE$1) {
+      throw new ProjectError(`the picture ${picture.name} is ${width}×${height}, and a picture is 1 to ${MAX_SIDE$1} px a side`);
+    }
+    const page = `pages/${index}.png`;
+    atlases.push({ name: page, width, height });
+    assets.push({ name: picture.name, atlasIndex: index, x: 0, y: 0, width, height, offsetX: 0, offsetY: 0, flags: 0 });
+    pages.push({ name: page, bytes: picture.bytes });
+  }
+  const indexBuffer = writeAssetIndex(atlases, assets);
+  const described = describedAssets(art.entries);
+  const metadata = writeAssetMetadata({ version: METADATA_VERSION, assets: described });
+  const entries = [
+    { name: INDEX_ENTRY, bytes: new Uint8Array(indexBuffer) },
+    { name: METADATA_ENTRY, bytes: encoder$1.encode(metadata) }
+  ];
+  if (art.idMap !== null) {
+    try {
+      checkNamesAgainstIndex(parseIdMap(JSON.parse(art.idMap)), parseAssetIndex(indexBuffer), new Set(described.keys()));
+    } catch (error) {
+      throw new ProjectError(`the id map: ${error.message}`);
+    }
+    entries.push({ name: ID_MAP_ENTRY, bytes: encoder$1.encode(art.idMap) });
+  }
+  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 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;
+  }
+  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 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);
+}
+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 DRAW_LAYERS = ["ground", "object", "foreground"];
+function bandOfAsset(facts) {
+  if (facts.name === null) return "ground";
+  if (facts.roof) return "roof";
+  if (facts.terrainCell || isGroundName(facts.name)) return "ground";
+  return "object";
+}
+function drawLayerOf(band, foreground) {
+  if (foreground) return "foreground";
+  return band === "ground" ? "ground" : "object";
+}
+function blank(width, height) {
+  return { width, height, data: new Uint8ClampedArray(width * height * 4) };
+}
+const SOLID = /^terrain\/ground\/([a-z0-9]+)$/;
+const WANG = /^terrain\/([a-z0-9]+)-([a-z0-9]+)\/wang-(\d{2})$/;
+function terrainTable(names) {
+  const terrains = /* @__PURE__ */ new Set();
+  const solid = /* @__PURE__ */ new Map();
+  const sets = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  for (const [id2, name] of names) {
+    const { tileset, inner } = splitTileset(name);
+    const whole = SOLID.exec(inner);
+    if (whole !== null) {
+      const terrain = scopedTerrain(tileset, whole[1]);
+      terrains.add(terrain);
+      solid.set(terrain, id2);
+      byId.set(id2, terrain);
+      continue;
+    }
+    const wang = WANG.exec(inner);
+    if (wang !== null) {
+      const lower = scopedTerrain(tileset, wang[1]);
+      const upper = scopedTerrain(tileset, wang[2]);
+      const mask = Number(wang[3]);
+      terrains.add(lower);
+      terrains.add(upper);
+      if (mask === 0) sets.set(`${lower}|${upper}`, { lower, upper, base: id2 });
+      byId.set(id2, mask === 15 ? upper : lower);
+    }
+  }
+  return { terrains, solid, sets, terrainOf: (id2) => byId.get(id2) ?? null };
+}
+const SHEET_SIDE = 4096;
+const SHEET_GAP = 2;
+class PackError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PackError";
+  }
+}
+const byName$1 = (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+const roundUp = (value, step) => Math.ceil(value / step) * step;
+function checked(items, side, gap) {
+  const seen = /* @__PURE__ */ new Set();
+  const largest = side - 2 * gap;
+  for (const item of items) {
+    if (seen.has(item.name)) throw new PackError(`two pictures are named ${item.name}`);
+    seen.add(item.name);
+    const whole = (value) => Number.isInteger(value) && value >= 1;
+    if (!whole(item.width) || !whole(item.height))
+      throw new PackError(`the picture ${item.name} is ${item.width}×${item.height}, and a picture is whole pixels`);
+    if (item.width > largest || item.height > largest) {
+      throw new PackError(`the picture ${item.name} is ${item.width}×${item.height}, and a sheet of ${side} holds pictures of at most ${largest} a side`);
+    }
+  }
+  return [...items];
+}
+function packSheets(items, side = SHEET_SIDE, gap = SHEET_GAP) {
+  const ordered = checked(items, side, gap).sort((left, right) => right.height - left.height || right.width - left.width || byName$1(left, right));
+  const sheets = [];
+  const placements = [];
+  const place = (sheet, page, shelf, item) => {
+    placements.push({ ...item, page, x: shelf.x, y: shelf.y });
+    shelf.x += item.width + gap;
+    sheet.right = Math.max(sheet.right, shelf.x);
+    sheet.bottom = Math.max(sheet.bottom, shelf.y + item.height + gap);
+  };
+  for (const item of ordered) {
+    let done = false;
+    for (const [page, sheet] of sheets.entries()) {
+      const shelf = sheet.shelves.find((open) => open.height >= item.height && open.x + item.width + gap <= side);
+      if (shelf !== void 0) {
+        place(sheet, page, shelf, item);
+        done = true;
+        break;
+      }
+      if (sheet.next + item.height + gap <= side) {
+        const opened = { y: sheet.next, height: item.height, x: gap };
+        sheet.shelves.push(opened);
+        sheet.next += item.height + gap;
+        place(sheet, page, opened, item);
+        done = true;
+        break;
+      }
+    }
+    if (!done) {
+      const sheet = { shelves: [], next: gap, right: gap, bottom: gap };
+      sheets.push(sheet);
+      const opened = { y: gap, height: item.height, x: gap };
+      sheet.shelves.push(opened);
+      sheet.next += item.height + gap;
+      place(sheet, sheets.length - 1, opened, item);
+    }
+  }
+  return {
+    pages: sheets.map((sheet) => ({ width: Math.min(side, roundUp(sheet.right, 4)), height: Math.min(side, roundUp(sheet.bottom, 4)) })),
+    placements: placements.sort(byName$1)
+  };
+}
+const ENGINES = ["default", "pixi", "phaser", "godot"];
+const EXPORT_FORMAT = 1;
+const DEFAULT_GODOT_ROOT = "res://pixelvibing/";
+const PHASER_ATLAS_KEY = "pixelvibing";
+const PLAYED_ANIMATION = "idle";
+const MAX_EXPORT_PIXELS = 8 * 4096 * 4096;
+const MIRRORED = "#flip";
+const encoder = new TextEncoder();
+const text = (path, value) => ({ path, bytes: encoder.encode(value) });
+const json = (path, value) => text(path, `${JSON.stringify(value, null, 2)}
+`);
+const byName = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const sheetName = (page) => `sheet-${page}.png`;
+function mirrored(raster) {
+  const out = blank(raster.width, raster.height);
+  for (let y = 0; y < raster.height; y += 1) {
+    for (let x = 0; x < raster.width; x += 1) {
+      const from = (y * raster.width + x) * 4;
+      const to = (y * raster.width + (raster.width - 1 - x)) * 4;
+      out.data.set(raster.data.subarray(from, from + 4), to);
+    }
+  }
+  return out;
+}
+function blit(into, raster, left, top) {
+  for (let y = 0; y < raster.height; y += 1) {
+    into.data.set(raster.data.subarray(y * raster.width * 4, (y + 1) * raster.width * 4), ((top + y) * into.width + left) * 4);
+  }
+}
+function animationsOf(metadata, rasters, omitted) {
+  const animations = /* @__PURE__ */ new Map();
+  for (const asset of [...metadata.keys()].sort(byName)) {
+    const entry = metadata.get(asset);
+    for (const [name, frames] of [...entry.animations.entries()].sort(([left], [right]) => byName(left, right))) {
+      const key = `${asset}:${name}`;
+      const missing = frames.find((frame) => !rasters.has(frame.asset));
+      if (missing !== void 0) {
+        omitted.push(`the animation ${key}: its frame ${missing.asset} has no picture`);
+        continue;
+      }
+      animations.set(
+        key,
+        frames.map((frame) => {
+          if (!frame.flip) return { frame: frame.asset, ms: frame.ms };
+          const flipped = `${frame.asset}${MIRRORED}`;
+          if (!rasters.has(flipped)) rasters.set(flipped, mirrored(rasters.get(frame.asset)));
+          return { frame: flipped, ms: frame.ms };
+        })
+      );
+    }
+  }
+  return animations;
+}
+function placedSprites(input, metadata, rasters, omitted) {
+  const { map, idMap } = input;
+  if (map === null) return [];
+  const pairs = [];
+  if (idMap !== null) {
+    for (const tile of map.tiles) {
+      for (const id2 of tile.layers) {
+        const name = idMap.nameForLooktype(id2);
+        if (name !== null) pairs.push([id2, name]);
+      }
+    }
+  }
+  const terrain = terrainTable(pairs);
+  const drawn = [];
+  let order = 0;
+  for (const tile of map.tiles) {
+    for (const id2 of tile.layers) {
+      order += 1;
+      const at = `(${tile.x}, ${tile.y}) on level ${tile.z}`;
+      const name = idMap?.nameForLooktype(id2) ?? null;
+      if (name === null) {
+        omitted.push(`the sprite ${id2} at ${at}: the id map names no asset for it`);
+        continue;
+      }
+      const raster = rasters.get(name);
+      if (raster === void 0) {
+        omitted.push(`the sprite ${name} at ${at}: there is no picture of it under out/`);
+        continue;
+      }
+      const meta = metadata.get(name);
+      const box = placeTileSprite(tile.x, tile.y, raster.width, raster.height, {
+        ...meta?.offset !== void 0 ? { offset: meta.offset } : {},
+        ...meta?.drawScale !== void 0 ? { drawScale: meta.drawScale } : {}
+      });
+      const band = bandOfAsset({ name, roof: meta?.roof === true, terrainCell: terrain.terrainOf(id2) !== null });
+      drawn.push({
+        frame: name,
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: box.height,
+        level: tile.z,
+        layer: drawLayerOf(band, meta?.foreground === true),
+        tile: [tile.x, tile.y],
+        animation: meta?.animations.has(PLAYED_ANIMATION) === true ? `${name}:${PLAYED_ANIMATION}` : null,
+        order
+      });
+    }
+  }
+  const layer = (sprite) => DRAW_LAYERS.indexOf(sprite.layer);
+  drawn.sort((a, b) => a.level - b.level || layer(a) - layer(b) || a.order - b.order);
+  return drawn.map(({ order: _, ...sprite }) => sprite);
+}
+function sheetsOf(rasters, codec2) {
+  const packed = packSheets([...rasters.entries()].map(([name, raster]) => ({ name, width: raster.width, height: raster.height })));
+  const pages = packed.pages.map((page) => blank(page.width, page.height));
+  for (const placed of packed.placements) blit(pages[placed.page], rasters.get(placed.name), placed.x, placed.y);
+  return { packed, place: new Map(packed.placements.map((placed) => [placed.name, placed])), images: pages.map((page) => codec2.encodePng(page)) };
+}
+function nineGridsOf(metadata, rasters) {
+  const grids = /* @__PURE__ */ new Map();
+  for (const [name, entry] of metadata) if (entry.nineGrid !== void 0 && rasters.has(name)) grids.set(name, entry.nineGrid);
+  return grids;
+}
+function defaultMap(made) {
+  return {
+    format: EXPORT_FORMAT,
+    width: made.map?.width ?? 0,
+    height: made.map?.height ?? 0,
+    tileSize: TILE_SIZE,
+    sprites: made.sprites
+  };
+}
+function defaultFiles(made) {
+  const { packed } = made.sheets;
+  const frames = Object.fromEntries(
+    packed.placements.map((placed) => {
+      const nineGrid = made.nineGrids.get(placed.name);
+      return [
+        placed.name,
+        { page: placed.page, x: placed.x, y: placed.y, width: placed.width, height: placed.height, ...nineGrid === void 0 ? {} : { nineGrid } }
+      ];
+    })
+  );
+  return [
+    json("sheets.json", {
+      format: EXPORT_FORMAT,
+      pages: packed.pages.map((page, index) => ({ image: sheetName(index), width: page.width, height: page.height })),
+      frames,
+      animations: Object.fromEntries(made.animations)
+    }),
+    json("map.json", defaultMap(made))
+  ];
+}
+const textureFrame = (placed) => ({
+  frame: { x: placed.x, y: placed.y, w: placed.width, h: placed.height },
+  rotated: false,
+  trimmed: false,
+  spriteSourceSize: { x: 0, y: 0, w: placed.width, h: placed.height },
+  sourceSize: { w: placed.width, h: placed.height }
+});
+function pixiFiles(made) {
+  const { packed, place } = made.sheets;
+  const sheets = packed.pages.map((page, index) => {
+    const frames = Object.fromEntries(
+      packed.placements.filter((placed) => placed.page === index).map((placed) => {
+        const grid = made.nineGrids.get(placed.name);
+        return [
+          placed.name,
+          { ...textureFrame(placed), ...grid === void 0 ? {} : { borders: { left: grid.left, top: grid.top, right: grid.right, bottom: grid.bottom } } }
+        ];
+      })
+    );
+    const animations = Object.fromEntries(
+      [...made.animations].filter(([, frames2]) => frames2.every((frame) => place.get(frame.frame)?.page === index)).map(([key, frames2]) => [key, frames2.map((frame) => frame.frame)])
+    );
+    const others = packed.pages.map((_, other) => `sheet-${other}.json`).filter((_, other) => other !== index);
+    return json(`sheet-${index}.json`, {
+      frames,
+      animations,
+      meta: {
+        app: "https://pixelvibing.com",
+        version: String(EXPORT_FORMAT),
+        image: sheetName(index),
+        format: "RGBA8888",
+        size: { w: page.width, h: page.height },
+        scale: "1",
+        ...others.length > 0 ? { related_multi_packs: others } : {}
+      }
+    });
+  });
+  return [...sheets, json("animations.json", { format: EXPORT_FORMAT, animations: Object.fromEntries(made.animations) }), json("map.json", defaultMap(made))];
+}
+function phaserFiles(made) {
+  const { packed } = made.sheets;
+  const atlas = {
+    textures: packed.pages.map((page, index) => ({
+      image: sheetName(index),
+      format: "RGBA8888",
+      size: { w: page.width, h: page.height },
+      scale: 1,
+      frames: packed.placements.filter((placed) => placed.page === index).map((placed) => ({ filename: placed.name, ...textureFrame(placed) }))
+    })),
+    meta: { app: "https://pixelvibing.com", version: String(EXPORT_FORMAT) }
+  };
+  const anims = {
+    anims: [...made.animations].map(([key, frames]) => ({
+      key,
+      type: "frame",
+      frameRate: 1e3,
+      repeat: -1,
+      frames: frames.map((frame) => ({ key: PHASER_ATLAS_KEY, frame: frame.frame, duration: Math.max(0, frame.ms - 1) }))
+    }))
+  };
+  const nineSlices = Object.fromEntries(
+    [...made.nineGrids].map(([name, grid]) => [name, { leftWidth: grid.left, rightWidth: grid.right, topHeight: grid.top, bottomHeight: grid.bottom }])
+  );
+  return [
+    json("atlas.json", atlas),
+    json("animations.json", anims),
+    json("map.json", defaultMap(made)),
+    ...made.nineGrids.size === 0 ? [] : [json("nine-slices.json", { format: EXPORT_FORMAT, atlas: PHASER_ATLAS_KEY, frames: nineSlices })]
+  ];
+}
+const godotString = (value) => JSON.stringify(value);
+const number = (value) => Number.isInteger(value) ? `${value}` : `${Number(value.toFixed(6))}`;
+const rect = (placed) => `Rect2(${placed.x}, ${placed.y}, ${placed.width}, ${placed.height})`;
+const nodeName = (name) => (name.split("/").at(-1) ?? name).replace(/[^A-Za-z0-9_]+/g, "_") || "piece";
+function godotFiles(made, root) {
+  const { packed, place } = made.sheets;
+  const sheetPath = (page) => `${root}${sheetName(page)}`;
+  const files = [];
+  for (const placed of packed.placements) {
+    files.push(
+      text(
+        `sprites/${placed.name}.tres`,
+        [
+          '[gd_resource type="AtlasTexture" load_steps=2 format=3]',
+          "",
+          `[ext_resource type="Texture2D" path=${godotString(sheetPath(placed.page))} id="sheet"]`,
+          "",
+          "[resource]",
+          'atlas = ExtResource("sheet")',
+          `region = ${rect(placed)}`,
+          ""
+        ].join("\n")
+      )
+    );
+  }
+  for (const [name, grid] of made.nineGrids) {
+    const placed = place.get(name);
+    files.push(
+      text(
+        `nine-patch/${name}.tscn`,
+        [
+          "[gd_scene load_steps=2 format=3]",
+          "",
+          `[ext_resource type="Texture2D" path=${godotString(`${root}sprites/${name}.tres`)} id="texture"]`,
+          "",
+          `[node name=${godotString(nodeName(name))} type="NinePatchRect"]`,
+          `offset_right = ${placed.width}.0`,
+          `offset_bottom = ${placed.height}.0`,
+          'texture = ExtResource("texture")',
+          `patch_margin_left = ${grid.left}`,
+          `patch_margin_top = ${grid.top}`,
+          `patch_margin_right = ${grid.right}`,
+          `patch_margin_bottom = ${grid.bottom}`,
+          ""
+        ].join("\n")
+      )
+    );
+  }
+  const atlasTextures = (names) => {
+    const ids = /* @__PURE__ */ new Map();
+    const blocks = [];
+    for (const name of names) {
+      if (ids.has(name)) continue;
+      const placed = place.get(name);
+      const id2 = `AtlasTexture_${ids.size}`;
+      ids.set(name, id2);
+      blocks.push(`[sub_resource type="AtlasTexture" id="${id2}"]
+atlas = ExtResource("sheet_${placed.page}")
+region = ${rect(placed)}
+`);
+    }
+    return { ids, blocks };
+  };
+  const sheetResources = packed.pages.map((_, page) => `[ext_resource type="Texture2D" path=${godotString(sheetPath(page))} id="sheet_${page}"]`);
+  const framesUsed = [...made.animations.values()].flatMap((frames) => frames.map((frame) => frame.frame));
+  const frameTextures = atlasTextures(framesUsed);
+  const animations = [...made.animations].map(
+    ([key, frames]) => [
+      "{",
+      `"frames": [${frames.map((frame) => `{
+"duration": ${number(frame.ms)},
+"texture": SubResource("${frameTextures.ids.get(frame.frame)}")
+}`).join(", ")}],`,
+      '"loop": true,',
+      `"name": &${godotString(key)},`,
+      '"speed": 1000.0',
+      "}"
+    ].join("\n")
+  );
+  files.push(
+    text(
+      "animations.tres",
+      [
+        `[gd_resource type="SpriteFrames" load_steps=${packed.pages.length + frameTextures.blocks.length + 1} format=3]`,
+        "",
+        ...sheetResources,
+        "",
+        ...frameTextures.blocks,
+        "[resource]",
+        `animations = [${animations.join(", ")}]`,
+        ""
+      ].join("\n")
+    )
+  );
+  const still = made.sprites.filter((sprite) => sprite.animation === null).map((sprite) => sprite.frame);
+  const spriteTextures = atlasTextures(still);
+  const levels = [...new Set(made.sprites.map((sprite) => sprite.level))];
+  const animated = made.sprites.some((sprite) => sprite.animation !== null);
+  const nodes = ['[node name="Map" type="Node2D"]', ""];
+  for (const level of levels) {
+    nodes.push(`[node name="Level${level}" type="Node2D" parent="."]`, "");
+    for (const layer of DRAW_LAYERS) nodes.push(`[node name="${layer}" type="Node2D" parent="Level${level}"]`, "");
+  }
+  for (const [index, sprite] of made.sprites.entries()) {
+    const size = place.get(sprite.frame);
+    const parent = `Level${sprite.level}/${sprite.layer}`;
+    const lines = [
+      sprite.animation === null ? `[node name="s${index}" type="Sprite2D" parent="${parent}"]` : `[node name="s${index}" type="AnimatedSprite2D" parent="${parent}"]`,
+      `position = Vector2(${number(sprite.x)}, ${number(sprite.y)})`
+    ];
+    if (sprite.width !== size.width || sprite.height !== size.height)
+      lines.push(`scale = Vector2(${number(sprite.width / size.width)}, ${number(sprite.height / size.height)})`);
+    if (sprite.animation === null) lines.push(`texture = SubResource("${spriteTextures.ids.get(sprite.frame)}")`, "centered = false");
+    else
+      lines.push(
+        'sprite_frames = ExtResource("frames")',
+        `animation = &${godotString(sprite.animation)}`,
+        `autoplay = ${godotString(sprite.animation)}`,
+        "centered = false"
+      );
+    nodes.push(...lines, "");
+  }
+  const external = [...sheetResources, ...animated ? [`[ext_resource type="SpriteFrames" path=${godotString(`${root}animations.tres`)} id="frames"]`] : []];
+  files.push(
+    text(
+      "map.tscn",
+      [`[gd_scene load_steps=${external.length + spriteTextures.blocks.length + 1} format=3]`, "", ...external, "", ...spriteTextures.blocks, ...nodes].join(
+        "\n"
+      )
+    )
+  );
+  return files;
+}
+function checkExportable(pictures) {
+  let pixels = 0;
+  for (const picture of pictures) {
+    const problem = nameProblem(picture.name);
+    if (problem !== null || picture.name.includes("\\"))
+      throw new ProjectError(`the picture ${JSON.stringify(picture.name)} is not named as an asset is: ${problem ?? "a name has no backslash"}`);
+    pixels += picture.width * picture.height;
+  }
+  if (pixels > MAX_EXPORT_PIXELS) throw new ProjectError(`the pictures add up to ${pixels} pixels, and an export holds at most ${MAX_EXPORT_PIXELS}`);
+}
+function exportProject(input, engine, codec2, options = {}) {
+  checkExportable(input.pictures.map((picture) => ({ name: picture.name, width: picture.raster.width, height: picture.raster.height })));
+  const metadata = describedAssets(input.entries);
+  const rasters = new Map(input.pictures.map((picture) => [picture.name, picture.raster]));
+  const omitted = [];
+  const animations = animationsOf(metadata, rasters, omitted);
+  const sprites = placedSprites(input, metadata, rasters, omitted);
+  const sheets = sheetsOf(rasters, codec2);
+  const made = { sheets, animations, sprites, map: input.map, nineGrids: nineGridsOf(metadata, rasters) };
+  const godotRoot = options.godotRoot ?? DEFAULT_GODOT_ROOT;
+  const described = engine === "default" ? defaultFiles(made) : engine === "pixi" ? pixiFiles(made) : engine === "phaser" ? phaserFiles(made) : godotFiles(made, godotRoot.endsWith("/") ? godotRoot : `${godotRoot}/`);
+  return {
+    files: [...sheets.images.map((bytes, page) => ({ path: sheetName(page), bytes })), ...described],
+    pictures: input.pictures.length,
+    sheets: sheets.images.length,
+    animations: animations.size,
+    sprites: sprites.length,
+    omitted
+  };
+}
+const MAX_SIDE = 4096;
+class PngError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PngError";
+  }
+}
+const SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+const CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+function readHeader(data) {
+  if (data.length !== 13) throw new PngError("the PNG's IHDR chunk is not 13 bytes");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const width = view.getUint32(0);
+  const height = view.getUint32(4);
+  if (width < 1 || height < 1 || width > MAX_SIDE || height > MAX_SIDE) {
+    throw new PngError(`the PNG is ${width} by ${height}; each side must be from 1 to ${MAX_SIDE} pixels`);
+  }
+  const [depth, colorType, , , interlace] = data.subarray(8, 13);
+  if (interlace !== 0) throw new PngError("an interlaced PNG is not read");
+  if (CHANNELS[colorType] === void 0) throw new PngError(`the PNG's colour type ${colorType} is not one PNG defines`);
+  const readable = depth === 8 || depth === 16 && colorType !== 3;
+  if (!readable) throw new PngError(`bit depth ${depth} is not read for colour type ${colorType}`);
+  return { width, height, depth, colorType };
+}
+const paeth = (a, b, c) => {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+};
+function unfilter(inflated, 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)];
+    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 at = y * stride;
+    for (let x = 0; x < stride; x += 1) {
+      const a = x >= bpp ? out[at + x - bpp] : 0;
+      const b = y > 0 ? out[at - stride + x] : 0;
+      const c = x >= bpp && y > 0 ? out[at - stride + x - bpp] : 0;
+      const predictor = filter === 0 ? 0 : filter === 1 ? a : filter === 2 ? b : filter === 3 ? a + b >> 1 : paeth(a, b, c);
+      out[at + x] = row[x] + predictor & 255;
+    }
+  }
+  return out;
+}
+function concat(parts) {
+  const out = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+function decodeWith(zlib, bytes) {
+  if (bytes.length < SIGNATURE.length || !SIGNATURE.every((byte, index) => bytes[index] === byte)) throw new PngError("the file is not a PNG");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let header = null;
+  let palette = null;
+  let transparency = null;
+  const data = [];
+  for (let at = SIGNATURE.length; at + 8 <= bytes.length; ) {
+    const length = view.getUint32(at);
+    const type = String.fromCharCode(...bytes.subarray(at + 4, at + 8));
+    const start = at + 8;
+    if (length > bytes.length - start - 4) throw new PngError("the PNG ends inside a chunk");
+    const body = bytes.subarray(start, start + length);
+    if (type === "IHDR") header = readHeader(body);
+    else if (header === null) throw new PngError("a PNG has IHDR first");
+    else if (type === "PLTE") palette = body;
+    else if (type === "tRNS") transparency = body;
+    else if (type === "IDAT") data.push(body);
+    else if (type === "IEND") break;
+    at = start + length + 4;
+  }
+  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;
+  try {
+    inflated = 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);
+}
+function toRgba(samples, header, palette, transparency) {
+  const { width, height, depth, colorType } = header;
+  const wide = depth === 16;
+  const channels = CHANNELS[colorType];
+  const out = new Uint8ClampedArray(width * height * 4);
+  const high = (index) => samples[wide ? index * 2 : index];
+  const whole = (index) => wide ? samples[index * 2] << 8 | samples[index * 2 + 1] : samples[index];
+  const keyed = (at) => transparency === null ? null : transparency[at] << 8 | transparency[at + 1];
+  const grey = colorType === 0 ? keyed(0) : null;
+  const rgb = colorType === 2 && transparency !== null && transparency.length >= 6 ? [keyed(0), keyed(2), keyed(4)] : null;
+  for (let pixel = 0; pixel < width * height; pixel += 1) {
+    const first = pixel * channels;
+    const at = pixel * 4;
+    if (colorType === 6) {
+      out.set([high(first), high(first + 1), high(first + 2), high(first + 3)], at);
+    } else if (colorType === 2) {
+      const clear = rgb !== null && whole(first) === rgb[0] && whole(first + 1) === rgb[1] && whole(first + 2) === rgb[2];
+      out.set([high(first), high(first + 1), high(first + 2), clear ? 0 : 255], at);
+    } else if (colorType === 4) {
+      const value = high(first);
+      out.set([value, value, value, high(first + 1)], at);
+    } else if (colorType === 0) {
+      const value = high(first);
+      out.set([value, value, value, grey !== null && whole(first) === grey ? 0 : 255], at);
+    } else {
+      const index = samples[first];
+      if (palette === null || index * 3 + 2 >= palette.length) throw new PngError("the PNG names a palette entry it does not have");
+      out.set([palette[index * 3], palette[index * 3 + 1], palette[index * 3 + 2], transparency?.[index] ?? 255], at);
+    }
+  }
+  return { width, height, data: out };
+}
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (const byte of bytes) c = CRC_TABLE[(c ^ byte) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  out.set(new TextEncoder().encode(type), 4);
+  out.set(data, 8);
+  view.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function encodeWith(zlib, raster) {
+  const stride = raster.width * 4;
+  const raw = new Uint8Array(raster.height * (stride + 1));
+  for (let y = 0; y < raster.height; y += 1) raw.set(raster.data.subarray(y * stride, (y + 1) * stride), y * (stride + 1) + 1);
+  const header = new Uint8Array(13);
+  const view = new DataView(header.buffer);
+  view.setUint32(0, raster.width);
+  view.setUint32(4, raster.height);
+  header.set([8, 6, 0, 0, 0], 8);
+  return concat([Uint8Array.from(SIGNATURE), chunk("IHDR", header), chunk("IDAT", zlib.deflate(raw)), chunk("IEND", new Uint8Array(0))]);
+}
+function pngCodec(zlib) {
+  return { decodePng: (bytes) => decodeWith(zlib, bytes), encodePng: (raster) => encodeWith(zlib, raster) };
+}
+const EXPORT_MARK = ".pixelvibing-export";
+const codec = pngCodec({ inflate: (data, maxOutputLength) => inflateSync(data, { maxOutputLength }), deflate: (data) => deflateSync(data) });
+async function isDirectory$1(path) {
+  try {
+    return (await lstat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function replaceable(path) {
+  try {
+    const info = await lstat(path);
+    if (!info.isDirectory()) return false;
+  } catch {
+    return true;
+  }
+  const names = await readdir(path);
+  return names.length === 0 || names.includes(EXPORT_MARK);
+}
+async function writeWhole(out, files, engine) {
+  const suffix = randomBytes(6).toString("hex");
+  const staging = `${out}.writing-${suffix}`;
+  const old = `${out}.replaced-${suffix}`;
+  await mkdir(dirname(out), { recursive: true });
+  try {
+    for (const file of files) {
+      const parts = file.path.split("/");
+      if (parts.some((part) => part === "" || part === "." || part === ".." || /[\\:]/.test(part))) {
+        throw new CliError(`the export named a file ${JSON.stringify(file.path)} it cannot write`);
+      }
+      const path = join(staging, ...parts);
+      if (!resolve(path).startsWith(`${resolve(staging)}${sep}`)) throw new CliError(`the export named a file ${JSON.stringify(file.path)} outside it`);
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, file.bytes);
+    }
+    await writeFile(join(staging, EXPORT_MARK), `${JSON.stringify({ engine })}
+`);
+  } catch (error) {
+    await rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+    throw error;
+  }
+  const had = await isDirectory$1(out);
+  if (had) await rename(out, old);
+  try {
+    await rename(staging, out);
+  } catch (error) {
+    if (had) await rename(old, out).catch(() => {
+    });
+    await rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+    throw error;
+  }
+  if (had) await rm(old, { recursive: true, force: true });
+}
+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://…>]",
+  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` }
+  },
+  positionals: [1, 1],
+  run: async (context, args) => {
+    const engine = args.positionals[0];
+    if (!ENGINES.includes(engine)) throw new CliError(`export makes ${ENGINES.join(", ")}, not ${engine}`);
+    const godotRoot = stringOf(args, "godot-root");
+    if (godotRoot !== void 0 && (!/^res:\/\/[A-Za-z0-9._\-/]*$/.test(godotRoot) || godotRoot.split("/").includes(".."))) {
+      throw new CliError("--godot-root is a res:// path of letters, digits and . _ - /, with no ..");
+    }
+    const local = await projectHere(context.io.cwd);
+    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`);
+    let result;
+    try {
+      const boundary = new Boundary([art]);
+      const read = await readProjectArt(boundary, art);
+      const mapText = await readProjectMap(boundary, art);
+      checkExportable(
+        read.pictures.map((picture) => {
+          if (!isPng(picture.bytes)) throw new CliError(`the picture ${picture.name} cannot be read: it is not a PNG`);
+          return { name: picture.name, ...pngSize(picture.bytes) };
+        })
+      );
+      const pictures = read.pictures.map((picture) => {
+        try {
+          return { name: picture.name, raster: codec.decodePng(picture.bytes) };
+        } catch (error) {
+          throw new CliError(`the picture ${picture.name} cannot be read: ${error.message}`);
+        }
+      });
+      result = exportProject(
+        {
+          pictures,
+          entries: read.entries,
+          map: mapText === null ? null : parseMapText(mapText, "pixelvibing/map.json").document,
+          idMap: read.idMap === null ? null : parseIdMap(JSON.parse(read.idMap))
+        },
+        engine,
+        codec,
+        godotRoot === void 0 ? {} : { godotRoot }
+      );
+    } catch (error) {
+      const refusals = [ProjectError, PackError, PngError, MapTextError, IdMapError, SyntaxError, CliError];
+      if (refusals.some((kind) => error instanceof kind)) throw new CliError(`nothing was exported: ${error.message}`);
+      throw error;
+    }
+    await writeWhole(out, result.files, engine);
+    const lines = [
+      `Exported for ${engine} into ${out}: ${result.pictures} pictures on ${result.sheets} sheet${result.sheets === 1 ? "" : "s"}, ${result.animations} animation${result.animations === 1 ? "" : "s"}, ${result.sprites} placed sprite${result.sprites === 1 ? "" : "s"}.`,
+      ...result.omitted.length > 0 ? [`Left out (${result.omitted.length}):`, ...result.omitted.map((line) => `  ${line}`)] : []
+    ];
+    answer(
+      context,
+      {
+        engine,
+        out,
+        pictures: result.pictures,
+        sheets: result.sheets,
+        animations: result.animations,
+        sprites: result.sprites,
+        omitted: result.omitted,
+        files: result.files.map((file) => file.path)
+      },
+      lines.join("\n")
+    );
+  }
+};
+function jobDelay(elapsedMs) {
+  if (elapsedMs < 2e4) return 2e3;
+  if (elapsedMs < 6e4) return 5e3;
+  return 1e4;
+}
+const jobEnded = (job) => job.state === "done" || job.state === "failed";
+function jobWords(job) {
+  switch (job.state) {
+    case "queued":
+      return job.attempts > 0 ? "waiting to be tried again" : "waiting in line";
+    case "running":
+      return "being drawn";
+    case "done":
+      return "done";
+    case "failed":
+      return job.reason === null ? "failed" : `failed: ${job.reason}`;
+  }
+}
+function costOf(prices, request) {
+  const quality = request.body.quality;
+  return costIn(prices, request.kind, typeof quality === "string" ? quality : void 0);
+}
+async function startGeneration(api, project, request) {
+  const ids = {};
+  for (const [field, images] of Object.entries(request.images ?? {})) {
+    if (images instanceof Uint8Array) ids[field] = await api.uploadImage(images);
+    else {
+      const list2 = [];
+      for (const image of images) list2.push(await api.uploadImage(image));
+      ids[field] = list2;
+    }
+  }
+  return api.generate(request.kind, { ...request.body, ...ids, project });
+}
+const LARGEST_FOOTPRINT = {
+  cols: Math.min(Math.floor(WINDOW_PX.width / SCALES.at(-1)), Math.floor(MAX_ASSEMBLED_PX / TILE_SIZE)),
+  rows: Math.min(Math.floor(WINDOW_PX.height / SCALES.at(-1)), Math.floor(MAX_ASSEMBLED_PX / TILE_SIZE))
+};
+function footprintProblem(footprint) {
+  const whole = (value) => Number.isInteger(value) && value >= 1;
+  if (!whole(footprint.cols) || !whole(footprint.rows)) return "a footprint is a whole number of tiles wide and tall, each at least one";
+  if (footprint.cols > LARGEST_FOOTPRINT.cols || footprint.rows > LARGEST_FOOTPRINT.rows || drawCanvas(footprint) === null) {
+    return `a ${footprint.cols}×${footprint.rows} tile footprint is larger than an object is made; at most ${LARGEST_FOOTPRINT.cols}×${LARGEST_FOOTPRINT.rows} tiles`;
+  }
+  return null;
+}
+function drawCanvas(footprint) {
+  const across = Math.floor(WINDOW_PX.width / (footprint.cols * TILE_SIZE));
+  const down = Math.floor(WINDOW_PX.height / (footprint.rows * TILE_SIZE));
+  const multiple = Math.min(across, down);
+  const pxPerTile = multiple >= 1 ? multiple * TILE_SIZE : SCALES.find((scale) => footprint.cols * scale <= WINDOW_PX.width && footprint.rows * scale <= WINDOW_PX.height);
+  if (pxPerTile === void 0) return null;
+  return { width: footprint.cols * pxPerTile, height: footprint.rows * pxPerTile, pxPerTile };
+}
+const CELLS_PER_TILE = 64;
+const MAX_CELL = 16;
+const MIN_CELL = 8;
+const ROUTE_MAX_EDGE = 3840;
+const ROUTE_MAX_PIXELS = 8294400;
+const DEFAULT_QUALITY = "medium";
+const ROUTE_MIN_PIXELS = 655360;
+const ROUTE_STEP = 16;
+function gridForCells(cols, rows, cellsPerTile = CELLS_PER_TILE) {
+  if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0) return null;
+  const drawn = (cell) => cols * cell <= ROUTE_MAX_EDGE && rows * cell <= ROUTE_MAX_EDGE && cols * cell * rows * cell <= ROUTE_MAX_PIXELS && cols * cell % ROUTE_STEP === 0 && rows * cell % ROUTE_STEP === 0;
+  const unscaled = (cell) => cols * cell * rows * cell >= ROUTE_MIN_PIXELS;
+  const canvas = (cell) => ({ width: cols * cell, height: rows * cell, cell, pxPerTile: cellsPerTile * cell });
+  if (drawn(MAX_CELL) && unscaled(MAX_CELL)) return canvas(MAX_CELL);
+  if (drawn(MAX_CELL)) {
+    for (let cell = MAX_CELL + 1; cell * Math.max(cols, rows) <= ROUTE_MAX_EDGE; cell += 1) if (drawn(cell) && unscaled(cell)) return canvas(cell);
+    return null;
+  }
+  for (let cell = MAX_CELL - 1; cell >= MIN_CELL; cell -= 1) if (drawn(cell) && unscaled(cell)) return canvas(cell);
+  return null;
+}
+function gridCanvas(footprint) {
+  return gridForCells(footprint.cols * CELLS_PER_TILE, footprint.rows * CELLS_PER_TILE);
+}
+function gridProblem(footprint) {
+  if (gridCanvas(footprint) !== null) return null;
+  const side = Math.floor(ROUTE_MAX_EDGE / (CELLS_PER_TILE * MIN_CELL));
+  const area = Math.floor(ROUTE_MAX_PIXELS / (CELLS_PER_TILE * MIN_CELL) ** 2);
+  return `a ${footprint.cols}×${footprint.rows} tile object is too large to draw on the grid: at most ${side} tiles on a side and ${area} tiles in all`;
+}
+function designCanvas(tiles) {
+  if (!Number.isInteger(tiles.cols) || !Number.isInteger(tiles.rows) || tiles.cols < 1 || tiles.rows < 1) return null;
+  const scale = scaleFor(tiles.cols, tiles.rows);
+  if (scale === null) return null;
+  return { cols: tiles.cols, rows: tiles.rows, scale, width: tiles.cols * scale, height: tiles.rows * scale };
+}
+const EDIT_QUALITIES = ["low", "medium", "high", "xhigh", "max"];
+function isEditQuality(value) {
+  return typeof value === "string" && EDIT_QUALITIES.includes(value);
+}
+const GENERATED = {
+  object: { references: 8, words: "an object" },
+  creature: { references: 3, words: "a creature" },
+  "level-design": { references: 3, words: "a level design" },
+  hud: { references: 0, words: "a HUD set" },
+  icons: { references: 0, words: "an icon set" },
+  "hud-mockup": { references: 3, words: "a HUD mockup" }
+};
+function listOf(given, what) {
+  const items = given.split(",").map((item) => item.trim());
+  if (items.some((item) => item === "")) throw new CliError(`${what} is a comma-separated list with no empty entry`);
+  return items;
+}
+function interfaceFields(kind, args) {
+  if (kind === "hud") {
+    if (stringOf(args, "names") !== void 0 || stringOf(args, "purpose") !== void 0) throw new CliError("--names and --purpose are an icon set's");
+    if (stringOf(args, "size") !== void 0) throw new CliError("--size is an object's or an icon set's");
+    const pieces = listOf(stringOf(args, "pieces") ?? HUD_PIECE_NAMES.join(","), "--pieces");
+    const unknown = pieces.find((piece) => !HUD_PIECE_NAMES.includes(piece));
+    if (unknown !== void 0) throw new CliError(`${unknown} is not a HUD piece: ${HUD_PIECE_NAMES.join(", ")}`);
+    if (new Set(pieces).size !== pieces.length) throw new CliError("--pieces names a piece twice");
+    return { fields: { pieces }, words: `a HUD set of ${pieces.join(", ")}` };
+  }
+  if (stringOf(args, "pieces") !== void 0) throw new CliError("--pieces is a HUD set's");
+  const given = stringOf(args, "names");
+  if (given === void 0) throw new CliError('name the icons with --names, such as --names "red potion,key,coin"');
+  const names = listOf(given, "--names");
+  if (names.length > MAX_ICONS) throw new CliError(`an icon set holds at most ${MAX_ICONS} icons, not ${names.length}`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (seen.has(name.toLowerCase())) throw new CliError(`--names names ${name} twice`);
+    seen.add(name.toLowerCase());
+  }
+  const purpose = stringOf(args, "purpose") ?? "item";
+  if (purpose !== "skill" && purpose !== "item") throw new CliError(`--purpose is skill or item, not ${purpose}`);
+  const size = Number(stringOf(args, "size") ?? DEFAULT_ICON_SIZE);
+  if (!ICON_SIZES.includes(size)) throw new CliError(`an icon's --size is ${ICON_SIZES.join(", ")} px`);
+  return { fields: { names, purpose, size }, words: `${names.length} ${purpose} icon${names.length === 1 ? "" : "s"} at ${size} px: ${names.join(", ")}` };
+}
+const MAX_DESIGN_TILES = 64;
+const MAX_REFERENCE_BYTES = 16 * 1024 * 1024;
+function sizeOf(given, what) {
+  const match = /^(\d{1,3})[x×](\d{1,3})$/i.exec(given.trim());
+  if (match === null) throw new CliError(`${what} is <cols>x<rows>, such as 2x1, not ${given}`);
+  return { cols: Number(match[1]), rows: Number(match[2]) };
+}
+async function referenceOf(context, path) {
+  const file = resolve(context.io.cwd, path);
+  let size;
+  try {
+    size = (await stat(file)).size;
+  } catch {
+    throw new CliError(`the reference ${path} cannot be read`);
+  }
+  if (size > MAX_REFERENCE_BYTES) throw new CliError(`the reference ${path} is ${size} bytes, and one is at most ${MAX_REFERENCE_BYTES}`);
+  const bytes = new Uint8Array(await readFile(file));
+  if (!isPng(bytes)) throw new CliError(`the reference ${path} is not a PNG`);
+  return bytes;
+}
+async function requestOf(context, kind, args) {
+  const known = GENERATED[kind];
+  if (known === void 0) throw new CliError(`generate makes ${Object.keys(GENERATED).join(", ")}, not ${kind}`);
+  const instruction = stringOf(args, "instruction")?.trim() ?? "";
+  const set = kind === "hud" || kind === "icons";
+  if (instruction === "" && !set) throw new CliError("say what to make with --instruction");
+  const quality = stringOf(args, "quality") ?? DEFAULT_QUALITY;
+  if (!isEditQuality(quality)) throw new CliError(`--quality is one of ${EDIT_QUALITIES.join(", ")}`);
+  const paths = stringsOf(args, "reference");
+  if (paths.length > known.references)
+    throw new CliError(known.references === 0 ? `${known.words} takes no reference` : `${known.words} takes at most ${known.references} references`);
+  if (set) {
+    const { fields, words: words2 } = interfaceFields(kind, args);
+    if (stringOf(args, "tiles") !== void 0) throw new CliError("--tiles is a level design's");
+    const body2 = { ...fields, ...instruction === "" ? {} : { instruction }, quality };
+    return { kind, body: body2, words: instruction === "" ? words2 : `${words2}; ${instruction}` };
+  }
+  for (const flag of ["pieces", "names", "purpose"])
+    if (stringOf(args, flag) !== void 0) throw new CliError(`--${flag} is ${flag === "pieces" ? "a HUD set's" : "an icon set's"}`);
+  const references = [];
+  for (const path of paths) references.push(await referenceOf(context, path));
+  const body = { instruction, quality };
+  let words = `${known.words}: ${instruction}`;
+  if (kind === "object") {
+    const footprint = sizeOf(stringOf(args, "size") ?? "1x1", "--size");
+    const problem = footprintProblem(footprint) ?? gridProblem(footprint);
+    if (problem !== null) throw new CliError(problem);
+    body.footprint = footprint;
+    words = `an object ${footprint.cols}×${footprint.rows} tiles: ${instruction}`;
+  } else if (stringOf(args, "size") !== void 0) throw new CliError("--size is an object's");
+  if (kind === "level-design") {
+    const tiles = sizeOf(stringOf(args, "tiles") ?? "6x4", "--tiles");
+    if (tiles.cols > MAX_DESIGN_TILES || tiles.rows > MAX_DESIGN_TILES || designCanvas(tiles) === null) {
+      throw new CliError(`a ${tiles.cols}×${tiles.rows} tile level design is not one that is drawn: 1 to ${MAX_DESIGN_TILES} tiles each way`);
+    }
+    body.tiles = tiles;
+    words = `a level design ${tiles.cols}×${tiles.rows} tiles across: ${instruction}`;
+  } else if (stringOf(args, "tiles") !== void 0) throw new CliError("--tiles is a level design's");
+  return { kind, body, ...references.length > 0 ? { images: { references } } : {}, words };
+}
+async function confirmed(context, platform, what, cost, yes) {
+  const credits = (await platform.web.billing()).credits;
+  const priced = cost === null ? "at a cost the platform will say" : `for ${cost} credit${cost === 1 ? "" : "s"}`;
+  context.io.warn(`Making ${what}, ${priced}; the account has ${credits}.
+`);
+  if (yes) return;
+  if (!context.io.interactive) throw new CliError("nothing was started: pass --yes to start it without a question");
+  const said = (await context.io.ask("Start it? [y/N] ")).trim().toLowerCase();
+  if (said !== "y" && said !== "yes") throw new CliError("nothing was started");
+}
+async function followed(context, platform, jobId) {
+  const since = context.services.now();
+  let said = "";
+  for (; ; ) {
+    const job = await platform.web.job(jobId);
+    const words = jobWords(job);
+    if (words !== said) context.io.warn(`  ${words}
+`);
+    said = words;
+    if (jobEnded(job)) return job;
+    await context.services.sleep(jobDelay(context.services.now() - since));
+  }
+}
+const generate = {
+  name: "generate",
+  summary: "Generate an object, a creature, a level design, a HUD set, icons or a HUD mockup on the platform, then pull it",
+  usage: "<object|creature|level-design|hud|icons|hud-mockup> [--instruction <text>] [--size <c>x<r>|<px>] [--tiles <c>x<r>] [--pieces <list>] [--names <list>] [--purpose skill|item] [--reference <png>]… [--quality <q>] [--yes]",
+  options: {
+    instruction: { type: "string", value: "<text>", description: "what to make, in your own words; a HUD set's or icon set's theme" },
+    size: {
+      type: "string",
+      value: "<cols>x<rows>|<px>",
+      description: "an object's footprint in tiles, 1x1 unless given; an icon's size, 16, 32 or 64 px, 32 unless given"
+    },
+    pieces: { type: "string", value: "<list>", description: `a HUD set's pieces, comma-separated: ${HUD_PIECE_NAMES.join(", ")}; all unless given` },
+    names: { type: "string", value: "<list>", description: `an icon set's icons, comma-separated, at most ${MAX_ICONS}` },
+    purpose: { type: "string", value: "skill|item", description: "whether an icon set is skills on badges or items alone; item unless given" },
+    tiles: { type: "string", value: "<cols>x<rows>", description: "how many tiles a level design is across, 6x4 unless given" },
+    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" }
+  },
+  positionals: [1, 1],
+  run: async (context, args) => {
+    const local = await projectHere(context.io.cwd);
+    const project = linkedOf(local);
+    const kind = args.positionals[0];
+    const request = await requestOf(context, kind, args);
+    const platform = await signedIn(context);
+    const cost = costOf(await platform.web.prices(), request);
+    await confirmed(context, platform, request.words, cost, flagOf(args, "yes"));
+    const jobId = await paying(platform, () => startGeneration(platform.web, project, request));
+    context.io.warn(`Started the job ${jobId}.
+`);
+    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"));
+    answer(context, { job: jobId, cost, ...pulled }, pulledWords(pulled));
+  }
+};
+const mcpHeaders = {
+  name: "mcp headers",
+  summary: "Print the headers a harness sends the remote MCP server, as JSON",
+  usage: "[--api <address>]",
+  options: { api: { type: "string", value: "<address>", description: "the API whose token to send, when it is not the platform's own" } },
+  run: async (context, args) => {
+    const api = stringOf(args, "api");
+    const apiUrl = apiUrlOf(api === void 0 ? context : { ...context, io: { ...context.io, env: { ...context.io.env, PIXELVIBING_API_URL: api } } });
+    const token = await tokenFor(context.services.store, originOf(apiUrl), context.io.env);
+    if (token === null) throw new CliError(`no account token for ${apiUrl}: run \`${PROGRAM_LOGIN}\`, or set ${TOKEN_VARIABLE}`);
+    context.io.write(`${JSON.stringify({ Authorization: `Bearer ${token}` })}
+`);
+  }
+};
+const NEW_MAP_SIZE = 32;
+const GROUND_LEVEL = 7;
+const STYLE_GUIDE_FILE = `${PROJECT_DIRECTORY}/style-guide.md`;
+function starterGuide(name) {
+  return [
+    `# ${name} — style guide`,
+    "",
+    "How this project's art looks. Every generation reads this page, so art made months",
+    "apart still matches. Replace each line with how your game looks.",
+    "",
+    "## Palette",
+    "",
+    "The colours, how many, and how saturated.",
+    "",
+    "## Outline",
+    "",
+    "Whether sprites have an outline, and in what colour.",
+    "",
+    "## Shading",
+    "",
+    "Where the light comes from, and how many shades a colour gets.",
+    "",
+    "## Camera",
+    "",
+    "Top-down, three-quarter or side view.",
+    ""
+  ].join("\n");
+}
+function newProjectFiles(name) {
+  const problem = projectNameProblem(name);
+  if (problem !== null) throw new ProjectError(problem);
+  const trimmed = name.trim();
+  const tiles = [];
+  for (let y = 0; y < NEW_MAP_SIZE; y += 1) {
+    for (let x = 0; x < NEW_MAP_SIZE; x += 1) tiles.push({ x, y, z: GROUND_LEVEL, layers: [], blocking: 0, zone: 0 });
+  }
+  return [
+    { path: PROJECT_FILE, text: writeProjectManifest({ format: PROJECT_FORMAT, name: trimmed }) },
+    { path: MAP_FILE, text: formatMap({ width: NEW_MAP_SIZE, height: NEW_MAP_SIZE, tiles }).text },
+    { path: STYLE_GUIDE_FILE, text: starterGuide(trimmed) }
+  ];
+}
+const GUIDE_KIND = "style-guide";
+const sha256$1 = (text2) => createHash("sha256").update(text2).digest("hex");
+const guidePath = (local) => join(local.root, ...STYLE_GUIDE_FILE.split("/"));
+async function localGuide(local) {
+  const boundary = artBoundary(local);
+  return await boundary.exists(guidePath(local)) ? boundary.readText(guidePath(local)) : null;
+}
+async function unpushed(local) {
+  const text2 = await localGuide(local);
+  if (text2 === null) return false;
+  const pulled = (await readRecord(local)).guide;
+  return pulled === null ? text2 !== starterGuide(local.manifest.name) : sha256$1(text2) !== pulled.sha256;
+}
+async function noGuide(platform, project) {
+  const { guide } = await platform.web.project(project);
+  if (guide.state === "writing") return new CliError("the platform project's style guide is being written: try again in a minute");
+  const how = `ask for one with \`pixel-vibing-cli guide revise "<what the game is>"\`, or write ${STYLE_GUIDE_FILE} and \`pixel-vibing-cli guide push\` it`;
+  if (guide.state === "failed")
+    return new CliError(`the platform project's style guide could not be written (${guide.reason ?? "no reason was given"}): ${how}`);
+  return new CliError(`the platform project has no style guide yet: ${how}`);
+}
+async function currentGuide(platform, project) {
+  const guide = await platform.web.guide(project);
+  if (guide === null) throw await noGuide(platform, project);
+  return guide;
+}
+async function writeGuide(local, guide) {
+  await artBoundary(local).writeFileReplacing(guidePath(local), guide.text);
+  const record = await readRecord(local);
+  await writeRecord(local, { ...record, guide: { version: guide.version, sha256: sha256$1(guide.text) } });
+}
+const CHANGED = "pixelvibing/style-guide.md has changes that were never pushed: push them with `pixel-vibing-cli guide push`, or pass --force to replace them with the platform's";
+const guidePull = {
+  name: "guide pull",
+  summary: "Write the platform project's style guide into pixelvibing/style-guide.md",
+  options: { force: { type: "boolean", description: "replace changes to the local copy that were never pushed" } },
+  run: async (context, args) => {
+    const local = await projectHere(context.io.cwd);
+    const project = linkedOf(local);
+    const platform = await signedIn(context);
+    const guide = await currentGuide(platform, project);
+    const record = await readRecord(local);
+    const text2 = await localGuide(local);
+    if (record.guide?.version === guide.version && text2 !== null && sha256$1(text2) === record.guide.sha256) {
+      answer(context, { version: guide.version, current: true }, `The style guide is current: version ${guide.version}.`);
+      return;
+    }
+    if (!flagOf(args, "force") && await unpushed(local)) throw new CliError(CHANGED);
+    await writeGuide(local, guide);
+    answer(context, { version: guide.version, current: false }, `Wrote version ${guide.version} of the style guide to ${STYLE_GUIDE_FILE}.`);
+  }
+};
+const guidePush = {
+  name: "guide push",
+  summary: "Send pixelvibing/style-guide.md as the style guide's next version",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    const project = linkedOf(local);
+    const text2 = await localGuide(local);
+    if (text2 === null) throw new CliError(`${STYLE_GUIDE_FILE} is not there: \`pixel-vibing-cli guide pull\` writes it`);
+    const pulled = (await readRecord(local)).guide;
+    if (pulled !== null && sha256$1(text2) === pulled.sha256) {
+      answer(context, { version: pulled.version, pushed: false }, `Nothing to push: ${STYLE_GUIDE_FILE} is version ${pulled.version} as it was pulled.`);
+      return;
+    }
+    const platform = await signedIn(context);
+    if (pulled === null && await platform.web.guide(project) !== null) {
+      throw new CliError("the style guide was never pulled here, so there is no version to write on top of: `pixel-vibing-cli guide pull` first");
+    }
+    if (pulled === null && text2 === starterGuide(local.manifest.name))
+      throw new CliError(`${STYLE_GUIDE_FILE} is still the starter page: write the game's guide in it first`);
+    const base = pulled?.version ?? 0;
+    let version2;
+    try {
+      version2 = await platform.web.saveGuide(project, text2, base);
+    } catch (error) {
+      if (error instanceof GuideConflict) {
+        throw new CliError(
+          `the platform's style guide is at version ${error.current}, and this copy was written on top of ${base}: nothing was kept. Keep your changes aside, \`pixel-vibing-cli guide pull --force\`, and make them again on top`
+        );
+      }
+      throw error;
+    }
+    const record = await readRecord(local);
+    await writeRecord(local, { ...record, guide: { version: version2, sha256: sha256$1(text2) } });
+    answer(context, { version: version2, pushed: true }, `Kept ${STYLE_GUIDE_FILE} as version ${version2} of the style guide.`);
+  }
+};
+const guideRevise = {
+  name: "guide revise",
+  summary: "Ask the platform to revise the style guide by an instruction, then pull it",
+  usage: "<instruction> [--yes] [--force]",
+  options: {
+    yes: { type: "boolean", short: "y", description: "start it without asking, once the cost is said" },
+    force: { type: "boolean", description: "replace changes to the local copy that were never pushed" }
+  },
+  positionals: [1, 1],
+  run: async (context, args) => {
+    const local = await projectHere(context.io.cwd);
+    const project = linkedOf(local);
+    const instruction = args.positionals[0].trim();
+    if (instruction === "") throw new CliError("say what to change in the style guide");
+    if (!flagOf(args, "force") && await unpushed(local)) throw new CliError(CHANGED);
+    const platform = await signedIn(context);
+    const cost = costIn(await platform.web.prices(), GUIDE_KIND);
+    await confirmed(context, platform, `a revision of the style guide: ${instruction}`, cost, flagOf(args, "yes"));
+    const jobId = await paying(platform, () => platform.web.reviseGuide(project, instruction));
+    context.io.warn(`Started the job ${jobId}.
+`);
+    const job = await followed(context, platform, jobId);
+    if (job.state === "failed") throw new CliError(`the revision failed: ${job.reason ?? "the platform gave no reason"}`);
+    const guide = await currentGuide(platform, project);
+    await writeGuide(local, guide);
+    answer(context, { job: jobId, version: guide.version }, `Revised the style guide: version ${guide.version} is in ${STYLE_GUIDE_FILE}.`);
+  }
+};
+const guideShow = {
+  name: "guide show",
+  summary: "Print the platform project's current style guide",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    const platform = await signedIn(context);
+    const guide = await currentGuide(platform, linkedOf(local));
+    answer(context, guide, guide.text);
+  }
+};
+const guideVersions = {
+  name: "guide versions",
+  summary: "List the style guide's versions, with how and when each was made",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    const platform = await signedIn(context);
+    const versions = await platform.web.guideVersions(linkedOf(local));
+    const how = { written: "written from the idea", revised: "revised by an instruction", person: "written by a person" };
+    answer(
+      context,
+      { versions },
+      versions.length === 0 ? "No versions yet." : versions.map((kept) => `${String(kept.version).padStart(4)}  ${kept.createdAt.slice(0, 10)}  ${how[kept.made]}`).join("\n")
+    );
+  }
+};
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initProject(cwd, given) {
+  const root = await realpath$1(cwd);
+  let files;
+  try {
+    files = newProjectFiles(given ?? basename(root));
+  } catch (error) {
+    if (error instanceof ProjectError) throw new CliError(error.message);
+    throw error;
+  }
+  for (const taken of [PROJECT_FILE, PROJECT_DIRECTORY]) {
+    if (await exists(join(root, taken)))
+      throw new CliError(`${join(root, taken)} is already there: this directory is a local project, or holds a ${taken} of its own`);
+  }
+  await mkdir(join(root, PROJECT_DIRECTORY));
+  for (const file of files) {
+    const parts = file.path.split("/");
+    if (parts.length > 2) await mkdir(join(root, ...parts.slice(0, -1)), { recursive: true });
+    await writeFile(join(root, ...parts), file.text, { flag: "wx" });
+  }
+  const manifest2 = files.find((file) => file.path === PROJECT_FILE);
+  return { root, name: JSON.parse(manifest2?.text ?? "{}").name, files: files.map((file) => file.path) };
+}
+const init = {
+  name: "init",
+  summary: "Make this directory a local project",
+  usage: "[<name>]",
+  positionals: [0, 1],
+  run: async (context, args) => {
+    const made = await initProject(context.io.cwd, args.positionals[0]);
+    answer(
+      context,
+      made,
+      `Made ${made.root} the local project ${made.name}: ${made.files.join(", ")}. Link it to a platform project with \`pixel-vibing-cli link\`.`
+    );
+  }
+};
+async function projectNamed(platform, wanted) {
+  const asked = wanted;
+  const lower = asked.toLowerCase();
+  if (isProjectId(wanted)) return platform.web.project(wanted);
+  let before = null;
+  const seen = [];
+  do {
+    const page = await platform.web.projects(before);
+    const found = page.projects.find((project) => project.name.toLowerCase() === lower);
+    if (found !== void 0) return found;
+    seen.push(...page.projects.map((project) => project.name));
+    before = page.next;
+  } while (before !== null);
+  throw new CliError(
+    seen.length === 0 ? `this account has no project yet: make one with \`pixel-vibing-cli link --idea "<what the game is>"\`` : `this account has no project named ${asked}: ${seen.join(", ")}`
+  );
+}
+async function chosenProject(context, platform) {
+  const { projects } = await platform.web.projects();
+  if (projects.length === 0) throw new CliError(`this account has no project yet: make one with \`pixel-vibing-cli link --idea "<what the game is>"\``);
+  if (!context.io.interactive) {
+    throw new CliError(`name one of your projects, by id or name: ${projects.map((project2) => project2.name).join(", ")}; or make one with --idea`);
+  }
+  context.io.warn(`${projects.map((project2, index) => `  ${index + 1}. ${project2.name}`).join("\n")}
+`);
+  const picked = Number((await context.io.ask("Link to which project (number): ")).trim());
+  const project = Number.isInteger(picked) ? projects[picked - 1] : void 0;
+  if (project === void 0) throw new CliError("no project has that number");
+  return project;
+}
+async function linkProject(context, platform, local, wanted, idea) {
+  let project;
+  if (idea !== void 0) {
+    const name = wanted ?? local.manifest.name;
+    const made = await paying(platform, () => platform.web.createProject(name, idea));
+    project = { id: made.id, name };
+  } else project = wanted === void 0 ? await chosenProject(context, platform) : await projectNamed(platform, wanted);
+  await writeLink(local, project.id);
+  return project;
+}
+const link = {
+  name: "link",
+  summary: "Name the platform project this local project generates for",
+  usage: "[<project id or name>] [--idea <what the game is>]",
+  options: {
+    idea: { type: "string", value: "<text>", description: "make the project on the platform first, from this idea, named as given or as the local project" }
+  },
+  positionals: [0, 1],
+  run: async (context, args) => {
+    const local = await projectHere(context.io.cwd);
+    const platform = await signedIn(context);
+    const idea = stringOf(args, "idea");
+    const project = await linkProject(context, platform, local, args.positionals[0], idea);
+    answer(
+      context,
+      { project: { id: project.id, name: project.name }, made: idea !== void 0 },
+      `${idea === void 0 ? "Linked" : "Made the platform project and linked"} ${local.manifest.name} to ${project.name} (${project.id}).${idea === void 0 ? "" : " Its style guide is being written from the idea: `pixel-vibing-cli guide pull` fetches it once it is."}`
+    );
+  }
+};
+const seal = {
+  name: "seal",
+  summary: "Seal the local project's art into its container, as the editor does",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    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.1.0";
+const manifest = {
+  version
+};
+const VERSION = manifest.version;
+const PINNED_PACKAGE = `@pixelvibing/cli@${VERSION}`;
+const SERVER_NAME = "pixelvibing";
+const PLAIN_ADDRESS = /^https?:\/\/[A-Za-z0-9.-]+(:[0-9]+)?(\/[A-Za-z0-9._~/-]*)?$/;
+function mcpEntry(apiUrl) {
+  if (!PLAIN_ADDRESS.test(apiUrl)) {
+    throw new CliError(`${apiUrl} cannot be written into a harness's command: an address there holds only letters, digits and . - : / _ ~`);
+  }
+  if (apiUrl === DEFAULT_API_URL) return { url: DEFAULT_MCP_URL, headers: `npx --yes ${PINNED_PACKAGE} mcp headers` };
+  return { url: `${apiUrl}/mcp`, headers: `npx --yes ${PINNED_PACKAGE} mcp headers --api ${apiUrl}` };
+}
+async function textOf(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+const CLAUDE_FILE = ".mcp.json";
+const CODEX_FILE = join(".codex", "config.toml");
+const TABLE = `[mcp_servers.${SERVER_NAME}]`;
+const isHeader = (line) => /^\s*\[/.test(line);
+function claudeWith(text2, entry, onlyWhereConfigured) {
+  let parsed2 = {};
+  if (text2 !== null) {
+    try {
+      parsed2 = JSON.parse(text2);
+    } catch (error) {
+      throw new CliError(`${CLAUDE_FILE} is not valid JSON, so it was left as it is: ${error.message}`);
+    }
+    if (typeof parsed2 !== "object" || parsed2 === null || Array.isArray(parsed2)) throw new CliError(`${CLAUDE_FILE} is not an object, so it was left as it is`);
+  }
+  const servers = parsed2.mcpServers;
+  if (servers !== void 0 && (typeof servers !== "object" || servers === null || Array.isArray(servers))) {
+    throw new CliError(`${CLAUDE_FILE}'s mcpServers is not an object, so it was left as it is`);
+  }
+  const current = servers ?? {};
+  if (onlyWhereConfigured && current[SERVER_NAME] === void 0) return null;
+  const next = { ...parsed2, mcpServers: { ...current, [SERVER_NAME]: { type: "http", url: entry.url, headersHelper: entry.headers } } };
+  return `${JSON.stringify(next, null, 2)}
+`;
+}
+function codexWith(text2, entry, onlyWhereConfigured) {
+  const table = [TABLE, `url = ${JSON.stringify(entry.url)}`, `http_headers_helper = ${JSON.stringify(entry.headers)}`];
+  const lines = (text2 ?? "").split("\n");
+  const start = lines.findIndex((line) => line.trim() === TABLE);
+  if (start === -1) {
+    if (onlyWhereConfigured) return null;
+    const before = (text2 ?? "").replace(/\n*$/, "");
+    return `${before === "" ? "" : `${before}
+
+`}${table.join("\n")}
+`;
+  }
+  let end = start + 1;
+  while (end < lines.length && !isHeader(lines[end])) end += 1;
+  const kept = lines.slice(start + 1, end).filter((line) => line.trim() !== "" && !/^\s*(url|http_headers_helper)\s*=/.test(line));
+  const rest = lines.slice(end);
+  return [...lines.slice(0, start), ...table, ...kept, ...rest.length > 0 ? ["", ...rest] : [""]].join("\n").replace(/\n{3,}/g, "\n\n");
+}
+async function configureHarness(root, harness, entry, onlyWhereConfigured = false) {
+  const file = harness === "claude" ? CLAUDE_FILE : CODEX_FILE;
+  const path = join(root, file);
+  const text2 = await textOf(path);
+  const next = harness === "claude" ? claudeWith(text2, entry, onlyWhereConfigured) : codexWith(text2, entry, onlyWhereConfigured);
+  if (next === null) return "absent";
+  if (next === text2) return "current";
+  if (harness === "codex") await mkdir(join(root, ".codex"), { recursive: true });
+  await writeFile(path, next);
+  return "written";
+}
+const HARNESS_FILES = { claude: ".mcp.json", codex: ".codex/config.toml" };
+const HARNESSES = { claude: ".claude", codex: ".codex" };
+const SKILLS_MANIFEST = "pixelvibing-skills.json";
+const sha256 = (text2) => createHash("sha256").update(text2).digest("hex");
+const SHIPPED_DIRECTORY = fileURLToPath(new URL("../skills/", import.meta.url));
+async function shippedSkills(directory = SHIPPED_DIRECTORY) {
+  const names = (await readdir(directory, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const skills = [];
+  for (const name of names.sort()) {
+    const text2 = await readFile(join(directory, name, "SKILL.md"), "utf8");
+    skills.push({ name, text: text2, sha256: sha256(text2) });
+  }
+  return skills;
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function harnessesFor(root, named) {
+  if (named.length > 0) {
+    const unknown = named.filter((name) => !(name in HARNESSES));
+    if (unknown.length > 0) throw new CliError(`--harness is ${Object.keys(HARNESSES).join(" or ")}, not ${unknown.join(", ")}`);
+    return [...new Set(named)];
+  }
+  const present = [];
+  for (const harness of Object.keys(HARNESSES)) if (await isDirectory(join(root, HARNESSES[harness]))) present.push(harness);
+  return present.length > 0 ? present : ["claude"];
+}
+const manifestPath = (root, harness) => join(root, HARNESSES[harness], SKILLS_MANIFEST);
+const skillPath = (root, harness, name) => join(root, HARNESSES[harness], "skills", name, "SKILL.md");
+async function readManifest(root, harness) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(await readFile(manifestPath(root, harness), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new CliError(`${manifestPath(root, harness)} cannot be read: ${error.message}`);
+  }
+  const skills = parsed2?.skills;
+  if (typeof skills !== "object" || skills === null) throw new CliError(`${manifestPath(root, harness)} records no skills`);
+  return Object.fromEntries(Object.entries(skills).filter((entry) => typeof entry[1] === "string"));
+}
+async function writeManifest(root, harness, skills) {
+  const sorted = Object.fromEntries(Object.entries(skills).sort(([left], [right]) => left < right ? -1 : 1));
+  await writeFile(manifestPath(root, harness), `${JSON.stringify({ format: 1, skills: sorted }, null, 2)}
+`);
+}
+async function writeSkill(root, harness, skill) {
+  const path = skillPath(root, harness, skill.name);
+  await mkdir(join(path, ".."), { recursive: true });
+  await writeFile(path, skill.text);
+}
+async function textAt(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function installMissing(root, harness, skills) {
+  const manifest2 = await readManifest(root, harness) ?? {};
+  const installed = [];
+  const left = [];
+  for (const skill of skills) {
+    const there = await textAt(skillPath(root, harness, skill.name));
+    if (there === null) {
+      await writeSkill(root, harness, skill);
+      manifest2[skill.name] = skill.sha256;
+      installed.push(skill.name);
+    } else if (sha256(there) === skill.sha256) manifest2[skill.name] = skill.sha256;
+    else if (manifest2[skill.name] === void 0) left.push(skill.name);
+  }
+  await writeManifest(root, harness, manifest2);
+  return { harness, installed, left };
+}
+async function updateSkills(root, skills) {
+  const updated = [];
+  for (const harness of Object.keys(HARNESSES)) {
+    const manifest2 = await readManifest(root, harness);
+    if (manifest2 === null) continue;
+    const replaced = [];
+    const installed = [];
+    for (const skill of skills) {
+      const recorded = manifest2[skill.name];
+      if (recorded === skill.sha256 && await textAt(skillPath(root, harness, skill.name)) !== null) continue;
+      await writeSkill(root, harness, skill);
+      (recorded === void 0 ? installed : replaced).push(skill.name);
+      manifest2[skill.name] = skill.sha256;
+    }
+    await writeManifest(root, harness, manifest2);
+    updated.push({ harness, replaced, installed });
+  }
+  return updated;
+}
+const setup = {
+  name: "setup",
+  summary: "Sign in, make and link the local project, and install the Skills, doing only what is missing",
+  usage: "[--harness claude|codex]… [--project <id|name> | --idea <text>] [--name <name>] [--provider <name>]",
+  options: {
+    harness: {
+      type: "string",
+      multiple: true,
+      value: "<claude|codex>",
+      description: "the harness to install the Skills into; those this repository has, else Claude Code"
+    },
+    project: { type: "string", value: "<id|name>", description: "the platform project to link, when the local project names none" },
+    idea: { type: "string", value: "<text>", description: "make the platform project from this idea, when the local project names none" },
+    name: { type: "string", value: "<name>", description: "the local project's name, when this directory is not one yet" },
+    provider: { type: "string", value: "<name>", description: "the provider to sign in with, when no token is kept" }
+  },
+  run: async (context, args) => {
+    const done = [];
+    const origin = originOf(apiUrlOf(context));
+    if (await tokenFor(context.services.store, origin, context.io.env) === null) {
+      const { account } = await signInInBrowser(context, stringOf(args, "provider"));
+      done.push(`signed in as ${account}`);
+    }
+    if (await findProject(context.io.cwd) === null) {
+      const made = await initProject(context.io.cwd, stringOf(args, "name"));
+      done.push(`made ${made.root} the local project ${made.name}`);
+    }
+    const local = await projectHere(context.io.cwd);
+    let linked = local.manifest.project ?? null;
+    if (linked === null) {
+      const project = await linkProject(context, await signedIn(context), local, stringOf(args, "project"), stringOf(args, "idea"));
+      linked = project.id;
+      done.push(`linked it to ${project.name}`);
+    }
+    const skills = await shippedSkills();
+    const harnesses = await harnessesFor(local.root, stringsOf(args, "harness"));
+    const entry = mcpEntry(apiUrlOf(context));
+    const installed = [];
+    for (const harness of harnesses) {
+      const result = await installMissing(local.root, harness, skills);
+      const mcp = await configureHarness(local.root, harness, entry);
+      installed.push({ ...result, mcp });
+      if (result.installed.length > 0) done.push(`installed ${result.installed.join(", ")} into ${HARNESSES[result.harness]}/skills/`);
+      if (mcp === "written") done.push(`configured the MCP server in ${HARNESS_FILES[harness]}`);
+      for (const name of result.left) {
+        context.io.warn(`${HARNESSES[result.harness]}/skills/${name}/ is already there and is not the one this CLI ships: it was left as it is.
+`);
+      }
+    }
+    answer(
+      context,
+      { root: local.root, project: linked, harnesses: installed },
+      done.length === 0 ? "Nothing to do: this repository is set up." : `Set up: ${done.join("; ")}.`
+    );
+  }
+};
+const update = {
+  name: "update",
+  summary: "Replace the installed Skills this CLI ships differently, and add those it ships since",
+  run: async (context) => {
+    const local = await projectHere(context.io.cwd);
+    const updated = await updateSkills(local.root, await shippedSkills());
+    if (updated.length === 0) throw new CliError("no Skills of this CLI are installed here: `pixel-vibing-cli setup` installs them");
+    const entry = mcpEntry(apiUrlOf(context));
+    const harnesses = [];
+    for (const result of updated) harnesses.push({ ...result, mcp: await configureHarness(local.root, result.harness, entry, true) });
+    const written = harnesses.flatMap((result) => [
+      ...result.replaced.map((name) => `replaced ${HARNESSES[result.harness]}/skills/${name}`),
+      ...result.installed.map((name) => `installed ${HARNESSES[result.harness]}/skills/${name}`),
+      ...result.mcp === "written" ? [`brought the MCP server in ${HARNESS_FILES[result.harness]} to this version`] : []
+    ]);
+    answer(context, { harnesses }, written.length === 0 ? "The Skills are current." : `Updated: ${written.join("; ")}.`);
+  }
+};
+const PROGRAM = "pixel-vibing-cli";
+const COMMON = {
+  json: { type: "boolean", description: "print the answer as JSON on standard output" },
+  help: { type: "boolean", short: "h", description: "show this command's options" }
+};
+const pad = (text2, width) => text2 + " ".repeat(Math.max(1, width - text2.length));
+function overview(commands) {
+  const width = Math.max(...commands.map((command) => command.name.length)) + 2;
+  return [
+    `Usage: ${PROGRAM} <command> [options]`,
+    "",
+    "Commands:",
+    ...commands.map((command) => `  ${pad(command.name, width)}${command.summary}`),
+    "",
+    `Run \`${PROGRAM} <command> --help\` for a command's options.`,
+    ""
+  ].join("\n");
+}
+function optionLabel(name, option) {
+  const long = `--${name}${option.type === "string" ? ` ${option.value ?? "<value>"}` : ""}`;
+  return option.short === void 0 ? long : `-${option.short}, ${long}`;
+}
+function usageOf(command) {
+  const options = Object.entries({ ...command.options, ...COMMON });
+  const labels = options.map(([name, option]) => optionLabel(name, option));
+  const width = Math.max(...labels.map((label) => label.length)) + 2;
+  return [
+    `Usage: ${PROGRAM} ${command.name}${command.usage === void 0 ? "" : ` ${command.usage}`}`,
+    "",
+    command.summary,
+    "",
+    "Options:",
+    ...options.map(([, option], index) => `  ${pad(labels[index] ?? "", width)}${option.description}${option.multiple === true ? " (repeatable)" : ""}`),
+    ""
+  ].join("\n");
+}
+function find(commands, argv) {
+  const [first, second] = argv;
+  const two = commands.find((command) => second !== void 0 && command.name === `${first} ${second}`);
+  if (two !== void 0) return { command: two, rest: argv.slice(2) };
+  const one = commands.find((command) => command.name === first);
+  return one === void 0 ? null : { command: one, rest: argv.slice(1) };
+}
+function parsed(command, rest) {
+  const options = Object.fromEntries(
+    Object.entries({ ...command.options, ...COMMON }).map(([name, option]) => [
+      name,
+      { type: option.type, ...option.short === void 0 ? {} : { short: option.short }, ...option.multiple === true ? { multiple: true } : {} }
+    ])
+  );
+  try {
+    const { values, positionals } = parseArgs({ args: rest, options, allowPositionals: true, strict: true });
+    return { values, positionals };
+  } catch (error) {
+    throw new CliError(`${error.message}
+
+${usageOf(command)}`);
+  }
+}
+async function dispatch(argv, options) {
+  const { commands, io } = options;
+  const [first] = argv;
+  if (first === void 0) {
+    io.warn(overview(commands));
+    return 1;
+  }
+  if (first === "--help" || first === "-h" || first === "help") {
+    io.write(overview(commands));
+    return 0;
+  }
+  if (first === "--version" || first === "-v") {
+    io.write(`${options.version}
+`);
+    return 0;
+  }
+  const found = find(commands, argv);
+  if (found === null) {
+    const family = commands.filter((command2) => command2.name.startsWith(`${first} `));
+    io.warn(family.length > 0 ? `${overview(family)}` : `${PROGRAM}: no command \`${first}\`
+
+${overview(commands)}`);
+    return 1;
+  }
+  const { command, rest } = found;
+  try {
+    const args = parsed(command, rest);
+    if (args.values.help === true) {
+      io.write(usageOf(command));
+      return 0;
+    }
+    const [least, most] = command.positionals ?? [0, 0];
+    if (args.positionals.length < least || args.positionals.length > most) {
+      throw new CliError(
+        `${PROGRAM} ${command.name} takes ${least === most ? least : `${least} to ${most}`} argument${most === 1 ? "" : "s"}
+
+${usageOf(command)}`
+      );
+    }
+    await command.run(await options.context(args.values.json === true), args);
+    return 0;
+  } catch (error) {
+    const said = error instanceof CliError ? error.message : options.explain?.(error) ?? (error instanceof Error ? error.message : String(error));
+    io.warn(`${said.endsWith("\n") ? said : `${said}
+`}`);
+    return 1;
+  }
+}
+function browserCommand(platform, url) {
+  if (platform === "win32") return ["rundll32", ["url.dll,FileProtocolHandler", url]];
+  if (platform === "darwin") return ["open", [url]];
+  return ["xdg-open", [url]];
+}
+function detached(command, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve2();
+    });
+  });
+}
+function machineServices(env) {
+  return {
+    store: systemStore(),
+    settingsFile: settingsPath(process.platform, env, homedir()),
+    fetch: globalThis.fetch,
+    openExternal: (url) => detached(...browserCommand(process.platform, url)),
+    hostname,
+    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
+    now: Date.now,
+    platform: process.platform,
+    home: homedir(),
+    launch: detached
+  };
+}
+const INTERRUPT = "";
+const END = "";
+const DELETE = /* @__PURE__ */ new Set(["", "\b"]);
+function readHidden(input, output, question) {
+  output.write(question);
+  return new Promise((resolve2, reject) => {
+    let typed = "";
+    const done = (finish) => {
+      input.removeListener("data", onData);
+      input.setRawMode?.(false);
+      input.pause();
+      output.write("\n");
+      finish();
+    };
+    const onData = (chunk2) => {
+      for (const char of chunk2.toString()) {
+        if (char === "\r" || char === "\n" || char === END) return done(() => resolve2(typed));
+        if (char === INTERRUPT) return done(() => reject(new Error("cancelled")));
+        if (DELETE.has(char)) typed = typed.slice(0, -1);
+        else typed += char;
+      }
+    };
+    input.setRawMode?.(true);
+    input.on("data", onData);
+    input.resume();
+  });
+}
+function readLine(input, output, question) {
+  const lines = createInterface({ input, output, terminal: output.isTTY === true });
+  return new Promise((resolve2) => {
+    lines.question(question, (answer2) => {
+      lines.close();
+      resolve2(answer2);
+    });
+  });
+}
+async function readAll(input) {
+  let text2 = "";
+  for await (const chunk2 of input) text2 += chunk2.toString();
+  return text2;
+}
+function terminalOf(streams) {
+  return {
+    write: (text2) => {
+      streams.stdout.write(text2);
+    },
+    warn: (text2) => {
+      streams.stderr.write(text2);
+    },
+    env: streams.env,
+    cwd: streams.cwd,
+    interactive: streams.stdin.isTTY === true && streams.stderr.isTTY === true,
+    ask: (question, hidden = false) => hidden ? readHidden(streams.stdin, streams.stderr, question) : readLine(streams.stdin, streams.stderr, question),
+    readInput: () => readAll(streams.stdin)
+  };
+}
+const COMMANDS = [
+  setup,
+  update,
+  login,
+  logout,
+  whoami,
+  init,
+  link,
+  generate,
+  list,
+  pull,
+  seal,
+  exportCommand,
+  editor,
+  guideShow,
+  guidePull,
+  guidePush,
+  guideRevise,
+  guideVersions,
+  mcpHeaders
+];
+function main(argv, streams, services = machineServices(streams.env)) {
+  const io = terminalOf(streams);
+  return dispatch(argv, { commands: COMMANDS, io, version: VERSION, context: (json2) => ({ io, json: json2, services }), explain });
+}
+process.exitCode = await main(process.argv.slice(2), {
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  env: process.env,
+  cwd: process.cwd()
+});