@bookklik/pivo-plate 0.0.0-stage → 0.2.1

package/lib/chunks/chunk-ZZLZL64O.js

@@ -0,0 +1,664 @@
+import {
+  PNG_LIMITS,
+  PROJECT_PNG_LIMITS,
+  isObjectVisibleValue,
+  pngBytesDataUrl,
+  pngCrc32,
+  pngDataUrlBytes,
+  validatePngBytes,
+  validatePngDataUrl,
+  validateProject
+} from "./chunk-PPDBMDTW.js";
+
+// src/io/util.ts
+import { zipSync, unzipSync, strFromU8, strToU8 } from "fflate";
+var ProjectIOError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectIOError";
+  }
+};
+var ContainerError = class extends ProjectIOError {
+  constructor(message) {
+    super(message);
+    this.name = "ContainerError";
+  }
+};
+var PayloadError = class extends ProjectIOError {
+  constructor(message) {
+    super(message);
+    this.name = "PayloadError";
+  }
+};
+var ExportError = class extends ProjectIOError {
+  constructor(message) {
+    super(message);
+    this.name = "ExportError";
+  }
+};
+var LIMITS = {
+  /** Hard cap on decompressed archive size (defends against zip bombs). */
+  maxUncompressed: 128 * 1024 * 1024,
+  // 128 MiB total
+  /** Cap per stored file after decompression. */
+  maxFileBytes: 96 * 1024 * 1024,
+  /** Cap on number of files in a container. */
+  maxEntries: 4096,
+  /** Cap on the compressed input size accepted by decodeProject. */
+  maxCompressed: 96 * 1024 * 1024,
+  /** dataURL→PNG conversion limit (embedded textures). */
+  maxDataUrlLength: 64 * 1024 * 1024,
+  /** Guard while resolving world-space vertices into typed arrays. */
+  maxWorldCoord: 1e6
+};
+function dataUrlToBytes(dataUrl) {
+  try {
+    const bytes = pngDataUrlBytes(dataUrl);
+    validatePngBytes(bytes);
+    return { bytes, mime: "image/png" };
+  } catch (error) {
+    throw new PayloadError(error instanceof Error ? error.message : String(error));
+  }
+}
+function bytesToDataUrl(bytes, mime = "image/png") {
+  if (mime !== "image/png") throw new PayloadError("Only PNG texture data URLs are supported");
+  try {
+    validatePngBytes(bytes);
+    return pngBytesDataUrl(bytes);
+  } catch (error) {
+    throw new PayloadError(error instanceof Error ? error.message : String(error));
+  }
+}
+var ENTRY_PROJECT = "project.json";
+var ATLAS_PREFIX = "atlases/";
+var ATLAS_SUFFIX = ".png";
+function safeEntryPath(path) {
+  if (typeof path !== "string" || path.length === 0 || path.length > 256) return null;
+  if (path !== ENTRY_PROJECT) {
+    if (!path.startsWith(ATLAS_PREFIX) || !path.endsWith(ATLAS_SUFFIX)) return null;
+    const id = path.slice(ATLAS_PREFIX.length, path.length - ATLAS_SUFFIX.length);
+    if (!/^[A-Za-z0-9_.-]{1,128}$/.test(id)) return null;
+  }
+  return path;
+}
+function buildContainer(projectJson, textures) {
+  const files = {};
+  files[ENTRY_PROJECT] = strToU8(projectJson);
+  if (textures.length + 1 > LIMITS.maxEntries || files[ENTRY_PROJECT].length > PROJECT_PNG_LIMITS.maxManifestBytes) throw new ContainerError("Project encoding exceeds manifest/entry budget");
+  let total = files[ENTRY_PROJECT].length;
+  for (const t of textures) {
+    const path = safeEntryPath(t.path);
+    if (!path) throw new ContainerError(`Refusing to store unexpected texture path "${t.path}"`);
+    total += t.bytes.length;
+    if (t.bytes.length > PNG_LIMITS.maxBytes || total > LIMITS.maxUncompressed) throw new ContainerError("Project encoding exceeds texture/archive budget");
+    files[path] = t.bytes;
+  }
+  const bytes = zipSync(files, { level: 6 });
+  if (bytes.length > LIMITS.maxCompressed) throw new ContainerError("Encoded project exceeds compressed archive budget");
+  return bytes;
+}
+function inspectZip(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let end = -1;
+  for (let offset = bytes.length - 22; offset >= Math.max(0, bytes.length - 65557); offset--) {
+    if (view.getUint32(offset, true) === 101010256 && offset + 22 + view.getUint16(offset + 20, true) === bytes.length) {
+      end = offset;
+      break;
+    }
+  }
+  if (end < 0) throw new ContainerError("Missing ZIP directory");
+  const count = view.getUint16(end + 10, true);
+  const centralSize = view.getUint32(end + 12, true);
+  const centralOffset = view.getUint32(end + 16, true);
+  if (count > LIMITS.maxEntries) throw new ContainerError("Project archive contains too many files");
+  if (view.getUint16(end + 4, true) !== 0 || view.getUint16(end + 6, true) !== 0 || view.getUint16(end + 8, true) !== count || centralOffset + centralSize !== end) {
+    throw new ContainerError("Unsupported or inconsistent ZIP directory");
+  }
+  const directory = /* @__PURE__ */ new Map();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let position = centralOffset;
+  for (let index = 0; index < count; index++) {
+    if (position + 46 > end || view.getUint32(position, true) !== 33639248) throw new ContainerError("Invalid ZIP directory entry");
+    const flags = view.getUint16(position + 8, true);
+    const method = view.getUint16(position + 10, true);
+    const crc = view.getUint32(position + 16, true);
+    const packed = view.getUint32(position + 20, true);
+    const size = view.getUint32(position + 24, true);
+    const nameLength = view.getUint16(position + 28, true);
+    const next = position + 46 + nameLength + view.getUint16(position + 30, true) + view.getUint16(position + 32, true);
+    const local = view.getUint32(position + 42, true);
+    if (next > end || local + 30 > centralOffset || view.getUint16(position + 34, true) !== 0 || (flags & 1) !== 0 || method !== 0 && method !== 8) throw new ContainerError("Unsupported ZIP entry");
+    const name = decoder.decode(bytes.subarray(position + 46, position + 46 + nameLength));
+    if (!safeEntryPath(name)) throw new ContainerError(`Project archive contains a disallowed path "${name}" (expected project.json or atlases/<id>.png)`);
+    if (directory.has(name)) throw new ContainerError("Duplicate ZIP entry");
+    if (view.getUint32(local, true) !== 67324752 || view.getUint16(local + 6, true) !== flags || view.getUint16(local + 8, true) !== method) throw new ContainerError("Inconsistent ZIP local header");
+    const localNameLength = view.getUint16(local + 26, true);
+    const start = local + 30 + localNameLength + view.getUint16(local + 28, true);
+    if (start + packed > centralOffset || decoder.decode(bytes.subarray(local + 30, local + 30 + localNameLength)) !== name) throw new ContainerError("Inconsistent ZIP payload");
+    if ((flags & 8) === 0 && (view.getUint32(local + 14, true) !== crc || view.getUint32(local + 18, true) !== packed || view.getUint32(local + 22, true) !== size)) throw new ContainerError("Inconsistent ZIP entry sizes or checksum");
+    directory.set(name, { size, crc });
+    position = next;
+  }
+  if (position !== end) throw new ContainerError("ZIP directory count mismatch");
+  return directory;
+}
+function openContainer(bytes) {
+  if (!(bytes instanceof Uint8Array) || bytes.length === 0) {
+    throw new ContainerError("Project file is empty or unreadable");
+  }
+  if (bytes.length > LIMITS.maxCompressed) {
+    throw new ContainerError("Project file is too large to open");
+  }
+  let raw;
+  let declaredTotal = 0, entryCount = 0;
+  const seen = /* @__PURE__ */ new Set();
+  let directory;
+  try {
+    directory = inspectZip(bytes);
+    raw = unzipSync(bytes, {
+      filter: (file) => {
+        if (++entryCount > LIMITS.maxEntries) throw new ContainerError("Project archive contains too many files");
+        if (file.name === ENTRY_PROJECT && file.originalSize > PROJECT_PNG_LIMITS.maxManifestBytes) throw new ContainerError("Project manifest exceeds byte budget");
+        if (file.name.startsWith("atlases/") && file.originalSize > PNG_LIMITS.maxBytes) throw new ContainerError("PNG archive entry exceeds byte budget");
+        if (file.originalSize > LIMITS.maxFileBytes) throw new ContainerError("Archive entry exceeds maximum file size");
+        declaredTotal += file.originalSize;
+        if (declaredTotal > LIMITS.maxUncompressed) throw new ContainerError("Project archive decompresses to an unreasonably large size");
+        if (!safeEntryPath(file.name)) throw new ContainerError(`Project archive contains a disallowed path "${file.name}"`);
+        if (seen.has(file.name)) throw new ContainerError("Duplicate ZIP entry");
+        seen.add(file.name);
+        return true;
+      }
+    });
+  } catch (err) {
+    throw new ContainerError(
+      `Not a valid .pvp project archive (corrupt or unsupported ZIP): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const names = Object.keys(raw);
+  if (names.length !== directory.size) throw new ContainerError("ZIP entry inventory mismatch");
+  for (const name of names) {
+    const expected = directory.get(name);
+    if (!expected || raw[name].length !== expected.size || pngCrc32(raw[name]) !== expected.crc) throw new ContainerError("ZIP entry size or checksum mismatch");
+  }
+  if (names.length === 0) {
+    throw new ContainerError("Project archive contains no files");
+  }
+  if (names.length > LIMITS.maxEntries) {
+    throw new ContainerError("Project archive contains too many files");
+  }
+  let total = 0;
+  const textures = /* @__PURE__ */ new Map();
+  let projectJson;
+  for (const name of names) {
+    const clean = name.replace(/\/+$/, "");
+    if (clean !== name && clean.length === 0) continue;
+    const safe = safeEntryPath(clean);
+    if (!safe) {
+      throw new ContainerError(
+        `Project archive contains a disallowed path "${name}" (expected project.json or atlases/<id>.png)`
+      );
+    }
+    const data = raw[name];
+    if (!data || data.length === 0) {
+      throw new ContainerError(`Project archive entry "${safe}" is empty`);
+    }
+    if (data.length > LIMITS.maxFileBytes) {
+      throw new ContainerError(`Project archive entry "${safe}" exceeds the maximum file size`);
+    }
+    total += data.length;
+    if (total > LIMITS.maxUncompressed) {
+      throw new ContainerError("Project archive decompresses to an unreasonably large size");
+    }
+    if (safe === ENTRY_PROJECT) {
+      projectJson = strFromU8(data);
+    } else {
+      const id = safe.slice(ATLAS_PREFIX.length, safe.length - ATLAS_SUFFIX.length);
+      try {
+        validatePngBytes(data);
+      } catch (error) {
+        throw new ContainerError(`Texture "${safe}" is not a valid PNG image: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      textures.set(id, data);
+    }
+  }
+  if (projectJson === void 0) {
+    throw new ContainerError("Project archive is missing project.json");
+  }
+  return { projectJson, textures };
+}
+
+// src/io/validate.ts
+function validateProjectValue(value) {
+  try {
+    return validateProject(value);
+  } catch (err) {
+    throw new PayloadError(err instanceof Error ? err.message : String(err));
+  }
+}
+function isObjectVisibleValue2(project, id) {
+  try {
+    return isObjectVisibleValue(project, id);
+  } catch (err) {
+    throw new PayloadError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/io/container.ts
+async function encodeProject(project) {
+  const safe = validateProjectValue(project);
+  const textures = [];
+  for (const atlas of safe.atlases) {
+    const { bytes } = dataUrlToBytes(atlas.dataUrl);
+    textures.push({ path: `atlases/${atlas.id}.png`, bytes });
+  }
+  const stored = {
+    ...safe,
+    atlases: safe.atlases.map((a) => ({ ...a, dataUrl: "" }))
+  };
+  const json = JSON.stringify(stored, null, 2);
+  return buildContainer(json, textures);
+}
+async function decodeProject(bytes) {
+  const { projectJson, textures } = openContainer(bytes);
+  let parsed;
+  try {
+    parsed = JSON.parse(projectJson);
+  } catch (err) {
+    throw new PayloadError(
+      `project.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new PayloadError("project.json must contain a JSON object");
+  }
+  const doc = parsed;
+  if (!Array.isArray(doc.atlases)) {
+    throw new PayloadError("project.json must contain an atlases array");
+  }
+  const withTextures = {
+    ...doc,
+    atlases: doc.atlases.map((raw) => {
+      if (!raw || typeof raw !== "object") return raw;
+      const a = raw;
+      if (typeof a.id !== "string") return raw;
+      const png = textures.get(a.id);
+      if (!png) {
+        throw new PayloadError(`Project archive is missing the texture for atlas "${a.id}"`);
+      }
+      return { ...a, dataUrl: bytesToDataUrl(png, "image/png") };
+    })
+  };
+  return validateProjectValue(withTextures);
+}
+
+// src/io/export.ts
+import { strToU8 as strToU82, zipSync as zipSync2 } from "fflate";
+
+// src/core/geometry.ts
+function cross(a, b, c) {
+  const u = b.map((n, i) => n - a[i]), v = c.map((n, i) => n - a[i]);
+  return [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+}
+function normalize(v) {
+  const length = Math.hypot(...v);
+  if (!length || !Number.isFinite(length)) return [0, 0, 0];
+  return v.map((n) => n === 0 ? 0 : n / length);
+}
+function tileCornerNormals(tile) {
+  const [a, b, c, d] = tile.vertices;
+  const first = cross(a, b, c), second = cross(a, c, d);
+  const sum = first.map((n, i) => n + second[i]);
+  const shared = Math.hypot(...sum) > 0 ? sum : Math.hypot(...first) > 0 ? first : second;
+  const sign = tile.reversed ? -1 : 1;
+  const signed = (v) => normalize(v).map((n) => n === 0 ? 0 : n * sign);
+  return [signed(shared), signed(first), signed(shared), signed(second)];
+}
+
+// src/io/geometry.ts
+function assertExportGeometry(tiles) {
+  for (const t of tiles) {
+    for (const [a, b, c] of [[0, 1, 2], [0, 2, 3]]) {
+      const p = t.vertices[a], q = t.vertices[b], r = t.vertices[c];
+      const u = q.map((v2, i) => v2 - p[i]), v = r.map((n, i) => n - p[i]);
+      const area = Math.hypot(u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]);
+      if (!Number.isFinite(area) || area < 1e-12) throw new ExportError(`Tile ${t.id} has a degenerate triangle; edit or delete it before exporting`);
+    }
+  }
+}
+
+// src/io/alpha.ts
+async function inspectAlpha(project) {
+  const result = /* @__PURE__ */ new Map();
+  const used = new Set(project.tiles.map((tile) => tile.atlasId));
+  for (const atlas of project.atlases.filter((atlas2) => used.has(atlas2.id))) {
+    const info = validatePngDataUrl(atlas.dataUrl, { width: atlas.width, height: atlas.height });
+    if (!info.alphaMode) throw new Error("PNG alpha inspection did not complete");
+    result.set(atlas.id, info.alphaMode);
+  }
+  return result;
+}
+
+// src/io/gltf.ts
+var ALIGN = 4;
+function padTo(n, align = ALIGN) {
+  return Math.ceil(n / align) * align;
+}
+function buildGlb(project, blendAtlasIds) {
+  const safe = validateProjectValue(project);
+  const visibleTiles = safe.tiles.filter((t) => isObjectVisibleValue2(safe, t.objectId));
+  if (visibleTiles.length === 0) {
+    throw new ExportError("Nothing to export: the project has no visible tiles");
+  }
+  assertExportGeometry(visibleTiles);
+  const atlasById = new Map(safe.atlases.map((a) => [a.id, a]));
+  for (const t of visibleTiles) {
+    if (!atlasById.has(t.atlasId)) {
+      throw new ExportError(`Tile "${t.id}" references atlas "${t.atlasId}" which does not exist`);
+    }
+  }
+  const chunks = [];
+  let bufferLength = 0;
+  const push = (bytes) => {
+    const aligned = padTo(bytes.byteLength);
+    chunks.push(bytes, new Uint8Array(aligned - bytes.byteLength));
+    bufferLength += aligned;
+  };
+  const byAtlas = /* @__PURE__ */ new Map();
+  for (const t of visibleTiles) {
+    const list = byAtlas.get(t.atlasId) ?? [];
+    list.push(t);
+    byAtlas.set(t.atlasId, list);
+  }
+  const bufferViews = [];
+  const accessors = [];
+  const images = [];
+  const materials = [];
+  const textures = [];
+  const samplers = [{ magFilter: 9728, minFilter: 9728, wrapS: 33071, wrapT: 33071 }];
+  const meshes = [];
+  const usedAlphaBlend = /* @__PURE__ */ new Set();
+  const bv = (bytes, target) => {
+    const byteOffset = bufferLength;
+    push(bytes);
+    const view = target ? { buffer: 0, byteOffset, byteLength: bytes.byteLength, target } : { buffer: 0, byteOffset, byteLength: bytes.byteLength };
+    bufferViews.push(view);
+    return bufferViews.length - 1;
+  };
+  const reserveBv = (byteLength) => {
+    const byteOffset = bufferLength;
+    const chunkIndex = chunks.length;
+    chunks.push(new Uint8Array(0));
+    chunks.push(new Uint8Array(padTo(byteLength)));
+    bufferLength += padTo(byteLength);
+    const view = { buffer: 0, byteOffset, byteLength };
+    bufferViews.push(view);
+    return { index: bufferViews.length - 1, chunkIndex };
+  };
+  const sortedAtlasIds = [...byAtlas.keys()].sort();
+  const deferredImages = [];
+  for (const atlasId of sortedAtlasIds) {
+    const atlas = atlasById.get(atlasId);
+    const { bytes } = dataUrlToBytes(atlas.dataUrl);
+    const { index, chunkIndex } = reserveBv(bytes.byteLength);
+    deferredImages.push({ chunkIndex, bytes });
+    images.push({ bufferView: index, mimeType: "image/png" });
+    textures.push({ sampler: 0, source: images.length - 1 });
+  }
+  const prims = [];
+  sortedAtlasIds.forEach((atlasId, primIndex) => {
+    const tiles = byAtlas.get(atlasId);
+    const atlas = atlasById.get(atlasId);
+    const pos = [];
+    const uv = [];
+    const nrm = [];
+    const idx = [];
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const tile of tiles) {
+      const base = pos.length / 3;
+      const verts = tileWorldCorners(tile);
+      const normals = tileCornerNormals(tile);
+      const tris = tile.reversed ? [0, 2, 1, 0, 3, 2] : [0, 1, 2, 0, 2, 3];
+      for (const i of tris) {
+        idx.push(base + i);
+      }
+      for (let i = 0; i < 4; i++) {
+        const v = verts[i];
+        pos.push(v[0], v[1], v[2]);
+        min[0] = Math.min(min[0], v[0]);
+        min[1] = Math.min(min[1], v[1]);
+        min[2] = Math.min(min[2], v[2]);
+        max[0] = Math.max(max[0], v[0]);
+        max[1] = Math.max(max[1], v[1]);
+        max[2] = Math.max(max[2], v[2]);
+        const u = tile.uvs[i];
+        uv.push(u[0], 1 - u[1]);
+        const n = normals[i];
+        nrm.push(n[0], n[1], n[2]);
+      }
+    }
+    const indexArray = new Uint32Array(idx);
+    const posArray = new Float32Array(pos);
+    const uvArray = new Float32Array(uv);
+    const nrmArray = new Float32Array(nrm);
+    const indexBv = bv(
+      indexArray,
+      34963
+      /* ELEMENT_ARRAY_BUFFER */
+    );
+    const posBv = bv(
+      posArray,
+      34962
+      /* ARRAY_BUFFER */
+    );
+    const uvBv = bv(uvArray, 34962);
+    const nrmBv = bv(nrmArray, 34962);
+    accessors.push({ bufferView: indexBv, byteOffset: 0, componentType: 5125, count: idx.length, type: "SCALAR" });
+    const indexAccessor = accessors.length - 1;
+    accessors.push({ bufferView: posBv, byteOffset: 0, componentType: 5126, count: pos.length / 3, type: "VEC3", min, max });
+    const posAccessor = accessors.length - 1;
+    accessors.push({ bufferView: uvBv, byteOffset: 0, componentType: 5126, count: uv.length / 2, type: "VEC2" });
+    const uvAccessor = accessors.length - 1;
+    accessors.push({ bufferView: nrmBv, byteOffset: 0, componentType: 5126, count: nrm.length / 3, type: "VEC3" });
+    const nrmAccessor = accessors.length - 1;
+    const hasAlpha = blendAtlasIds ? blendAtlasIds.has(atlasId) : atlasHasTransparency(safe, atlas);
+    if (hasAlpha) usedAlphaBlend.add(atlasId);
+    materials.push({
+      name: materialName(safe, atlasId, primIndex),
+      pbrMetallicRoughness: {
+        baseColorTexture: { index: primIndex },
+        metallicFactor: 0,
+        roughnessFactor: 1
+      },
+      alphaMode: hasAlpha ? "BLEND" : "MASK",
+      ...hasAlpha ? {} : { alphaCutoff: 0.5 },
+      doubleSided: true
+    });
+    prims.push({
+      attributes: { POSITION: posAccessor, TEXCOORD_0: uvAccessor, NORMAL: nrmAccessor },
+      indices: indexAccessor,
+      material: primIndex,
+      mode: 4
+    });
+  });
+  meshes.push({ primitives: prims });
+  const nodes = [{ name: safe.name || "pivo-plate", mesh: 0 }];
+  const scenes = [{ nodes: [0] }];
+  const scene = 0;
+  const asset = { version: "2.0", generator: "pivo-plate io/export" };
+  const gltf = {
+    asset,
+    scene,
+    scenes,
+    nodes,
+    meshes,
+    materials,
+    textures,
+    samplers,
+    images,
+    bufferViews,
+    accessors,
+    buffers: [{ byteLength: bufferLength }]
+  };
+  for (const { chunkIndex, bytes } of deferredImages) {
+    const pad = padTo(bytes.byteLength) - bytes.byteLength;
+    chunks[chunkIndex] = bytes;
+    chunks[chunkIndex + 1] = new Uint8Array(pad);
+  }
+  const json = JSON.stringify(gltf);
+  const jsonBytes = new TextEncoder().encode(json);
+  const jsonPadded = padTo(jsonBytes.length);
+  const binPadded = padTo(bufferLength);
+  const total = 12 + 8 + jsonPadded + 8 + binPadded;
+  const out = new Uint8Array(total);
+  const dv = new DataView(out.buffer);
+  dv.setUint32(0, 1179937895, true);
+  dv.setUint32(4, 2, true);
+  dv.setUint32(8, total, true);
+  dv.setUint32(12, jsonPadded, true);
+  dv.setUint32(16, 1313821514, true);
+  out.set(jsonBytes, 20);
+  if (jsonPadded > jsonBytes.length) out.fill(32, 20 + jsonBytes.length, 20 + jsonPadded);
+  const binHeader = 20 + jsonPadded;
+  dv.setUint32(binHeader, binPadded, true);
+  dv.setUint32(binHeader + 4, 5130562, true);
+  let off = binHeader + 8;
+  for (const c of chunks) {
+    out.set(new Uint8Array(c.buffer, c.byteOffset, c.byteLength), off);
+    off += c.byteLength;
+  }
+  return out;
+}
+function tileWorldCorners(tile) {
+  return [tile.vertices[0], tile.vertices[1], tile.vertices[2], tile.vertices[3]];
+}
+function materialName(project, atlasId, index) {
+  const atlas = project.atlases.find((a) => a.id === atlasId);
+  const raw = atlas?.name ?? atlasId;
+  const safe = raw.replace(/[^A-Za-z0-9_.-]/g, "_");
+  return `${safe}_${index}`;
+}
+var atlasTransparencyOverride = null;
+function atlasHasTransparency(project, atlas) {
+  if (atlasTransparencyOverride) return atlasTransparencyOverride(atlas);
+  return false;
+}
+
+// src/io/export.ts
+async function exportOBJ(project, inspectedAlpha) {
+  const safe = validateProjectValue(project);
+  const alphaModes = inspectedAlpha ?? await inspectAlpha(safe);
+  const visibleTiles = safe.tiles.filter((t) => isObjectVisibleValue2(safe, t.objectId));
+  if (visibleTiles.length === 0) {
+    throw new ExportError("Nothing to export: the project has no visible tiles");
+  }
+  assertExportGeometry(visibleTiles);
+  const atlasById = new Map(safe.atlases.map((a) => [a.id, a]));
+  for (const t of visibleTiles) {
+    if (!atlasById.has(t.atlasId)) {
+      throw new ExportError(`Tile "${t.id}" references atlas "${t.atlasId}" which does not exist`);
+    }
+  }
+  const objLines = [];
+  objLines.push("# Exported by pivo-plate (Y-up, meters, baked world-space vertices)");
+  objLines.push(`# ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  const mtlLines = ["# pivo-plate material library"];
+  const usedMatNames = /* @__PURE__ */ new Set();
+  const materialNames = [];
+  const texturesToWrite = [];
+  const objectNameOf = /* @__PURE__ */ new Map();
+  for (const o of safe.objects) {
+    let n = o.name.replace(/[^A-Za-z0-9_.-]/g, "_");
+    if (n.length === 0) n = "object";
+    let candidate = n;
+    let k = 1;
+    while (objectNameOf.size > 0 && [...objectNameOf.values()].includes(candidate)) {
+      candidate = `${n}_${k++}`;
+    }
+    objectNameOf.set(o.id, candidate);
+  }
+  safe.atlases.forEach((atlas, i) => {
+    let base = atlas.name.replace(/[^A-Za-z0-9_.-]/g, "_");
+    if (base.length === 0) base = `material_${i}`;
+    let name = base;
+    let k = 1;
+    while (usedMatNames.has(name)) name = `${base}_${k++}`;
+    usedMatNames.add(name);
+    materialNames.push(name);
+  });
+  let faceIndex = 0;
+  const currentObjectName = /* @__PURE__ */ new Map();
+  for (const tile of visibleTiles) {
+    const objName = objectNameOf.get(tile.objectId) ?? "object";
+    if (currentObjectName.get("current") !== objName) {
+      objLines.push(`o ${objName}`);
+      currentObjectName.set("current", objName);
+    }
+    const matIndex = safe.atlases.findIndex((a) => a.id === tile.atlasId);
+    const matName = materialNames[matIndex] ?? "material_0";
+    objLines.push(`usemtl ${matName}`);
+    const baseIndex = faceIndex * 4 + 1;
+    for (const v of tile.vertices) {
+      objLines.push(`v ${fmt(v[0])} ${fmt(v[1])} ${fmt(v[2])}`);
+    }
+    for (const uv of tile.uvs) {
+      objLines.push(`vt ${fmt(uv[0])} ${fmt(uv[1])}`);
+    }
+    for (const n of tileCornerNormals(tile)) objLines.push(`vn ${fmt(n[0])} ${fmt(n[1])} ${fmt(n[2])}`);
+    const tri = (a, b, c) => `f ${a}/${a}/${a} ${b}/${b}/${b} ${c}/${c}/${c}`;
+    if (tile.reversed) {
+      objLines.push(tri(baseIndex, baseIndex + 2, baseIndex + 1));
+      objLines.push(tri(baseIndex, baseIndex + 3, baseIndex + 2));
+    } else {
+      objLines.push(tri(baseIndex, baseIndex + 1, baseIndex + 2));
+      objLines.push(tri(baseIndex, baseIndex + 2, baseIndex + 3));
+    }
+    faceIndex++;
+  }
+  safe.atlases.forEach((atlas, i) => {
+    const matName = materialNames[i];
+    const texFile = `textures/${atlas.id}.png`;
+    mtlLines.push(`newmtl ${matName}`);
+    mtlLines.push("Kd 1.000 1.000 1.000");
+    mtlLines.push("Ks 0.000 0.000 0.000");
+    mtlLines.push(`map_Kd ${texFile}`);
+    const transparent = alphaModes?.get(atlas.id) !== void 0 && alphaModes.get(atlas.id) !== "opaque";
+    mtlLines.push("d 1.000");
+    if (transparent) mtlLines.push(`map_d ${texFile}`);
+    if (transparent) mtlLines.push("illum 9");
+    mtlLines.push("");
+    const { bytes } = dataUrlToBytes(atlas.dataUrl);
+    texturesToWrite.push({ path: texFile, bytes });
+  });
+  const objText = objLines.join("\n") + "\n";
+  const mtlName = "pivo-plate.mtl";
+  const objWithMtl = [`mtllib ${mtlName}`, ...objLines].join("\n") + "\n";
+  const files = {
+    "pivo-plate.obj": strToU82(objWithMtl),
+    [mtlName]: strToU82(mtlLines.join("\n") + "\n")
+  };
+  for (const t of texturesToWrite) files[t.path] = t.bytes;
+  return zipSync2(files, { level: 6 });
+}
+function fmt(n) {
+  let s = n.toFixed(6);
+  if (s.includes(".")) s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return s === "" || s === "-0" ? "0" : s;
+}
+async function exportGLB(project, inspectedAlpha) {
+  const safe = validateProjectValue(project);
+  const alphaModes = inspectedAlpha ?? await inspectAlpha(safe);
+  return buildGlb(safe, alphaModes ? new Set([...alphaModes].filter(([, mode]) => mode === "blend").map(([id]) => id)) : void 0);
+}
+
+export {
+  ProjectIOError,
+  ContainerError,
+  PayloadError,
+  ExportError,
+  encodeProject,
+  decodeProject,
+  inspectAlpha,
+  exportOBJ,
+  exportGLB
+};