makeables 0.10.0 → 0.12.0

package/dist/chunk-KLJRRHMY.js

@@ -0,0 +1,3352 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../design/dist/chunk-BAQXEQNG.js
+import QRCode from "qrcode";
+function badgeQrLayout(destination, width, maxCellSize = 20) {
+  const url = new URL(destination);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.href.length > 400)
+    throw new Error("El destino del QR no es v\xE1lido.");
+  const matrix = QRCode.create(url.href, { errorCorrectionLevel: "M" }).modules;
+  const cell = Math.min(maxCellSize, Math.floor(width / (matrix.size + 8)));
+  if (cell < 2) throw new Error("El QR necesita m\xE1s espacio.");
+  return { matrix, cell };
+}
+
+// ../design/dist/chunk-J74I2FPH.js
+var MAX_SVG_BYTES = 1e6;
+var TAG = /<([a-z][\w:.-]*)((?:\s+[^\s=<>/]+(?:\s*=\s*(?:"[^"<]*"|'[^'<]*'|[^\s"'<>]+))?)*)\s*\/?>/gi;
+var ATTRIBUTE = /([^\s=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'<>]+)))?/g;
+var CLOSING_TAG = /<\/[a-z][\w:.-]*\s*>/gi;
+var CSS_URL = /url\(\s*(["']?)(.*?)\1\s*\)/gi;
+var EMBEDDED_IMAGE = /^data:image\/(?:png|jpeg|jpg|webp|gif);base64,[a-z0-9+/=\s]+$/i;
+var FORBIDDEN_ELEMENTS = /* @__PURE__ */ new Set([
+  "script",
+  "foreignobject",
+  "iframe",
+  "embed",
+  "object",
+  "audio",
+  "video",
+  "canvas",
+  "handler",
+  "listener"
+]);
+function fail(error) {
+  return { ok: false, error };
+}
+function localName(name) {
+  return name.toLowerCase().replace(/^[\w.-]+:/, "");
+}
+function checkSubmittedSvg(input) {
+  const svg2 = input.replace(/^/, "").trim();
+  if (!svg2) return fail("The file is empty.");
+  if (new TextEncoder().encode(svg2).byteLength > MAX_SVG_BYTES) {
+    return fail("The SVG must be 1 MB or smaller.");
+  }
+  if (/<!(?:doctype|entity)/i.test(svg2))
+    return fail("DOCTYPE and entity declarations are not allowed.");
+  if (/(?:java|vb)script\s*:/i.test(svg2)) return fail("Script URLs are not allowed.");
+  if (/@import/i.test(svg2)) return fail("CSS @import is not allowed.");
+  for (const match of svg2.matchAll(CSS_URL)) {
+    if (!match[2]?.trim().startsWith("#")) {
+      return fail("CSS url() may only reference elements inside the file (#id).");
+    }
+  }
+  const markup = svg2.replace(/^<\?xml[^>]*\?>/i, "").replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "").trim();
+  if (markup.replace(TAG, "").replace(CLOSING_TAG, "").includes("<")) {
+    return fail("The SVG contains malformed markup.");
+  }
+  const tags2 = [...markup.matchAll(TAG)];
+  const [root] = tags2;
+  if (root?.index !== 0 || localName(root[1] ?? "") !== "svg") {
+    return fail("The file must be an SVG document starting with <svg>.");
+  }
+  if (!/<\/svg\s*>$/i.test(markup)) return fail("The SVG is incomplete.");
+  for (const [index, tag] of tags2.entries()) {
+    const element = localName(tag[1] ?? "");
+    if (FORBIDDEN_ELEMENTS.has(element)) return fail(`<${tag[1]}> elements are not allowed.`);
+    for (const attribute of (tag[2] ?? "").matchAll(ATTRIBUTE)) {
+      const name = localName(attribute[1] ?? "");
+      const value = (attribute[2] ?? attribute[3] ?? attribute[4] ?? "").trim();
+      if (name.startsWith("on")) {
+        return fail("Event handler attributes (onload, onclick\u2026) are not allowed.");
+      }
+      if (name === "href" && !value.startsWith("#") && !EMBEDDED_IMAGE.test(value)) {
+        return fail(
+          "Links must point inside the file (#id) or embed a base64 PNG, JPEG, WebP, or GIF."
+        );
+      }
+      if (name === "attributename" && localName(value) === "href") {
+        return fail("Animating links is not allowed.");
+      }
+      if (index === 0 && name === "viewbox") {
+        const box2 = value.split(/[\s,]+/).map(Number).join(" ");
+        if (box2 !== "0 0 1200 756") return fail('The <svg> element needs viewBox="0 0 1200 756".');
+      }
+    }
+  }
+  if (!/\sviewBox\s*=/i.test(root[2] ?? "")) {
+    return fail('The <svg> element needs viewBox="0 0 1200 756".');
+  }
+  return { ok: true, svg: svg2 };
+}
+
+// ../design/dist/chunk-HIVKVAE6.js
+var shaderFunctions = [
+  "abs",
+  "acos",
+  "asin",
+  "atan",
+  "atan2",
+  "ceil",
+  "clamp",
+  "cos",
+  "cross",
+  "distance",
+  "dot",
+  "exp",
+  "exp2",
+  "floor",
+  "fract",
+  "length",
+  "log",
+  "log2",
+  "max",
+  "min",
+  "mix",
+  "normalize",
+  "pow",
+  "reflect",
+  "round",
+  "select",
+  "sign",
+  "sin",
+  "smoothstep",
+  "sqrt",
+  "step",
+  "tan",
+  "tanh",
+  "trunc",
+  "vec2f",
+  "vec3f",
+  "vec4f",
+  "f32",
+  "noise2",
+  "cells2"
+];
+var functions = new Set(shaderFunctions);
+var inputs = ["p", "t", "pointer", "seed"];
+function shaderCodeIssue(code) {
+  if (!code || code.length > 4800) return "Usa una f\xF3rmula de hasta 4800 caracteres.";
+  if (!/^[\x20-\x7e\n\r\t]+$/.test(code) || /\/[/*]|\*\//.test(code))
+    return "La f\xF3rmula solo admite c\xF3digo sin comentarios.";
+  const statements = code.trim().split(";");
+  if (statements.pop()?.trim() || statements.length < 1 || statements.length > 40)
+    return "La f\xF3rmula debe terminar en return y tener hasta 40 instrucciones.";
+  const names = /* @__PURE__ */ new Set([...inputs, ...shaderFunctions, "true", "false"]);
+  let tokens = 0;
+  let calls = 0;
+  let noiseCalls = 0;
+  for (const [index, statement] of statements.entries()) {
+    const last = index === statements.length - 1;
+    const match = last ? /^\s*return\s+([\s\S]+)$/.exec(statement) : /^\s*let\s+([A-Za-z][A-Za-z0-9_]*)\s*=\s*([\s\S]+)$/.exec(statement);
+    if (!match) return "Usa declaraciones let y un \xFAnico return final.";
+    const name = last ? void 0 : match[1];
+    if (name && (names.has(name) || name.startsWith("__"))) return "Nombre reservado o repetido.";
+    const expression = last ? match[1] : match[2];
+    const parts = expression.match(
+      /(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?f?|[A-Za-z_][A-Za-z0-9_]*|\s+|&&|\|\||==|!=|<=|>=|[().,+\-*/%<>!]/g
+    ) ?? [];
+    if (parts.join("") !== expression) return "La f\xF3rmula contiene sintaxis no admitida.";
+    const significant = parts.filter((part) => part.trim());
+    let depth = 0;
+    for (const [i, part] of significant.entries()) {
+      if (++tokens > 700) return "La f\xF3rmula es demasiado compleja.";
+      if (part === "(" && ++depth > 16) return "Demasiados niveles en la f\xF3rmula.";
+      if (part === ")" && --depth < 0) return "Par\xE9ntesis incompletos.";
+      if (!/^[A-Za-z_]/.test(part)) continue;
+      if (significant[i - 1] === ".") {
+        if (!/^[xyzwrgba]{1,4}$/.test(part)) return "Solo se permiten componentes de vectores.";
+      } else if (significant[i + 1] === "(") {
+        if (!functions.has(part)) return `Funci\xF3n no admitida: ${part}.`;
+        if (++calls > 80) return "La f\xF3rmula admite hasta 80 llamadas.";
+        if ((part === "noise2" || part === "cells2") && ++noiseCalls > 12)
+          return "Usa como m\xE1ximo 12 muestras de ruido.";
+      } else if (!names.has(part)) return "La f\xF3rmula usa una variable no disponible.";
+    }
+    if (depth !== 0) return "Par\xE9ntesis incompletos.";
+    if (name) names.add(name);
+  }
+}
+
+// ../design/dist/chunk-6WXIEGBU.js
+import { z } from "zod";
+var text = (max2) => z.string().trim().min(1).max(max2).regex(/^[^\p{Cc}\p{Cf}]+$/u);
+var range = (min, max2) => z.number().finite().min(min).max(max2);
+var color = z.string().regex(/^#[0-9a-fA-F]{6}$/);
+var prismFieldSchema = z.object({
+  layers: z.array(
+    z.object({
+      basis: z.enum(["noise", "cells", "ribbons", "rings"]),
+      scale: range(0.5, 6),
+      stretch: range(0.3, 3),
+      angle: range(-180, 180),
+      warp: range(0, 2),
+      drift: range(-0.5, 0.5),
+      weight: range(0.1, 1),
+      blend: z.enum(["add", "multiply"])
+    }).strict()
+  ).min(1).max(4).refine((layers) => layers[0]?.blend === "add", "Start with an additive layer."),
+  relief: range(0, 1),
+  refraction: range(0, 0.5),
+  film: range(0, 1),
+  coverage: range(0.15, 1)
+}).strict();
+var prismShaderSchema = z.object({
+  version: z.literal(1),
+  code: z.string().max(4800).superRefine((code, ctx) => {
+    const issue = shaderCodeIssue(code);
+    if (issue) ctx.addIssue({ code: z.ZodIssueCode.custom, message: issue });
+  })
+}).strict();
+var prismStyleSchema = z.object({
+  version: z.literal(1),
+  name: text(48),
+  description: text(160),
+  surface: z.enum(["prism", "satin", "chrome"]),
+  finish: z.enum(["crystal", "opal", "obsidian"]),
+  palette: z.array(color).length(3),
+  accent: color,
+  portrait: z.object({ strength: range(0, 1), saturation: range(0, 1.5), contrast: range(0.65, 1.4) }).strict(),
+  texture: z.object({
+    pattern: z.enum(["none", "grain", "contours", "brushed", "grid"]),
+    amount: range(0, 0.45),
+    scale: range(0.25, 2)
+  }).strict(),
+  material: z.object({ roughness: range(0.12, 0.85), iridescence: range(0, 0.65) }).strict(),
+  field: prismFieldSchema.optional(),
+  shader: prismShaderSchema.optional(),
+  motion: z.object({ speed: range(0, 1), amplitude: range(0, 0.75) }).strict(),
+  heading: z.enum(["sans", "serif", "mono"])
+}).strict();
+var prismRecipeSchema = prismStyleSchema.extend({
+  material: z.object({ roughness: range(0, 1), iridescence: range(0, 0.65) }).strict(),
+  seed: z.number().int().min(0).max(4294967295),
+  promptVersion: z.enum([
+    "style-director-v1",
+    "material-director-v2",
+    "material-director-v3",
+    "shader-director-v1",
+    "shader-director-v2"
+  ]),
+  model: text(100)
+}).strict().refine((recipe) => !recipe.shader || Boolean(recipe.field), {
+  path: ["field"],
+  message: "A shader material requires a fallback field."
+});
+var styleRequestSchema = z.object({
+  prompt: text(600),
+  mode: z.enum(["compositor", "shader"]).optional(),
+  current: prismRecipeSchema.optional()
+}).strict();
+var styleOutputSchema = z.object({
+  styles: z.array(prismStyleSchema.extend({ field: prismFieldSchema })).min(1).max(3)
+}).strict();
+var generatedUnitControl = (bounds) => range(0, 1).transform((value) => Math.min(bounds.maxValue ?? 1, Math.max(bounds.minValue ?? 0, value))).pipe(bounds);
+var generatedColor = z.string().trim().regex(
+  /^#{0,2}[0-9a-fA-F]{6}$/,
+  "Use six hexadecimal digits, e.g. #e06c9f. Convert color names to hex; no CSS names or functions."
+).transform((value) => `#${value.replace(/^#+/, "")}`).pipe(color).describe("A six-digit hexadecimal color with one #, e.g. #e06c9f. No color names.");
+var styleGenerationSchema = z.object({
+  styles: z.array(
+    prismStyleSchema.omit({ version: true, shader: true }).extend({
+      field: prismFieldSchema,
+      palette: z.array(generatedColor).length(3),
+      accent: generatedColor,
+      material: prismStyleSchema.shape.material.extend({
+        roughness: generatedUnitControl(prismStyleSchema.shape.material.shape.roughness),
+        iridescence: generatedUnitControl(prismStyleSchema.shape.material.shape.iridescence)
+      })
+    })
+  ).min(1).max(3)
+}).strict();
+var shaderGenerationSchema = z.object({
+  style: styleGenerationSchema.shape.styles.element.extend({
+    shader: prismShaderSchema.omit({ version: true }).extend({
+      code: prismShaderSchema.shape.code.refine(
+        (code) => !/\bnormalize\s*\(/.test(code),
+        "normalize can receive a zero vector. Use v / max(length(v), 0.0001) instead."
+      )
+    })
+  })
+}).strict();
+
+// ../design/dist/chunk-UM5HMGRC.js
+import { z as z3 } from "zod";
+import { z as z2 } from "zod";
+import { z as z22 } from "zod";
+var CONTACTLESS_ARCS = [
+  "M1060 134 Q1068 143 1060 152",
+  "M1072 124 Q1088 143 1072 162",
+  "M1084 114 Q1108 143 1084 172",
+  "M1096 104 Q1128 143 1096 182"
+];
+var CONTACTLESS_STROKE_WIDTH = 7.5;
+var DEFAULT_CARD_DETAILS = {
+  showChip: true,
+  chipColor: "#d9b875",
+  chipSlot: "middle-left",
+  showContactless: true,
+  contactlessColor: "#ffffff",
+  contactlessSlot: "upper-right",
+  network: "mastercard",
+  networkColorMode: "brand",
+  networkSlot: "lower-right",
+  visaVariant: "boxed"
+};
+var CHIP_OFFSET = {
+  "middle-left": [0, 0],
+  "upper-left": [0, -125]
+};
+var CONTACTLESS_OFFSET = {
+  "upper-right": [-70, 60],
+  "middle-right": [-70, 245]
+};
+var NETWORK_ORIGIN = {
+  "lower-right": {
+    mastercard: [990, 585],
+    visa: [905, 550],
+    amex: [995, 565],
+    discover: [925, 600]
+  },
+  "upper-right": {
+    mastercard: [990, 290],
+    visa: [905, 290],
+    amex: [995, 280],
+    discover: [925, 300]
+  }
+};
+var VISA_PATH = "m 651.18503,0.50000002 c -70.93272,0 -134.32163,36.76584998 -134.32163,104.69357998 0,77.90028 112.42264,83.28082 112.42264,122.41576 0,16.47806 -18.88384,31.22851 -51.13668,31.22851 -45.77308,0 -79.98403,-20.61081 -79.98403,-20.61081 l -14.63836,68.54658 c 0,0 39.41037,17.40989 91.73375,17.40989 77.55217,0 138.57651,-38.57104 138.57651,-107.66029 0,-82.3157 -112.89106,-87.53633 -112.89106,-123.86008 0,-12.9082 15.50201,-27.05169 47.66251,-27.05169 36.28682,0 65.89216,14.98968 65.89216,14.98968 l 14.32608,-66.20444 c 0,0 -32.21317,-13.89668998 -77.64189,-13.89668998 z M 2.2175605,5.49657 0.49999253,15.48969 c 0,0 29.84159547,5.46149 56.71878047,16.35593 34.606624,12.4927 37.071853,19.7653 42.900167,42.35367 l 63.51098,244.83152 85.13673,0 131.15974,-313.53424 -84.94155,0 L 210.7069,218.67018 176.3165,37.97422 C 173.1626,17.29371 157.18709,5.49657 137.63219,5.49657 l -135.4146295,0 z m 411.8650095,0 -66.63383,313.53424 80.99895,0 66.39962,-313.53424 -80.76474,0 z m 451.75943,0 c -19.53181,0 -29.88045,10.45695 -37.47421,28.73022 l -118.66834,284.80402 84.94155,0 16.434,-47.46734 103.48348,0 9.99312,47.46734 74.94843,0 -65.3847,-313.53424 -68.27333,0 z m 11.04709,84.70733 25.17799,117.65341 -67.45359,0 42.2756,-117.65341 z";
+function networkMarkup(network, mode, visaVariant) {
+  const mono = mode === "white" ? "#ffffff" : "#111111";
+  if (network === "mastercard") {
+    const red = mode === "brand" ? "#eb001b" : mono;
+    const yellow = mode === "brand" ? "#f79e1b" : mono;
+    const orange = mode === "brand" ? "#ff5f00" : mono;
+    return `<circle cx="50" cy="42" r="39" fill="${red}"/><circle cx="96" cy="42" r="39" fill="${yellow}"/><circle cx="96" cy="42" r="39" fill="${orange}" clip-path="url(#mc-overlap)"/>`;
+  }
+  if (network === "visa") {
+    const color22 = visaVariant === "boxed" || mode === "brand" ? "url(#visa-brand)" : mono;
+    const mark = `<path d="${VISA_PATH}" fill="${color22}"/>`;
+    return visaVariant === "boxed" ? `<rect width="240" height="120" fill="#ffffff"/><g transform="translate(10 24) scale(.22)">${mark}</g>` : `<g transform="translate(15 0) scale(.22)">${mark}</g>`;
+  }
+  if (network === "amex") {
+    const background = mode === "brand" ? "#2e77bc" : mono;
+    const foreground = mode === "black" ? "#ffffff" : mode === "white" ? "#111111" : "#ffffff";
+    return `<rect width="142" height="94" rx="4" fill="${background}"/><text x="71" y="42" text-anchor="middle" fill="${foreground}" font-family="Arial,Helvetica,sans-serif" font-size="23" font-weight="900" letter-spacing="-1.5">AMERICAN</text><text x="71" y="70" text-anchor="middle" fill="${foreground}" font-family="Arial,Helvetica,sans-serif" font-size="27" font-weight="900" letter-spacing="-1.8">EXPRESS</text>`;
+  }
+  const ink = mode === "brand" ? "#202024" : mono;
+  const sun = mode === "brand" ? "#f58220" : mono;
+  return `<g transform="scale(.88)"><g font-family="Arial,Helvetica,sans-serif" font-size="44" font-weight="900" letter-spacing="-2" fill="${ink}"><text x="0" y="63">DISC</text><text x="153" y="63">VER</text></g><circle cx="132" cy="46" r="19" fill="none" stroke="${sun}" stroke-width="10"/></g>`;
+}
+function cardDetailsSvg(details) {
+  const [chipX, chipY] = CHIP_OFFSET[details.chipSlot];
+  const [contactlessX, contactlessY] = CONTACTLESS_OFFSET[details.contactlessSlot];
+  const [networkX, networkY] = details.network === "none" ? [0, 0] : NETWORK_ORIGIN[details.networkSlot][details.network];
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="756" viewBox="0 0 1200 756">
+    <defs>
+      <linearGradient id="metal" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#fff" stop-opacity=".8"/><stop offset=".22" stop-color="#000" stop-opacity=".18"/><stop offset=".48" stop-color="#fff" stop-opacity=".55"/><stop offset=".72" stop-color="#000" stop-opacity=".26"/><stop offset="1" stop-color="#fff" stop-opacity=".35"/></linearGradient>
+      <linearGradient id="visa-brand" x1="0" y1="0" x2="1000" y2="0" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#20225f"/><stop offset=".2" stop-color="#1a1f61"/><stop offset=".41" stop-color="#172272"/><stop offset=".6" stop-color="#152682"/><stop offset=".8" stop-color="#12288e"/><stop offset="1" stop-color="#0e2c9a"/></linearGradient>
+      <clipPath id="mc-overlap"><circle cx="50" cy="42" r="39"/></clipPath>
+    </defs>
+    ${details.showChip ? `<g transform="translate(${chipX} ${chipY})"><rect x="84" y="357" width="151" height="112" rx="17" fill="#100e0b" fill-opacity=".8" stroke="${details.chipColor}" stroke-opacity=".32" stroke-width="2"/><rect x="90" y="363" width="139" height="100" rx="13" fill="${details.chipColor}" stroke="#fff" stroke-opacity=".65" stroke-width="2"/><rect x="90" y="363" width="139" height="100" rx="13" fill="url(#metal)"/><path d="M90 397H229M90 430H229M137 363V463M183 363V463" fill="none" stroke="#1b1715" stroke-opacity=".55" stroke-width="2.4"/><rect x="137" y="397" width="46" height="33" rx="8" fill="none" stroke="#1b1715" stroke-opacity=".7" stroke-width="2.4"/><path d="M137 412H90M183 412H229" stroke="#fff" stroke-opacity=".55" stroke-width="1.2"/></g>` : ""}
+    ${details.showContactless ? `<g transform="translate(${contactlessX} ${contactlessY}) translate(1086 143) scale(1.3 1.15) translate(-1086 -143)" fill="none" stroke="${details.contactlessColor}" stroke-width="${CONTACTLESS_STROKE_WIDTH}" stroke-linecap="round" stroke-linejoin="round">${CONTACTLESS_ARCS.map((arc) => `<path d="${arc}"/>`).join("")}</g>` : ""}
+    ${details.network === "none" ? "" : `<g transform="translate(${networkX} ${networkY + (details.network === "visa" && details.visaVariant === "plain" ? 45 : 0)})">${networkMarkup(details.network, details.networkColorMode, details.visaVariant)}</g>`}
+  </svg>`;
+}
+var NETWORK_SIZE = {
+  mastercard: { x: 8, y: 0, w: 130, h: 84 },
+  visa: { x: 0, y: 0, w: 240, h: 120 },
+  amex: { x: 0, y: 0, w: 142, h: 94 },
+  discover: { x: 0, y: 0, w: 228, h: 66 }
+};
+function cardMarkRegion(spec) {
+  if (spec.mark === "chip") {
+    const [, dy] = CHIP_OFFSET[spec.slot] ?? [0, 0];
+    return { x: 82, y: 355 + dy, w: 155, h: 116 };
+  }
+  if (spec.mark === "contactless") {
+    const [dx, dy] = CONTACTLESS_OFFSET[spec.slot] ?? [0, 0];
+    return { x: 1036 + dx, y: 86 + dy, w: 92, h: 114 };
+  }
+  const network = spec.network ?? "mastercard";
+  const [ox, oy] = NETWORK_ORIGIN[spec.slot]?.[network] ?? [0, 0];
+  const size = NETWORK_SIZE[network];
+  if (network === "visa" && spec.visaVariant === "plain")
+    return { x: ox + 15, y: oy + 45, w: 222, h: 76 };
+  return { x: ox + size.x, y: oy + size.y, w: size.w, h: size.h };
+}
+function cardMarkSvg(spec) {
+  const details = {
+    ...DEFAULT_CARD_DETAILS,
+    showChip: spec.mark === "chip",
+    showContactless: spec.mark === "contactless",
+    network: spec.mark === "network" ? spec.network ?? "mastercard" : "none"
+  };
+  if (spec.mark === "chip") {
+    details.chipSlot = spec.slot;
+    if (spec.color) details.chipColor = spec.color;
+  } else if (spec.mark === "contactless") {
+    details.contactlessSlot = spec.slot;
+    if (spec.color) details.contactlessColor = spec.color;
+  } else {
+    details.networkSlot = spec.slot;
+    details.networkColorMode = spec.colorMode ?? "brand";
+    details.visaVariant = spec.visaVariant ?? "boxed";
+  }
+  const { x, y, w, h } = cardMarkRegion(spec);
+  return cardDetailsSvg(details).replace(
+    'width="1200" height="756" viewBox="0 0 1200 756"',
+    `width="${w}" height="${h}" viewBox="${x} ${y} ${w} ${h}"`
+  );
+}
+var printProductIds = ["badge", "card", "sticker"];
+var digitalProductIds = ["post", "square", "story", "landscape"];
+var productIds = [...printProductIds, ...digitalProductIds];
+var designProfiles = {
+  badge: {
+    id: "badge",
+    label: "Badge",
+    width: 1024,
+    height: 1536,
+    kinds: ["text", "shape", "portrait", "graphic", "effect", "gradient", "image"],
+    keepClear: [],
+    preview: "lanyard"
+  },
+  card: {
+    id: "card",
+    label: "Card",
+    width: 1200,
+    height: 756,
+    kinds: ["text", "shape", "graphic", "gradient", "effect"],
+    // Wallet prints the masked card number here; estimated from a Wallet screenshot.
+    keepClear: [{ label: "card number", x: 64, y: 615, w: 406, h: 100 }],
+    preview: "card"
+  },
+  sticker: {
+    id: "sticker",
+    label: "Sticker",
+    width: 1024,
+    height: 1024,
+    kinds: ["text", "shape", "graphic", "gradient", "image"],
+    keepClear: [],
+    preview: "die-cut"
+  },
+  post: digitalProfile("post", "Post", 1080, 1350),
+  square: digitalProfile("square", "Square", 1080, 1080),
+  story: digitalProfile("story", "Story", 1080, 1920),
+  landscape: digitalProfile("landscape", "Landscape", 1920, 1080)
+};
+function digitalProfile(id3, label, width, height) {
+  return {
+    id: id3,
+    label,
+    width,
+    height,
+    kinds: ["text", "shape", "portrait", "graphic", "gradient", "effect", "image"],
+    keepClear: [],
+    preview: "flat",
+    digital: true
+  };
+}
+function designProfile(design) {
+  return designProfiles[design.product ?? "badge"];
+}
+var stickerMaterialSchema = z2.object({
+  finish: z2.enum(["glitter", "holographic", "vinyl"]),
+  /** Die-cut border in canvas pixels; `widthMm` gives it a printed size. */
+  border: z2.number().min(0).max(40),
+  /** Printed width of the square canvas. Defaults to 75 mm. */
+  widthMm: z2.number().min(10).max(300).optional(),
+  sparkle: z2.number().min(0).max(1),
+  gloss: z2.number().min(0).max(1.5),
+  seed: z2.number().int().min(0).max(4294967295),
+  holography: z2.number().min(0).max(1).optional(),
+  relief: z2.number().min(0).max(1.5).optional(),
+  flakes: z2.number().min(40).max(500).optional(),
+  stock: z2.enum(["white", "holographic", "holo-glitter"]).optional(),
+  laminate: z2.enum(["gloss", "matte"]).optional(),
+  liner: z2.string().min(1).max(40).optional(),
+  /** RGB = foil, glitter, relief. Follow the named image layer's placement and alpha. */
+  effectMap: z2.object({
+    asset: z2.string().regex(/^[a-z][a-z0-9-]{0,39}$/),
+    layer: z2.string().min(1).max(80)
+  }).optional(),
+  /** Optical overrides follow editable layer geometry, including later transforms. */
+  regions: z2.record(
+    z2.string().min(1).max(80),
+    z2.object({
+      foil: z2.number().min(0).max(1),
+      glitter: z2.number().min(0).max(1),
+      relief: z2.number().min(0).max(1)
+    })
+  ).optional()
+});
+var defaultStickerMaterial = {
+  finish: "glitter",
+  border: 18,
+  sparkle: 0.72,
+  gloss: 0.5,
+  seed: 280926
+};
+var tags = /* @__PURE__ */ new Set([
+  "g",
+  "defs",
+  "rect",
+  "circle",
+  "ellipse",
+  "path",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "image",
+  "use",
+  "symbol",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "pattern",
+  "clipPath",
+  "mask",
+  "filter",
+  "feTurbulence",
+  "feColorMatrix",
+  "feGaussianBlur",
+  "feMerge",
+  "feMergeNode",
+  "feDropShadow",
+  "feOffset"
+]);
+var attributes = /* @__PURE__ */ new Set([
+  "viewBox",
+  "width",
+  "height",
+  "role",
+  "aria-label",
+  "aria-labelledby",
+  "id",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "offset",
+  "stop-color",
+  "x",
+  "y",
+  "type",
+  "baseFrequency",
+  "numOctaves",
+  "seed",
+  "stitchTiles",
+  "values",
+  "fill",
+  "d",
+  "stroke",
+  "stroke-width",
+  "opacity",
+  "cx",
+  "cy",
+  "r",
+  "style",
+  "clip-path",
+  "filter",
+  "gradientUnits",
+  "stop-opacity",
+  "stdDeviation",
+  "result",
+  "in",
+  "mask",
+  "rx",
+  "transform",
+  "ry",
+  "patternUnits",
+  "shape-rendering",
+  "href",
+  "stroke-opacity",
+  "font-family",
+  "font-size",
+  "font-weight",
+  "letter-spacing",
+  "fill-opacity",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "text-anchor",
+  "stroke-dasharray",
+  "points",
+  "fill-rule",
+  "dx",
+  "dy",
+  "flood-color",
+  "preserveAspectRatio",
+  "gradientTransform",
+  "spreadMethod",
+  "clip-rule",
+  "color-interpolation-filters",
+  "filterUnits",
+  "maskUnits"
+]);
+var blend = /^mix-blend-mode:\s*(normal|multiply|screen|overlay|soft-light|hard-light|color-dodge|color-burn|darken|lighten);?$/;
+var safeAttribute = (value, key) => {
+  if (!attributes.has(key)) return false;
+  if (key === "href")
+    return /^#[\w.-]+$/.test(value) || /^data:image\/(?:png|jpeg|webp|gif);base64,[A-Za-z0-9+/=]+$/.test(value);
+  if (key === "style") return blend.test(value);
+  if (/url\s*\(/i.test(value)) return /^url\(#[\w.-]+\)$/.test(value);
+  return !/[<>]/.test(value);
+};
+var svgNodeSchema = z22.lazy(
+  () => z22.object({
+    tag: z22.string().refine((tag) => tags.has(tag), "Unsupported SVG element"),
+    attrs: z22.record(z22.string().max(28e5)).superRefine((attrs, ctx) => {
+      for (const [key, value] of Object.entries(attrs))
+        if (!safeAttribute(value, key))
+          ctx.addIssue({ code: "custom", message: `Unsupported SVG attribute: ${key}` });
+    }).optional(),
+    text: z22.string().max(2e3).optional(),
+    children: z22.array(svgNodeSchema).max(1e3).optional()
+  })
+);
+var svgSourceSchema = z22.object({
+  definitions: z22.array(svgNodeSchema).max(100),
+  /** Provenance of the original file, not a network location. */
+  originalSha256: z22.string().regex(/^[a-f0-9]{64}$/),
+  attribution: z22.string().max(5e3).optional()
+});
+var escapeSvg = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function svgNodeXml(node, prefix = "", colors = {}) {
+  const attrs = Object.entries(node.attrs ?? {}).map(([key, original]) => {
+    let value = colors[original] ?? original;
+    if (key === "id") value = `${prefix}${value}`;
+    else if (key === "href" && value.startsWith("#")) value = `#${prefix}${value.slice(1)}`;
+    else value = value.replace(/url\(#([\w.-]+)\)/g, (_, id3) => `url(#${prefix}${id3})`);
+    return ` ${key}="${escapeSvg(value)}"`;
+  }).join("");
+  return `<${node.tag}${attrs}>${escapeSvg(node.text ?? "")}${(node.children ?? []).map((child) => svgNodeXml(child, prefix, colors)).join("")}</${node.tag}>`;
+}
+var color2 = z3.string().regex(/^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i);
+var box = {
+  id: z3.string().regex(/^[a-z][a-z0-9-]{0,39}$/),
+  name: z3.string().min(1).max(80).optional(),
+  // Bounds of the largest canvas (story height, landscape width); designIssues checks each
+  // product's own canvas.
+  x: z3.number().min(0).max(1919),
+  y: z3.number().min(0).max(1919),
+  w: z3.number().min(1).max(1920),
+  h: z3.number().min(1).max(1920),
+  rotation: z3.number().min(-180).max(180).optional(),
+  opacity: z3.number().min(0).max(1).optional(),
+  visible: z3.boolean().optional(),
+  channel: z3.enum(["print", "ink"]).optional(),
+  protectMaterial: z3.boolean().optional(),
+  /** Card-only print finish: foil catches the light, raised is embossed on the front. */
+  finish: z3.enum(["foil", "raised"]).optional()
+};
+var text2 = z3.object({
+  ...box,
+  kind: z3.literal("text"),
+  text: z3.string().max(160),
+  binding: z3.enum([
+    "none",
+    "name",
+    "role",
+    "organization",
+    "number",
+    "event",
+    "location",
+    "date",
+    "bio",
+    "roleOrganization",
+    "website",
+    "roleCode",
+    "admissionRole",
+    "signature",
+    "template"
+  ]),
+  color: color2,
+  font: z3.enum([
+    "sans",
+    "serif",
+    "mono",
+    "display",
+    "brand",
+    "script",
+    "pixel",
+    "archive",
+    "rounded"
+  ]),
+  strokeColor: color2.optional(),
+  strokeWidth: z3.number().min(0).max(40).optional(),
+  size: z3.number().min(12).max(220),
+  weight: z3.enum(["400", "500", "600", "700", "800", "900"]),
+  align: z3.enum(["left", "center", "right"]),
+  tracking: z3.number().min(-8).max(40).optional(),
+  lineHeight: z3.number().min(0.7).max(2).optional(),
+  transform: z3.enum(["none", "uppercase", "lowercase"]).optional(),
+  segment: z3.enum(["all", "first", "last"]).optional(),
+  fit: z3.enum(["wrap", "shrink", "spread"]).optional(),
+  baseline: z3.enum(["top", "alphabetic"]).optional(),
+  italic: z3.boolean().optional(),
+  prefix: z3.string().max(30).optional(),
+  suffix: z3.string().max(30).optional(),
+  highlights: z3.array(z3.object({ text: z3.string().min(1).max(40), color: color2 })).max(8).optional(),
+  baselineOffset: z3.number().min(0).max(260).optional(),
+  numberDigits: z3.number().int().min(1).max(8).optional()
+});
+var shape = z3.object({
+  ...box,
+  kind: z3.literal("shape"),
+  shape: z3.enum(["rectangle", "ellipse", "line", "frame", "corners", "arch", "bevel"]),
+  color: color2,
+  radius: z3.number().min(0).max(160),
+  stroke: z3.number().min(0).max(20),
+  opacity: z3.number().min(0).max(1)
+});
+var portrait = z3.object({
+  ...box,
+  kind: z3.literal("portrait"),
+  radius: z3.number().min(0).max(400),
+  filter: z3.enum([
+    "original",
+    "mono",
+    "rose",
+    "blue",
+    "warm",
+    "thermal",
+    "silver",
+    "cyanotype",
+    "vintage"
+  ]),
+  crop: z3.object({
+    x: z3.number().min(0).max(1),
+    y: z3.number().min(0).max(1),
+    zoom: z3.number().min(1).max(12)
+  }).optional(),
+  cropMode: z3.enum(["cover", "focus"]).optional(),
+  fade: z3.object({
+    x: z3.number().min(0).max(0.5),
+    right: z3.number().min(0).max(0.5).optional(),
+    top: z3.number().min(0).max(0.5),
+    bottom: z3.number().min(0).max(0.5)
+  }).optional(),
+  tint: color2.optional(),
+  tintMode: z3.enum(["multiply", "color"]).optional(),
+  tintOpacity: z3.number().min(0).max(1).optional(),
+  contrast: z3.number().min(0.5).max(2).optional(),
+  brightness: z3.number().min(0.3).max(1.8).optional(),
+  blur: z3.number().min(0).max(24).optional(),
+  saturation: z3.number().min(0).max(2).optional(),
+  clip: z3.enum(["rectangle", "arch", "ellipse"]).optional()
+});
+var qr = z3.object({
+  ...box,
+  kind: z3.literal("qr"),
+  foreground: color2.optional(),
+  background: color2.optional(),
+  align: z3.enum(["center", "start"]).optional(),
+  maxCellSize: z3.number().int().min(2).max(20).optional()
+});
+var effect = z3.object({
+  ...box,
+  kind: z3.literal("effect"),
+  effect: z3.enum(["ribbons", "contours", "orbits", "grain", "chromatic-flow"]),
+  colors: z3.array(color2).length(3),
+  scale: z3.number().min(0.5).max(6),
+  opacity: z3.number().min(0).max(1)
+});
+var graphic = z3.object({
+  ...box,
+  kind: z3.literal("graphic"),
+  pattern: z3.enum([
+    "grid",
+    "snow",
+    "sky",
+    "grain",
+    "terrain",
+    "seal",
+    "cross",
+    "window",
+    "stamp",
+    "scanlines",
+    "path",
+    "paper",
+    "chromatic-paper",
+    "checkerboard"
+  ]),
+  color: color2,
+  ink: color2.optional(),
+  accent: color2,
+  density: z3.number().min(0.1).max(3),
+  seed: z3.number().int().min(0).max(4294967295),
+  path: z3.string().max(16e3).regex(/^[MmLlHhVvCcSsQqTtAaZz0-9.,eE+\-\s]*$/).optional(),
+  viewBox: z3.object({
+    width: z3.number().min(1).max(16384),
+    height: z3.number().min(1).max(16384)
+  }).optional(),
+  stroke: z3.number().min(0).max(20).optional(),
+  variant: z3.enum(["plain", "technical", "editorial", "postal", "snow", "grid", "waves"]).optional(),
+  reverse: z3.boolean().optional(),
+  fill: z3.boolean().optional()
+});
+var gradient = z3.object({
+  ...box,
+  kind: z3.literal("gradient"),
+  direction: z3.enum(["horizontal", "vertical", "diagonal", "radial"]),
+  stops: z3.array(z3.object({ at: z3.number().min(0).max(1), color: color2 })).min(2).max(8)
+});
+var ART_ASSET = "art";
+var assetId = z3.string().regex(/^[a-z][a-z0-9-]{0,39}$/);
+var credit = z3.object({ label: z3.string().min(1).max(120), url: z3.string().url() });
+var designAssetSchema = z3.discriminatedUnion("source", [
+  // Unchanged artwork and optical maps from an attributed bundled sticker collection.
+  z3.object({
+    source: z3.literal("sticker"),
+    collection: z3.enum(["typingmind", "community", "moraleja"]),
+    slug: z3.string().regex(/^[a-z0-9-]{1,80}$/),
+    file: z3.enum(["artwork", "effects"]),
+    name: z3.string().min(1).max(80),
+    credit
+  }),
+  // A Petdex sprite bundled with Makeables, served from /stickers/petdex/<slug>.webp.
+  z3.object({
+    source: z3.literal("petdex"),
+    slug: z3.string().regex(/^[a-z0-9-]{1,80}$/),
+    name: z3.string().min(1).max(80),
+    credit: credit.optional()
+  }),
+  // A Makeables gallery artwork, served as a raster preview.
+  z3.object({
+    source: z3.literal("gallery"),
+    slug: z3.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+    /** editor-artwork.svg is the same art without baked-in card details. */
+    file: z3.enum(["artwork.svg", "editor-artwork.svg"]).optional(),
+    name: z3.string().min(1).max(80)
+  }),
+  // An image embedded in the document, so it renders anywhere without a store.
+  z3.object({
+    source: z3.literal("image"),
+    name: z3.string().min(1).max(80),
+    data: z3.string().regex(/^data:image\/(png|webp|jpeg|gif|svg\+xml);base64,[A-Za-z0-9+/=]+$/).max(28e5).superRefine((value, context) => {
+      if (!value.startsWith("data:image/svg+xml;base64,")) return;
+      try {
+        const svg2 = new TextDecoder().decode(
+          Uint8Array.from(atob(value.split(",")[1]), (c) => c.charCodeAt(0))
+        );
+        const checked = checkSubmittedSvg(svg2);
+        if (!checked.ok) context.addIssue({ code: "custom", message: checked.error });
+      } catch {
+        context.addIssue({ code: "custom", message: "Invalid embedded SVG." });
+      }
+    }),
+    pixelated: z3.boolean().optional(),
+    /** Detail available before resizing; does not claim upsampling adds pixels. */
+    sourcePixels: z3.object({
+      width: z3.number().int().positive().max(24e3),
+      height: z3.number().int().positive().max(24e3)
+    }).strict().optional(),
+    credit: credit.optional()
+  })
+]);
+var image = z3.object({
+  ...box,
+  kind: z3.literal("image"),
+  asset: assetId,
+  /** cover crops to fill the box (artwork); contain keeps the whole image (stickers). */
+  fit: z3.enum(["cover", "contain"]).optional(),
+  /** An intentional full-canvas backdrop may contain the image without cropping. */
+  background: z3.boolean().optional(),
+  opacity: z3.number().min(0).max(1),
+  radius: z3.number().min(0).max(160)
+});
+var cardMark = z3.object({
+  ...box,
+  kind: z3.literal("card-mark"),
+  mark: z3.enum(["chip", "contactless", "network"]),
+  slot: z3.enum(["middle-left", "upper-left", "upper-right", "middle-right", "lower-right"]),
+  color: color2.optional(),
+  network: z3.enum(["mastercard", "visa", "amex", "discover"]).optional(),
+  colorMode: z3.enum(["brand", "white", "black"]).optional(),
+  visaVariant: z3.enum(["boxed", "plain"]).optional()
+});
+var svg = z3.object({
+  ...box,
+  kind: z3.literal("svg"),
+  nodes: z3.array(svgNodeSchema).min(1).max(1e3),
+  sourceBox: z3.object({
+    x: z3.number(),
+    y: z3.number(),
+    w: z3.number().positive(),
+    h: z3.number().positive()
+  }),
+  colors: z3.record(z3.string(), color2).optional()
+});
+var badgeLayerSchema = z3.discriminatedUnion("kind", [
+  svg,
+  cardMark,
+  text2,
+  shape,
+  portrait,
+  qr,
+  effect,
+  image,
+  graphic,
+  gradient
+]);
+var face = z3.object({ background: color2, layers: z3.array(badgeLayerSchema).max(96) });
+var badgeDesignObjectSchema = z3.object({
+  /** Omitted means badge. */
+  product: z3.enum(productIds).optional(),
+  sticker: stickerMaterialSchema.optional(),
+  version: z3.literal(1),
+  source: z3.string().max(60).optional(),
+  name: z3.string().min(1).max(60),
+  description: z3.string().max(180),
+  artwork: z3.object({ assetId: z3.string().uuid() }).optional(),
+  assets: z3.record(assetId, designAssetSchema).optional(),
+  svgSource: svgSourceSchema.optional(),
+  event: z3.string().min(1).max(80),
+  artPrompt: z3.string().max(1200),
+  material: z3.object({
+    /** Physical badge holder; independent of the printed surface. Omitted means bare. */
+    holder: z3.enum(["bare", "laminated"]).optional(),
+    surface: z3.enum(["satin", "prism", "chrome"]),
+    /** Card-only physical stock; omitted keeps the coated `surface`. */
+    stock: z3.enum(["metal", "holographic", "soft-touch"]).optional(),
+    /** Card-only optics that tune the stock to one design. */
+    optics: z3.object({
+      /** Brushed-metal or laminate grain: straight at `angle`, rays or rings around `center`. */
+      grain: z3.enum(["linear", "radial", "concentric"]).optional(),
+      angle: z3.number().min(0).max(180).optional(),
+      center: z3.object({ x: z3.number().min(0).max(1), y: z3.number().min(0).max(1) }).optional(),
+      grainStrength: z3.number().min(0).max(1).optional(),
+      /** Foil color; omitted keeps each layer's own ink. */
+      foil: color2.optional(),
+      /** Color of the moving highlight. */
+      light: color2.optional(),
+      /** Three stops the holographic laminate cycles through instead of a full rainbow. */
+      spectrum: z3.array(color2).length(3).optional(),
+      diffraction: z3.enum(["linear", "radial"]).optional(),
+      sparkle: z3.number().min(0).max(1).optional(),
+      relief: z3.number().min(0).max(1).optional(),
+      /** Width of the moving highlight, from a sharp streak to a broad glow. */
+      sheen: z3.number().min(0).max(1).optional()
+    }).strict().optional(),
+    roughness: z3.number().min(0).max(1),
+    iridescence: z3.number().min(0).max(0.65),
+    speed: z3.number().min(0).max(1),
+    recipe: prismRecipeSchema.optional(),
+    effect: z3.enum(["standard", "ribbons", "topographic"]).optional(),
+    focus: z3.object({
+      x: z3.number().min(0).max(1),
+      y: z3.number().min(0).max(1),
+      radius: z3.number().min(0.1).max(0.5)
+    }).optional()
+  }),
+  front: face,
+  back: face
+});
+function isRoleBoundLayer(layer) {
+  return layer.kind === "text" && (["role", "roleOrganization", "admissionRole"].includes(layer.binding) || layer.binding === "template" && /\{(?:role|roleOrganization|admissionRole)\}/.test(layer.text));
+}
+function overlaps(a, b) {
+  const aa = designLayerBounds(a);
+  const bb = designLayerBounds(b);
+  return aa.x < bb.x + bb.w && aa.x + aa.w > bb.x && aa.y < bb.y + bb.h && aa.y + aa.h > bb.y;
+}
+function designLayerBounds(layer) {
+  const angle = (layer.rotation ?? 0) * Math.PI / 180;
+  const swap = Math.abs(layer.rotation ?? 0) === 90;
+  const width = swap ? layer.h : layer.w;
+  const height = swap ? layer.w : layer.h;
+  const w = Math.abs(Math.cos(angle)) * width + Math.abs(Math.sin(angle)) * height;
+  const h = Math.abs(Math.sin(angle)) * width + Math.abs(Math.cos(angle)) * height;
+  return { x: layer.x + (layer.w - w) / 2, y: layer.y + (layer.h - h) / 2, w, h };
+}
+function luminance(hex2) {
+  const rgb = [1, 3, 5].map((start) => Number.parseInt(hex2.slice(start, start + 2), 16) / 255);
+  return rgb.map((value) => value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4).reduce((total, value, index) => total + value * [0.2126, 0.7152, 0.0722][index], 0);
+}
+function designIssues(design) {
+  const issues = [];
+  const profile = designProfile(design);
+  const badge = profile.id === "badge";
+  if (!badge && design.material.holder) issues.push("A holder is only available for badges.");
+  if (profile.id !== "card" && (design.material.stock || design.material.optics))
+    issues.push("Stock and optics are only available for cards.");
+  for (const side of ["front", "back"])
+    for (const layer of design[side].layers) {
+      if (!layer.finish) continue;
+      if (profile.id !== "card")
+        issues.push(`${side}.${layer.id}: finish is only available for cards.`);
+      else if (layer.finish === "raised" && side === "back")
+        issues.push(`back.${layer.id}: raised finish is only available on the front.`);
+    }
+  const assets = design.assets ?? {};
+  if (design.sticker?.effectMap) {
+    const { asset, layer } = design.sticker.effectMap;
+    if (!assets[asset]) issues.push(`sticker.effectMap: missing asset ${asset}`);
+    if (!design.front.layers.some((value) => value.id === layer && value.kind === "image"))
+      issues.push(`sticker.effectMap: ${layer} must name a front image layer`);
+  }
+  for (const id3 of Object.keys(design.sticker?.regions ?? {}))
+    if (!design.front.layers.some((layer) => layer.id === id3))
+      issues.push(`sticker.regions: missing front layer ${id3}`);
+  if (profile.id === "sticker" && design.back.layers.length)
+    issues.push("Stickers have one editable face; keep back layers empty.");
+  if (profile.digital && design.back.layers.length)
+    issues.push(`${profile.label} is a single image; keep back layers empty.`);
+  if (Object.keys(assets).length > 24) issues.push("assets: 24 como m\xE1ximo");
+  for (const side of ["front", "back"])
+    for (const layer of design[side].layers)
+      if (layer.kind === "image" && layer.asset !== ART_ASSET && !assets[layer.asset])
+        issues.push(`${side}.${layer.id}: falta el asset ${layer.asset}`);
+  for (const side of ["front", "back"]) {
+    const layers = design[side].layers;
+    const ids = /* @__PURE__ */ new Set();
+    for (const [i, layer] of layers.entries()) {
+      if (ids.has(layer.id)) issues.push(`${side}: ID repetido ${layer.id}`);
+      ids.add(layer.id);
+      const bounds = designLayerBounds(layer);
+      if (bounds.x < -0.01 || bounds.y < -0.01 || bounds.x + bounds.w > profile.width + 0.01 || bounds.y + bounds.h > profile.height + 0.01)
+        issues.push(`${side}.${layer.id}: outside the ${profile.label.toLowerCase()}`);
+      if (profile.id === "sticker" && layer.kind === "text" && layer.binding !== "none")
+        issues.push("Sticker text uses free text, without participant bindings.");
+      if (profile.id === "sticker" && layer.kind === "portrait")
+        issues.push("Stickers use image layers, not participant portraits.");
+      if (!badge && layer.kind === "qr")
+        issues.push(`${side}.${layer.id}: QR codes are for badges`);
+      if (layer.kind === "svg" && !design.svgSource)
+        issues.push(`${side}.${layer.id}: missing original SVG definitions`);
+      if (side === "front" && layer.visible !== false && !isBackground(layer, profile)) {
+        for (const area of profile.keepClear)
+          if (intersects(bounds, area))
+            issues.push(`${side}.${layer.id}: covers the ${area.label} area`);
+      }
+      if (badge && ["text", "portrait", "qr"].includes(layer.kind) && bounds.y < 89.99)
+        issues.push(`${side}.${layer.id}: reserva superior de 90 px`);
+      if ((layer.kind === "portrait" || layer.kind === "image") && layer.channel === "ink")
+        issues.push(`${side}.${layer.id}: las im\xE1genes pertenecen a la impresi\xF3n`);
+      if (layer.kind === "graphic" && layer.pattern === "path") {
+        const path = layer.path?.trim() ?? "";
+        const numbers = path.match(/[-+]?(?:\d*\.?\d+)(?:[eE][-+]?\d+)?/g) ?? [];
+        if (!/^[Mm]/.test(path) || numbers.some(
+          (value) => !Number.isFinite(Number(value)) || Math.abs(Number(value)) > 16384
+        ))
+          issues.push(`${side}.${layer.id}: trazado inv\xE1lido o fuera de rango`);
+      }
+      if (layer.kind === "qr") {
+        const minimum = side === "front" ? 128 : 280;
+        if (layer.w < minimum || layer.w !== layer.h || layer.rotation || (layer.opacity ?? 1) !== 1)
+          issues.push(`${side}.${layer.id}: QR cuadrado de al menos ${minimum} px`);
+        const foreground = layer.foreground ?? "#111111";
+        const background = layer.background ?? "#ffffff";
+        const light = Math.max(luminance(foreground), luminance(background));
+        const dark = Math.min(luminance(foreground), luminance(background));
+        if ((light + 0.05) / (dark + 0.05) < 4.5 || [foreground, background].some(
+          (value) => value.length > 7 && value.slice(7).toLowerCase() !== "ff"
+        ))
+          issues.push(`${side}.${layer.id}: el QR necesita colores opacos y contrastantes`);
+        if (layer.visible !== false && layers.slice(i + 1).some((l) => l.visible !== false && overlaps(layer, l)))
+          issues.push(`${side}.${layer.id}: QR tapado por otra capa`);
+      }
+    }
+    if (badge && layers.length < 3) issues.push(`${side}: al menos 3 capas`);
+    if (badge && !layers.some((l) => l.kind === "text" && l.binding === "name"))
+      issues.push(`${side}: falta el nombre vinculado`);
+  }
+  const portraits = design.front.layers.filter((l) => l.kind === "portrait").length;
+  if (badge && (portraits < 1 || portraits > 4)) issues.push("front: debe tener un retrato");
+  if (!badge && portraits > 4) issues.push("front: 4 portraits at most");
+  for (const side of ["front", "back"])
+    if (design[side].layers.filter((layer) => layer.kind === "effect").length > 24)
+      issues.push(`${side}: m\xE1ximo 24 efectos`);
+  if (badge && !design.back.layers.some((l) => l.kind === "qr")) issues.push("back: falta el QR");
+  if (badge && !design.back.layers.some(isRoleBoundLayer))
+    issues.push("back: falta el rol vinculado");
+  return issues;
+}
+function intersects(a, b) {
+  return a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+}
+function isBackground(layer, profile) {
+  if (layer.kind === "svg" && !layer.rotation && ["x", "y", "w", "h"].every((key) => layer[key] === layer.sourceBox[key]))
+    return true;
+  return (layer.kind === "image" || layer.kind === "gradient" || layer.kind === "effect" || layer.kind === "graphic" || layer.kind === "svg") && (layer.kind !== "image" || layer.fit !== "contain" || layer.background === true) && layer.x <= 0 && layer.y <= 0 && layer.x + layer.w >= profile.width && layer.y + layer.h >= profile.height;
+}
+var badgeDesignSchema = badgeDesignObjectSchema.transform((design) => {
+  if (design.product !== "card") return design;
+  return {
+    ...design,
+    front: {
+      ...design.front,
+      layers: design.front.layers.map(
+        (layer) => layer.kind === "card-mark" ? { ...layer, ...cardMarkRegion(layer) } : layer
+      )
+    },
+    back: {
+      ...design.back,
+      layers: design.back.layers.map(
+        (layer) => layer.kind === "card-mark" ? { ...layer, ...cardMarkRegion(layer) } : layer
+      )
+    }
+  };
+}).superRefine((design, context) => {
+  for (const message of designIssues(design))
+    context.addIssue({ code: z3.ZodIssueCode.custom, message });
+});
+var designLockSchema = z3.object({
+  front: z3.array(z3.string()).max(96),
+  back: z3.array(z3.string()).max(96),
+  material: z3.boolean()
+});
+function preserveDesignLocks(current, next, locks) {
+  const output = structuredClone(next);
+  if (locks.material) {
+    output.material = structuredClone(current.material);
+    output.sticker = current.sticker ? structuredClone(current.sticker) : void 0;
+  }
+  for (const side of ["front", "back"]) {
+    const locked = new Set(locks[side]);
+    output[side].layers = output[side].layers.filter((l) => !locked.has(l.id));
+    for (const [index, layer] of current[side].layers.entries()) {
+      if (locked.has(layer.id))
+        output[side].layers.splice(
+          Math.min(index, output[side].layers.length),
+          0,
+          structuredClone(layer)
+        );
+    }
+  }
+  return badgeDesignSchema.parse(output);
+}
+function referencedDesignAssets(design) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...["front", "back"].flatMap(
+        (side) => design[side].layers.flatMap((layer) => layer.kind === "image" ? [layer.asset] : [])
+      ),
+      ...design.sticker?.effectMap ? [design.sticker.effectMap.asset] : []
+    ])
+  ];
+}
+function pruneAssets(design) {
+  if (design.sticker) {
+    const ids = new Set(design.front.layers.map((layer) => layer.id));
+    design = {
+      ...design,
+      sticker: {
+        ...design.sticker,
+        effectMap: design.sticker.effectMap && ids.has(design.sticker.effectMap.layer) ? design.sticker.effectMap : void 0,
+        regions: design.sticker.regions ? Object.fromEntries(Object.entries(design.sticker.regions).filter(([id3]) => ids.has(id3))) : void 0
+      }
+    };
+  }
+  if (!design.assets) return design;
+  const used = new Set(referencedDesignAssets(design));
+  const assets = Object.fromEntries(Object.entries(design.assets).filter(([id3]) => used.has(id3)));
+  return { ...design, assets };
+}
+var STICKER_SIZE = 280;
+var STICKER_SLOTS = [
+  [0.74, 0.3],
+  [0.26, 0.66],
+  [0.74, 0.66],
+  [0.26, 0.3]
+];
+function stickerPosition(layers, w, h, canvas, front) {
+  const count = layers.filter((layer) => layer.kind === "image" && layer.fit === "contain").length;
+  const place = ([cx, cy]) => ({
+    x: Math.round(Math.min(canvas.width - 1 - w, Math.max(0, canvas.width * cx - w / 2))),
+    y: Math.round(Math.min(canvas.height - 1 - h, Math.max(0, canvas.height * cy - h / 2)))
+  });
+  const clear = (position) => !front || canvas.keepClear.every(
+    (area) => !(position.x < area.x + area.w && area.x < position.x + w && position.y < area.y + area.h && area.y < position.y + h)
+  );
+  const slots = STICKER_SLOTS.map(place).filter(clear);
+  const usable = slots.length ? slots : STICKER_SLOTS.map(place);
+  const slot = usable[count % usable.length];
+  const nudge = Math.floor(count / usable.length) * 36;
+  return {
+    x: Math.min(canvas.width - 1 - w, slot.x + nudge),
+    y: Math.min(canvas.height - 1 - h, slot.y + nudge)
+  };
+}
+function addSticker(design, side, asset, size, id3) {
+  const canvas = designProfile(design);
+  const longest = Math.min(STICKER_SIZE, Math.round(Math.min(canvas.width, canvas.height) / 3));
+  const ratio = longest / Math.max(size.width, size.height, 1);
+  const w = Math.max(1, Math.round(size.width * ratio));
+  const h = Math.max(1, Math.round(size.height * ratio));
+  const assetId2 = `sticker-${id3}`;
+  const layer = {
+    id: assetId2,
+    kind: "image",
+    asset: assetId2,
+    fit: "contain",
+    ...stickerPosition(design[side].layers, w, h, canvas, side === "front"),
+    w,
+    h,
+    opacity: 1,
+    radius: 0
+  };
+  const layers = [...design[side].layers];
+  const qr2 = layers.findIndex((item) => item.kind === "qr");
+  layers.splice(qr2 < 0 ? layers.length : qr2, 0, layer);
+  return badgeDesignSchema.parse({
+    ...design,
+    assets: { ...design.assets, [assetId2]: asset },
+    [side]: { ...design[side], layers }
+  });
+}
+function cardMarkLayer(id3, spec) {
+  const { x, y, w, h } = cardMarkRegion(spec);
+  return { id: id3, kind: "card-mark", ...spec, x, y, w, h };
+}
+function createCardDesign(gallery) {
+  const { width, height } = designProfiles.card;
+  return badgeDesignSchema.parse({
+    product: "card",
+    version: 1,
+    name: gallery.title,
+    description: "",
+    event: gallery.title,
+    artPrompt: "",
+    material: { surface: "satin", roughness: 0.4, iridescence: 0, speed: 0 },
+    assets: {
+      artwork: {
+        source: "gallery",
+        slug: gallery.slug,
+        name: gallery.title,
+        ...gallery.file ? { file: gallery.file } : {}
+      }
+    },
+    front: {
+      background: "#111111",
+      layers: [
+        {
+          id: "artwork",
+          kind: "image",
+          asset: "artwork",
+          fit: "cover",
+          x: 0,
+          y: 0,
+          w: width,
+          h: height,
+          opacity: 1,
+          radius: 0
+        },
+        cardMarkLayer("chip", { mark: "chip", slot: "middle-left", color: "#d9b875" }),
+        cardMarkLayer("contactless", {
+          mark: "contactless",
+          slot: "upper-right",
+          color: "#ffffff"
+        }),
+        cardMarkLayer("network", {
+          mark: "network",
+          slot: "lower-right",
+          network: "mastercard",
+          colorMode: "brand"
+        })
+      ]
+    },
+    back: { background: "#141414", layers: [] }
+  });
+}
+
+// ../design/dist/chunk-O2KBFMBV.js
+import { z as z4 } from "zod";
+var COMMUNITY_IMAGE_LIMIT = 3e6;
+var COMMUNITY_JSON_LIMIT = 256e3;
+var digestSchema = z4.string().regex(/^[a-f0-9]{64}$/);
+var secretSchema = z4.string().regex(/^\d{13}\.[a-f0-9]{64}$/);
+var COMMUNITY_PREPARATION_TTL = 60 * 60 * 1e3;
+var communityParticipantSchema = z4.object({
+  name: z4.string().trim().min(1).max(80),
+  role: z4.string().max(100),
+  organization: z4.string().max(100),
+  number: z4.number().int().min(1).max(999999),
+  eventName: z4.string().min(1).max(80),
+  publicUrl: z4.string().url().max(512).refine((value) => ["https:", "http:"].includes(new URL(value).protocol)),
+  signature: z4.object({ seed: z4.number().int().min(0).max(4294967295), version: z4.literal(1) }),
+  metadata: z4.object({
+    roleLabel: z4.string().max(100).default(""),
+    eventName: z4.string().max(80).default(""),
+    eventDate: z4.string().max(100).default(""),
+    location: z4.string().max(100).default(""),
+    website: z4.string().max(200).default(""),
+    bio: z4.string().max(600).default("")
+  }).strict()
+}).strict();
+var communitySnapshotSchema = z4.object({
+  format: z4.literal(1),
+  design: badgeDesignSchema,
+  participant: communityParticipantSchema,
+  images: z4.object({ portrait: digestSchema, artwork: digestSchema.nullable() }).strict()
+}).strict().superRefine(({ design, images, participant }, context) => {
+  const visible = (layer) => layer.visible !== false && (layer.opacity ?? 1) > 0;
+  if (Object.values(design.assets ?? {}).some((asset) => asset.source === "image"))
+    context.addIssue({
+      code: "custom",
+      message: "Uploaded stickers can't be published yet. Keep Petdex stickers or remove your uploads."
+    });
+  for (const side of ["front", "back"]) {
+    if (!design[side].layers.some(
+      (layer) => visible(layer) && layer.kind === "text" && layer.binding === "name"
+    ))
+      context.addIssue({ code: "custom", message: `El nombre debe verse en ${side}.` });
+  }
+  if (!design.front.layers.some((layer) => visible(layer) && layer.kind === "portrait"))
+    context.addIssue({ code: "custom", message: "El retrato debe ser visible." });
+  if (!design.back.layers.some((layer) => visible(layer) && isRoleBoundLayer(layer)))
+    context.addIssue({ code: "custom", message: "El rol debe ser visible." });
+  if (!design.back.layers.some((layer) => visible(layer) && layer.kind === "qr"))
+    context.addIssue({ code: "custom", message: "El QR debe ser visible." });
+  for (const layer of [...design.front.layers, ...design.back.layers]) {
+    if (!visible(layer) || layer.kind !== "qr") continue;
+    try {
+      badgeQrLayout(participant.publicUrl, layer.w, layer.maxCellSize);
+    } catch (reason) {
+      context.addIssue({ code: "custom", message: reason.message });
+    }
+  }
+  if (Boolean(design.artwork) !== Boolean(images.artwork) || [...design.front.layers, ...design.back.layers].some(
+    (layer) => visible(layer) && layer.kind === "image"
+  ) && !images.artwork)
+    context.addIssue({ code: "custom", message: "Falta la ilustraci\xF3n de este dise\xF1o." });
+});
+var intentBase = {
+  operationId: z4.string().uuid(),
+  snapshotHash: digestSchema,
+  title: z4.string().min(1).max(60),
+  participantName: z4.string().min(1).max(80)
+};
+var communityIntentSchema = z4.discriminatedUnion("action", [
+  z4.object({ ...intentBase, action: z4.literal("create") }).strict(),
+  z4.object({
+    ...intentBase,
+    action: z4.literal("update"),
+    publicationId: z4.string().uuid(),
+    expectedVersion: z4.number().int().positive()
+  }).strict(),
+  z4.object({
+    ...intentBase,
+    action: z4.literal("withdraw"),
+    publicationId: z4.string().uuid(),
+    expectedVersion: z4.number().int().positive()
+  }).strict()
+]);
+function canonicalJson(value) {
+  return JSON.stringify(
+    value,
+    (_, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item
+  );
+}
+async function communityDigest(value) {
+  const bytes = typeof value === "string" ? new TextEncoder().encode(value) : await value.arrayBuffer();
+  return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var bundleImageSchema = z4.object({
+  mimeType: z4.enum(["image/png", "image/jpeg", "image/webp"]),
+  base64: z4.string().min(4).max(4e6).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/)
+}).strict();
+var badgeBundleSchema = z4.object({
+  format: z4.literal("makeables-bundle"),
+  version: z4.literal(1),
+  snapshot: communitySnapshotSchema,
+  images: z4.object({
+    portrait: bundleImageSchema,
+    artwork: bundleImageSchema.nullable()
+  }).strict()
+}).strict();
+function bundleImageBytes(image2) {
+  return Uint8Array.from(atob(image2.base64), (character) => character.charCodeAt(0));
+}
+async function validateBadgeBundle(input) {
+  const bundle = badgeBundleSchema.parse(input);
+  const serialized = canonicalJson(bundle.snapshot);
+  if (new TextEncoder().encode(serialized).length > COMMUNITY_JSON_LIMIT)
+    throw new Error("The badge exceeds the 256 KB publication limit.");
+  for (const slot of ["portrait", "artwork"]) {
+    const image2 = bundle.images[slot];
+    if (!image2 && !bundle.snapshot.images[slot]) continue;
+    if (!image2) throw new Error(`Missing ${slot} image.`);
+    const bytes = bundleImageBytes(image2);
+    if (!bytes.length || bytes.length > COMMUNITY_IMAGE_LIMIT)
+      throw new Error(`The ${slot} exceeds the 3 MB publication limit.`);
+    const digest = await communityDigest(new Blob([bytes]));
+    if (digest !== bundle.snapshot.images[slot])
+      throw new Error(`The ${slot} does not match the saved badge.`);
+  }
+  return { bundle, snapshotHash: await communityDigest(serialized) };
+}
+
+// ../design/dist/chunk-7TRETK3A.js
+import { z as z5 } from "zod";
+var printerPresets = {
+  generic: {
+    name: "Generic kiss-cut printer",
+    cutSpot: "CutContour",
+    whiteSpot: "White",
+    bleedMm: 1,
+    safeMm: 1.5,
+    gapMm: 3,
+    marginMm: 5
+  }
+};
+var sheetSizes = {
+  a5: { name: "A5", widthMm: 148, heightMm: 210 },
+  a6: { name: "A6", widthMm: 105, heightMm: 148 },
+  "10x15": { name: "10 \xD7 15 cm", widthMm: 100, heightMm: 150 }
+};
+var sheetTypes = {
+  classic: {
+    name: "Classic sheet",
+    cut: "kiss-cut",
+    sizes: ["a5"],
+    stock: "white",
+    laminate: "matte",
+    borderMm: 2,
+    white: false,
+    stickerWidthMm: 45
+  },
+  small: {
+    name: "Small sheet",
+    cut: "kiss-cut",
+    sizes: ["a6", "10x15"],
+    stock: "white",
+    laminate: "gloss",
+    borderMm: 2,
+    white: false,
+    stickerWidthMm: 35
+  },
+  single: {
+    name: "Single sticker",
+    cut: "die-cut",
+    sizes: [],
+    stock: "white",
+    laminate: "gloss",
+    borderMm: 2,
+    white: false,
+    stickerWidthMm: 75
+  },
+  clear: {
+    name: "Clear",
+    cut: "kiss-cut",
+    sizes: ["a6"],
+    stock: "clear",
+    laminate: "gloss",
+    borderMm: 0,
+    white: true,
+    stickerWidthMm: 35
+  },
+  holographic: {
+    name: "Holographic",
+    cut: "kiss-cut",
+    sizes: ["a6"],
+    stock: "holographic",
+    laminate: "gloss",
+    borderMm: 2,
+    white: true,
+    stickerWidthMm: 35
+  }
+};
+var sheetTypeIds = Object.keys(sheetTypes);
+var id = z5.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
+var sheetItemSchema = z5.object({
+  id,
+  design: badgeDesignSchema,
+  /** Centre of the sticker canvas on the sheet. */
+  x: z5.number().min(-1e3).max(1e3),
+  y: z5.number().min(-1e3).max(1e3),
+  rotation: z5.number().min(-360).max(360),
+  /** Printed width of the square sticker canvas. */
+  widthMm: z5.number().min(5).max(300)
+});
+var stickerSheetSchema = z5.object({
+  format: z5.literal("makeables-sheet"),
+  version: z5.literal(1),
+  name: z5.string().min(1).max(80),
+  type: z5.enum(sheetTypeIds),
+  printer: z5.enum(Object.keys(printerPresets)),
+  size: z5.enum(Object.keys(sheetSizes)).optional(),
+  /** Border override for every sticker; the type's border otherwise. */
+  borderMm: z5.number().min(0).max(10).optional(),
+  /** Auto-pack keeps this sticker where it is. */
+  hero: id.optional(),
+  items: z5.array(sheetItemSchema).max(200)
+}).superRefine((sheet, context) => {
+  const type = sheetTypes[sheet.type];
+  if (type.cut === "kiss-cut" && !sheet.size)
+    context.addIssue({ code: "custom", path: ["size"], message: "Kiss-cut sheets need a size." });
+  if (sheet.size && !type.sizes.includes(sheet.size))
+    context.addIssue({
+      code: "custom",
+      path: ["size"],
+      message: `${type.name} comes in ${type.sizes.join(", ") || "the sticker's own size"}.`
+    });
+  if (type.cut === "die-cut" && sheet.items.length > 1)
+    context.addIssue({
+      code: "custom",
+      path: ["items"],
+      message: "A single sticker file holds one sticker."
+    });
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, item] of sheet.items.entries()) {
+    if (ids.has(item.id))
+      context.addIssue({
+        code: "custom",
+        path: ["items", index, "id"],
+        message: "Duplicate id."
+      });
+    ids.add(item.id);
+    if (item.design.product !== "sticker")
+      context.addIssue({
+        code: "custom",
+        path: ["items", index, "design"],
+        message: "Sheet items are sticker designs."
+      });
+  }
+  if (sheet.hero && !ids.has(sheet.hero))
+    context.addIssue({ code: "custom", path: ["hero"], message: "Hero is not on the sheet." });
+});
+function sheetSpec(sheet) {
+  const type = sheetTypes[sheet.type];
+  const size = sheet.size ? sheetSizes[sheet.size] : void 0;
+  return {
+    ...printerPresets[sheet.printer],
+    type,
+    borderMm: sheet.borderMm ?? type.borderMm,
+    widthMm: size?.widthMm,
+    heightMm: size?.heightMm
+  };
+}
+function createStickerSheet(type, name = sheetTypes[type].name) {
+  const sizes = sheetTypes[type].sizes;
+  return {
+    format: "makeables-sheet",
+    version: 1,
+    name,
+    type,
+    printer: "generic",
+    ...sizes[0] ? { size: sizes[0] } : {},
+    items: []
+  };
+}
+function sheetBorderPixels(borderMm, widthMm, pixels) {
+  return borderMm * pixels / widthMm;
+}
+
+// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var Worker;
+try {
+  Worker = require2("worker_threads").Worker;
+} catch (e) {
+}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i = 1; i < a.length; ++i) {
+    if (a[i] > m)
+      m = a[i];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i = 0; i < d.length; ++i) {
+    if (d[i])
+      t.push({ s: i, f: d[i] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+    r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i = 1; i < s; ++i) {
+    if (t2[i].s > maxSym)
+      maxSym = t2[i].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (; i < s; ++i) {
+      var i2_1 = t2[i].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i;
+    }
+    for (; i >= 0 && dt; --i) {
+      var i2_3 = t2[i].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli++] = v;
+  };
+  for (var i = 1; i <= s; ++i) {
+    if (c[i] == cln && i != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (; cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (; cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i = 0; i < cl.length; ++i)
+    l += cf[i] * cl[i];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i = 0; i < s; ++i)
+    out[o + i + 4] = dat[i];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i = 0; i < lclt.length; ++i)
+    ++lcfreq[lclt[i] & 31];
+  for (var i = 0; i < lcdt.length; ++i)
+    ++lcfreq[lcdt[i] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i = 0; i < nlcc; ++i)
+      wbits(out, p + 3 * i, lct[clim[i]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0; it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i = 0; i < clct.length; ++i) {
+        var len = clct[i] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i = 0; i < li; ++i) {
+    var sym = syms[i];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i2) {
+      return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25e3);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (; i + 2 < s; ++i) {
+      var hv = hsh(i);
+      var imod = i & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i) {
+        var rem = s - i;
+        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+          li = lc_1 = eb = 0, bs = i;
+          for (var j = 0; j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0; j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i + l] == dat[i + l - dif]) {
+              var nl = 0;
+              for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0; j < mmd; ++j) {
+                  var ti = i - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i];
+          ++lf[dat[i]];
+        }
+      }
+    }
+    for (i = Math.max(i, wi); i < s; ++i) {
+      syms[li++] = dat[i];
+      ++lf[dat[i]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i, st.w = wi;
+    }
+  } else {
+    for (var i = st.w || 0; i < s + lst; i += 65535) {
+      var e = i + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var crct = /* @__PURE__ */ (function() {
+  var t = new Int32Array(256);
+  for (var i = 0; i < 256; ++i) {
+    var c = i, k = 9;
+    while (--k)
+      c = (c & 1 && -306674912) ^ c >>> 1;
+    t[i] = c;
+  }
+  return t;
+})();
+var crc = function() {
+  var c = -1;
+  return {
+    p: function(d) {
+      var cr = c;
+      for (var i = 0; i < d.length; ++i)
+        cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
+      c = cr;
+    },
+    d: function() {
+      return ~c;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var mrg = function(a, b) {
+  var o = {};
+  for (var k in a)
+    o[k] = a[k];
+  for (var k in b)
+    o[k] = b[k];
+  return o;
+};
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+var wbytes = function(d, b, v) {
+  for (; v; ++b)
+    d[b] = v, v >>>= 8;
+};
+function deflateSync(data, opts) {
+  return dopt(data, opts || {}, 0, 0);
+}
+var Inflate = /* @__PURE__ */ (function() {
+  function Inflate2(opts, cb) {
+    if (typeof opts == "function")
+      cb = opts, opts = {};
+    this.ondata = cb;
+    var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+    this.s = { i: 0, b: dict ? dict.length : 0 };
+    this.o = new u8(32768);
+    this.p = new u8(0);
+    if (dict)
+      this.o.set(dict);
+  }
+  Inflate2.prototype.e = function(c) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c;
+    else if (c.length) {
+      var n = new u8(this.p.length + c.length);
+      n.set(this.p), n.set(c, this.p.length), this.p = n;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt, bts, this.s.b), this.d);
+    this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+    this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+  };
+  Inflate2.prototype.push = function(chunk, final) {
+    this.e(chunk), this.c(final);
+  };
+  return Inflate2;
+})();
+var fltn = function(d, p, t, o) {
+  for (var k in d) {
+    var val = d[k], n = p + k, op = o;
+    if (Array.isArray(val))
+      op = mrg(o, val[1]), val = val[0];
+    if (val instanceof u8)
+      t[n] = [val, op];
+    else {
+      t[n += "/"] = [new u8(0), op];
+      fltn(val, n, t, o);
+    }
+  }
+};
+var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+var dutf8 = function(d) {
+  for (var r = "", i = 0; ; ) {
+    var c = d[i++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i + eb > d.length)
+      return { s: r, r: slc(d, i - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
+  }
+};
+function strToU8(str, latin1) {
+  if (latin1) {
+    var ar_1 = new u8(str.length);
+    for (var i = 0; i < str.length; ++i)
+      ar_1[i] = str.charCodeAt(i);
+    return ar_1;
+  }
+  if (te)
+    return te.encode(str);
+  var l = str.length;
+  var ar = new u8(str.length + (str.length >> 1));
+  var ai = 0;
+  var w = function(v) {
+    ar[ai++] = v;
+  };
+  for (var i = 0; i < l; ++i) {
+    if (ai + 5 > ar.length) {
+      var n = new u8(ai + 8 + (l - i << 1));
+      n.set(ar);
+      ar = n;
+    }
+    var c = str.charCodeAt(i);
+    if (c < 128 || latin1)
+      w(c);
+    else if (c < 2048)
+      w(192 | c >> 6), w(128 | c & 63);
+    else if (c > 55295 && c < 57344)
+      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+    else
+      w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+  }
+  return slc(ar, 0, ai);
+}
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i = 0; i < dat.length; i += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var z64e = function(d, b) {
+  for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
+    ;
+  return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+var exfl = function(ex) {
+  var le = 0;
+  if (ex) {
+    for (var k in ex) {
+      var l = ex[k].length;
+      if (l > 65535)
+        err(9);
+      le += l + 4;
+    }
+  }
+  return le;
+};
+var wzh = function(d, b, f, fn, u, c, ce, co) {
+  var fl2 = fn.length, ex = f.extra, col = co && co.length;
+  var exl = exfl(ex);
+  wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
+  if (ce != null)
+    d[b++] = 20, d[b++] = f.os;
+  d[b] = 20, b += 2;
+  d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
+  d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
+  var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
+  if (y < 0 || y > 119)
+    err(10);
+  wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
+  if (c != -1) {
+    wbytes(d, b, f.crc);
+    wbytes(d, b + 4, c < 0 ? -c - 2 : c);
+    wbytes(d, b + 8, f.size);
+  }
+  wbytes(d, b + 12, fl2);
+  wbytes(d, b + 14, exl), b += 16;
+  if (ce != null) {
+    wbytes(d, b, col);
+    wbytes(d, b + 6, f.attrs);
+    wbytes(d, b + 10, ce), b += 14;
+  }
+  d.set(fn, b);
+  b += fl2;
+  if (exl) {
+    for (var k in ex) {
+      var exf = ex[k], l = exf.length;
+      wbytes(d, b, +k);
+      wbytes(d, b + 2, l);
+      d.set(exf, b + 4), b += 4 + l;
+    }
+  }
+  if (col)
+    d.set(co, b), b += col;
+  return b;
+};
+var wzf = function(o, b, c, d, e) {
+  wbytes(o, b, 101010256);
+  wbytes(o, b + 8, c);
+  wbytes(o, b + 10, c);
+  wbytes(o, b + 12, d);
+  wbytes(o, b + 16, e);
+};
+function zipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var r = {};
+  var files = [];
+  fltn(data, "", r, opts);
+  var o = 0;
+  var tot = 0;
+  for (var fn in r) {
+    var _a2 = r[fn], file2 = _a2[0], p = _a2[1];
+    var compression = p.level == 0 ? 0 : 8;
+    var f = strToU8(fn), s = f.length;
+    var com = p.comment, m = com && strToU8(com), ms = m && m.length;
+    var exl = exfl(p.extra);
+    if (s > 65535)
+      err(11);
+    var d = compression ? deflateSync(file2, p) : file2, l = d.length;
+    var c = crc();
+    c.p(file2);
+    files.push(mrg(p, {
+      size: file2.length,
+      crc: c.d(),
+      c: d,
+      f,
+      m,
+      u: s != fn.length || m && com.length != ms,
+      o,
+      compression
+    }));
+    o += 30 + s + exl + l;
+    tot += 76 + 2 * (s + exl) + (ms || 0) + l;
+  }
+  var out = new u8(tot + 22), oe = o, cdl = tot - o;
+  for (var i = 0; i < files.length; ++i) {
+    var f = files[i];
+    wzh(out, f.o, f, f.f, f.u, f.c.length);
+    var badd = 30 + f.f.length + exfl(f.extra);
+    out.set(f.c, f.o + badd);
+    wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
+  }
+  wzf(out, o, files.length, cdl, oe);
+  return out;
+}
+var UnzipPassThrough = /* @__PURE__ */ (function() {
+  function UnzipPassThrough2() {
+  }
+  UnzipPassThrough2.prototype.push = function(data, final) {
+    this.ondata(null, data, final);
+  };
+  UnzipPassThrough2.compression = 0;
+  return UnzipPassThrough2;
+})();
+var UnzipInflate = /* @__PURE__ */ (function() {
+  function UnzipInflate2() {
+    var _this = this;
+    this.i = new Inflate(function(dat, final) {
+      _this.ondata(null, dat, final);
+    });
+  }
+  UnzipInflate2.prototype.push = function(data, final) {
+    try {
+      this.i.push(data, final);
+    } catch (e) {
+      this.ondata(e, null, final);
+    }
+  };
+  UnzipInflate2.compression = 8;
+  return UnzipInflate2;
+})();
+var Unzip = /* @__PURE__ */ (function() {
+  function Unzip2(cb) {
+    this.onfile = cb;
+    this.k = [];
+    this.o = {
+      0: UnzipPassThrough
+    };
+    this.p = et;
+  }
+  Unzip2.prototype.push = function(chunk, final) {
+    var _this = this;
+    if (!this.onfile)
+      err(5);
+    if (!this.p)
+      err(4);
+    if (this.c > 0) {
+      var len = Math.min(this.c, chunk.length);
+      var toAdd = chunk.subarray(0, len);
+      this.c -= len;
+      if (this.d)
+        this.d.push(toAdd, !this.c);
+      else
+        this.k[0].push(toAdd);
+      chunk = chunk.subarray(len);
+      if (chunk.length)
+        return this.push(chunk, final);
+    } else {
+      var f = 0, i = 0, is = void 0, buf = void 0;
+      if (!this.p.length)
+        buf = chunk;
+      else if (!chunk.length)
+        buf = this.p;
+      else {
+        buf = new u8(this.p.length + chunk.length);
+        buf.set(this.p), buf.set(chunk, this.p.length);
+      }
+      var l = buf.length, oc = this.c, add = oc && this.d;
+      var _loop_2 = function() {
+        var _a2;
+        var sig = b4(buf, i);
+        if (sig == 67324752) {
+          f = 1, is = i;
+          this_1.d = null;
+          this_1.c = 0;
+          var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);
+          if (l > i + 30 + fnl + es) {
+            var chks_3 = [];
+            this_1.k.unshift(chks_3);
+            f = 2;
+            var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);
+            var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);
+            if (sc_1 == 4294967295) {
+              _a2 = dd ? [-2] : z64e(buf, i), sc_1 = _a2[0], su_1 = _a2[1];
+            } else if (dd)
+              sc_1 = -1;
+            i += es;
+            this_1.c = sc_1;
+            var d_1;
+            var file_1 = {
+              name: fn_1,
+              compression: cmp_1,
+              start: function() {
+                if (!file_1.ondata)
+                  err(5);
+                if (!sc_1)
+                  file_1.ondata(null, et, true);
+                else {
+                  var ctr = _this.o[cmp_1];
+                  if (!ctr)
+                    file_1.ondata(err(14, "unknown compression type " + cmp_1, 1), null, false);
+                  d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);
+                  d_1.ondata = function(err2, dat3, final2) {
+                    file_1.ondata(err2, dat3, final2);
+                  };
+                  for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {
+                    var dat2 = chks_4[_i];
+                    d_1.push(dat2, false);
+                  }
+                  if (_this.k[0] == chks_3 && _this.c)
+                    _this.d = d_1;
+                  else
+                    d_1.push(et, true);
+                }
+              },
+              terminate: function() {
+                if (d_1 && d_1.terminate)
+                  d_1.terminate();
+              }
+            };
+            if (sc_1 >= 0)
+              file_1.size = sc_1, file_1.originalSize = su_1;
+            this_1.onfile(file_1);
+          }
+          return "break";
+        } else if (oc) {
+          if (sig == 134695760) {
+            is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;
+            return "break";
+          } else if (sig == 33639248) {
+            is = i -= 4, f = 3, this_1.c = 0;
+            return "break";
+          }
+        }
+      };
+      var this_1 = this;
+      for (; i < l - 4; ++i) {
+        var state_1 = _loop_2();
+        if (state_1 === "break")
+          break;
+      }
+      this.p = et;
+      if (oc < 0) {
+        var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 134695760 && 4)) : buf.subarray(0, i);
+        if (add)
+          add.push(dat, !!f);
+        else
+          this.k[+(f == 2)].push(dat);
+      }
+      if (f & 2)
+        return this.push(buf.subarray(i), final);
+      this.p = buf.subarray(i);
+    }
+    if (final) {
+      if (this.c)
+        err(13);
+      this.p = null;
+    }
+  };
+  Unzip2.prototype.register = function(decoder) {
+    this.o[decoder.compression] = decoder;
+  };
+  return Unzip2;
+})();
+
+// ../design/dist/submission.js
+import { z as z32 } from "zod";
+import { z as z6 } from "zod";
+import { z as z23 } from "zod";
+var id2 = z6.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/);
+var hex = z6.string().regex(/^#[0-9a-fA-F]{6}$/);
+var file = z6.string().min(1).max(4096);
+var brandSlugSchema = z6.string().regex(/^[a-z0-9][a-z0-9-]{1,39}$/);
+var brandLayouts = ["editorial", "poster", "grid"];
+var brandFields = {
+  format: z6.literal("makeables-brand"),
+  version: z6.literal(1),
+  slug: brandSlugSchema,
+  name: z6.string().trim().min(1).max(60),
+  language: z6.enum(["en", "es"]).default("en"),
+  tagline: z6.string().trim().max(80).optional(),
+  description: z6.string().trim().min(1).max(400),
+  website: z6.string().url().max(512).refine((value) => new URL(value).protocol === "https:", "Use an https website.").optional(),
+  palette: z6.object({ paper: hex, ink: hex, accent: hex, accent2: hex.optional() }).strict().default({ paper: "#f4f1eb", ink: "#141414", accent: "#ff5a1f" }),
+  layout: z6.enum(brandLayouts).default("editorial"),
+  /** A design.md read from the brand's own site: palette roles, type, motifs, voice, what to avoid. */
+  guide: z6.string().trim().max(8e3).optional(),
+  logos: z6.array(
+    z6.object({
+      id: id2,
+      name: z6.string().trim().min(1).max(40),
+      file,
+      /** Light art needs a dark backdrop and the reverse. */
+      tone: z6.enum(["light", "dark"]).optional()
+    }).strict()
+  ).max(8).default([]),
+  cover: file.optional(),
+  families: z6.array(
+    z6.object({
+      id: id2,
+      name: z6.string().trim().min(1).max(40),
+      headline: z6.string().trim().max(80).default(""),
+      description: z6.string().trim().max(240).default("")
+    }).strict()
+  ).max(6).default([]),
+  kits: z6.array(
+    z6.object({
+      id: id2,
+      family: id2.optional(),
+      file: file.optional(),
+      submission: z6.string().uuid().optional()
+    }).strict().refine((kit) => kit.file || kit.submission, "A kit needs a local file or a submission.")
+  ).max(12).default([]),
+  /** The agreed art source for this brand; checked by `kit check --brand`. */
+  plan: z6.object({
+    source: z6.enum(["official", "generated", "mixed"]).default("mixed"),
+    generator: z6.string().trim().max(60).optional(),
+    stickers: z6.number().int().min(1).max(24).optional(),
+    generated: z6.array(file).max(64).default([])
+  }).strict().optional()
+};
+function uniqueIds(brand, ctx) {
+  for (const key of ["logos", "families", "kits"])
+    if (new Set(brand[key].map((entry) => entry.id)).size !== brand[key].length)
+      ctx.addIssue({ code: "custom", path: [key], message: "Duplicate IDs." });
+  const families = new Set(brand.families.map((family) => family.id));
+  for (const kit of brand.kits)
+    if (kit.family && !families.has(kit.family))
+      ctx.addIssue({ code: "custom", path: ["kits"], message: `Unknown family: ${kit.family}.` });
+}
+var brandDocumentSchema = z6.object(brandFields).strict().superRefine(uniqueIds);
+var brandPackageDocumentSchema = brandDocumentSchema.superRefine((brand, ctx) => {
+  if (!brand.kits.length)
+    ctx.addIssue({ code: "custom", path: ["kits"], message: "Add at least one kit." });
+  for (const kit of brand.kits)
+    if (!kit.submission || kit.file)
+      ctx.addIssue({
+        code: "custom",
+        path: ["kits"],
+        message: `Submit kit ${kit.id} before the brand; published brands reference kit submissions.`
+      });
+  for (const path of [brand.cover, ...brand.logos.map((logo) => logo.file)])
+    if (path && !/^identity\/[a-z0-9-]+\.(png|webp|jpg|jpeg)$/.test(path))
+      ctx.addIssue({ code: "custom", message: `Brand files live under identity/: ${path}.` });
+  if (brand.plan) ctx.addIssue({ code: "custom", message: "The local art plan is not published." });
+});
+var id22 = z23.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/);
+var member = z23.object({ id: id22, file: z23.string().min(1).max(4096) }).strict();
+var kitDocumentSchema = z23.object({
+  format: z23.literal("makeables-kit"),
+  version: z23.literal(1),
+  name: z23.string().trim().min(1).max(60),
+  items: z23.array(member).max(24),
+  sheets: z23.array(member).max(4).default([])
+}).strict().superRefine((kit, ctx) => {
+  for (const key of ["items", "sheets"])
+    if (new Set(kit[key].map((item) => item.id)).size !== kit[key].length)
+      ctx.addIssue({ code: "custom", path: [key], message: "Duplicate member IDs." });
+});
+var FILE_LIMIT = 5e6;
+var PACKAGE_LIMIT = 24e6;
+var FILE_COUNT_LIMIT = 40;
+var KIT_FILE_COUNT_LIMIT = 160;
+var MANIFEST_LIMIT = 2e5;
+var providers = { ...designProfiles, kit: { label: "Kit" }, brand: { label: "Brand" } };
+var pathPattern = /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.(?:json|svg|png|webp|jpg|jpeg|gif|pdf)$/;
+var pathSchema = z32.string().max(100).regex(pathPattern);
+var archivePathSchema = z32.string().max(147).regex(pathPattern);
+var mimeSchema = z32.enum([
+  "application/json",
+  "image/svg+xml",
+  "image/png",
+  "image/webp",
+  "image/jpeg",
+  "image/gif",
+  "application/pdf"
+]);
+var submissionMetadataSchema = z32.object({
+  title: z32.string().trim().min(1).max(60),
+  category: z32.enum(["Anime", "Gaming", "Minimal", "Abstract"]).default("Abstract"),
+  creditName: z32.string().trim().min(1).max(60),
+  creditUrl: z32.string().url().max(512).refine((value) => new URL(value).protocol === "https:").nullable().default(null)
+}).strict();
+var manifestBase = z32.object({
+  format: z32.literal("makeables-package"),
+  version: z32.literal(1),
+  // Digital formats are screen assets; only printed products are submitted.
+  product: z32.enum(printProductIds),
+  finish: stickerMaterialSchema.shape.finish.optional(),
+  title: z32.string().min(1).max(60),
+  document: pathSchema.optional(),
+  source: pathSchema.optional(),
+  front: pathSchema,
+  back: pathSchema.optional(),
+  portrait: pathSchema.optional(),
+  artwork: pathSchema.optional(),
+  assets: z32.record(z32.string().max(60), pathSchema).default({}),
+  files: z32.array(
+    z32.object({
+      path: pathSchema,
+      mime: mimeSchema,
+      bytes: z32.number().int().min(1).max(FILE_LIMIT),
+      sha256: z32.string().regex(/^[a-f0-9]{64}$/)
+    }).strict()
+  ).min(1).max(FILE_COUNT_LIMIT)
+}).strict();
+var designManifestSchema = manifestBase.superRefine((m, ctx) => {
+  const paths = new Set(m.files.map((f) => f.path));
+  const issue = (message) => ctx.addIssue({ code: "custom", message });
+  if (paths.has("manifest.json")) issue("manifest.json is reserved for the package index.");
+  if (paths.size !== m.files.length) issue("Duplicate asset paths.");
+  if (m.files.reduce((n, f) => n + f.bytes, 0) > PACKAGE_LIMIT) issue("The package exceeds 24 MB.");
+  if (!m.document && !m.source) issue("Include the editable document or original artwork.");
+  if (m.document && m.product !== "sticker" && !m.back) issue("Include previews of both faces.");
+  if (m.product === "sticker" && !m.finish) issue("Include the sticker finish.");
+  if (m.product !== "sticker" && m.finish) issue("Only stickers have a sticker finish.");
+  if (m.product === "sticker" && (m.back || m.portrait))
+    issue("Stickers contain one face and no participant portrait.");
+  for (const path of [
+    m.document,
+    m.source,
+    m.front,
+    m.back,
+    m.portrait,
+    m.artwork,
+    ...Object.values(m.assets)
+  ])
+    if (path && !paths.has(path)) issue(`Missing asset: ${path}.`);
+  for (const file2 of m.files) {
+    if (file2.mime === "application/pdf") issue("Print PDFs belong to kit sheets.");
+    if (![
+      m.document,
+      m.source,
+      m.front,
+      m.back,
+      m.portrait,
+      m.artwork,
+      ...Object.values(m.assets)
+    ].includes(file2.path))
+      issue(`Unreferenced file: ${file2.path}.`);
+    if (file2.path === m.document !== (file2.mime === "application/json"))
+      issue("Only the editable document may contain JSON.");
+    if (file2.path === m.source && (m.product !== "card" || !["image/svg+xml", "image/png", "image/jpeg", "image/webp"].includes(file2.mime)))
+      issue("Original artwork must be a card SVG, PNG, JPEG or WebP.");
+    if ([m.front, m.back].includes(file2.path) && file2.path !== m.source && file2.mime === "image/svg+xml")
+      issue("Use raster previews for layered documents.");
+  }
+});
+var kitId = z32.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/);
+var kitManifestSchema = manifestBase.extend({
+  product: z32.literal("kit"),
+  files: z32.array(manifestBase.shape.files.element.extend({ path: archivePathSchema })).min(1).max(KIT_FILE_COUNT_LIMIT),
+  items: z32.array(z32.object({ id: kitId, manifest: designManifestSchema }).strict()).min(1).max(24),
+  sheets: z32.array(
+    z32.object({
+      id: kitId,
+      document: pathSchema,
+      preview: pathSchema,
+      pdf: pathSchema.optional()
+    }).strict()
+  ).max(4).default([])
+}).superRefine((m, ctx) => {
+  const issue = (message) => ctx.addIssue({ code: "custom", message });
+  if (m.document || m.source || m.back || m.portrait || m.artwork || m.finish)
+    issue("A kit has a cover and member documents, not a single design.");
+  if (Object.keys(m.assets).length) issue("Kit images belong to their member manifests.");
+  if (new Set(m.items.map((item) => item.id)).size !== m.items.length)
+    issue("Duplicate kit item IDs.");
+  if (new Set(m.sheets.map((sheet) => sheet.id)).size !== m.sheets.length)
+    issue("Duplicate kit sheet IDs.");
+  const expected = /* @__PURE__ */ new Map([
+    [m.front, { mime: "image/png" }]
+  ]);
+  const add = (path, file2) => {
+    if (expected.has(path)) issue(`Duplicate kit file: ${path}.`);
+    expected.set(path, file2);
+  };
+  for (const item of m.items)
+    for (const file2 of item.manifest.files) add(`items/${item.id}/${file2.path}`, file2);
+  for (const sheet of m.sheets) {
+    add(sheet.document, { mime: "application/json" });
+    add(sheet.preview, { mime: "image/png" });
+    if (sheet.pdf) add(sheet.pdf, { mime: "application/pdf" });
+  }
+  if (expected.has("manifest.json")) issue("manifest.json is reserved.");
+  if (new Set(m.files.map((file2) => file2.path)).size !== m.files.length || m.files.length !== expected.size)
+    issue("The kit file list must contain exactly its cover, members and sheets.");
+  if (m.files.reduce((sum, file2) => sum + file2.bytes, 0) > PACKAGE_LIMIT)
+    issue("The package exceeds 24 MB.");
+  for (const file2 of m.files) {
+    const wanted = expected.get(file2.path);
+    if (!wanted || wanted.mime !== file2.mime || wanted.bytes !== void 0 && wanted.bytes !== file2.bytes || wanted.sha256 !== void 0 && wanted.sha256 !== file2.sha256)
+      issue(`Kit member metadata does not match: ${file2.path}.`);
+    if (file2.mime === "application/pdf" && !file2.path.endsWith(".pdf"))
+      issue("Print PDFs must use .pdf paths.");
+  }
+  for (const path of expected.keys())
+    if (!m.files.some((file2) => file2.path === path)) issue(`Missing kit file: ${path}.`);
+});
+var BRAND_FILE_COUNT_LIMIT = 12;
+var brandManifestSchema = manifestBase.extend({
+  product: z32.literal("brand"),
+  slug: brandSlugSchema,
+  document: z32.literal("brand.json"),
+  front: z32.literal("cover.png"),
+  files: manifestBase.shape.files.max(BRAND_FILE_COUNT_LIMIT),
+  kits: z32.array(z32.string().uuid()).min(1).max(12)
+}).superRefine((m, ctx) => {
+  const issue = (message) => ctx.addIssue({ code: "custom", message });
+  if (m.source || m.back || m.portrait || m.artwork || m.finish || Object.keys(m.assets).length)
+    issue("A brand has a cover, its brand.json and identity files.");
+  if (new Set(m.kits).size !== m.kits.length) issue("Duplicate brand kits.");
+  const paths = new Set(m.files.map((file2) => file2.path));
+  if (paths.size !== m.files.length) issue("Duplicate brand files.");
+  if (!paths.has("brand.json") || !paths.has("cover.png"))
+    issue("Include brand.json and cover.png.");
+  for (const file2 of m.files) {
+    if (file2.path === "brand.json" ? file2.mime !== "application/json" : !["image/png", "image/webp", "image/jpeg"].includes(file2.mime))
+      issue(`Unexpected brand file: ${file2.path}.`);
+    if (file2.path !== "brand.json" && file2.path !== "cover.png" && !file2.path.startsWith("identity/"))
+      issue(`Brand files live under identity/: ${file2.path}.`);
+  }
+  if (m.files.reduce((sum, file2) => sum + file2.bytes, 0) > PACKAGE_LIMIT)
+    issue("The package exceeds 24 MB.");
+});
+var manifestSchema = z32.union([
+  designManifestSchema,
+  kitManifestSchema,
+  brandManifestSchema
+]);
+var documentSchema = z32.object({ design: badgeDesignSchema, participant: communityParticipantSchema.optional() }).strict();
+var encoder = new TextEncoder();
+var jsonBytes = (value) => encoder.encode(canonicalJson(value));
+var parseJson = (bytes) => JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+var hashBytes = (bytes) => communityDigest(new Blob([new Uint8Array(bytes)]));
+function requiredAssets(design) {
+  const layers = [...design.front.layers, ...design.back.layers];
+  return {
+    portrait: layers.some((l) => l.kind === "portrait"),
+    artwork: Boolean(design.artwork) || layers.some((l) => l.kind === "image" && l.asset === "art"),
+    assets: [
+      ...referencedDesignAssets(design).filter(
+        (id3) => id3 !== "art" && design.assets?.[id3]?.source !== "image"
+      )
+    ]
+  };
+}
+function missingAssets(draft) {
+  const required = requiredAssets(draft.design);
+  return [
+    ...required.portrait && !draft.portrait ? ["portrait"] : [],
+    ...required.artwork && !draft.artwork ? ["artwork"] : [],
+    ...required.assets.filter((id3) => !draft.assets[id3])
+  ];
+}
+async function importDraft(value) {
+  if (value && typeof value === "object" && "format" in value && value.format === "makeables-bundle") {
+    const { bundle } = await validateBadgeBundle(value);
+    const draft = {
+      design: bundle.snapshot.design,
+      participant: bundle.snapshot.participant,
+      files: {},
+      mime: {},
+      assets: {}
+    };
+    for (const slot of ["portrait", "artwork"]) {
+      const image2 = bundle.images[slot];
+      if (!image2) continue;
+      const path = `${slot}.${image2.mimeType.split("/")[1]}`;
+      draft[slot] = path;
+      draft.files[path] = bundleImageBytes(image2);
+      draft.mime[path] = image2.mimeType;
+    }
+    return draft;
+  }
+  const document = documentSchema.parse(
+    value && typeof value === "object" && "design" in value ? value : { design: value }
+  );
+  return { ...document, files: {}, mime: {}, assets: {} };
+}
+async function assemblePackage(input, files, mime) {
+  const manifest = manifestSchema.parse({
+    ...input,
+    format: "makeables-package",
+    version: 1,
+    files: await Promise.all(
+      Object.entries(files).map(async ([path, bytes]) => ({
+        path,
+        mime: mime[path],
+        bytes: bytes.length,
+        sha256: await hashBytes(bytes)
+      }))
+    )
+  });
+  const result = { manifest, files };
+  await validatePackage(result);
+  return result;
+}
+async function draftPackage(draft, previews) {
+  const product = draft.design.product ?? "badge";
+  if (!printProductIds.includes(product))
+    throw new Error("Digital formats are exported as images, not submitted.");
+  const sticker = product === "sticker";
+  if (!sticker && !previews.back) throw new Error("Include previews of both faces.");
+  const missing = missingAssets(draft);
+  if (missing.length) throw new Error(`Add the missing images: ${missing.join(", ")}.`);
+  return assemblePackage(
+    {
+      product,
+      ...sticker ? { finish: draft.design.sticker?.finish ?? defaultStickerMaterial.finish } : {},
+      title: draft.design.name,
+      document: "design.json",
+      front: "front.png",
+      ...sticker ? {} : { back: "back.png" },
+      portrait: draft.portrait,
+      artwork: draft.artwork,
+      assets: draft.assets
+    },
+    {
+      ...draft.files,
+      "design.json": jsonBytes({
+        design: draft.design,
+        ...!sticker && draft.participant ? { participant: draft.participant } : {}
+      }),
+      "front.png": previews.front,
+      ...!sticker && previews.back ? { "back.png": previews.back } : {}
+    },
+    {
+      ...draft.mime,
+      "design.json": "application/json",
+      "front.png": "image/png",
+      ...sticker ? {} : { "back.png": "image/png" }
+    }
+  );
+}
+async function svgPackage(bytes, title = "Untitled card") {
+  const check = checkSubmittedSvg(new TextDecoder().decode(bytes));
+  if (!check.ok) throw new Error(check.error);
+  return assemblePackage(
+    { product: "card", title, source: "artwork.svg", front: "artwork.svg", assets: {} },
+    { "artwork.svg": bytes },
+    { "artwork.svg": "image/svg+xml" }
+  );
+}
+async function rasterPackage(bytes, mime, title = "Untitled card") {
+  const extension = mime === "image/jpeg" ? "jpg" : mime.split("/")[1];
+  const path = `artwork.${extension}`;
+  return assemblePackage(
+    { product: "card", title, source: path, front: path, assets: {} },
+    { [path]: bytes },
+    { [path]: mime }
+  );
+}
+async function validatePackage(pkg) {
+  const manifest = manifestSchema.parse(pkg.manifest);
+  if (jsonBytes(manifest).length > MANIFEST_LIMIT)
+    throw new Error("The package manifest exceeds 200 KB.");
+  if (Object.keys(pkg.files).length !== manifest.files.length)
+    throw new Error("The package file list does not match its manifest.");
+  for (const file2 of manifest.files) {
+    const bytes = pkg.files[file2.path];
+    if (!bytes || bytes.length !== file2.bytes || await hashBytes(bytes) !== file2.sha256)
+      throw new Error(`Missing or changed asset: ${file2.path}.`);
+  }
+  if (manifest.product === "kit") {
+    for (const item of manifest.items) await validatePackage(kitMemberPackage(pkg, item.id));
+    for (const sheet of manifest.sheets) {
+      const document = stickerSheetSchema.parse(parseJson(pkg.files[sheet.document]));
+      if (!document.items.length) throw new Error("A kit sheet must contain stickers.");
+      for (const item of document.items)
+        if (requiredAssets(item.design).assets.length || requiredAssets(item.design).artwork)
+          throw new Error("Kit sheets must embed their artwork.");
+      if (sheet.pdf) {
+        const text3 = new TextDecoder("latin1").decode(pkg.files[sheet.pdf]);
+        if (!text3.startsWith("%PDF-") || !text3.trimEnd().endsWith("%%EOF"))
+          throw new Error("Invalid print PDF.");
+      }
+    }
+    return manifest;
+  }
+  if (manifest.product === "brand") {
+    const brand = brandPackageDocumentSchema.parse(parseJson(pkg.files["brand.json"]));
+    const paths = new Set(manifest.files.map((file2) => file2.path));
+    for (const path of [brand.cover, ...brand.logos.map((logo) => logo.file)])
+      if (path && !paths.has(path)) throw new Error(`Missing brand file: ${path}.`);
+    if (brand.slug !== manifest.slug) throw new Error("The brand slug and manifest do not match.");
+    if (brand.kits.map((kit) => kit.submission).join() !== manifest.kits.join())
+      throw new Error("The brand kits and manifest do not match.");
+    return manifest;
+  }
+  for (const file2 of manifest.files.filter((f) => f.mime === "image/svg+xml")) {
+    const check = checkSubmittedSvg(new TextDecoder().decode(pkg.files[file2.path]));
+    if (!check.ok) throw new Error(check.error);
+  }
+  if (manifest.document) {
+    const document = documentSchema.parse(parseJson(pkg.files[manifest.document]));
+    if ((document.design.product ?? "badge") !== manifest.product)
+      throw new Error("The document and product do not match.");
+    if (manifest.product === "sticker" && manifest.finish !== (document.design.sticker?.finish ?? defaultStickerMaterial.finish))
+      throw new Error("The sticker finish and document do not match.");
+    if (manifest.product === "sticker" && document.participant)
+      throw new Error("Sticker packages must not contain participant information.");
+    const missing = missingAssets({ ...document, ...manifest, files: pkg.files, mime: {} });
+    if (missing.length) throw new Error(`Missing images: ${missing.join(", ")}.`);
+    if (requiredAssets(document.design).portrait && !document.participant)
+      throw new Error(
+        "Include participant details with a personalized badge. Export a package from the editor."
+      );
+  }
+  return manifest;
+}
+function checkArchive(bytes) {
+  if (bytes.length > PACKAGE_LIMIT + MANIFEST_LIMIT) throw new Error("The ZIP exceeds 24 MB.");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length < 22) throw new Error("Invalid ZIP archive.");
+  let end = bytes.length - 22;
+  while (end >= Math.max(0, bytes.length - 65557) && view.getUint32(end, true) !== 101010256)
+    end--;
+  if (end < 0 || end < bytes.length - 65557) throw new Error("Invalid ZIP directory.");
+  const count = view.getUint16(end + 10, true);
+  if (count > KIT_FILE_COUNT_LIMIT + 1 || view.getUint16(end + 4, true) || view.getUint16(end + 6, true))
+    throw new Error("Unsupported ZIP archive.");
+  let offset = view.getUint32(end + 16, true), total = 0;
+  const names = /* @__PURE__ */ new Set();
+  for (let index = 0; index < count; index++) {
+    if (offset + 46 > end || view.getUint32(offset, true) !== 33639248)
+      throw new Error("Invalid ZIP entry.");
+    const flags = view.getUint16(offset + 8, true), size = view.getUint32(offset + 24, true), length = view.getUint16(offset + 28, true);
+    const name = new TextDecoder().decode(bytes.subarray(offset + 46, offset + 46 + length));
+    if (flags & 1 || names.has(name) || name !== "manifest.json" && !archivePathSchema.safeParse(name).success || size > (name === "manifest.json" ? MANIFEST_LIMIT : FILE_LIMIT))
+      throw new Error("Unsafe, duplicate or oversized ZIP entry.");
+    total += size;
+    if (total > PACKAGE_LIMIT + MANIFEST_LIMIT) throw new Error("The expanded ZIP exceeds 24 MB.");
+    names.add(name);
+    offset += 46 + length + view.getUint16(offset + 30, true) + view.getUint16(offset + 32, true);
+  }
+  if (offset !== end || !names.has("manifest.json"))
+    throw new Error("Use a Makeables ZIP with manifest.json at its root.");
+  return names;
+}
+async function readPackageZip(bytes) {
+  const names = checkArchive(bytes);
+  const files = {};
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0;
+  const archive = new Unzip((file2) => {
+    if (!names.has(file2.name) || seen.has(file2.name) || (file2.originalSize ?? 0) > FILE_LIMIT)
+      throw new Error("Invalid ZIP entry.");
+    seen.add(file2.name);
+    const chunks = [];
+    let size = 0;
+    file2.ondata = (error, chunk, final) => {
+      if (error) throw error;
+      size += chunk.length;
+      total += chunk.length;
+      if (size > (file2.name === "manifest.json" ? MANIFEST_LIMIT : FILE_LIMIT) || total > PACKAGE_LIMIT + MANIFEST_LIMIT) {
+        file2.terminate();
+        throw new Error("The expanded ZIP exceeds its size limit.");
+      }
+      chunks.push(chunk);
+      if (final) {
+        const data = new Uint8Array(size);
+        let offset = 0;
+        for (const part of chunks) {
+          data.set(part, offset);
+          offset += part.length;
+        }
+        files[file2.name] = data;
+      }
+    };
+    file2.start();
+  });
+  archive.register(UnzipInflate);
+  for (let offset = 0; offset < bytes.length; offset += 1024)
+    archive.push(bytes.subarray(offset, offset + 1024), offset + 1024 >= bytes.length);
+  if (Object.keys(files).length !== names.size) throw new Error("Incomplete ZIP archive.");
+  const manifest = manifestSchema.parse(parseJson(files["manifest.json"]));
+  delete files["manifest.json"];
+  const pkg = { manifest, files };
+  await validatePackage(pkg);
+  return pkg;
+}
+async function packageZip(pkg) {
+  await validatePackage(pkg);
+  return zipSync({ "manifest.json": jsonBytes(pkg.manifest), ...pkg.files }, { level: 0 });
+}
+function draftFromPackage(pkg) {
+  if (pkg.manifest.product === "brand") throw new Error("A brand package has no single design.");
+  if (pkg.manifest.product === "kit")
+    throw new Error("Choose a kit member before opening its design.");
+  if (!pkg.manifest.document)
+    throw new Error("This package contains an original SVG, not a layered document.");
+  const doc = documentSchema.parse(parseJson(pkg.files[pkg.manifest.document]));
+  const paths = /* @__PURE__ */ new Set([
+    pkg.manifest.portrait,
+    pkg.manifest.artwork,
+    ...Object.values(pkg.manifest.assets)
+  ]);
+  return {
+    ...doc,
+    portrait: pkg.manifest.portrait,
+    artwork: pkg.manifest.artwork,
+    assets: pkg.manifest.assets,
+    files: Object.fromEntries(Object.entries(pkg.files).filter(([path]) => paths.has(path))),
+    mime: Object.fromEntries(
+      pkg.manifest.files.filter((f) => paths.has(f.path)).map((f) => [f.path, f.mime])
+    )
+  };
+}
+function productOf(pkg) {
+  return pkg.manifest.product;
+}
+function packageJson(pkg) {
+  return {
+    format: "makeables-package",
+    version: 1,
+    manifest: pkg.manifest,
+    files: Object.fromEntries(
+      Object.entries(pkg.files).map(([path, bytes]) => {
+        let binary = "";
+        for (const byte of bytes) binary += String.fromCharCode(byte);
+        return [path, btoa(binary)];
+      })
+    )
+  };
+}
+async function readPackageJson(value) {
+  const input = z32.object({
+    format: z32.literal("makeables-package"),
+    version: z32.literal(1),
+    manifest: manifestSchema,
+    files: z32.record(
+      archivePathSchema,
+      z32.string().max(Math.ceil(FILE_LIMIT / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/)
+    )
+  }).strict().parse(value);
+  if (Object.keys(input.files).length !== input.manifest.files.length)
+    throw new Error("The package file list does not match its manifest.");
+  for (const file2 of input.manifest.files) {
+    const encoded = input.files[file2.path];
+    const length = encoded ? encoded.length / 4 * 3 - (encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0) : 0;
+    if (length !== file2.bytes) throw new Error(`Missing or changed asset: ${file2.path}.`);
+  }
+  const files = Object.fromEntries(
+    Object.entries(input.files).map(([path, base64]) => [
+      path,
+      Uint8Array.from(atob(base64), (c) => c.charCodeAt(0))
+    ])
+  );
+  const pkg = { manifest: input.manifest, files };
+  await validatePackage(pkg);
+  return pkg;
+}
+function kitMemberPackage(pkg, id3) {
+  if (pkg.manifest.product !== "kit") throw new Error("This package is not a kit.");
+  const item = pkg.manifest.items.find((item2) => item2.id === id3);
+  if (!item) throw new Error("Unknown kit piece.");
+  return {
+    manifest: item.manifest,
+    files: Object.fromEntries(
+      item.manifest.files.map((file2) => [file2.path, pkg.files[`items/${id3}/${file2.path}`]])
+    )
+  };
+}
+
+export {
+  __commonJS,
+  __toESM,
+  checkSubmittedSvg,
+  cardMarkSvg,
+  designProfile,
+  stickerMaterialSchema,
+  defaultStickerMaterial,
+  svgNodeSchema,
+  svgNodeXml,
+  badgeLayerSchema,
+  badgeDesignObjectSchema,
+  badgeDesignSchema,
+  preserveDesignLocks,
+  pruneAssets,
+  addSticker,
+  cardMarkLayer,
+  createCardDesign,
+  sheetSizes,
+  sheetTypes,
+  sheetTypeIds,
+  stickerSheetSchema,
+  sheetSpec,
+  createStickerSheet,
+  sheetBorderPixels,
+  badgeQrLayout,
+  communityParticipantSchema,
+  strToU8,
+  zipSync,
+  brandSlugSchema,
+  brandLayouts,
+  brandDocumentSchema,
+  brandPackageDocumentSchema,
+  kitDocumentSchema,
+  FILE_LIMIT,
+  PACKAGE_LIMIT,
+  FILE_COUNT_LIMIT,
+  KIT_FILE_COUNT_LIMIT,
+  MANIFEST_LIMIT,
+  providers,
+  submissionMetadataSchema,
+  designManifestSchema,
+  kitManifestSchema,
+  BRAND_FILE_COUNT_LIMIT,
+  brandManifestSchema,
+  manifestSchema,
+  documentSchema,
+  jsonBytes,
+  parseJson,
+  hashBytes,
+  requiredAssets,
+  missingAssets,
+  importDraft,
+  assemblePackage,
+  draftPackage,
+  svgPackage,
+  rasterPackage,
+  validatePackage,
+  readPackageZip,
+  packageZip,
+  draftFromPackage,
+  productOf,
+  packageJson,
+  readPackageJson,
+  kitMemberPackage
+};