@bookklik/pivo-plate 0.0.0-stage → 0.2.0

package/lib/chunks/chunk-OYM3ZMMA.js

@@ -0,0 +1,1169 @@
+// src/core/png.ts
+import { Inflate } from "pako";
+var PNG_LIMITS = Object.freeze({
+  maxBytes: 32 * 1024 * 1024,
+  maxDimension: 16384,
+  maxPixels: 16777216,
+  maxInflatedBytes: 192 * 1024 * 1024,
+  maxChunks: 4096,
+  maxAncillaryBytes: 4 * 1024 * 1024,
+  maxMetadataInflatedBytes: 1024 * 1024
+});
+var PROJECT_PNG_LIMITS = Object.freeze({
+  maxPngBytes: 64 * 1024 * 1024,
+  maxPixels: 33554432,
+  maxInflatedBytes: 192 * 1024 * 1024,
+  maxManifestBytes: 24 * 1024 * 1024
+});
+var PngValidationError = class extends Error {
+  constructor(message) {
+    super(`PNG validation: ${message}`);
+    this.name = "PngValidationError";
+  }
+};
+var fail = (message) => {
+  throw new PngValidationError(message);
+};
+var table = new Uint32Array(256);
+for (let n = 0; n < 256; n++) {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+  table[n] = c >>> 0;
+}
+function pngCrc32(bytes) {
+  let c = 4294967295;
+  for (const b of bytes) c = table[(c ^ b) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+var u32 = (b, o) => b[o] * 16777216 + (b[o + 1] << 16) + (b[o + 2] << 8) + b[o + 3] >>> 0;
+var channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+var depths = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
+var adam7 = [[0, 0, 8, 8], [4, 0, 8, 8], [0, 4, 4, 8], [2, 0, 4, 4], [0, 2, 2, 4], [1, 0, 2, 2], [0, 1, 1, 2]];
+function passes(width, height, bits, interlace) {
+  const steps = interlace ? adam7 : [[0, 0, 1, 1]];
+  return steps.map(([x, y, dx, dy]) => {
+    const w = Math.max(0, Math.ceil((width - x) / dx)), h = Math.max(0, Math.ceil((height - y) / dy));
+    return { width: w, height: h, rowBytes: Math.ceil(w * bits / 8) };
+  }).filter((p) => p.width && p.height);
+}
+function limited(overrides) {
+  const result = { ...PNG_LIMITS };
+  for (const key of Object.keys(overrides)) {
+    const v = overrides[key];
+    if (v === void 0) continue;
+    if (!Number.isSafeInteger(v) || v < 1 || v > PNG_LIMITS[key]) fail(`invalid ${key} budget`);
+    result[key] = v;
+  }
+  return result;
+}
+function boundedZlib(parts, maxOutput, onData) {
+  const nonempty = parts.filter((p) => p.length);
+  const inputBytes = nonempty.reduce((n, p) => n + p.length, 0);
+  if (inputBytes < 6) fail("missing or truncated zlib stream");
+  const first = nonempty[0];
+  const header = first.length >= 2 ? [first[0], first[1]] : [first[0], nonempty[1]?.[0]];
+  if (header[1] === void 0 || (header[0] & 15) !== 8 || header[0] >>> 4 > 7 || ((header[0] << 8) + header[1]) % 31 || (header[1] & 32) !== 0) fail("invalid PNG zlib header or preset dictionary");
+  const inflater = new Inflate({ windowBits: 15, chunkSize: 16384 });
+  const state = inflater;
+  let produced = 0;
+  inflater.onData = (chunk) => {
+    produced += chunk.length;
+    if (produced > maxOutput) fail("inflated data exceeds output budget");
+    onData(chunk);
+  };
+  for (let i = 0; i < nonempty.length; i++) {
+    if (state.ended) fail("extra data after zlib stream");
+    const ok = inflater.push(nonempty[i], i === nonempty.length - 1);
+    if (!ok || inflater.err) fail(`corrupt/truncated zlib stream: ${inflater.msg || inflater.err}`);
+  }
+  const stream = inflater.strm;
+  if (!state.ended || stream.total_in !== inputBytes || stream.avail_in) fail("incomplete or extra zlib stream data");
+  return produced;
+}
+function keywordEnd(data) {
+  const end = data.indexOf(0);
+  if (end < 1 || end > 79) fail("invalid PNG text/profile keyword");
+  return end;
+}
+function checkCompressedMetadata(type, data, remaining) {
+  if (type === "iCCP" || type === "zTXt") {
+    const n = keywordEnd(data);
+    if (data[n + 1] !== 0) fail("invalid metadata compression method");
+    return boundedZlib([data.subarray(n + 2)], remaining, () => {
+    });
+  }
+  if (type === "iTXt") {
+    let n = keywordEnd(data) + 1;
+    const compressed = data[n++], method = data[n++];
+    if (compressed !== 0 && compressed !== 1 || method !== 0) fail("invalid international-text compression");
+    for (let i = 0; i < 2; i++) {
+      const end = data.indexOf(0, n);
+      if (end < 0) fail("truncated international text");
+      n = end + 1;
+    }
+    return compressed ? boundedZlib([data.subarray(n)], remaining, () => {
+    }) : data.length - n;
+  }
+  return 0;
+}
+function paeth(a, b, c) {
+  const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+function validatePixels(idat, layout, bitDepth, colorType, paletteEntries, maxInflated, onRow) {
+  const expected = layout.reduce((n, p) => n + (p.rowBytes + 1) * p.height, 0);
+  if (!Number.isSafeInteger(expected) || expected > maxInflated) fail("scanline size exceeds inflated-byte budget");
+  const bpp = Math.max(1, Math.ceil(channels[colorType] * bitDepth / 8));
+  let pass = 0, y = 0, x = -1, filter = 0;
+  let row = new Uint8Array(layout[0].rowBytes), previous = new Uint8Array(row.length);
+  const output = boundedZlib(idat, expected, (chunk) => {
+    for (const byte of chunk) {
+      if (pass >= layout.length) fail("excess scanline data");
+      if (x === -1) {
+        if (byte > 4) fail("invalid scanline filter");
+        filter = byte;
+        x = 0;
+        continue;
+      }
+      const left = x >= bpp ? row[x - bpp] : 0, up = previous[x], corner = x >= bpp ? previous[x - bpp] : 0;
+      const predictor = filter === 0 ? 0 : filter === 1 ? left : filter === 2 ? up : filter === 3 ? Math.floor((left + up) / 2) : paeth(left, up, corner);
+      row[x++] = byte + predictor & 255;
+      if (x === row.length) {
+        if (colorType === 3) {
+          const mask = (1 << bitDepth) - 1;
+          for (let px = 0; px < layout[pass].width; px++) {
+            const bit = px * bitDepth, index = row[bit >>> 3] >>> 8 - bitDepth - (bit & 7) & mask;
+            if (index >= paletteEntries) fail("palette index outside PLTE");
+          }
+        }
+        onRow?.(row, layout[pass].width);
+        const old = previous;
+        previous = row;
+        row = old;
+        x = -1;
+        y++;
+        if (y === layout[pass].height) {
+          pass++;
+          y = 0;
+          if (pass < layout.length) {
+            row = new Uint8Array(layout[pass].rowBytes);
+            previous = new Uint8Array(row.length);
+          }
+        }
+      }
+    }
+  });
+  if (output !== expected || pass !== layout.length || x !== -1) fail("decoded scanline length does not match IHDR dimensions");
+  return output;
+}
+function expectedSize(info, expected) {
+  if (expected && (info.width !== expected.width || info.height !== expected.height)) fail(`actual dimensions ${info.width}x${info.height} do not match atlas metadata ${expected.width}x${expected.height}`);
+}
+function validatePngBytes(bytes, expected, overrides = {}) {
+  const limits = limited(overrides);
+  if (!(bytes instanceof Uint8Array) || bytes.length < 8) fail("missing PNG signature");
+  if (bytes.length > limits.maxBytes) fail("PNG file exceeds byte budget");
+  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+  if (signature.some((n, i) => bytes[i] !== n)) fail("invalid PNG signature");
+  let offset = 8, width = 0, height = 0, bitDepth = 0, colorType = 0, interlace = 0, chunkCount = 0, ancillary = 0, metadataOutput = 0;
+  let ihdr = false, ended = false, palette = false, trns = false, dataStarted = false, dataEnded = false;
+  let paletteEntries = 0;
+  const idat = [];
+  let transparency;
+  const seen = /* @__PURE__ */ new Set();
+  while (offset < bytes.length) {
+    if (++chunkCount > limits.maxChunks) fail("chunk count exceeds budget");
+    if (offset + 12 > bytes.length) fail("truncated chunk header");
+    const length = u32(bytes, offset);
+    if (length > 2147483647 || length > bytes.length - offset - 12) fail("truncated/oversized PNG chunk");
+    const type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
+    if (!/^[A-Za-z]{4}$/.test(type) || type[2] !== type[2].toUpperCase()) fail("invalid chunk type or reserved bit");
+    const start = offset + 8, end = start + length, data = bytes.subarray(start, end);
+    if (pngCrc32(bytes.subarray(offset + 4, end)) !== u32(bytes, end)) fail(`CRC mismatch in ${type}`);
+    if (!ihdr && type !== "IHDR") fail("IHDR must be first");
+    if (["acTL", "fcTL", "fdAT"].includes(type)) fail("animated PNG is unsupported; use a static PNG");
+    if (type === "IHDR") {
+      if (ihdr || length !== 13) fail("duplicate or invalid IHDR");
+      ihdr = true;
+      width = u32(data, 0);
+      height = u32(data, 4);
+      bitDepth = data[8];
+      colorType = data[9];
+      interlace = data[12];
+      if (!width || !height || width > limits.maxDimension || height > limits.maxDimension || width * height > limits.maxPixels) fail("actual PNG dimensions/pixels exceed budget");
+      if (!depths[colorType]?.includes(bitDepth) || data[10] !== 0 || data[11] !== 0 || interlace !== 0 && interlace !== 1) fail("invalid bit depth/color/compression/filter/interlace in IHDR");
+    } else if (type === "PLTE") {
+      if (palette || dataStarted || trns || colorType === 0 || colorType === 4 || !length || length % 3 || length > 768) fail("invalid/duplicate/misordered PLTE");
+      palette = true;
+      paletteEntries = length / 3;
+      if (colorType === 3 && paletteEntries > 2 ** bitDepth) fail("palette exceeds indexed bit depth");
+    } else if (type === "tRNS") {
+      if (trns || dataStarted || colorType === 4 || colorType === 6) fail("invalid/duplicate/misordered tRNS");
+      trns = true;
+      if (colorType === 3 && (!palette || !length || length > paletteEntries)) fail("indexed transparency requires valid PLTE");
+      if (colorType === 0 && length !== 2 || colorType === 2 && length !== 6) fail("invalid transparency chunk length");
+      transparency = data;
+      if (colorType === 0 || colorType === 2) {
+        for (let i = 0; i < length; i += 2) if (data[i] * 256 + data[i + 1] > 2 ** bitDepth - 1) fail("transparency sample outside bit depth");
+      }
+    } else if (type === "IDAT") {
+      if (dataEnded) fail("nonconsecutive IDAT chunks");
+      if (colorType === 3 && !palette) fail("indexed PNG missing PLTE");
+      dataStarted = true;
+      idat.push(data);
+    } else if (type === "IEND") {
+      if (length || !dataStarted) fail("invalid IEND or missing IDAT");
+      ended = true;
+      offset = end + 4;
+      if (offset !== bytes.length) fail("trailing data after IEND");
+      break;
+    } else {
+      if (type[0] === type[0].toUpperCase()) fail(`unknown critical chunk ${type}`);
+      if (dataStarted) dataEnded = true;
+      ancillary += length;
+      if (ancillary > limits.maxAncillaryBytes) fail("ancillary-byte budget exceeded");
+      if (["iCCP", "sRGB", "gAMA", "cHRM", "sBIT", "pHYs", "bKGD", "hIST"].includes(type)) {
+        if (seen.has(type)) fail(`duplicate ${type}`);
+        seen.add(type);
+        if (dataStarted) fail(`misordered ${type}`);
+      }
+      if (["iCCP", "sRGB", "gAMA", "cHRM", "sBIT"].includes(type) && palette) fail(`misordered ${type}`);
+      if (type === "iCCP" && seen.has("sRGB") || type === "sRGB" && seen.has("iCCP")) fail("conflicting color profile chunks");
+      if (type === "sRGB" && (length !== 1 || data[0] > 3) || type === "gAMA" && (length !== 4 || !u32(data, 0)) || type === "cHRM" && length !== 32 || type === "pHYs" && (length !== 9 || data[8] > 1)) fail(`invalid ${type}`);
+      if (type === "hIST" && (!palette || length !== paletteEntries * 2)) fail("invalid histogram");
+      if (type === "sBIT") {
+        const count = colorType === 3 ? 3 : channels[colorType];
+        if (length !== count || [...data].some((n) => n < 1 || n > (colorType === 3 ? 8 : bitDepth))) fail("invalid significant bits");
+      }
+      if (type === "bKGD" && (colorType === 3 ? !palette || length !== 1 || data[0] >= paletteEntries : length !== (colorType === 0 || colorType === 4 ? 2 : 6))) fail("invalid background chunk");
+      if (["iCCP", "zTXt", "iTXt"].includes(type)) {
+        if (metadataOutput >= limits.maxMetadataInflatedBytes) fail("metadata output budget exceeded");
+        metadataOutput += checkCompressedMetadata(type, data, limits.maxMetadataInflatedBytes - metadataOutput);
+        if (metadataOutput > limits.maxMetadataInflatedBytes) fail("metadata output budget exceeded");
+      }
+      if (type === "tEXt") keywordEnd(data);
+    }
+    offset = end + 4;
+  }
+  if (!ihdr || !ended || !dataStarted) fail("missing IHDR, IDAT or IEND");
+  const layout = passes(width, height, channels[colorType] * bitDepth, interlace);
+  let alphaMode = "opaque";
+  const maxSample = 2 ** bitDepth - 1;
+  const sample = (row, index) => {
+    if (bitDepth === 16) return row[index * 2] * 256 + row[index * 2 + 1];
+    if (bitDepth === 8) return row[index];
+    const bit = index * bitDepth;
+    return row[bit >>> 3] >>> 8 - bitDepth - (bit & 7) & maxSample;
+  };
+  const inspectRow = (row, rowWidth) => {
+    if (alphaMode === "blend" || !transparency && colorType !== 4 && colorType !== 6) return;
+    for (let pixel = 0; pixel < rowWidth; pixel++) {
+      let alpha = 255, maximum = 255;
+      if (colorType === 4 || colorType === 6) {
+        maximum = maxSample;
+        alpha = sample(row, pixel * channels[colorType] + channels[colorType] - 1);
+      } else if (colorType === 3) alpha = transparency?.[sample(row, pixel)] ?? 255;
+      else if (transparency) {
+        let matches = true;
+        for (let channel = 0; channel < channels[colorType]; channel++) if (sample(row, pixel * channels[colorType] + channel) !== transparency[channel * 2] * 256 + transparency[channel * 2 + 1]) {
+          matches = false;
+          break;
+        }
+        if (matches) alpha = 0;
+      }
+      if (alpha > 0 && alpha < maximum) {
+        alphaMode = "blend";
+        return;
+      }
+      if (alpha === 0) alphaMode = "cutout";
+    }
+  };
+  const inflatedBytes = validatePixels(idat, layout, bitDepth, colorType, paletteEntries, limits.maxInflatedBytes, inspectRow);
+  const info = { width, height, bitDepth, colorType, interlace, byteLength: bytes.length, inflatedBytes, chunks: chunkCount, ancillaryBytes: ancillary, alphaMode };
+  expectedSize(info, expected);
+  return Object.freeze(info);
+}
+function preflightPngDataUrl(url, expected) {
+  const prefix = "data:image/png;base64,";
+  if (typeof url !== "string") fail("expected PNG base64 data URL");
+  if (url.length > prefix.length + 4 * Math.ceil(PNG_LIMITS.maxBytes / 3)) fail("PNG data URL exceeds byte budget");
+  if (!url.startsWith(prefix)) fail("expected PNG base64 data URL");
+  const b64 = url.slice(prefix.length);
+  if (b64.length < 44 || b64.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(b64)) fail("invalid/truncated PNG base64 payload");
+  const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0, byteLength = b64.length / 4 * 3 - padding;
+  if (byteLength > PNG_LIMITS.maxBytes) fail("PNG base64 decoded size exceeds byte budget");
+  let bin = "";
+  try {
+    bin = atob(b64.slice(0, 44));
+  } catch {
+    fail("invalid PNG base64 header");
+  }
+  const b = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  if ([137, 80, 78, 71, 13, 10, 26, 10].some((n, i) => b[i] !== n) || u32(b, 8) !== 13 || String.fromCharCode(...b.subarray(12, 16)) !== "IHDR") fail("invalid PNG signature or IHDR");
+  if (pngCrc32(b.subarray(12, 29)) !== u32(b, 29)) fail("CRC mismatch in IHDR");
+  const width = u32(b, 16), height = u32(b, 20), bitDepth = b[24], colorType = b[25], interlace = b[28];
+  if (!width || !height || width > PNG_LIMITS.maxDimension || height > PNG_LIMITS.maxDimension || width * height > PNG_LIMITS.maxPixels) fail("actual PNG dimensions/pixels exceed budget");
+  if (!depths[colorType]?.includes(bitDepth) || b[26] !== 0 || b[27] !== 0 || interlace !== 0 && interlace !== 1) fail("invalid IHDR encoding");
+  const inflatedBytes = passes(width, height, channels[colorType] * bitDepth, interlace).reduce((n, p) => n + (p.rowBytes + 1) * p.height, 0);
+  if (inflatedBytes > PNG_LIMITS.maxInflatedBytes) fail("scanline size exceeds inflated-byte budget");
+  const info = { width, height, bitDepth, colorType, interlace, byteLength, inflatedBytes, chunks: 0, ancillaryBytes: 0 };
+  expectedSize(info, expected);
+  return info;
+}
+function pngDataUrlBytes(url) {
+  const prefix = "data:image/png;base64,";
+  if (typeof url !== "string") fail("expected PNG base64 data URL");
+  if (url.length > prefix.length + 4 * Math.ceil(PNG_LIMITS.maxBytes / 3)) fail("PNG data URL exceeds byte budget");
+  if (!url.startsWith(prefix)) fail("expected PNG base64 data URL");
+  const b64 = url.slice(prefix.length);
+  if (!b64 || b64.length % 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(b64)) fail("invalid PNG base64 payload");
+  const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0, size = b64.length / 4 * 3 - padding;
+  if (size > PNG_LIMITS.maxBytes) fail("PNG base64 decoded size exceeds byte budget");
+  let bin = "";
+  try {
+    bin = atob(b64);
+  } catch {
+    fail("invalid PNG base64 payload");
+  }
+  if (bin.length !== size) fail("invalid PNG base64 length");
+  const bytes = new Uint8Array(size);
+  for (let i = 0; i < size; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+function pngBytesDataUrl(bytes) {
+  if (bytes.length > PNG_LIMITS.maxBytes) fail("PNG file exceeds byte budget");
+  let bin = "";
+  for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return "data:image/png;base64," + btoa(bin);
+}
+var cache = /* @__PURE__ */ new Map();
+var cacheChars = 0;
+function validatePngDataUrl(url, expected) {
+  let info = cache.get(url);
+  if (!info) {
+    info = validatePngBytes(pngDataUrlBytes(url));
+    if (url.length <= 8 * 1024 * 1024) {
+      while (cache.size >= 16 || cacheChars + url.length > 8 * 1024 * 1024) {
+        const key = cache.keys().next().value;
+        if (key === void 0) break;
+        cacheChars -= key.length;
+        cache.delete(key);
+      }
+      cache.set(url, info);
+      cacheChars += url.length;
+    }
+  }
+  expectedSize(info, expected);
+  return info;
+}
+function checkProjectPngBudget(infos, manifestBytes) {
+  const bytes = infos.reduce((n, i) => n + i.byteLength, 0), pixels = infos.reduce((n, i) => n + i.width * i.height, 0), inflated = infos.reduce((n, i) => n + i.inflatedBytes, 0);
+  if (bytes > PROJECT_PNG_LIMITS.maxPngBytes) fail("project aggregate PNG-byte budget exceeded");
+  if (pixels > PROJECT_PNG_LIMITS.maxPixels) fail("project aggregate pixel budget exceeded");
+  if (inflated > PROJECT_PNG_LIMITS.maxInflatedBytes) fail("project aggregate inflated-byte budget exceeded");
+  if (manifestBytes > PROJECT_PNG_LIMITS.maxManifestBytes) fail("project manifest-byte budget exceeded");
+}
+
+// src/core/hierarchy.ts
+var MAX_HIERARCHY_DEPTH = 128;
+function depthError(id) {
+  return new Error(
+    `Object "${id}" exceeds the maximum hierarchy depth of ${MAX_HIERARCHY_DEPTH}`
+  );
+}
+function ancestorChain(objects, id) {
+  const byId = new Map(objects.map((o) => [o.id, o]));
+  if (!byId.has(id)) throw new Error(`ancestorChain: unknown object id "${id}"`);
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([id]);
+  let cur = byId.get(id).parentId;
+  while (cur !== null) {
+    if (chain.length >= MAX_HIERARCHY_DEPTH) throw depthError(id);
+    const parent = byId.get(cur);
+    if (!parent) throw new Error(`ancestorChain: object "${id}" references unknown parent "${cur}"`);
+    if (seen.has(parent.id)) {
+      throw new Error(`ancestorChain: object hierarchy contains a cycle at "${parent.id}"`);
+    }
+    seen.add(parent.id);
+    chain.push(parent);
+    cur = parent.parentId;
+  }
+  return chain;
+}
+function objectDepths(objects) {
+  const byId = new Map(objects.map((o) => [o.id, o]));
+  const depths2 = /* @__PURE__ */ new Map();
+  for (const o of objects) {
+    if (depths2.has(o.id)) continue;
+    const pending = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cur = o;
+    while (cur && !depths2.has(cur.id)) {
+      if (seen.has(cur.id)) {
+        throw new Error(`object hierarchy contains a cycle at "${cur.id}"`);
+      }
+      seen.add(cur.id);
+      if (pending.length > MAX_HIERARCHY_DEPTH) throw depthError(o.id);
+      pending.push(cur);
+      if (cur.parentId === null) {
+        cur = void 0;
+        break;
+      }
+      const parent = byId.get(cur.parentId);
+      if (!parent) {
+        throw new Error(`object "${cur.id}" references unknown parent "${cur.parentId}"`);
+      }
+      cur = parent;
+    }
+    let base = cur ? depths2.get(cur.id) + 1 : 0;
+    for (let i = pending.length - 1; i >= 0; i--) {
+      if (base > MAX_HIERARCHY_DEPTH) throw depthError(pending[i].id);
+      depths2.set(pending[i].id, base);
+      base++;
+    }
+  }
+  return depths2;
+}
+function isObjectVisibleValue(project, id) {
+  const chain = ancestorChain(project.objects, id);
+  const self = project.objects.find((o) => o.id === id);
+  if (!self) throw new Error(`isObjectVisibleValue: unknown object id "${id}"`);
+  return chain.every((o) => o.visible) && self.visible;
+}
+
+// src/core/types.ts
+var DEFAULT_OBJECT_ID = "object-main";
+
+// src/core/editor.ts
+function uid(prefix = "") {
+  const bytes = new Uint8Array(8);
+  globalThis.crypto?.getRandomValues?.(bytes);
+  if (!bytes.some((b) => b !== 0)) {
+    const t = Date.now();
+    for (let i = 0; i < 8; i++) bytes[i] = Math.floor(t / 2 ** (i * 8) % 256) ^ i * 2654435761 >>> 0 & 255;
+  }
+  let hex = "";
+  for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+  return prefix ? `${prefix}-${hex}` : hex;
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function v3(x, y, z) {
+  return [x, y, z];
+}
+function createProject(name = "Untitled") {
+  const object = {
+    id: DEFAULT_OBJECT_ID,
+    name: DEFAULT_OBJECT_ID,
+    parentId: null,
+    visible: true,
+    locked: false
+  };
+  return { format: "pivo-plate", version: 1, name, atlases: [], objects: [object], tiles: [] };
+}
+var blankSelection = () => ({ tileIds: [], vertices: [] });
+function createSession(project) {
+  const firstAtlas = project.atlases[0];
+  const brush = firstAtlas ? { atlasId: firstAtlas.id, region: { x: firstAtlas.margin, y: firstAtlas.margin, width: firstAtlas.tileWidth, height: firstAtlas.tileHeight }, rotation: 0, flipX: false, flipY: false } : { atlasId: "blank", region: { x: 0, y: 0, width: 0, height: 0 }, rotation: 0, flipX: false, flipY: false };
+  return {
+    mode: "draw",
+    crosshair: [0, 0, 0],
+    plane: "XY",
+    planeLocked: false,
+    grid: 1,
+    tileSize: 1,
+    activeObjectId: project.objects[0]?.id ?? DEFAULT_OBJECT_ID,
+    brush,
+    selection: blankSelection()
+  };
+}
+function snap(value, grid) {
+  if (!Number.isFinite(value)) return value;
+  if (!Number.isFinite(grid) || grid <= 0) return value;
+  const snapped = Math.round(value / grid) * grid;
+  return snapped === 0 ? 0 : snapped;
+}
+function floorSnap(value, grid) {
+  if (!Number.isFinite(value)) return value;
+  if (!Number.isFinite(grid) || grid <= 0) return value;
+  const snapped = Math.floor(value / grid) * grid;
+  return snapped === 0 ? 0 : snapped;
+}
+function planePoint(point, plane, crosshair, grid) {
+  const [x, y, z] = point;
+  const px = floorSnap(x, grid);
+  const py = floorSnap(y, grid);
+  const pz = floorSnap(z, grid);
+  switch (plane) {
+    case "XY":
+      return [px, py, crosshair[2]];
+    case "XZ":
+      return [px, crosshair[1], pz];
+    case "YZ":
+      return [crosshair[0], py, pz];
+  }
+}
+function tileCorners(origin, plane, tileSize) {
+  const [x, y, z] = origin;
+  const s = tileSize;
+  switch (plane) {
+    // a=x, b=y; CCW seen from +Z
+    case "XY":
+      return [[x, y, z], [x + s, y, z], [x + s, y + s, z], [x, y + s, z]];
+    // a=z, b=x; CCW seen from +Y (faces up)
+    case "XZ":
+      return [[x, y, z], [x, y, z + s], [x + s, y, z + s], [x + s, y, z]];
+    // a=y, b=z; CCW seen from +X
+    case "YZ":
+      return [[x, y, z], [x, y + s, z], [x, y + s, z + s], [x, y, z + s]];
+  }
+}
+function validateBrushAgainstAtlas(atlas, brush) {
+  const { region } = brush;
+  if (!region || !Number.isFinite(region.x) || !Number.isFinite(region.y) || !Number.isFinite(region.width) || !Number.isFinite(region.height)) {
+    throw new Error("brush region must be finite");
+  }
+  if (!Number.isInteger(brush.rotation) || brush.rotation < 0 || brush.rotation > 3) {
+    throw new Error("brush rotation must be an integer number of quarter-turns (0..3)");
+  }
+  if (typeof brush.flipX !== "boolean" || typeof brush.flipY !== "boolean") {
+    throw new Error("brush flipX and flipY must be booleans");
+  }
+  if (region.width <= 0 || region.height <= 0) {
+    throw new Error("brush region must have positive width and height");
+  }
+  if (region.x < 0 || region.y < 0 || region.x + region.width > atlas.width || region.y + region.height > atlas.height) {
+    throw new Error(`brush region ${region.x},${region.y} ${region.width}x${region.height} is outside the ${atlas.width}x${atlas.height} atlas`);
+  }
+}
+function checkBrushRotation(rotation) {
+  if (!Number.isInteger(rotation) || rotation < 0 || rotation > 3) {
+    throw new Error("brush rotation must be an integer number of quarter-turns (0..3)");
+  }
+}
+function makeTile(project, session, origin) {
+  const objectId = session.activeObjectId;
+  const object = project.objects.find((o) => o.id === objectId);
+  if (!object) throw new Error(`makeTile: unknown active object "${objectId}"`);
+  if (isObjectLocked(project, objectId)) {
+    throw new Error("makeTile: active object is locked (ancestor lock inherited)");
+  }
+  const atlasId = session.brush.atlasId;
+  if (!project.atlases.some((a) => a.id === atlasId)) throw new Error("Import a PNG tileset before drawing");
+  if (!origin.every(Number.isFinite) || !Number.isFinite(session.tileSize) || session.tileSize <= 0) throw new Error("Tile origin and size must be finite and size must be positive");
+  checkBrushRotation(session.brush.rotation);
+  const brushAtlas = project.atlases.find((a) => a.id === atlasId);
+  if (brushAtlas) validateBrushAgainstAtlas(brushAtlas, session.brush);
+  const tile = {
+    id: uid("tile"),
+    objectId,
+    atlasId,
+    vertices: tileCorners(origin, session.plane, session.tileSize),
+    uvs: brushUVsFromSession(project, session),
+    reversed: false
+  };
+  project.tiles.push(tile);
+  return tile;
+}
+function brushUVsFromSession(project, session) {
+  const atlas = project.atlases.find((a) => a.id === session.brush.atlasId);
+  if (!atlas) {
+    return [[0, 0], [1, 0], [1, 1], [0, 1]];
+  }
+  return brushUVs(atlas, session.brush);
+}
+function brushUVs(atlas, brush) {
+  const { region, rotation, flipX, flipY } = brush;
+  const w = atlas.width || 1;
+  const h = atlas.height || 1;
+  const x0 = region.x / w, x1 = (region.x + region.width) / w;
+  const y0 = region.y / h, y1 = (region.y + region.height) / h;
+  const imgCorners = [
+    [x0, y1],
+    [x1, y1],
+    [x1, y0],
+    [x0, y0]
+  ];
+  const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+  const rotated = imgCorners.map((_, i) => [...imgCorners[(i + rotation) % 4]]);
+  const flipped = rotated.map(([px, py]) => [
+    flipX ? 2 * cx - px : px,
+    flipY ? 2 * cy - py : py
+  ]);
+  const uvs = flipped.map(([px, py]) => [px, 1 - py]);
+  return uvs;
+}
+function findObject(project, id) {
+  const object = project.objects.find((o) => o.id === id);
+  if (!object) throw new Error(`Unknown object id "${id}"`);
+  return object;
+}
+function isObjectLocked(project, id) {
+  const self = project.objects.find((o) => o.id === id);
+  if (!self) return false;
+  return [self, ...ancestorChain(project.objects, id)].some((o) => o.locked);
+}
+function isObjectVisible(project, id) {
+  const self = project.objects.find((o) => o.id === id);
+  if (!self) return false;
+  return [self, ...ancestorChain(project.objects, id)].every((o) => o.visible);
+}
+function collectDescendants(project, id) {
+  const out = /* @__PURE__ */ new Set([id]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const o of project.objects) {
+      if (o.parentId && out.has(o.parentId) && !out.has(o.id)) {
+        out.add(o.id);
+        changed = true;
+      }
+    }
+  }
+  return out;
+}
+function reparentObject(project, id, parentId) {
+  const object = findObject(project, id);
+  if (parentId === null) {
+    object.parentId = null;
+    return;
+  }
+  if (parentId === id) throw new Error("reparentObject: cannot parent an object to itself");
+  const parent = findObject(project, parentId);
+  if (collectDescendants(project, id).has(parent.id)) {
+    throw new Error("reparentObject: cycle detected (parent is a descendant of the object)");
+  }
+  object.parentId = parent.id;
+}
+function selectedCorners(project, selection) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [...selection.vertices, ...selection.tileIds.flatMap((tileId) => [0, 1, 2, 3].map((corner) => ({ tileId, corner })))];
+  for (const v of entries) {
+    const key = `${v.tileId}#${v.corner}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const tile = project.tiles.find((t) => t.id === v.tileId);
+    if (!tile) continue;
+    if (v.corner < 0 || v.corner > 3 || !Number.isInteger(v.corner)) continue;
+    out.push({ tile, corner: v.corner });
+  }
+  return out;
+}
+function editableSelectedTiles(project, selection) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of selection.tileIds) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const tile = project.tiles.find((t) => t.id === id);
+    if (!tile) continue;
+    if (isObjectLocked(project, tile.objectId)) continue;
+    out.push(tile);
+  }
+  return out;
+}
+function editableSelectedCorners(project, selection) {
+  return selectedCorners(project, selection).filter(
+    ({ tile }) => !isObjectLocked(project, tile.objectId)
+  );
+}
+function translateSelection(project, selection, delta) {
+  if (!Number.isFinite(delta[0]) || !Number.isFinite(delta[1]) || !Number.isFinite(delta[2])) {
+    throw new Error("translateSelection: delta must be finite");
+  }
+  for (const { tile, corner } of editableSelectedCorners(project, selection)) {
+    const v = tile.vertices[corner];
+    tile.vertices[corner] = [v[0] + delta[0], v[1] + delta[1], v[2] + delta[2]];
+  }
+}
+function rotateSelection(project, selection, axis, radians, pivot) {
+  if (!Number.isFinite(radians)) throw new Error("rotateSelection: radians must be finite");
+  if (!pivot.every(Number.isFinite)) throw new Error("rotateSelection: pivot must be finite");
+  const cos = Math.cos(radians), sin = Math.sin(radians);
+  for (const { tile, corner } of editableSelectedCorners(project, selection)) {
+    const [px, py, pz] = tile.vertices[corner];
+    const dx = px - pivot[0], dy = py - pivot[1], dz = pz - pivot[2];
+    let nx, ny, nz;
+    switch (axis) {
+      case "x":
+        nx = px;
+        ny = pivot[1] + dy * cos - dz * sin;
+        nz = pivot[2] + dy * sin + dz * cos;
+        break;
+      case "y":
+        ny = py;
+        nz = pivot[2] + dz * cos - dx * sin;
+        nx = pivot[0] + dz * sin + dx * cos;
+        break;
+      case "z":
+        nz = pz;
+        nx = pivot[0] + dx * cos - dy * sin;
+        ny = pivot[1] + dx * sin + dy * cos;
+        break;
+    }
+    tile.vertices[corner] = [nx, ny, nz];
+  }
+}
+function scaleSelection(project, selection, factor, pivot) {
+  if (!factor.every(Number.isFinite) || !pivot.every(Number.isFinite)) {
+    throw new Error("scaleSelection: factor and pivot must be finite");
+  }
+  for (const { tile, corner } of editableSelectedCorners(project, selection)) {
+    const [px, py, pz] = tile.vertices[corner];
+    tile.vertices[corner] = [
+      pivot[0] + (px - pivot[0]) * factor[0],
+      pivot[1] + (py - pivot[1]) * factor[1],
+      pivot[2] + (pz - pivot[2]) * factor[2]
+    ];
+  }
+}
+function duplicateSelection(project, selection, delta) {
+  if (!delta.every(Number.isFinite)) throw new Error("duplicateSelection: delta must be finite");
+  const newIds = [];
+  for (const tile of editableSelectedTiles(project, selection)) {
+    const copy = {
+      ...clone(tile),
+      id: uid("tile"),
+      vertices: tile.vertices.map(([x, y, z]) => [x + delta[0], y + delta[1], z + delta[2]]),
+      uvs: clone(tile.uvs)
+    };
+    project.tiles.push(copy);
+    newIds.push(copy.id);
+  }
+  return newIds;
+}
+function deleteSelection(project, selection) {
+  const requested = new Set(selection.tileIds);
+  if (requested.size === 0) {
+    if (selection.vertices.length > 0) {
+      throw new Error("deleteSelection: corner-only selection cannot delete tiles");
+    }
+    return;
+  }
+  const deletable = new Set(
+    editableSelectedTiles(project, selection).map((t) => t.id)
+  );
+  if (deletable.size === 0 && requested.size > 0) {
+    const anyReal = selection.tileIds.some((id) => project.tiles.some((t) => t.id === id));
+    if (anyReal) throw new Error("deleteSelection: selected tiles are locked");
+  }
+  project.tiles = project.tiles.filter((t) => !deletable.has(t.id));
+}
+function reverseSelection(project, selection) {
+  for (const tile of editableSelectedTiles(project, selection)) {
+    tile.reversed = !tile.reversed;
+  }
+}
+function applyBrush(project, selection, brush) {
+  const atlas = project.atlases.find((a) => a.id === brush.atlasId);
+  if (!atlas) throw new Error(`applyBrush: unknown atlas "${brush.atlasId}"`);
+  validateBrushAgainstAtlas(atlas, brush);
+  const uvs = brushUVs(atlas, brush);
+  for (const tile of editableSelectedTiles(project, selection)) {
+    tile.atlasId = brush.atlasId;
+    tile.uvs = clone(uvs);
+  }
+}
+var UV_TOLERANCE = 1e-6;
+function checkUvInRange(tileId, uv) {
+  const [u, v] = uv;
+  if (u < -UV_TOLERANCE || u > 1 + UV_TOLERANCE || v < -UV_TOLERANCE || v > 1 + UV_TOLERANCE) {
+    throw new Error(`Tile "${tileId}" has UVs outside the 0..1 range`);
+  }
+}
+function normalizeUv(uv) {
+  return [
+    Math.min(1, Math.max(0, uv[0])),
+    Math.min(1, Math.max(0, uv[1]))
+  ];
+}
+function transformUVs(project, selection, operation, offset) {
+  if (offset !== void 0 && (!Number.isFinite(offset[0]) || !Number.isFinite(offset[1]))) {
+    throw new Error("transformUVs: offset must be finite");
+  }
+  const editable = editableSelectedTiles(project, selection);
+  const computed = [];
+  for (const tile of editable) {
+    const uvs = tile.uvs;
+    const cu = (uvs[0][0] + uvs[1][0] + uvs[2][0] + uvs[3][0]) / 4;
+    const cv = (uvs[0][1] + uvs[1][1] + uvs[2][1] + uvs[3][1]) / 4;
+    const moved = operation === "rotate" ? uvs.map((_, i) => [...uvs[(i + 1) % 4]]) : uvs.map(([u, v]) => {
+      let nu = u, nv = v;
+      switch (operation) {
+        case "flipX":
+          nu = 2 * cu - u;
+          break;
+        case "flipY":
+          nv = 2 * cv - v;
+          break;
+      }
+      return [nu, nv];
+    });
+    const withOffset = offset ? moved.map(([u, v]) => [u + offset[0], v + offset[1]]) : moved;
+    computed.push({ tile, uvs: withOffset });
+  }
+  for (const { tile, uvs: next } of computed) {
+    tile.uvs = next;
+  }
+}
+var MAX_ATLASES = 4095;
+var MAX_OBJECTS = 1e5;
+var MAX_TILES = 1e6;
+var MAX_NAME = 4096;
+var MAX_DATAURL = 64 * 1024 * 1024;
+var MAX_INT = Number.MAX_SAFE_INTEGER;
+var ATLAS_ID_PATTERN = /^[A-Za-z0-9_.-]{1,128}$/;
+var ValidationError = class extends Error {
+};
+function fail2(msg) {
+  throw new ValidationError(msg);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function checkFinite(name, v) {
+  if (typeof v !== "number" || !Number.isFinite(v)) fail2(`${name} must be a finite number`);
+  return v;
+}
+function checkNonNegInt(name, v) {
+  if (typeof v !== "number" || !Number.isInteger(v) || v < 0) fail2(`${name} must be a non-negative integer`);
+  return v;
+}
+function checkString(name, v, maxLen = MAX_NAME) {
+  if (typeof v !== "string") fail2(`${name} must be a string`);
+  if (v.length > maxLen) fail2(`${name} exceeds maximum length`);
+  return v;
+}
+function checkName(name, v, maxLen = MAX_NAME) {
+  const s = checkString(name, v, maxLen);
+  if (s.length === 0) fail2(`${name} must be a non-empty string`);
+  return s;
+}
+function checkId(name, v) {
+  const s = checkString(name, v, 512);
+  if (s.length === 0) fail2(`${name} must be non-empty`);
+  return s;
+}
+function checkPngDataUrl(name, v) {
+  try {
+    preflightPngDataUrl(v);
+  } catch (error) {
+    fail2(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return v;
+}
+function validateProject(value) {
+  if (!isPlainObject(value)) fail2("project must be an object");
+  if (value["format"] !== "pivo-plate") fail2('project.format must be "pivo-plate"');
+  if (value["version"] !== 1) fail2("project.version must be 1");
+  const name = checkName("project.name", value["name"]);
+  if (!Array.isArray(value["atlases"])) fail2("project.atlases must be an array");
+  if (!Array.isArray(value["objects"])) fail2("project.objects must be an array");
+  if (!Array.isArray(value["tiles"])) fail2("project.tiles must be an array");
+  const atlasesRaw = value["atlases"];
+  const objectsRaw = value["objects"];
+  const tilesRaw = value["tiles"];
+  if (atlasesRaw.length > MAX_ATLASES) fail2("too many atlases");
+  if (objectsRaw.length > MAX_OBJECTS) fail2("too many objects");
+  if (tilesRaw.length > MAX_TILES) fail2("too many tiles");
+  const atlases = atlasesRaw.map((a, i) => {
+    if (!isPlainObject(a)) fail2(`atlases[${i}] must be an object`);
+    const atlasId = checkId(`atlases[${i}].id`, a["id"]);
+    if (!ATLAS_ID_PATTERN.test(atlasId)) {
+      fail2(`atlases[${i}].id "${atlasId}" may only contain letters, digits, dot, underscore and dash (1..128 chars)`);
+    }
+    return {
+      id: atlasId,
+      name: checkName(`atlases[${i}].name`, a["name"]),
+      width: checkNonNegInt(`atlases[${i}].width`, a["width"]),
+      height: checkNonNegInt(`atlases[${i}].height`, a["height"]),
+      tileWidth: checkNonNegInt(`atlases[${i}].tileWidth`, a["tileWidth"]),
+      tileHeight: checkNonNegInt(`atlases[${i}].tileHeight`, a["tileHeight"]),
+      margin: checkNonNegInt(`atlases[${i}].margin`, a["margin"]),
+      spacing: checkNonNegInt(`atlases[${i}].spacing`, a["spacing"]),
+      dataUrl: checkPngDataUrl(`atlases[${i}].dataUrl`, checkString(`atlases[${i}].dataUrl`, a["dataUrl"], MAX_DATAURL))
+    };
+  });
+  const pngHeaders = atlases.map((a) => preflightPngDataUrl(a.dataUrl, { width: a.width, height: a.height }));
+  checkProjectPngBudget(pngHeaders, 0);
+  for (const a of atlases) {
+    if (a.width < 1 || a.height < 1 || a.width > 16384 || a.height > 16384 || a.width * a.height > 16777216) fail2("Atlas dimensions must be between 1 and 16384");
+    if (a.tileWidth < 1 || a.tileHeight < 1 || a.tileWidth > a.width || a.tileHeight > a.height) fail2("Atlas tile dimensions must be positive and fit the image");
+    if (a.margin * 2 + a.tileWidth > a.width || a.margin * 2 + a.tileHeight > a.height) fail2("Atlas margin leaves no complete cell");
+  }
+  const objects = objectsRaw.map((o, i) => {
+    if (!isPlainObject(o)) fail2(`objects[${i}] must be an object`);
+    const visible = o["visible"], locked = o["locked"];
+    if (typeof visible !== "boolean") fail2(`objects[${i}].visible must be a boolean`);
+    if (typeof locked !== "boolean") fail2(`objects[${i}].locked must be a boolean`);
+    const parentRaw = o["parentId"];
+    if (parentRaw !== null && typeof parentRaw !== "string") fail2(`objects[${i}].parentId must be a string or null`);
+    return {
+      id: checkId(`objects[${i}].id`, o["id"]),
+      name: checkName(`objects[${i}].name`, o["name"]),
+      parentId: parentRaw === null ? null : checkId(`objects[${i}].parentId`, parentRaw),
+      visible,
+      locked
+    };
+  });
+  const objectIds = new Set(objects.map((o) => o.id));
+  const objectById = new Map(objects.map((o) => [o.id, o]));
+  for (const o of objects) {
+    if (o.parentId === o.id) fail2(`object "${o.id}" cannot be its own parent`);
+    if (o.parentId !== null && !objectIds.has(o.parentId)) fail2(`object "${o.id}" has unknown parentId "${o.parentId}"`);
+  }
+  const depthCache = objectDepths(objects);
+  for (const o of objects) {
+    const d = depthCache.get(o.id);
+    if (d === void 0) fail2(`object "${o.id}" could not be placed in the hierarchy`);
+    if (d > MAX_HIERARCHY_DEPTH) fail2(`object "${o.id}" is in a parenting cycle or exceeds the maximum hierarchy depth of ${MAX_HIERARCHY_DEPTH}`);
+  }
+  const objectHasAtlas = /* @__PURE__ */ new Map();
+  const tiles = tilesRaw.map((t, i) => {
+    if (!isPlainObject(t)) fail2(`tiles[${i}] must be an object`);
+    const tileId = checkId(`tiles[${i}].id`, t["id"]);
+    const objectId = checkId(`tiles[${i}].objectId`, t["objectId"]);
+    if (!objectIds.has(objectId)) fail2(`tiles[${i}] references unknown objectId "${objectId}"`);
+    const atlasId = checkId(`tiles[${i}].atlasId`, t["atlasId"]);
+    const vertsRaw = t["vertices"];
+    if (!Array.isArray(vertsRaw) || vertsRaw.length !== 4) fail2(`tiles[${i}].vertices must be an array of 4 corners`);
+    const vertices = vertsRaw.map((v, j) => {
+      if (!Array.isArray(v) || v.length !== 3) fail2(`tiles[${i}].vertices[${j}] must be [x,y,z]`);
+      return [
+        checkFinite(`tiles[${i}].vertices[${j}].x`, v[0]),
+        checkFinite(`tiles[${i}].vertices[${j}].y`, v[1]),
+        checkFinite(`tiles[${i}].vertices[${j}].z`, v[2])
+      ];
+    });
+    for (const [vx, vy, vz] of vertices) {
+      if (Math.abs(vx) > MAX_INT || Math.abs(vy) > MAX_INT || Math.abs(vz) > MAX_INT) {
+        fail2(`tiles[${i}] has coordinates beyond safe integer range`);
+      }
+    }
+    const uvsRaw = t["uvs"];
+    if (!Array.isArray(uvsRaw) || uvsRaw.length !== 4) fail2(`tiles[${i}].uvs must be an array of 4 pairs`);
+    const uvs = uvsRaw.map((u, j) => {
+      if (!Array.isArray(u) || u.length !== 2) fail2(`tiles[${i}].uvs[${j}] must be [u,v]`);
+      const uv = [
+        checkFinite(`tiles[${i}].uvs[${j}].u`, u[0]),
+        checkFinite(`tiles[${i}].uvs[${j}].v`, u[1])
+      ];
+      checkUvInRange(tileId, uv);
+      return normalizeUv(uv);
+    });
+    if (typeof t["reversed"] !== "boolean") fail2(`tiles[${i}].reversed must be a boolean`);
+    if (!objectHasAtlas.has(objectId)) objectHasAtlas.set(objectId, /* @__PURE__ */ new Set());
+    return {
+      id: tileId,
+      objectId,
+      atlasId,
+      vertices,
+      uvs,
+      reversed: t["reversed"]
+    };
+  });
+  const tileIds = /* @__PURE__ */ new Set();
+  for (const t of tiles) {
+    if (tileIds.has(t.id)) fail2(`duplicate tile id "${t.id}"`);
+    tileIds.add(t.id);
+  }
+  const atlasIds = /* @__PURE__ */ new Set();
+  for (const a of atlases) {
+    if (atlasIds.has(a.id)) fail2(`duplicate atlas id "${a.id}"`);
+    atlasIds.add(a.id);
+  }
+  const objIdSet = /* @__PURE__ */ new Set();
+  for (const o of objects) {
+    if (objIdSet.has(o.id)) fail2(`duplicate object id "${o.id}"`);
+    objIdSet.add(o.id);
+  }
+  for (const t of tiles) {
+    if (!atlasIds.has(t.atlasId)) fail2(`tile "${t.id}" references unknown atlasId "${t.atlasId}"`);
+  }
+  const project = { format: "pivo-plate", version: 1, name, atlases, objects, tiles };
+  const manifest = { ...project, atlases: atlases.map((a) => ({ ...a, dataUrl: "" })) };
+  const manifestBytes = new TextEncoder().encode(JSON.stringify(manifest, null, 2)).length;
+  checkProjectPngBudget(pngHeaders, manifestBytes);
+  atlases.forEach((a) => validatePngDataUrl(a.dataUrl, { width: a.width, height: a.height }));
+  return project;
+}
+var MAX_HISTORY = 64;
+var EditorStore = class {
+  constructor(project, historyBudget = 128 * 1024 * 1024) {
+    this.historyBudget = historyBudget;
+    if (!Number.isFinite(historyBudget) || historyBudget < 1) throw new Error("History byte budget must be positive");
+    const validated = validateProject(project);
+    this._project = clone(validated);
+    this._savedSnapshot = JSON.stringify(this._project);
+  }
+  historyBudget;
+  _project;
+  _undoStack = [];
+  _redoStack = [];
+  _label = "";
+  _revision = 0;
+  _savedSnapshot = "";
+  _listeners = /* @__PURE__ */ new Set();
+  historyCosts = /* @__PURE__ */ new WeakMap();
+  get project() {
+    return this._project;
+  }
+  get canUndo() {
+    return this._undoStack.length > 0;
+  }
+  get canRedo() {
+    return this._redoStack.length > 0;
+  }
+  /** Label of the most recent committed transaction ('' if none yet). */
+  get historyLabel() {
+    return this._label;
+  }
+  /** Monotonically increasing counter bumped on every state change. */
+  get revision() {
+    return this._revision;
+  }
+  /** Semantic dirty flag: current state differs from last saved state. */
+  get dirty() {
+    return JSON.stringify(this._project) !== this._savedSnapshot;
+  }
+  subscribe(fn) {
+    this._listeners.add(fn);
+    return () => this._listeners.delete(fn);
+  }
+  emit() {
+    for (const fn of this._listeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }
+  pushHistory(label, before) {
+    this._undoStack.push(before);
+    this._redoStack = [];
+    while (this._undoStack.length > MAX_HISTORY || this.retainedHistoryBytes > this.historyBudget && this._undoStack.length > 1) this._undoStack.shift();
+    this._label = label;
+  }
+  get retainedHistoryBytes() {
+    return [...this._undoStack, ...this._redoStack].reduce((bytes, p) => {
+      let cost = this.historyCosts.get(p);
+      if (cost === void 0) {
+        cost = JSON.stringify(p).length * 2;
+        this.historyCosts.set(p, cost);
+      }
+      return bytes + cost;
+    }, 0);
+  }
+  /**
+   * Run a synchronous mutation. The callback receives a working draft; the
+   * raw draft is validated with the canonical validator BEFORE publication
+   * and before JSON cloning could mask NaN/Infinity (which stringify to
+   * null). On validation failure or throw, state, revision, history, redo
+   * and dirty state are untouched. The committed project is re-cloned so no
+   * retained reference to the draft (including a callback that keeps mutating
+   * asynchronously after rejection or resolution) can alias committed state.
+   */
+  transact(label, fn) {
+    const before = clone(this._project);
+    const working = clone(this._project);
+    try {
+      const result = fn(working);
+      if (result !== null && (typeof result === "object" || typeof result === "function") && typeof result.then === "function") {
+        void Promise.resolve(result).catch(() => {
+        });
+        throw new Error("EditorStore transactions must be synchronous");
+      }
+    } catch (err) {
+      void err;
+      throw err;
+    }
+    let validated;
+    try {
+      validated = validateProject(working);
+    } catch (err) {
+      throw err instanceof Error ? err : new Error(String(err));
+    }
+    const beforeJson = JSON.stringify(before);
+    const workingJson = JSON.stringify(validated);
+    if (beforeJson === workingJson) {
+      return;
+    }
+    this._project = validated;
+    this.pushHistory(label, before);
+    this._revision++;
+    this.emit();
+  }
+  undo() {
+    const prev = this._undoStack.pop();
+    if (!prev) return;
+    this._redoStack.push(this._project);
+    this._project = prev;
+    this._revision++;
+    this.emit();
+  }
+  redo() {
+    const next = this._redoStack.pop();
+    if (!next) return;
+    this._undoStack.push(this._project);
+    this._project = next;
+    this._revision++;
+    this.emit();
+  }
+  /** Replace the whole project (e.g. load). Validates BEFORE replacing the
+   * current project: on invalid input the existing state, history, revision
+   * and dirty flags are untouched. Clears undo/redo history on success. */
+  replace(project) {
+    const validated = validateProject(project);
+    this._project = clone(validated);
+    this._undoStack = [];
+    this._redoStack = [];
+    this._revision++;
+    this.emit();
+  }
+  /** Mark the snapshot actually downloaded; edits during a save stay dirty. */
+  markSaved(snapshot = this._project) {
+    this._savedSnapshot = JSON.stringify(validateProject(snapshot));
+    this.emit();
+  }
+};
+
+export {
+  PNG_LIMITS,
+  PROJECT_PNG_LIMITS,
+  validatePngBytes,
+  pngDataUrlBytes,
+  pngBytesDataUrl,
+  validatePngDataUrl,
+  MAX_HIERARCHY_DEPTH,
+  isObjectVisibleValue,
+  uid,
+  clone,
+  v3,
+  createProject,
+  createSession,
+  snap,
+  planePoint,
+  tileCorners,
+  validateBrushAgainstAtlas,
+  makeTile,
+  brushUVs,
+  isObjectLocked,
+  isObjectVisible,
+  reparentObject,
+  selectedCorners,
+  translateSelection,
+  rotateSelection,
+  scaleSelection,
+  duplicateSelection,
+  deleteSelection,
+  reverseSelection,
+  applyBrush,
+  UV_TOLERANCE,
+  checkUvInRange,
+  normalizeUv,
+  transformUVs,
+  validateProject,
+  EditorStore
+};