makeables 0.10.0 → 0.11.0

package/dist/{chunk-G6OTYITI.js → chunk-YB2YJCBS.js}

@@ -1,1393 +1,38 @@
-// ../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 box3 = value.split(/[\s,]+/).map(Number).join(" ");
-        if (box3 !== "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-XV4DY67T.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 productIds = ["badge", "card", "sticker"];
-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"
-  }
-};
-function designProfile(design2) {
-  return designProfiles[design2.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; designIssues checks each product's own canvas.
-  x: z3.number().min(0).max(1535),
-  y: z3.number().min(0).max(1535),
-  w: z3.number().min(1).max(1536),
-  h: z3.number().min(1).max(1536),
-  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(hex) {
-  const rgb = [1, 3, 5].map((start) => Number.parseInt(hex.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(design2) {
-  const issues2 = [];
-  const profile = designProfile(design2);
-  const badge = profile.id === "badge";
-  if (!badge && design2.material.holder) issues2.push("A holder is only available for badges.");
-  if (profile.id !== "card" && (design2.material.stock || design2.material.optics))
-    issues2.push("Stock and optics are only available for cards.");
-  for (const side2 of ["front", "back"])
-    for (const layer of design2[side2].layers) {
-      if (!layer.finish) continue;
-      if (profile.id !== "card")
-        issues2.push(`${side2}.${layer.id}: finish is only available for cards.`);
-      else if (layer.finish === "raised" && side2 === "back")
-        issues2.push(`back.${layer.id}: raised finish is only available on the front.`);
-    }
-  const assets = design2.assets ?? {};
-  if (design2.sticker?.effectMap) {
-    const { asset, layer } = design2.sticker.effectMap;
-    if (!assets[asset]) issues2.push(`sticker.effectMap: missing asset ${asset}`);
-    if (!design2.front.layers.some((value) => value.id === layer && value.kind === "image"))
-      issues2.push(`sticker.effectMap: ${layer} must name a front image layer`);
-  }
-  for (const id3 of Object.keys(design2.sticker?.regions ?? {}))
-    if (!design2.front.layers.some((layer) => layer.id === id3))
-      issues2.push(`sticker.regions: missing front layer ${id3}`);
-  if (profile.id === "sticker" && design2.back.layers.length)
-    issues2.push("Stickers have one editable face; keep back layers empty.");
-  if (Object.keys(assets).length > 24) issues2.push("assets: 24 como m\xE1ximo");
-  for (const side2 of ["front", "back"])
-    for (const layer of design2[side2].layers)
-      if (layer.kind === "image" && layer.asset !== ART_ASSET && !assets[layer.asset])
-        issues2.push(`${side2}.${layer.id}: falta el asset ${layer.asset}`);
-  for (const side2 of ["front", "back"]) {
-    const layers = design2[side2].layers;
-    const ids = /* @__PURE__ */ new Set();
-    for (const [i, layer] of layers.entries()) {
-      if (ids.has(layer.id)) issues2.push(`${side2}: 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)
-        issues2.push(`${side2}.${layer.id}: outside the ${profile.label.toLowerCase()}`);
-      if (profile.id === "sticker" && layer.kind === "text" && layer.binding !== "none")
-        issues2.push("Sticker text uses free text, without participant bindings.");
-      if (profile.id === "sticker" && layer.kind === "portrait")
-        issues2.push("Stickers use image layers, not participant portraits.");
-      if (!badge && layer.kind === "qr")
-        issues2.push(`${side2}.${layer.id}: QR codes are for badges`);
-      if (layer.kind === "svg" && !design2.svgSource)
-        issues2.push(`${side2}.${layer.id}: missing original SVG definitions`);
-      if (side2 === "front" && layer.visible !== false && !isBackground(layer, profile)) {
-        for (const area2 of profile.keepClear)
-          if (intersects(bounds, area2))
-            issues2.push(`${side2}.${layer.id}: covers the ${area2.label} area`);
-      }
-      if (badge && ["text", "portrait", "qr"].includes(layer.kind) && bounds.y < 89.99)
-        issues2.push(`${side2}.${layer.id}: reserva superior de 90 px`);
-      if ((layer.kind === "portrait" || layer.kind === "image") && layer.channel === "ink")
-        issues2.push(`${side2}.${layer.id}: las im\xE1genes pertenecen a la impresi\xF3n`);
-      if (layer.kind === "graphic" && layer.pattern === "path") {
-        const path2 = layer.path?.trim() ?? "";
-        const numbers2 = path2.match(/[-+]?(?:\d*\.?\d+)(?:[eE][-+]?\d+)?/g) ?? [];
-        if (!/^[Mm]/.test(path2) || numbers2.some(
-          (value) => !Number.isFinite(Number(value)) || Math.abs(Number(value)) > 16384
-        ))
-          issues2.push(`${side2}.${layer.id}: trazado inv\xE1lido o fuera de rango`);
-      }
-      if (layer.kind === "qr") {
-        const minimum = side2 === "front" ? 128 : 280;
-        if (layer.w < minimum || layer.w !== layer.h || layer.rotation || (layer.opacity ?? 1) !== 1)
-          issues2.push(`${side2}.${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"
-        ))
-          issues2.push(`${side2}.${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)))
-          issues2.push(`${side2}.${layer.id}: QR tapado por otra capa`);
-      }
-    }
-    if (badge && layers.length < 3) issues2.push(`${side2}: al menos 3 capas`);
-    if (badge && !layers.some((l) => l.kind === "text" && l.binding === "name"))
-      issues2.push(`${side2}: falta el nombre vinculado`);
-  }
-  const portraits = design2.front.layers.filter((l) => l.kind === "portrait").length;
-  if (badge && (portraits < 1 || portraits > 4)) issues2.push("front: debe tener un retrato");
-  if (!badge && portraits > 4) issues2.push("front: 4 portraits at most");
-  for (const side2 of ["front", "back"])
-    if (design2[side2].layers.filter((layer) => layer.kind === "effect").length > 24)
-      issues2.push(`${side2}: m\xE1ximo 24 efectos`);
-  if (badge && !design2.back.layers.some((l) => l.kind === "qr")) issues2.push("back: falta el QR");
-  if (badge && !design2.back.layers.some(isRoleBoundLayer))
-    issues2.push("back: falta el rol vinculado");
-  return issues2;
-}
-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((design2) => {
-  if (design2.product !== "card") return design2;
-  return {
-    ...design2,
-    front: {
-      ...design2.front,
-      layers: design2.front.layers.map(
-        (layer) => layer.kind === "card-mark" ? { ...layer, ...cardMarkRegion(layer) } : layer
-      )
-    },
-    back: {
-      ...design2.back,
-      layers: design2.back.layers.map(
-        (layer) => layer.kind === "card-mark" ? { ...layer, ...cardMarkRegion(layer) } : layer
-      )
-    }
-  };
-}).superRefine((design2, context) => {
-  for (const message of designIssues(design2))
-    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 side2 of ["front", "back"]) {
-    const locked = new Set(locks[side2]);
-    output[side2].layers = output[side2].layers.filter((l) => !locked.has(l.id));
-    for (const [index, layer] of current[side2].layers.entries()) {
-      if (locked.has(layer.id))
-        output[side2].layers.splice(
-          Math.min(index, output[side2].layers.length),
-          0,
-          structuredClone(layer)
-        );
-    }
-  }
-  return badgeDesignSchema.parse(output);
-}
-function referencedDesignAssets(design2) {
-  return [
-    .../* @__PURE__ */ new Set([
-      ...["front", "back"].flatMap(
-        (side2) => design2[side2].layers.flatMap((layer) => layer.kind === "image" ? [layer.asset] : [])
-      ),
-      ...design2.sticker?.effectMap ? [design2.sticker.effectMap.asset] : []
-    ])
-  ];
-}
-function pruneAssets(design2) {
-  if (design2.sticker) {
-    const ids = new Set(design2.front.layers.map((layer) => layer.id));
-    design2 = {
-      ...design2,
-      sticker: {
-        ...design2.sticker,
-        effectMap: design2.sticker.effectMap && ids.has(design2.sticker.effectMap.layer) ? design2.sticker.effectMap : void 0,
-        regions: design2.sticker.regions ? Object.fromEntries(Object.entries(design2.sticker.regions).filter(([id3]) => ids.has(id3))) : void 0
-      }
-    };
-  }
-  if (!design2.assets) return design2;
-  const used = new Set(referencedDesignAssets(design2));
-  const assets = Object.fromEntries(Object.entries(design2.assets).filter(([id3]) => used.has(id3)));
-  return { ...design2, 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, canvas2, front) {
-  const count = layers.filter((layer) => layer.kind === "image" && layer.fit === "contain").length;
-  const place = ([cx, cy]) => ({
-    x: Math.round(Math.min(canvas2.width - 1 - w, Math.max(0, canvas2.width * cx - w / 2))),
-    y: Math.round(Math.min(canvas2.height - 1 - h, Math.max(0, canvas2.height * cy - h / 2)))
-  });
-  const clear = (position) => !front || canvas2.keepClear.every(
-    (area2) => !(position.x < area2.x + area2.w && area2.x < position.x + w && position.y < area2.y + area2.h && area2.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(canvas2.width - 1 - w, slot.x + nudge),
-    y: Math.min(canvas2.height - 1 - h, slot.y + nudge)
-  };
-}
-function addSticker(design2, side2, asset, size, id3) {
-  const canvas2 = designProfile(design2);
-  const longest = Math.min(STICKER_SIZE, Math.round(Math.min(canvas2.width, canvas2.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(design2[side2].layers, w, h, canvas2, side2 === "front"),
-    w,
-    h,
-    opacity: 1,
-    radius: 0
-  };
-  const layers = [...design2[side2].layers];
-  const qr2 = layers.findIndex((item) => item.kind === "qr");
-  layers.splice(qr2 < 0 ? layers.length : qr2, 0, layer);
-  return badgeDesignSchema.parse({
-    ...design2,
-    assets: { ...design2.assets, [assetId2]: asset },
-    [side2]: { ...design2[side2], 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-MF6TKV3S.js
-import { z as z4 } 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 = z4.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/);
-var sheetItemSchema = z4.object({
-  id,
-  design: badgeDesignSchema,
-  /** Centre of the sticker canvas on the sheet. */
-  x: z4.number().min(-1e3).max(1e3),
-  y: z4.number().min(-1e3).max(1e3),
-  rotation: z4.number().min(-360).max(360),
-  /** Printed width of the square sticker canvas. */
-  widthMm: z4.number().min(5).max(300)
-});
-var stickerSheetSchema = z4.object({
-  format: z4.literal("makeables-sheet"),
-  version: z4.literal(1),
-  name: z4.string().min(1).max(80),
-  type: z4.enum(sheetTypeIds),
-  printer: z4.enum(Object.keys(printerPresets)),
-  size: z4.enum(Object.keys(sheetSizes)).optional(),
-  /** Border override for every sticker; the type's border otherwise. */
-  borderMm: z4.number().min(0).max(10).optional(),
-  /** Auto-pack keeps this sticker where it is. */
-  hero: id.optional(),
-  items: z4.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;
-}
+import {
+  PACKAGE_LIMIT,
+  addSticker,
+  badgeDesignObjectSchema,
+  badgeDesignSchema,
+  badgeLayerSchema,
+  badgeQrLayout,
+  cardMarkLayer,
+  cardMarkSvg,
+  createCardDesign,
+  defaultStickerMaterial,
+  designProfile,
+  draftPackage,
+  hashBytes,
+  importDraft,
+  jsonBytes,
+  missingAssets,
+  parseJson,
+  preserveDesignLocks,
+  pruneAssets,
+  readPackageJson,
+  readPackageZip,
+  requiredAssets,
+  sheetBorderPixels,
+  sheetSpec,
+  sheetTypes,
+  stickerMaterialSchema,
+  submissionMetadataSchema,
+  svgNodeXml,
+  svgPackage
+} from "./chunk-DLTVENEP.js";
 
 // ../design/dist/chunk-VKBNWHNO.js
-var t = (id3, value, x, baseline, w, size, font, color3, extra = {}) => ({
-  id: id3,
+var t = (id, value, x, baseline, w, size, font, color, extra = {}) => ({
+  id,
   kind: "text",
   binding: value.startsWith("$") ? value.slice(1) : "none",
   text: value.startsWith("$") ? "" : value,
@@ -1397,7 +42,7 @@ var t = (id3, value, x, baseline, w, size, font, color3, extra = {}) => ({
   h: Math.min(size * 1.15, 1536 - baseline + size),
   size,
   font,
-  color: color3,
+  color,
   weight: ["mono", "pixel", "script"].includes(font) ? "400" : "700",
   align: "left",
   baseline: "alphabetic",
@@ -1406,19 +51,19 @@ var t = (id3, value, x, baseline, w, size, font, color3, extra = {}) => ({
   lineHeight: 1,
   ...extra
 });
-var s = (id3, x, y, w, h, color3, shape2 = "rectangle", opacity = 1) => ({
-  id: id3,
+var s = (id, x, y, w, h, color, shape = "rectangle", opacity = 1) => ({
+  id,
   kind: "shape",
   x,
   y,
   w,
   h,
-  color: color3,
-  shape: shape2,
+  color,
+  shape,
   opacity,
   channel: "ink",
   radius: 0,
-  stroke: shape2 === "corners" ? 4 : 2
+  stroke: shape === "corners" ? 4 : 2
 });
 var p = (x, y, w, h, extra = {}) => ({
   id: "portrait",
@@ -1432,15 +77,15 @@ var p = (x, y, w, h, extra = {}) => ({
   crop: { x: 0.5, y: 0.5, zoom: 1 },
   ...extra
 });
-var g = (id3, pattern, x, y, w, h, color3, accent = color3, extra = {}) => ({
-  id: id3,
+var g = (id, pattern, x, y, w, h, color, accent = color, extra = {}) => ({
+  id,
   kind: "graphic",
   pattern,
   x,
   y,
   w,
   h,
-  color: color3,
+  color,
   accent,
   density: 1,
   seed: 1,
@@ -1457,7 +102,7 @@ var q = (x, y, w) => ({
   foreground: "#090a0b"
 });
 var upper = { transform: "uppercase" };
-var rule = (id3, y, color3, x = 84, w = 856) => s(id3, x, y, w, 1.5, color3, "rectangle", 0.35);
+var rule = (id, y, color, x = 84, w = 856) => s(id, x, y, w, 1.5, color, "rectangle", 0.35);
 var flow = () => g("flow", "chromatic-paper", 0, 0, 1024, 1536, "#f8eff3", "#f563fc");
 function design(source, event, description, background, front, back, surface = "satin") {
   return {
@@ -1715,7 +360,7 @@ var archive = design(
     q(92, 931, 336)
   ]
 );
-function classic(id3, event, title, subtitle, base, ink, accent, font, layout) {
+function classic(id, event, title, subtitle, base, ink, accent, font, layout) {
   const variant = layout === "winter" ? "snow" : layout === "postage" ? "postal" : "grid";
   const decoration = () => [g("paper", "paper", 0, 0, 1024, 1536, base, accent, { variant, ink })];
   const x = layout === "terminal" ? 102 : layout === "postage" ? 160 : 140;
@@ -1812,7 +457,7 @@ function classic(id3, event, title, subtitle, base, ink, accent, font, layout) {
     { ...q(84, 823, 374), foreground: "#141414", maxCellSize: 10 }
   ];
   return design(
-    id3,
+    id,
     event,
     layout === "winter" ? "Cristal de invierno, nieve y retrato con arco." : layout === "terminal" ? "F\xF3sforo c\xE1lido, ret\xEDcula y l\xEDneas de escaneo." : "Cobre quemado, marco doble y sello de edici\xF3n.",
     base,
@@ -1821,9 +466,9 @@ function classic(id3, event, title, subtitle, base, ink, accent, font, layout) {
     layout === "winter" ? "prism" : "satin"
   );
 }
-var window2 = (id3, x, y, w, h, title) => [
-  g(id3, "window", x, y, w, h, "#dedede", "#1807c7"),
-  t(`${id3}-title`, title, x + 20, y + 43, w - 150, 23, "pixel", "#ffffff")
+var window2 = (id, x, y, w, h, title) => [
+  g(id, "window", x, y, w, h, "#dedede", "#1807c7"),
+  t(`${id}-title`, title, x + 20, y + 43, w - 150, 23, "pixel", "#ffffff")
 ];
 var sky = () => g("sky", "sky", 0, 0, 1024, 1536, "#28518b", "#79a310", { seed: 1010 });
 var vibecode = design(
@@ -2103,9 +748,9 @@ var gtm = design(
     q(92, 974, 360)
   ]
 );
-var signalFrame = (id3, y, h) => [
-  s(`${id3}-rule`, 72, y, 660, h, "#f4f4f2", "frame", 0.22),
-  s(id3, 72, y, 660, h, "#f4f4f2", "corners")
+var signalFrame = (id, y, h) => [
+  s(`${id}-rule`, 72, y, 660, h, "#f4f4f2", "frame", 0.22),
+  s(id, 72, y, 660, h, "#f4f4f2", "corners")
 ];
 var signalHeader = () => [
   ...signalFrame("header", 148, 190),
@@ -2125,7 +770,7 @@ var signalHeader = () => [
   }),
   s("red-rule", 788, 148, 7, 52, "#bd0a2b")
 ];
-var numbers = (id3, y) => t(id3, "#{number} * #{number} * #{number}", 108, y, 586, 26, "mono", "#f4f4f2", {
+var numbers = (id, y) => t(id, "#{number} * #{number} * #{number}", 108, y, 586, 26, "mono", "#f4f4f2", {
   binding: "template",
   fit: "spread",
   opacity: 0.4
@@ -2221,7 +866,7 @@ var collectionDesigns = [
 ].map((value) => badgeDesignSchema.parse(value));
 
 // ../design/dist/index.js
-import { z as z5 } from "zod";
+import { z } from "zod";
 var cardFinishRecipes = {
   // A printer's proof: CMY registration light, scanline grain, sharp glitch edges.
   afterimage: {
@@ -2734,77 +1379,77 @@ var chrome = {
   iridescence: 0.1,
   speed: 0.12
 };
-function named(id3, [x, y, w, h]) {
+function named(id, [x, y, w, h]) {
   return {
-    id: id3,
-    name: id3.replace(/-/g, " ").replace(/^./, (letter) => letter.toUpperCase()),
+    id,
+    name: id.replace(/-/g, " ").replace(/^./, (letter) => letter.toUpperCase()),
     x,
     y,
     w,
     h
   };
 }
-function rect(id3, box3, color3, radius = 0, opacity = 1) {
+function rect(id, box2, color, radius = 0, opacity = 1) {
   return {
-    ...named(id3, box3),
+    ...named(id, box2),
     kind: "shape",
     shape: "rectangle",
-    color: color3,
+    color,
     radius,
     stroke: 0,
     opacity,
     protectMaterial: false
   };
 }
-function circle(id3, cx, cy, radius, color3, stroke = 0, opacity = 1) {
+function circle(id, cx, cy, radius, color, stroke = 0, opacity = 1) {
   if (stroke > 0) {
     const r = radius - stroke / 2;
     return path(
-      id3,
+      id,
       [cx - radius, cy - radius, radius * 2, radius * 2],
       `M${radius - r} ${radius}a${r} ${r} 0 1 0 ${r * 2} 0a${r} ${r} 0 1 0 ${-r * 2} 0`,
-      color3,
+      color,
       stroke,
       opacity
     );
   }
   return {
-    ...named(id3, [cx - radius, cy - radius, radius * 2, radius * 2]),
+    ...named(id, [cx - radius, cy - radius, radius * 2, radius * 2]),
     kind: "shape",
     shape: "ellipse",
-    color: color3,
+    color,
     radius: 0,
     stroke,
     opacity,
     protectMaterial: false
   };
 }
-function path(id3, box3, d, color3, stroke = 0, opacity = 1, viewBox) {
+function path(id, box2, d, color, stroke = 0, opacity = 1, viewBox) {
   return {
-    ...named(id3, box3),
+    ...named(id, box2),
     kind: "graphic",
     pattern: "path",
-    color: color3,
-    accent: color3,
+    color,
+    accent: color,
     density: 1,
     seed: 1,
     path: d,
-    viewBox: viewBox ?? { width: box3[2], height: box3[3] },
+    viewBox: viewBox ?? { width: box2[2], height: box2[3] },
     stroke,
     opacity,
     protectMaterial: false
   };
 }
-function field(id3, d, color3, stroke = 0, opacity = 1) {
-  return path(id3, full, d, color3, stroke, opacity);
+function field(id, d, color, stroke = 0, opacity = 1) {
+  return path(id, full, d, color, stroke, opacity);
 }
-function text3(id3, value, box3, color3, size = 20, font = "mono", weight = "500") {
+function text(id, value, box2, color, size = 20, font = "mono", weight = "500") {
   return {
-    ...named(id3, box3),
+    ...named(id, box2),
     kind: "text",
     text: value,
     binding: "none",
-    color: color3,
+    color,
     font,
     size,
     weight,
@@ -2814,18 +1459,18 @@ function text3(id3, value, box3, color3, size = 20, font = "mono", weight = "500
     protectMaterial: true
   };
 }
-function gradient2(id3, colors, direction = "diagonal", box3 = full) {
+function gradient(id, colors, direction = "diagonal", box2 = full) {
   return {
-    ...named(id3, box3),
+    ...named(id, box2),
     kind: "gradient",
     direction,
-    stops: colors.map((color3, index) => ({ color: color3, at: index / (colors.length - 1) }))
+    stops: colors.map((color, index) => ({ color, at: index / (colors.length - 1) }))
   };
 }
-function film(id3, effect22, colors, opacity = 0.1, box3 = full) {
-  return { ...named(id3, box3), kind: "effect", effect: effect22, colors, scale: 1.4, opacity };
+function film(id, effect22, colors, opacity = 0.1, box2 = full) {
+  return { ...named(id, box2), kind: "effect", effect: effect22, colors, scale: 1.4, opacity };
 }
-function stars(id3, color3, seed, count = 45) {
+function stars(id, color, seed, count = 45) {
   let state = seed;
   const random2 = () => {
     state = state * 1664525 + 1013904223 >>> 0;
@@ -2837,7 +1482,7 @@ function stars(id3, color3, seed, count = 45) {
     const r = random2() > 0.85 ? 2.5 : 1.2;
     return `M${x - r} ${y}h${r * 2}m${-r} ${-r}v${r * 2}`;
   }).join("");
-  return field(id3, d, color3, 1.5, 0.65);
+  return field(id, d, color, 1.5, 0.65);
 }
 function smallStar(x, y, r) {
   return `${Array.from({ length: 10 }, (_, i) => {
@@ -2846,12 +1491,12 @@ function smallStar(x, y, r) {
     return `${i ? "L" : "M"}${(x + Math.cos(angle) * radius).toFixed(2)} ${(y + Math.sin(angle) * radius).toFixed(2)}`;
   }).join("")}Z`;
 }
-function grid(id3, box3, color3, cell, opacity = 0.2) {
-  const [, , w, h] = box3;
+function grid(id, box2, color, cell, opacity = 0.2) {
+  const [, , w, h] = box2;
   let d = "";
   for (let x = 0; x <= w; x += cell) d += `M${x} 0V${h}`;
   for (let y = 0; y <= h; y += cell) d += `M0 ${y}H${w}`;
-  return path(id3, box3, d, color3, 1, opacity);
+  return path(id, box2, d, color, 1, opacity);
 }
 var cardDirections = {
   afterimage: {
@@ -2977,30 +1622,30 @@ var cardDirections = {
 };
 function cardReverse(slug, original) {
   const { base, ink, accent } = cardDirections[slug];
-  const motif2 = (index, box3, opacity = 1) => {
+  const motif2 = (index, box2, opacity = 1) => {
     const source = original[index - 1];
-    const scale = Math.min(box3[2] / source.w, box3[3] / source.h);
+    const scale = Math.min(box2[2] / source.w, box2[3] / source.h);
     const w = source.w * scale, h = source.h * scale;
     return {
       ...structuredClone(source),
       id: `reverse-source-${index}`,
       name: `Reverse \xB7 ${source.name}`,
-      x: box3[0] + (box3[2] - w) / 2,
-      y: box3[1] + (box3[3] - h) / 2,
+      x: box2[0] + (box2[2] - w) / 2,
+      y: box2[1] + (box2[3] - h) / 2,
       w,
       h,
       opacity
     };
   };
-  const label = (id3, value, x, y, w = 900, color3 = ink) => text3(id3, value, [x, y, w, 28], color3, 14);
-  const title = (value, x = 80, y = 260, w = 900, size = 88, font = "sans") => text3("reverse-title", value, [x, y, w, size * 2.5], ink, size, font, "600");
-  const line2 = (id3, y, color3 = ink) => path(id3, [80, y, 1040, 2], "M0 1H1040", color3, 1, 0.5);
+  const label = (id, value, x, y, w = 900, color = ink) => text(id, value, [x, y, w, 28], color, 14);
+  const title = (value, x = 80, y = 260, w = 900, size = 88, font = "sans") => text("reverse-title", value, [x, y, w, size * 2.5], ink, size, font, "600");
+  const line2 = (id, y, color = ink) => path(id, [80, y, 1040, 2], "M0 1H1040", color, 1, 0.5);
   const frame = () => field("reverse-frame", "M40 40H1160V716H40Z", accent, 1, 0.5);
   let layers;
   switch (slug) {
     case "afterimage":
       layers = [
-        gradient2("graphite", ["#11141c", "#242c37"]),
+        gradient("graphite", ["#11141c", "#242c37"]),
         grid("registration-grid", [40, 40, 1120, 676], "#738090", 40, 0.08),
         ...[0, 1, 2].map(
           (i) => circle(
@@ -3024,7 +1669,7 @@ function cardReverse(slug, original) {
       break;
     case "blue-hour":
       layers = [
-        gradient2("nightfall", ["#111535", "#283a6b"], "vertical"),
+        gradient("nightfall", ["#111535", "#283a6b"], "vertical"),
         stars("city-stars", "#dce6ff", 420, 55),
         motif2(3, [940, 76, 110, 110]),
         motif2(4, [0, 527, 1200, 229], 0.7),
@@ -3038,12 +1683,12 @@ function cardReverse(slug, original) {
       break;
     case "checkpoint":
       layers = [
-        gradient2("save-screen", ["#291b46", "#40204f"]),
+        gradient("save-screen", ["#291b46", "#40204f"]),
         grid("save-pixels", [0, 0, 1200, 756], "#bf8aaf", 24, 0.07),
         rect("save-panel-shadow", [105, 156, 990, 400], "#130e29"),
         rect("save-panel", [92, 143, 990, 400], "#684369"),
         rect("save-inset", [104, 155, 966, 376], "#2c2047"),
-        text3("save-title", "SAVE COMPLETE", [158, 211, 820, 85], ink, 53, "pixel"),
+        text("save-title", "SAVE COMPLETE", [158, 211, 820, 85], ink, 53, "pixel"),
         label("save-message", "A GOOD PLACE TO BEGIN AGAIN.", 161, 323, 860),
         ...Array.from(
           { length: 12 },
@@ -3060,9 +1705,9 @@ function cardReverse(slug, original) {
         rect("obsidian-veil", [0, 0, 1200, 756], "#070909", 0, 0.58),
         frame(),
         field("inner-gold-rim", "M58 58H1142V698H58Z", accent, 1, 0.2),
-        text3("private-reverse", "PRIVATE EDITION", [80, 79, 1030, 30], ink, 17),
+        text("private-reverse", "PRIVATE EDITION", [80, 79, 1030, 30], ink, 17),
         motif2(8, [442, 175, 318, 137]),
-        text3(
+        text(
           "builders-manifesto",
           "BUILD. SHIP. REPEAT.",
           [180, 389, 850, 75],
@@ -3078,10 +1723,10 @@ function cardReverse(slug, original) {
       break;
     case "dream-sequence":
       layers = [
-        gradient2("dream-paper", ["#8e8bc4", "#c5b0df", "#f0d5d8"], "vertical"),
+        gradient("dream-paper", ["#8e8bc4", "#c5b0df", "#f0d5d8"], "vertical"),
         stars("dream-dust", "#fffaf6", 782, 28),
         motif2(3, [672, 398, 528, 358], 0.65),
-        text3(
+        text(
           "dream-letter",
           "see you on\nthe other side.",
           [96, 224, 970, 235],
@@ -3098,7 +1743,7 @@ function cardReverse(slug, original) {
       break;
     case "electric-bloom":
       layers = [
-        gradient2("violet-foil", ["#130c23", "#331639", "#15142f"]),
+        gradient("violet-foil", ["#130c23", "#331639", "#15142f"]),
         stars("pollen", "#dccbff", 119, 65),
         film("interference", "orbits", ["#2c183b", "#b97bca", "#73bfcf"], 0.14),
         ...[242, 200, 154].map(
@@ -3113,24 +1758,24 @@ function cardReverse(slug, original) {
       break;
     case "extra-life":
       layers = [
-        gradient2("arcade-panel", ["#120d20", "#341136"]),
+        gradient("arcade-panel", ["#120d20", "#341136"]),
         grid("arcade-grid", [0, 0, 1200, 756], "#a653b8", 28, 0.07),
         label("arcade-index", "EXTRA LIFE / PLAYER ONE", 82, 77),
-        text3("continue-question", "CONTINUE?", [79, 203, 1050, 111], ink, 77, "pixel"),
+        text("continue-question", "CONTINUE?", [79, 203, 1050, 111], ink, 77, "pixel"),
         ...[0, 1, 2].map((i) => ({
           ...motif2(20, [88 + i * 126, 376, 92, 85], i < 2 ? 1 : 0.22),
           id: `life-${i}`
         })),
         rect("yes-button-shadow", [757, 371, 310, 117], "#4b214e"),
         rect("yes-button", [746, 360, 310, 117], accent),
-        text3("yes-label", "YES +1", [785, 394, 245, 69], "#ffffff", 39, "pixel"),
+        text("yes-label", "YES +1", [785, 394, 245, 69], "#ffffff", 39, "pixel"),
         line2("arcade-rule", 557, "#8a4c94"),
         label("extra-message", "ONE MORE CHANCE. MAKE IT COUNT.", 86, 612)
       ];
       break;
     case "form-study":
       layers = [
-        gradient2("mineral-stock", ["#f4ede1", "#ded8ca"]),
+        gradient("mineral-stock", ["#f4ede1", "#ded8ca"]),
         film("paper-fibres", "grain", ["#ece6d9", "#b9ad94", "#ffffff"], 0.04),
         rect("clay-margin", [0, 0, 44, 756], "#c45b43"),
         circle("ochre-form", 960, 190, 120, "#d9a342"),
@@ -3144,11 +1789,11 @@ function cardReverse(slug, original) {
       break;
     case "garra-29":
       layers = [
-        gradient2("maroon-enamel", ["#8d1828", "#b02138"]),
+        gradient("maroon-enamel", ["#8d1828", "#b02138"]),
         film("heritage-grain", "grain", ["#a6192e", "#d49a9a", "#5b1120"], 0.04),
         field("cream-frame", "M38 38H1162V718H38Z", ink, 1.5, 0.8),
-        text3("heritage-number", "29", [83, 257, 534, 302], ink, 218, "sans", "800"),
-        text3("one-legacy", "ONE\nLEGACY.", [704, 390, 438, 151], ink, 57, "sans", "700"),
+        text("heritage-number", "29", [83, 257, 534, 302], ink, 218, "sans", "800"),
+        text("one-legacy", "ONE\nLEGACY.", [704, 390, 438, 151], ink, 57, "sans", "700"),
         ...Array.from(
           { length: 29 },
           (_, i) => path(
@@ -3165,7 +1810,7 @@ function cardReverse(slug, original) {
       break;
     case "hunter-license-1999":
       layers = [
-        gradient2("vermilion-lacquer", ["#a83429", "#ca563b"]),
+        gradient("vermilion-lacquer", ["#a83429", "#ca563b"]),
         frame(),
         rect("gold-header", [0, 73, 1200, 85], accent),
         label("classic-header", "HUNTER ASSOCIATION / CLASSIC EDITION", 81, 101, 1030, "#6a2d26"),
@@ -3180,7 +1825,7 @@ function cardReverse(slug, original) {
     case "hunter-license-green": {
       const green = slug.endsWith("green");
       layers = [
-        gradient2(
+        gradient(
           "association-metal",
           green ? ["#123b23", "#286440", "#17432a"] : ["#dbe9ec", "#a9cbdc", "#c9dfe6"]
         ),
@@ -3205,10 +1850,10 @@ function cardReverse(slug, original) {
     }
     case "interval":
       layers = [
-        gradient2("warm-paper", ["#f7f2e8", "#e7e2d8"]),
+        gradient("warm-paper", ["#f7f2e8", "#e7e2d8"]),
         grid("measuring-field", [81, 135, 1038, 479], "#bbb2a2", 39, 0.17),
         rect("vermilion-spine", [80, 135, 21, 478], accent),
-        text3("second-interval", "02", [786, 364, 337, 238], ink, 180, "sans", "400"),
+        text("second-interval", "02", [786, 364, 337, 238], ink, 180, "sans", "400"),
         label("interval-title", "INTERVAL / THE SPACE BETWEEN", 81, 79),
         title("ROOM\nTO THINK.", 130, 221, 700, 73),
         field(
@@ -3223,7 +1868,7 @@ function cardReverse(slug, original) {
       break;
     case "moon-rabbit":
       layers = [
-        gradient2("moonlit-indigo", ["#0a1229", "#292c4c"], "vertical"),
+        gradient("moonlit-indigo", ["#0a1229", "#292c4c"], "vertical"),
         stars("night-stars", "#dce1e8", 550, 74),
         motif2(8, [831, 92, 205, 205]),
         circle("moon-orbit", 934, 195, 133, "#d1cbed", 1, 0.3),
@@ -3236,7 +1881,7 @@ function cardReverse(slug, original) {
       break;
     case "side-quest":
       layers = [
-        gradient2("map-ocean", ["#174d6b", "#2a7892"]),
+        gradient("map-ocean", ["#174d6b", "#2a7892"]),
         grid("map-grid", [0, 0, 1200, 756], "#a3d3dd", 36, 0.12),
         motif2(2, [755, 133, 365, 456], 0.75),
         title("TAKE A\nDETOUR.", 80, 179, 800, 74, "pixel"),
@@ -3261,8 +1906,8 @@ function cardReverse(slug, original) {
       break;
     case "soft-signal":
       layers = [
-        gradient2("porcelain", ["#f5eee5", "#e7d8cc"]),
-        gradient2("copper-bloom", ["#d9946355", "#d9946300"], "radial"),
+        gradient("porcelain", ["#f5eee5", "#e7d8cc"]),
+        gradient("copper-bloom", ["#d9946355", "#d9946300"], "radial"),
         ...[64, 112, 170, 238, 316].map(
           (r, i) => field(
             `receive-ring-${i}`,
@@ -3286,10 +1931,10 @@ function cardReverse(slug, original) {
       break;
     case "solstice":
       layers = [
-        gradient2("late-sunset", ["#241832", "#683151"], "vertical"),
+        gradient("late-sunset", ["#241832", "#683151"], "vertical"),
         stars("last-stars", "#f2c8aa", 311, 35),
         circle("sun-outline", 959, 184, 160, "#f1b577", 1.5, 0.6),
-        gradient2("horizon-glow", ["#ec935644", "#ec935600"], "radial", [664, 40, 490, 400]),
+        gradient("horizon-glow", ["#ec935644", "#ec935600"], "radial", [664, 40, 490, 400]),
         title("THE LONGEST\nLIGHT", 79, 218, 1030, 77),
         label("solar-index", "SOLSTICE / THE OTHER SIDE OF DAY", 84, 80),
         field("far-dune", "M0 586Q240 500 611 601T1200 544V756H0Z", "#5d2d4c"),
@@ -3300,11 +1945,11 @@ function cardReverse(slug, original) {
       break;
     case "streak-guardian":
       layers = [
-        gradient2("green-enamel", ["#68d311", "#48b000"]),
+        gradient("green-enamel", ["#68d311", "#48b000"]),
         circle("duo-aura", 930, 406, 250, "#c2f078", 0, 0.2),
         label("practice-header", "STREAK GUARDIAN / ONE DAY AT A TIME", 83, 81),
-        text3("week-count", "07", [75, 206, 530, 272], "#ffffff", 210, "sans", "800"),
-        text3(
+        text("week-count", "07", [75, 206, 530, 272], "#ffffff", 210, "sans", "800"),
+        text(
           "week-label",
           "SMALL STEPS.\nREAL PROGRESS.",
           [92, 490, 590, 90],
@@ -3328,24 +1973,24 @@ function cardReverse(slug, original) {
       break;
     case "system-dialog":
       layers = [
-        gradient2("desktop", ["#e8ebf1", "#bcc8db"]),
+        gradient("desktop", ["#e8ebf1", "#bcc8db"]),
         grid("desktop-grid", [0, 0, 1200, 756], "#9aa9c1", 32, 0.17),
         rect("status-shadow", [165, 150, 892, 446], "#647089", 0, 0.2),
         rect("status-frame", [152, 137, 892, 446], "#405471"),
         rect("status-paper", [159, 144, 878, 432], "#f3f5f9"),
         rect("status-titlebar", [166, 151, 864, 53], "#304976"),
-        text3("status-title", "REVERSE SIDE", [192, 166, 788, 37], "#ffffff", 23),
+        text("status-title", "REVERSE SIDE", [192, 166, 788, 37], "#ffffff", 23),
         ...["LAYERS   : OPEN", "MATERIAL : LIVE", "STATUS   : READY"].map(
-          (value, i) => text3(`status-row-${i}`, value, [238, 266 + i * 69, 745, 47], ink, 28)
+          (value, i) => text(`status-row-${i}`, value, [238, 266 + i * 69, 745, 47], ink, 28)
         ),
         rect("status-button", [790, 480, 194, 57], "#dfe5ee"),
-        text3("status-ok", "OK", [858, 495, 92, 36], ink, 24),
+        text("status-ok", "OK", [858, 495, 92, 36], ink, 24),
         label("local-note", "SYSTEM DIALOG / LOCAL SESSION", 154, 654)
       ];
       break;
     default:
       layers = [
-        gradient2("brushed-silver", ["#eceee7", "#c9d1c8"]),
+        gradient("brushed-silver", ["#eceee7", "#c9d1c8"]),
         grid("maker-grid", [40, 40, 1120, 676], "#839589", 40, 0.13),
         label("maker-index", "VIBECODERS / REVERSE ENGINEERING", 85, 84),
         path("opening-bracket", [81, 244, 82, 231], "M82 0L0 115L82 231", ink, 3),
@@ -3396,9 +2041,9 @@ function originalCards() {
   });
 }
 var canvas = { x: 0, y: 0, w: 1200, h: 756 };
-function text22(id3, value, x, y, w, size, color3) {
+function text2(id, value, x, y, w, size, color) {
   return {
-    id: id3,
+    id,
     kind: "text",
     text: value,
     binding: "none",
@@ -3407,36 +2052,36 @@ function text22(id3, value, x, y, w, size, color3) {
     w,
     h: size * 1.5,
     size,
-    color: color3,
+    color,
     font: "mono",
     weight: "500",
     align: "left",
     tracking: 2
   };
 }
-function line(id3, x, y, w, color3) {
+function line(id, x, y, w, color) {
   return {
-    id: id3,
+    id,
     kind: "shape",
     shape: "line",
     x,
     y,
     w,
     h: 2,
-    color: color3,
+    color,
     radius: 0,
     stroke: 1,
     opacity: 0.5
   };
 }
-function effect2(id3, kind, colors, opacity) {
-  return { id: id3, kind: "effect", effect: kind, ...canvas, colors, scale: 1.3, opacity };
+function effect(id, kind, colors, opacity) {
+  return { id, kind: "effect", effect: kind, ...canvas, colors, scale: 1.3, opacity };
 }
-function style(id3, name, description, palette2, ink, material, layers) {
+function style(id, name, description, palette2, ink, material, layers) {
   return badgeDesignSchema.parse({
     version: 1,
     product: "card",
-    source: id3,
+    source: id,
     name,
     description,
     event: "Makeables",
@@ -3457,10 +2102,10 @@ function style(id3, name, description, palette2, ink, material, layers) {
           ]
         },
         ...layers,
-        text22("wordmark", "makeables", 74, 62, 570, 38, ink),
-        text22("edition", "MATERIAL STUDIES", 76, 123, 570, 16, ink),
-        text22("title", name.toUpperCase(), 76, 500, 760, 25, ink),
-        text22("series", "DESIGNED TO BE YOURS", 78, 542, 660, 13, ink),
+        text2("wordmark", "makeables", 74, 62, 570, 38, ink),
+        text2("edition", "MATERIAL STUDIES", 76, 123, 570, 16, ink),
+        text2("title", name.toUpperCase(), 76, 500, 760, 25, ink),
+        text2("series", "DESIGNED TO BE YOURS", 78, 542, 660, 13, ink),
         line("title-rule", 76, 589, 1028, ink),
         cardMarkLayer("chip", { mark: "chip", slot: "middle-left", color: "#c7d0d9" }),
         cardMarkLayer("contactless", { mark: "contactless", slot: "upper-right", color: ink }),
@@ -3476,7 +2121,7 @@ function style(id3, name, description, palette2, ink, material, layers) {
     back: {
       background: palette2[0],
       layers: [
-        effect2("reverse-field", "contours", palette2, 0.3),
+        effect("reverse-field", "contours", palette2, 0.3),
         {
           id: "reverse-panel",
           kind: "shape",
@@ -3490,11 +2135,11 @@ function style(id3, name, description, palette2, ink, material, layers) {
           stroke: 0,
           opacity: 0.9
         },
-        text22("reverse-wordmark", "makeables / material studies", 76, 310, 1040, 24, ink),
+        text2("reverse-wordmark", "makeables / material studies", 76, 310, 1040, 24, ink),
         line("reverse-rule", 76, 380, 1048, ink),
-        text22("reverse-title", name.toUpperCase(), 76, 430, 1e3, 46, ink),
-        text22("reverse-caption", "A SMALL CANVAS. ENDLESS POSSIBILITIES.", 78, 524, 1020, 16, ink),
-        text22("reverse-footer", "ORIGINAL ARTWORK / MAKEABLES", 78, 658, 1e3, 13, ink)
+        text2("reverse-title", name.toUpperCase(), 76, 430, 1e3, 46, ink),
+        text2("reverse-caption", "A SMALL CANVAS. ENDLESS POSSIBILITIES.", 78, 524, 1020, 16, ink),
+        text2("reverse-footer", "ORIGINAL ARTWORK / MAKEABLES", 78, 658, 1e3, 13, ink)
       ]
     }
   });
@@ -3528,7 +2173,7 @@ var materialCardStyles = [
         }
       },
       [
-        effect2("pearl-ribbons", "chromatic-flow", ["#eee8f1", "#c784d9", "#81d7df"], 0.75),
+        effect("pearl-ribbons", "chromatic-flow", ["#eee8f1", "#c784d9", "#81d7df"], 0.75),
         {
           id: "orbital-seal",
           kind: "graphic",
@@ -3543,7 +2188,7 @@ var materialCardStyles = [
           seed: 81,
           opacity: 0.5
         },
-        text22("atelier", "STUDIO / 01", 820, 66, 280, 15, "#6c6487")
+        text2("atelier", "STUDIO / 01", 820, 66, 280, 15, "#6c6487")
       ]
     ),
     { wordmark: "foil", "reverse-wordmark": "foil" }
@@ -3573,7 +2218,7 @@ var materialCardStyles = [
         }
       },
       [
-        effect2("engraved-contours", "contours", ["#0b101a", "#536277", "#b3c4d5"], 0.34),
+        effect("engraved-contours", "contours", ["#0b101a", "#536277", "#b3c4d5"], 0.34),
         {
           id: "technical-grid",
           kind: "graphic",
@@ -3588,7 +2233,7 @@ var materialCardStyles = [
           seed: 29,
           opacity: 0.22
         },
-        text22("atelier", "STUDIO / 02", 820, 66, 280, 15, "#ffffff")
+        text2("atelier", "STUDIO / 02", 820, 66, 280, 15, "#ffffff")
       ]
     ),
     { wordmark: "raised", title: "foil", "technical-grid": "foil", "reverse-title": "foil" }
@@ -3617,7 +2262,7 @@ var materialCardStyles = [
         }
       },
       [
-        effect2("solar-orbits", "orbits", ["#ecd9be", "#bd4a2e", "#efaa50"], 0.36),
+        effect("solar-orbits", "orbits", ["#ecd9be", "#bd4a2e", "#efaa50"], 0.36),
         {
           id: "sun-disc",
           kind: "shape",
@@ -3644,7 +2289,7 @@ var materialCardStyles = [
           stroke: 2,
           opacity: 0.5
         },
-        text22("atelier", "STUDIO / 03", 820, 66, 280, 15, "#202024")
+        text2("atelier", "STUDIO / 03", 820, 66, 280, 15, "#202024")
       ]
     ),
     { "sun-disc": "raised", "sun-ring": "foil", wordmark: "raised", "reverse-title": "foil" }
@@ -3652,16 +2297,16 @@ var materialCardStyles = [
 ];
 var curatedCardStyles = originalCards();
 var cardStyles = [...materialCardStyles, ...curatedCardStyles];
-function findCardStyle(id3) {
-  return cardStyles.find((design2) => design2.source === id3);
+function findCardStyle(id) {
+  return cardStyles.find((design2) => design2.source === id);
 }
-var faceEdits = z5.object({
+var faceEdits = z.object({
   background: badgeDesignObjectSchema.shape.front.shape.background.optional(),
-  upsert: z5.array(badgeLayerSchema).max(96).optional(),
-  remove: z5.array(z5.string()).max(96).optional(),
-  order: z5.array(z5.string()).max(96).optional()
+  upsert: z.array(badgeLayerSchema).max(96).optional(),
+  remove: z.array(z.string()).max(96).optional(),
+  order: z.array(z.string()).max(96).optional()
 });
-var designEditsSchema = z5.object({
+var designEditsSchema = z.object({
   name: badgeDesignObjectSchema.shape.name.optional(),
   event: badgeDesignObjectSchema.shape.event.optional(),
   description: badgeDesignObjectSchema.shape.description.optional(),
@@ -3684,30 +2329,30 @@ function applyDesignEdits(base, input, locks) {
   for (const side2 of ["front", "back"]) {
     const change = edits[side2];
     if (!change) continue;
-    const face2 = next[side2];
-    if (change.background) face2.background = change.background;
-    for (const id3 of change.remove ?? []) {
-      if (!face2.layers.some((layer) => layer.id === id3))
-        throw new Error(`No existe ${side2}.${id3}.`);
-      face2.layers = face2.layers.filter((layer) => layer.id !== id3);
+    const face = next[side2];
+    if (change.background) face.background = change.background;
+    for (const id of change.remove ?? []) {
+      if (!face.layers.some((layer) => layer.id === id))
+        throw new Error(`No existe ${side2}.${id}.`);
+      face.layers = face.layers.filter((layer) => layer.id !== id);
     }
     const replacements = /* @__PURE__ */ new Set();
     for (const layer of change.upsert ?? []) {
       if (replacements.has(layer.id)) throw new Error(`Cambio repetido ${side2}.${layer.id}.`);
       replacements.add(layer.id);
-      const index = face2.layers.findIndex((item) => item.id === layer.id);
-      if (index >= 0) face2.layers[index] = layer;
+      const index = face.layers.findIndex((item) => item.id === layer.id);
+      if (index >= 0) face.layers[index] = layer;
       else {
-        const qr2 = face2.layers.findIndex((item) => item.kind === "qr");
-        face2.layers.splice(qr2 < 0 ? face2.layers.length : qr2, 0, layer);
+        const qr = face.layers.findIndex((item) => item.kind === "qr");
+        face.layers.splice(qr < 0 ? face.layers.length : qr, 0, layer);
       }
     }
     if (change.order) {
-      if (change.order.length !== face2.layers.length || new Set(change.order).size !== face2.layers.length)
+      if (change.order.length !== face.layers.length || new Set(change.order).size !== face.layers.length)
         throw new Error(`El orden debe incluir todas las capas de ${side2} exactamente una vez.`);
-      face2.layers = change.order.map((id3) => {
-        const layer = face2.layers.find((item) => item.id === id3);
-        if (!layer) throw new Error(`No existe ${side2}.${id3}.`);
+      face.layers = change.order.map((id) => {
+        const layer = face.layers.find((item) => item.id === id);
+        if (!layer) throw new Error(`No existe ${side2}.${id}.`);
         return layer;
       });
     }
@@ -6065,14 +4710,14 @@ var collection2 = [
   ["brew", "cf3f2e1a-4a31-42de-ad6c-8825303b2f09"]
 ];
 var communityStickerIds = collection2.map(
-  ([, id3]) => `community-${id3}`
+  ([, id]) => `community-${id}`
 );
-var communityStickerStyles = collection2.map(([slug, id3]) => {
+var communityStickerStyles = collection2.map(([slug, id]) => {
   const original = badgeDesignSchema.parse(community_sticker_sources_default[slug]);
-  const credit2 = { label: "Railly Hugo", url: `https://makeables.dev/submissions/${id3}` };
+  const credit = { label: "Railly Hugo", url: `https://makeables.dev/submissions/${id}` };
   return badgeDesignSchema.parse({
     ...original,
-    source: `community-${id3}`,
+    source: `community-${id}`,
     artPrompt: "Adapted from the original Community artwork with real Ann Nguyen / TypingMind image references: simple contemporary shapes, integrated lettering, calm negative space and selective optical finish. Keep the exact identity and wording. GPT Image 2 via Vercel AI Gateway; prompts and provenance in sticker-revisions/2026-09-30. Original editable layers are retained hidden; the new illustration is a raster layer.",
     assets: {
       ...original.assets,
@@ -6082,7 +4727,7 @@ var communityStickerStyles = collection2.map(([slug, id3]) => {
         slug,
         file: "artwork",
         name: original.name,
-        credit: credit2
+        credit
       },
       "optical-map": {
         source: "sticker",
@@ -6090,7 +4735,7 @@ var communityStickerStyles = collection2.map(([slug, id3]) => {
         slug,
         file: "effects",
         name: "Foil \xB7 glitter \xB7 relief",
-        credit: credit2
+        credit
       }
     },
     front: {
@@ -20011,1725 +18656,8 @@ function findDesign(source) {
   return designCatalog.find((design2) => design2.source === source);
 }
 
-// ../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-ZUAL6SF5.js
-import { z as z6 } from "zod";
-var COMMUNITY_IMAGE_LIMIT = 3e6;
-var COMMUNITY_JSON_LIMIT = 256e3;
-var digestSchema = z6.string().regex(/^[a-f0-9]{64}$/);
-var secretSchema = z6.string().regex(/^\d{13}\.[a-f0-9]{64}$/);
-var COMMUNITY_PREPARATION_TTL = 60 * 60 * 1e3;
-var communityParticipantSchema = z6.object({
-  name: z6.string().trim().min(1).max(80),
-  role: z6.string().max(100),
-  organization: z6.string().max(100),
-  number: z6.number().int().min(1).max(999999),
-  eventName: z6.string().min(1).max(80),
-  publicUrl: z6.string().url().max(512).refine((value) => ["https:", "http:"].includes(new URL(value).protocol)),
-  signature: z6.object({ seed: z6.number().int().min(0).max(4294967295), version: z6.literal(1) }),
-  metadata: z6.object({
-    roleLabel: z6.string().max(100).default(""),
-    eventName: z6.string().max(80).default(""),
-    eventDate: z6.string().max(100).default(""),
-    location: z6.string().max(100).default(""),
-    website: z6.string().max(200).default(""),
-    bio: z6.string().max(600).default("")
-  }).strict()
-}).strict();
-var communitySnapshotSchema = z6.object({
-  format: z6.literal(1),
-  design: badgeDesignSchema,
-  participant: communityParticipantSchema,
-  images: z6.object({ portrait: digestSchema, artwork: digestSchema.nullable() }).strict()
-}).strict().superRefine(({ design: design2, images, participant }, context) => {
-  const visible = (layer) => layer.visible !== false && (layer.opacity ?? 1) > 0;
-  if (Object.values(design2.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 side2 of ["front", "back"]) {
-    if (!design2[side2].layers.some(
-      (layer) => visible(layer) && layer.kind === "text" && layer.binding === "name"
-    ))
-      context.addIssue({ code: "custom", message: `El nombre debe verse en ${side2}.` });
-  }
-  if (!design2.front.layers.some((layer) => visible(layer) && layer.kind === "portrait"))
-    context.addIssue({ code: "custom", message: "El retrato debe ser visible." });
-  if (!design2.back.layers.some((layer) => visible(layer) && isRoleBoundLayer(layer)))
-    context.addIssue({ code: "custom", message: "El rol debe ser visible." });
-  if (!design2.back.layers.some((layer) => visible(layer) && layer.kind === "qr"))
-    context.addIssue({ code: "custom", message: "El QR debe ser visible." });
-  for (const layer of [...design2.front.layers, ...design2.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(design2.artwork) !== Boolean(images.artwork) || [...design2.front.layers, ...design2.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: z6.string().uuid(),
-  snapshotHash: digestSchema,
-  title: z6.string().min(1).max(60),
-  participantName: z6.string().min(1).max(80)
-};
-var communityIntentSchema = z6.discriminatedUnion("action", [
-  z6.object({ ...intentBase, action: z6.literal("create") }).strict(),
-  z6.object({
-    ...intentBase,
-    action: z6.literal("update"),
-    publicationId: z6.string().uuid(),
-    expectedVersion: z6.number().int().positive()
-  }).strict(),
-  z6.object({
-    ...intentBase,
-    action: z6.literal("withdraw"),
-    publicationId: z6.string().uuid(),
-    expectedVersion: z6.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 = z6.object({
-  mimeType: z6.enum(["image/png", "image/jpeg", "image/webp"]),
-  base64: z6.string().min(4).max(4e6).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/)
-}).strict();
-var badgeBundleSchema = z6.object({
-  format: z6.literal("makeables-bundle"),
-  version: z6.literal(1),
-  snapshot: communitySnapshotSchema,
-  images: z6.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) };
-}
-
-// ../../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 s2 = cd.length;
-  var i = 0;
-  var l = new u16(mb);
-  for (; i < s2; ++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 < s2; ++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(s2);
-    for (i = 0; i < s2; ++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, p2, m) {
-  var o = p2 / 8 | 0;
-  return (d[o] | d[o + 1] << 8) >> (p2 & 7) & m;
-};
-var bits16 = function(d, p2) {
-  var o = p2 / 8 | 0;
-  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p2 & 7);
-};
-var shft = function(p2) {
-  return (p2 + 7) / 8 | 0;
-};
-var slc = function(v, s2, e) {
-  if (s2 == null || s2 < 0)
-    s2 = 0;
-  if (e == null || e > v.length)
-    e = v.length;
-  return new u8(v.subarray(s2, 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 s2 = shft(pos) + 4, l = dat[s2 - 4] | dat[s2 - 3] << 8, t2 = s2 + l;
-        if (t2 > sl) {
-          if (noSt)
-            err(0);
-          break;
-        }
-        if (resize)
-          cbuf(bt + l);
-        buf.set(dat.subarray(s2, t2), bt);
-        st.b = bt += l, st.p = pos = t2 * 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 s2 = r >> 4;
-          if (s2 < 16) {
-            ldt[i++] = s2;
-          } else {
-            var c = 0, n = 0;
-            if (s2 == 16)
-              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
-            else if (s2 == 17)
-              n = 3 + bits(dat, pos, 7), pos += 3;
-            else if (s2 == 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, p2, v) {
-  v <<= p2 & 7;
-  var o = p2 / 8 | 0;
-  d[o] |= v;
-  d[o + 1] |= v >> 8;
-};
-var wbits16 = function(d, p2, v) {
-  v <<= p2 & 7;
-  var o = p2 / 8 | 0;
-  d[o] |= v;
-  d[o + 1] |= v >> 8;
-  d[o + 2] |= v >> 16;
-};
-var hTree = function(d, mb) {
-  var t2 = [];
-  for (var i = 0; i < d.length; ++i) {
-    if (d[i])
-      t2.push({ s: i, f: d[i] });
-  }
-  var s2 = t2.length;
-  var t22 = t2.slice();
-  if (!s2)
-    return { t: et, l: 0 };
-  if (s2 == 1) {
-    var v = new u8(t2[0].s + 1);
-    v[t2[0].s] = 1;
-    return { t: v, l: 1 };
-  }
-  t2.sort(function(a, b) {
-    return a.f - b.f;
-  });
-  t2.push({ s: -1, f: 25001 });
-  var l = t2[0], r = t2[1], i0 = 0, i1 = 1, i2 = 2;
-  t2[0] = { s: -1, f: l.f + r.f, l, r };
-  while (i1 != s2 - 1) {
-    l = t2[t2[i0].f < t2[i2].f ? i0++ : i2++];
-    r = t2[i0 != i1 && t2[i0].f < t2[i2].f ? i0++ : i2++];
-    t2[i1++] = { s: -1, f: l.f + r.f, l, r };
-  }
-  var maxSym = t22[0].s;
-  for (var i = 1; i < s2; ++i) {
-    if (t22[i].s > maxSym)
-      maxSym = t22[i].s;
-  }
-  var tr = new u16(maxSym + 1);
-  var mbt = ln(t2[i1 - 1], tr, 0);
-  if (mbt > mb) {
-    var i = 0, dt = 0;
-    var lft = mbt - mb, cst = 1 << lft;
-    t22.sort(function(a, b) {
-      return tr[b.s] - tr[a.s] || a.f - b.f;
-    });
-    for (; i < s2; ++i) {
-      var i2_1 = t22[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 = t22[i].s;
-      if (tr[i2_2] < mb)
-        dt -= 1 << mb - tr[i2_2]++ - 1;
-      else
-        ++i;
-    }
-    for (; i >= 0 && dt; --i) {
-      var i2_3 = t22[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 s2 = c.length;
-  while (s2 && !c[--s2])
-    ;
-  var cl = new u16(++s2);
-  var cli = 0, cln = c[0], cls = 1;
-  var w = function(v) {
-    cl[cli++] = v;
-  };
-  for (var i = 1; i <= s2; ++i) {
-    if (c[i] == cln && i != s2)
-      ++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: s2 };
-};
-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 s2 = dat.length;
-  var o = shft(pos + 2);
-  out[o] = s2 & 255;
-  out[o + 1] = s2 >> 8;
-  out[o + 2] = out[o] ^ 255;
-  out[o + 3] = out[o + 1] ^ 255;
-  for (var i = 0; i < s2; ++i)
-    out[o + i + 4] = dat[i];
-  return (o + 4 + s2) * 8;
-};
-var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p2) {
-  wbits(out, p2++, 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, p2, dat.subarray(bs, bs + bl));
-  var lm, ll, dm, dl;
-  wbits(out, p2, 1 + (dtlen < ftlen)), p2 += 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, p2, nlc - 257);
-    wbits(out, p2 + 5, ndc - 1);
-    wbits(out, p2 + 10, nlcc - 4);
-    p2 += 14;
-    for (var i = 0; i < nlcc; ++i)
-      wbits(out, p2 + 3 * i, lct[clim[i]]);
-    p2 += 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, p2, llm[len]), p2 += lct[len];
-        if (len > 15)
-          wbits(out, p2, clct[i] >> 5 & 127), p2 += 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, p2, lm[len + 257]), p2 += ll[len + 257];
-      if (len > 7)
-        wbits(out, p2, sym >> 23 & 31), p2 += fleb[len];
-      var dst = sym & 31;
-      wbits16(out, p2, dm[dst]), p2 += dl[dst];
-      if (dst > 3)
-        wbits16(out, p2, sym >> 5 & 8191), p2 += fdeb[dst];
-    } else {
-      wbits16(out, p2, lm[sym]), p2 += ll[sym];
-    }
-  }
-  wbits16(out, p2, lm[256]);
-  return p2 + 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 s2 = st.z || dat.length;
-  var o = new u8(pre + s2 + 5 * (1 + Math.ceil(s2 / 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 < s2; ++i) {
-      var hv = hsh(i);
-      var imod = i & 32767, pimod = head[hv];
-      prev[imod] = pimod;
-      head[hv] = imod;
-      if (wi <= i) {
-        var rem = s2 - 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 < s2; ++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 < s2 + lst; i += 65535) {
-      var e = i + 65535;
-      if (e >= s2) {
-        w[pos / 8 | 0] = lst;
-        e = s2;
-      }
-      pos = wfblk(w, pos + 1, dat.subarray(i, e));
-    }
-    st.i = s2;
-  }
-  return slc(o, 0, pre + shft(pos) + post);
-};
-var crct = /* @__PURE__ */ (function() {
-  var t2 = new Int32Array(256);
-  for (var i = 0; i < 256; ++i) {
-    var c = i, k = 9;
-    while (--k)
-      c = (c & 1 && -306674912) ^ c >>> 1;
-    t2[i] = c;
-  }
-  return t2;
-})();
-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, p2, t2, o) {
-  for (var k in d) {
-    var val = d[k], n = p2 + k, op = o;
-    if (Array.isArray(val))
-      op = mrg(o, val[1]), val = val[0];
-    if (val instanceof u8)
-      t2[n] = [val, op];
-    else {
-      t2[n += "/"] = [new u8(0), op];
-      fltn(val, n, t2, 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), s2 = _a2.s, r = _a2.r;
-    if (r.length)
-      err(8);
-    return s2;
-  }
-}
-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], file = _a2[0], p2 = _a2[1];
-    var compression = p2.level == 0 ? 0 : 8;
-    var f = strToU8(fn), s2 = f.length;
-    var com = p2.comment, m = com && strToU8(com), ms = m && m.length;
-    var exl = exfl(p2.extra);
-    if (s2 > 65535)
-      err(11);
-    var d = compression ? deflateSync(file, p2) : file, l = d.length;
-    var c = crc();
-    c.p(file);
-    files.push(mrg(p2, {
-      size: file.length,
-      crc: c.d(),
-      c: d,
-      f,
-      m,
-      u: s2 != fn.length || m && com.length != ms,
-      o,
-      compression
-    }));
-    o += 30 + s2 + exl + l;
-    tot += 76 + 2 * (s2 + 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 z23 } from "zod";
-import { z as z7 } from "zod";
-var id2 = z7.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/);
-var member = z7.object({ id: id2, file: z7.string().min(1).max(4096) }).strict();
-var kitDocumentSchema = z7.object({
-  format: z7.literal("makeables-kit"),
-  version: z7.literal(1),
-  name: z7.string().trim().min(1).max(60),
-  items: z7.array(member).max(24),
-  sheets: z7.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" } };
-var pathPattern = /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.(?:json|svg|png|webp|jpg|jpeg|gif|pdf)$/;
-var pathSchema = z23.string().max(100).regex(pathPattern);
-var archivePathSchema = z23.string().max(147).regex(pathPattern);
-var mimeSchema = z23.enum([
-  "application/json",
-  "image/svg+xml",
-  "image/png",
-  "image/webp",
-  "image/jpeg",
-  "image/gif",
-  "application/pdf"
-]);
-var submissionMetadataSchema = z23.object({
-  title: z23.string().trim().min(1).max(60),
-  category: z23.enum(["Anime", "Gaming", "Minimal", "Abstract"]).default("Abstract"),
-  creditName: z23.string().trim().min(1).max(60),
-  creditUrl: z23.string().url().max(512).refine((value) => new URL(value).protocol === "https:").nullable().default(null)
-}).strict();
-var manifestBase = z23.object({
-  format: z23.literal("makeables-package"),
-  version: z23.literal(1),
-  product: z23.enum(productIds),
-  finish: stickerMaterialSchema.shape.finish.optional(),
-  title: z23.string().min(1).max(60),
-  document: pathSchema.optional(),
-  source: pathSchema.optional(),
-  front: pathSchema,
-  back: pathSchema.optional(),
-  portrait: pathSchema.optional(),
-  artwork: pathSchema.optional(),
-  assets: z23.record(z23.string().max(60), pathSchema).default({}),
-  files: z23.array(
-    z23.object({
-      path: pathSchema,
-      mime: mimeSchema,
-      bytes: z23.number().int().min(1).max(FILE_LIMIT),
-      sha256: z23.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 path2 of [
-    m.document,
-    m.source,
-    m.front,
-    m.back,
-    m.portrait,
-    m.artwork,
-    ...Object.values(m.assets)
-  ])
-    if (path2 && !paths.has(path2)) issue(`Missing asset: ${path2}.`);
-  for (const file of m.files) {
-    if (file.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(file.path))
-      issue(`Unreferenced file: ${file.path}.`);
-    if (file.path === m.document !== (file.mime === "application/json"))
-      issue("Only the editable document may contain JSON.");
-    if (file.path === m.source && (m.product !== "card" || !["image/svg+xml", "image/png", "image/jpeg", "image/webp"].includes(file.mime)))
-      issue("Original artwork must be a card SVG, PNG, JPEG or WebP.");
-    if ([m.front, m.back].includes(file.path) && file.path !== m.source && file.mime === "image/svg+xml")
-      issue("Use raster previews for layered documents.");
-  }
-});
-var kitId = z23.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/);
-var kitManifestSchema = manifestBase.extend({
-  product: z23.literal("kit"),
-  files: z23.array(manifestBase.shape.files.element.extend({ path: archivePathSchema })).min(1).max(KIT_FILE_COUNT_LIMIT),
-  items: z23.array(z23.object({ id: kitId, manifest: designManifestSchema }).strict()).min(1).max(24),
-  sheets: z23.array(
-    z23.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 = (path2, file) => {
-    if (expected.has(path2)) issue(`Duplicate kit file: ${path2}.`);
-    expected.set(path2, file);
-  };
-  for (const item of m.items)
-    for (const file of item.manifest.files) add(`items/${item.id}/${file.path}`, file);
-  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((file) => file.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, file) => sum + file.bytes, 0) > PACKAGE_LIMIT)
-    issue("The package exceeds 24 MB.");
-  for (const file of m.files) {
-    const wanted = expected.get(file.path);
-    if (!wanted || wanted.mime !== file.mime || wanted.bytes !== void 0 && wanted.bytes !== file.bytes || wanted.sha256 !== void 0 && wanted.sha256 !== file.sha256)
-      issue(`Kit member metadata does not match: ${file.path}.`);
-    if (file.mime === "application/pdf" && !file.path.endsWith(".pdf"))
-      issue("Print PDFs must use .pdf paths.");
-  }
-  for (const path2 of expected.keys())
-    if (!m.files.some((file) => file.path === path2)) issue(`Missing kit file: ${path2}.`);
-});
-var manifestSchema = z23.union([designManifestSchema, kitManifestSchema]);
-var documentSchema = z23.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(design2) {
-  const layers = [...design2.front.layers, ...design2.back.layers];
-  return {
-    portrait: layers.some((l) => l.kind === "portrait"),
-    artwork: Boolean(design2.artwork) || layers.some((l) => l.kind === "image" && l.asset === "art"),
-    assets: [
-      ...referencedDesignAssets(design2).filter(
-        (id22) => id22 !== "art" && design2.assets?.[id22]?.source !== "image"
-      )
-    ]
-  };
-}
-function missingAssets(draft) {
-  const required = requiredAssets(draft.design);
-  return [
-    ...required.portrait && !draft.portrait ? ["portrait"] : [],
-    ...required.artwork && !draft.artwork ? ["artwork"] : [],
-    ...required.assets.filter((id22) => !draft.assets[id22])
-  ];
-}
-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 path2 = `${slot}.${image2.mimeType.split("/")[1]}`;
-      draft[slot] = path2;
-      draft.files[path2] = bundleImageBytes(image2);
-      draft.mime[path2] = image2.mimeType;
-    }
-    return draft;
-  }
-  const document2 = documentSchema.parse(
-    value && typeof value === "object" && "design" in value ? value : { design: value }
-  );
-  return { ...document2, 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 ([path2, bytes]) => ({
-        path: path2,
-        mime: mime[path2],
-        bytes: bytes.length,
-        sha256: await hashBytes(bytes)
-      }))
-    )
-  });
-  const result = { manifest, files };
-  await validatePackage(result);
-  return result;
-}
-async function draftPackage(draft, previews) {
-  const sticker = draft.design.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: draft.design.product ?? "badge",
-      ...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 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 file of manifest.files) {
-    const bytes = pkg.files[file.path];
-    if (!bytes || bytes.length !== file.bytes || await hashBytes(bytes) !== file.sha256)
-      throw new Error(`Missing or changed asset: ${file.path}.`);
-  }
-  if (manifest.product === "kit") {
-    for (const item of manifest.items) await validatePackage(kitMemberPackage(pkg, item.id));
-    for (const sheet of manifest.sheets) {
-      const document2 = stickerSheetSchema.parse(parseJson(pkg.files[sheet.document]));
-      if (!document2.items.length) throw new Error("A kit sheet must contain stickers.");
-      for (const item of document2.items)
-        if (requiredAssets(item.design).assets.length || requiredAssets(item.design).artwork)
-          throw new Error("Kit sheets must embed their artwork.");
-      if (sheet.pdf) {
-        const text4 = new TextDecoder("latin1").decode(pkg.files[sheet.pdf]);
-        if (!text4.startsWith("%PDF-") || !text4.trimEnd().endsWith("%%EOF"))
-          throw new Error("Invalid print PDF.");
-      }
-    }
-    return manifest;
-  }
-  for (const file of manifest.files.filter((f) => f.mime === "image/svg+xml")) {
-    const check = checkSubmittedSvg(new TextDecoder().decode(pkg.files[file.path]));
-    if (!check.ok) throw new Error(check.error);
-  }
-  if (manifest.document) {
-    const document2 = documentSchema.parse(parseJson(pkg.files[manifest.document]));
-    if ((document2.design.product ?? "badge") !== manifest.product)
-      throw new Error("The document and product do not match.");
-    if (manifest.product === "sticker" && manifest.finish !== (document2.design.sticker?.finish ?? defaultStickerMaterial.finish))
-      throw new Error("The sticker finish and document do not match.");
-    if (manifest.product === "sticker" && document2.participant)
-      throw new Error("Sticker packages must not contain participant information.");
-    const missing = missingAssets({ ...document2, ...manifest, files: pkg.files, mime: {} });
-    if (missing.length) throw new Error(`Missing images: ${missing.join(", ")}.`);
-    if (requiredAssets(document2.design).portrait && !document2.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 archive2 = new Unzip((file) => {
-    if (!names.has(file.name) || seen.has(file.name) || (file.originalSize ?? 0) > FILE_LIMIT)
-      throw new Error("Invalid ZIP entry.");
-    seen.add(file.name);
-    const chunks = [];
-    let size = 0;
-    file.ondata = (error, chunk, final) => {
-      if (error) throw error;
-      size += chunk.length;
-      total += chunk.length;
-      if (size > (file.name === "manifest.json" ? MANIFEST_LIMIT : FILE_LIMIT) || total > PACKAGE_LIMIT + MANIFEST_LIMIT) {
-        file.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[file.name] = data;
-      }
-    };
-    file.start();
-  });
-  archive2.register(UnzipInflate);
-  for (let offset = 0; offset < bytes.length; offset += 1024)
-    archive2.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 === "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(([path2]) => paths.has(path2))),
-    mime: Object.fromEntries(
-      pkg.manifest.files.filter((f) => paths.has(f.path)).map((f) => [f.path, f.mime])
-    )
-  };
-}
-function packageJson(pkg) {
-  return {
-    format: "makeables-package",
-    version: 1,
-    manifest: pkg.manifest,
-    files: Object.fromEntries(
-      Object.entries(pkg.files).map(([path2, bytes]) => {
-        let binary = "";
-        for (const byte of bytes) binary += String.fromCharCode(byte);
-        return [path2, btoa(binary)];
-      })
-    )
-  };
-}
-async function readPackageJson(value) {
-  const input = z23.object({
-    format: z23.literal("makeables-package"),
-    version: z23.literal(1),
-    manifest: manifestSchema,
-    files: z23.record(
-      archivePathSchema,
-      z23.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 file of input.manifest.files) {
-    const encoded = input.files[file.path];
-    const length = encoded ? encoded.length / 4 * 3 - (encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0) : 0;
-    if (length !== file.bytes) throw new Error(`Missing or changed asset: ${file.path}.`);
-  }
-  const files = Object.fromEntries(
-    Object.entries(input.files).map(([path2, base64]) => [
-      path2,
-      Uint8Array.from(atob(base64), (c) => c.charCodeAt(0))
-    ])
-  );
-  const pkg = { manifest: input.manifest, files };
-  await validatePackage(pkg);
-  return pkg;
-}
-function kitMemberPackage(pkg, id22) {
-  if (pkg.manifest.product !== "kit") throw new Error("This package is not a kit.");
-  const item = pkg.manifest.items.find((item2) => item2.id === id22);
-  if (!item) throw new Error("Unknown kit piece.");
-  return {
-    manifest: item.manifest,
-    files: Object.fromEntries(
-      item.manifest.files.map((file) => [file.path, pkg.files[`items/${id22}/${file.path}`]])
-    )
-  };
-}
-
-// src/errors.ts
-var InputError = class extends Error {
+// src/errors.ts
+var InputError = class extends Error {
 };
 
 // src/card.ts
@@ -21864,7 +18792,7 @@ function designSvgImages(design2, onlySide, masks = true) {
 var cardMarkImageId = (layerId) => `mark:${layerId}`;
 
 // ../renderer/src/andes.ts
-import QRCode2 from "qrcode";
+import QRCode from "qrcode";
 function terrain(ctx, seed, top, height) {
   ctx.save();
   ctx.beginPath();
@@ -21909,7 +18837,7 @@ function contourSeal(ctx, seed, x, y) {
 }
 
 // ../renderer/src/edition.ts
-import QRCode3 from "qrcode";
+import QRCode2 from "qrcode";
 
 // ../renderer/src/signature.ts
 function materialSignature(signature = { seed: 0, version: 1 }) {
@@ -22255,15 +19183,15 @@ function paintDesignGraphic(ctx, layer) {
     }
     return;
   }
-  const { w, h, color: color3, accent, density, seed, pattern } = layer;
-  ctx.fillStyle = color3;
+  const { w, h, color, accent, density, seed, pattern } = layer;
+  ctx.fillStyle = color;
   ctx.strokeStyle = accent;
   ctx.lineWidth = layer.stroke ?? 2;
   if (pattern === "checkerboard") {
     const size = 20 / density;
     for (let row = 0; row < h / size; row++)
       for (let col = 0; col < w / size; col++) {
-        ctx.fillStyle = (row + col) % 2 ? accent : color3;
+        ctx.fillStyle = (row + col) % 2 ? accent : color;
         ctx.fillRect(col * size, row * size, size, size);
       }
   } else if (pattern === "path") {
@@ -22278,7 +19206,7 @@ function paintDesignGraphic(ctx, layer) {
     ctx.fillRect(0, 0, w - 4, h - 4);
     ctx.fillStyle = "#808080";
     ctx.fillRect(4, 4, w - 4, h - 4);
-    ctx.fillStyle = color3;
+    ctx.fillStyle = color;
     ctx.fillRect(4, 4, w - 9, h - 9);
     ctx.fillStyle = accent;
     ctx.fillRect(8, 8, w - 19, 50);
@@ -22347,7 +19275,7 @@ function paintDesignGraphic(ctx, layer) {
         layout: layer.variant === "plain" ? "archive" : layer.variant === "technical" ? "signal" : layer.variant === "editorial" ? "editorial" : layer.variant === "postal" ? "postage" : "terminal",
         title: [],
         subtitle: "",
-        base: color3,
+        base: color,
         ink: layer.ink ?? accent,
         accent,
         motif: pattern === "snow" || layer.variant === "snow" ? "snow" : layer.variant === "waves" ? "waves" : "grid",
@@ -22408,8 +19336,8 @@ function filterPixels(pixels, filter) {
   }
   const spread = Math.max(64, high - low);
   for (let i = 0; i < pixels.length; i += 4) {
-    const luminance2 = pixels[i] * 0.45 + pixels[i + 1] * 0.45 + pixels[i + 2] * 0.1;
-    const value = Math.max(0, Math.min(1, (luminance2 - low) / spread));
+    const luminance = pixels[i] * 0.45 + pixels[i + 1] * 0.45 + pixels[i + 2] * 0.1;
+    const value = Math.max(0, Math.min(1, (luminance - low) / spread));
     if (filter === "thermal") {
       palette(value ** 0.72, thermal, pixels, i);
     } else if (filter === "cyanotype") {
@@ -22420,33 +19348,33 @@ function filterPixels(pixels, filter) {
       pixels[i + 1] = silver * 0.99;
       pixels[i + 2] = silver * 1.03;
     } else if (filter === "vintage") {
-      pixels[i] = 24 + pixels[i] * 0.74 + luminance2 * 0.14;
-      pixels[i + 1] = 20 + pixels[i + 1] * 0.69 + luminance2 * 0.12;
-      pixels[i + 2] = 22 + pixels[i + 2] * 0.57 + luminance2 * 0.09;
+      pixels[i] = 24 + pixels[i] * 0.74 + luminance * 0.14;
+      pixels[i + 1] = 20 + pixels[i + 1] * 0.69 + luminance * 0.12;
+      pixels[i + 2] = 22 + pixels[i + 2] * 0.57 + luminance * 0.09;
     }
   }
 }
 
 // ../renderer/src/design-photo.ts
-function containDesignImage(ctx, image2, w, h, pixelated = false) {
-  const scale = Math.min(w / image2.width, h / image2.height);
-  const dw = image2.width * scale;
-  const dh = image2.height * scale;
+function containDesignImage(ctx, image, w, h, pixelated = false) {
+  const scale = Math.min(w / image.width, h / image.height);
+  const dw = image.width * scale;
+  const dh = image.height * scale;
   ctx.save();
   ctx.imageSmoothingEnabled = !pixelated;
-  ctx.drawImage(image2, (w - dw) / 2, (h - dh) / 2, dw, dh);
+  ctx.drawImage(image, (w - dw) / 2, (h - dh) / 2, dw, dh);
   ctx.restore();
 }
-function coverDesignImage(ctx, image2, w, h, layer) {
+function coverDesignImage(ctx, image, w, h, layer) {
   const crop = layer?.crop;
-  const scale = Math.max(w / image2.width, h / image2.height) * (crop?.zoom ?? 1);
+  const scale = Math.max(w / image.width, h / image.height) * (crop?.zoom ?? 1);
   const cw = w / scale;
   const ch = h / scale;
-  const x = layer?.cropMode === "focus" ? Math.max(0, Math.min(image2.width - cw, image2.width * (crop?.x ?? 0.5) - cw / 2)) : (image2.width - cw) * (crop?.x ?? 0.5);
-  const y = layer?.cropMode === "focus" ? Math.max(0, Math.min(image2.height - ch, image2.height * (crop?.y ?? 0.5) - ch / 2)) : (image2.height - ch) * (crop?.y ?? 0.5);
-  ctx.drawImage(image2, x, y, cw, ch, 0, 0, w, h);
+  const x = layer?.cropMode === "focus" ? Math.max(0, Math.min(image.width - cw, image.width * (crop?.x ?? 0.5) - cw / 2)) : (image.width - cw) * (crop?.x ?? 0.5);
+  const y = layer?.cropMode === "focus" ? Math.max(0, Math.min(image.height - ch, image.height * (crop?.y ?? 0.5) - ch / 2)) : (image.height - ch) * (crop?.y ?? 0.5);
+  ctx.drawImage(image, x, y, cw, ch, 0, 0, w, h);
 }
-function paintDesignPhoto(ctx, layer, image2) {
+function paintDesignPhoto(ctx, layer, image) {
   const photo = document.createElement("canvas");
   photo.width = Math.ceil(layer.w);
   photo.height = Math.ceil(layer.h);
@@ -22462,7 +19390,7 @@ function paintDesignPhoto(ctx, layer, image2) {
   if (layer.brightness !== void 0) filters.push(`brightness(${layer.brightness})`);
   if (layer.blur) filters.push(`blur(${layer.blur}px)`);
   surface.filter = filters.join(" ");
-  coverDesignImage(surface, image2, layer.w, layer.h, layer);
+  coverDesignImage(surface, image, layer.w, layer.h, layer);
   surface.filter = "none";
   if (["thermal", "silver", "cyanotype", "vintage"].includes(layer.filter)) {
     const pixels = surface.getImageData(0, 0, photo.width, photo.height);
@@ -22495,17 +19423,17 @@ function paintDesignPhoto(ctx, layer, image2) {
     for (const horizontal of [true, false]) {
       const start = horizontal ? layer.fade.x : layer.fade.top;
       const end = horizontal ? layer.fade.right ?? layer.fade.x : layer.fade.bottom;
-      const gradient3 = surface.createLinearGradient(
+      const gradient2 = surface.createLinearGradient(
         0,
         0,
         horizontal ? layer.w : 0,
         horizontal ? 0 : layer.h
       );
-      gradient3.addColorStop(0, start ? "#00000000" : "#000000");
-      gradient3.addColorStop(start, "#000000");
-      gradient3.addColorStop(1 - end, "#000000");
-      gradient3.addColorStop(1, end ? "#00000000" : "#000000");
-      surface.fillStyle = gradient3;
+      gradient2.addColorStop(0, start ? "#00000000" : "#000000");
+      gradient2.addColorStop(start, "#000000");
+      gradient2.addColorStop(1 - end, "#000000");
+      gradient2.addColorStop(1, end ? "#00000000" : "#000000");
+      surface.fillStyle = gradient2;
       surface.fillRect(0, 0, layer.w, layer.h);
     }
   }
@@ -22592,9 +19520,15 @@ function paintDesignText(ctx, layer, data) {
   let wrapped;
   if (layer.fit === "shrink" || layer.fit === "spread") {
     wrapped = value.split("\n");
-    const measured = Math.max(...wrapped.map((line2) => ctx.measureText(line2).width), 1);
+    const tracking = layer.tracking ?? 0;
+    const widest = wrapped.reduce(
+      (a, b) => ctx.measureText(b).width > ctx.measureText(a).width ? b : a,
+      ""
+    );
+    const measured = Math.max(ctx.measureText(widest).width, 1);
     if (measured > width) {
-      size *= width / measured;
+      const spacing = tracking * [...widest].length;
+      size *= Math.max(0.05, (width - spacing) / Math.max(1, measured - spacing));
       font();
     }
   } else {
@@ -22656,7 +19590,7 @@ function plate(width = 1024, height = 1536) {
   if (!ctx) throw new Error("No se pudo preparar el dise\xF1o.");
   return { canvas: canvas2, ctx };
 }
-function effect3(ctx, layer) {
+function effect2(ctx, layer) {
   const { w, h, colors, scale } = layer;
   if (layer.effect === "chromatic-flow") {
     const tile = document.createElement("canvas");
@@ -22684,11 +19618,11 @@ function effect3(ctx, layer) {
     ctx.drawImage(tile, 0, 0, w, h);
     return;
   }
-  const gradient3 = ctx.createLinearGradient(0, h, w, 0);
+  const gradient2 = ctx.createLinearGradient(0, h, w, 0);
   colors.forEach((c, i) => {
-    gradient3.addColorStop(i / 2, c);
+    gradient2.addColorStop(i / 2, c);
   });
-  ctx.fillStyle = gradient3;
+  ctx.fillStyle = gradient2;
   ctx.fillRect(0, 0, w, h);
   ctx.strokeStyle = colors[2];
   ctx.lineWidth = 1.5;
@@ -22724,7 +19658,7 @@ function effect3(ctx, layer) {
     ctx.stroke();
   }
 }
-function paint(ctx, input, data, portrait2, images) {
+function paint(ctx, input, data, portrait, images) {
   let layer = input;
   ctx.save();
   ctx.translate(layer.x, layer.y);
@@ -22749,7 +19683,7 @@ function paint(ctx, input, data, portrait2, images) {
   ctx.clip();
   ctx.globalAlpha = layer.opacity ?? 1;
   if (layer.kind === "text") paintDesignText(ctx, layer, data);
-  else if (layer.kind === "effect") effect3(ctx, layer);
+  else if (layer.kind === "effect") effect2(ctx, layer);
   else if (layer.kind === "graphic") paintDesignGraphic(ctx, layer);
   else if (layer.kind === "shape") {
     const inset = layer.shape === "frame" ? layer.stroke / 2 : 0;
@@ -22815,7 +19749,7 @@ function paint(ctx, input, data, portrait2, images) {
       for (let c = 0; c < matrix.size; c++)
         if (matrix.get(r, c)) ctx.fillRect(offset + c * cell, offset + r * cell, cell, cell);
   } else if (layer.kind === "gradient") {
-    const gradient3 = layer.direction === "radial" ? ctx.createRadialGradient(
+    const gradient2 = layer.direction === "radial" ? ctx.createRadialGradient(
       layer.w / 2,
       layer.h / 2,
       0,
@@ -22828,29 +19762,29 @@ function paint(ctx, input, data, portrait2, images) {
       layer.direction === "vertical" ? 0 : layer.w,
       layer.direction === "horizontal" ? 0 : layer.h
     );
-    for (const stop of layer.stops) gradient3.addColorStop(stop.at, stop.color);
-    ctx.fillStyle = gradient3;
+    for (const stop of layer.stops) gradient2.addColorStop(stop.at, stop.color);
+    ctx.fillStyle = gradient2;
     ctx.fillRect(0, 0, layer.w, layer.h);
-  } else if (layer.kind === "portrait" && portrait2) paintDesignPhoto(ctx, layer, portrait2);
+  } else if (layer.kind === "portrait" && portrait) paintDesignPhoto(ctx, layer, portrait);
   else if (layer.kind === "card-mark") {
-    const image2 = images?.get(cardMarkImageId(layer.id));
-    if (image2) ctx.drawImage(image2, 0, 0, layer.w, layer.h);
+    const image = images?.get(cardMarkImageId(layer.id));
+    if (image) ctx.drawImage(image, 0, 0, layer.w, layer.h);
   } else if (layer.kind === "image") {
-    const image2 = images?.get(layer.asset);
+    const image = images?.get(layer.asset);
     const pixelated = data.document?.assets?.[layer.asset];
-    if (image2 && layer.fit === "contain")
+    if (image && layer.fit === "contain")
       containDesignImage(
         ctx,
-        image2,
+        image,
         layer.w,
         layer.h,
         pixelated?.source === "petdex" || pixelated?.source === "image" && pixelated.pixelated
       );
-    else if (image2) coverDesignImage(ctx, image2, layer.w, layer.h);
+    else if (image) coverDesignImage(ctx, image, layer.w, layer.h);
   }
   ctx.restore();
 }
-function createDesignFace(data, side2, portrait2, images, channel) {
+function createDesignFace(data, side2, portrait, images, channel) {
   const design2 = data.document;
   if (!design2) throw new Error("Falta el documento del dise\xF1o.");
   const { width, height } = designProfile(design2);
@@ -22864,14 +19798,14 @@ function createDesignFace(data, side2, portrait2, images, channel) {
   for (const layer of design2[side2].layers) {
     if (layer.kind === "svg") {
       const run = firstInRun.get(layer.id);
-      const image2 = run ? images?.get(run.id) : void 0;
-      if (image2 && (!channel || channel === run?.channel))
-        ctx.drawImage(image2, 0, 0, width, height);
+      const image = run ? images?.get(run.id) : void 0;
+      if (image && (!channel || channel === run?.channel))
+        ctx.drawImage(image, 0, 0, width, height);
       continue;
     }
     if (layer.visible === false) continue;
     const layerChannel = layer.channel ?? (["text", "qr"].includes(layer.kind) ? "ink" : "print");
-    if (!channel || channel === layerChannel) paint(ctx, layer, data, portrait2, images);
+    if (!channel || channel === layerChannel) paint(ctx, layer, data, portrait, images);
   }
   return canvas2;
 }
@@ -23191,7 +20125,7 @@ function measureStickerOutline(pixels, width, height) {
 }
 
 // ../renderer/src/sticker.ts
-var clamp = (value, min = 0, max2 = 1) => Math.min(max2, Math.max(min, value));
+var clamp = (value, min = 0, max = 1) => Math.min(max, Math.max(min, value));
 function hash(value) {
   let n = value | 0;
   n = Math.imul(n ^ n >>> 16, 73244475);
@@ -23343,7 +20277,7 @@ function prepareSticker(art, material, optical) {
     coat.clearRect(0, 0, width, height);
     coat.globalCompositeOperation = "source-over";
     const shift = light.x * width * 0.38 + light.y * width * 0.14;
-    const gradient3 = coat.createLinearGradient(
+    const gradient2 = coat.createLinearGradient(
       shift - width * 0.3,
       0,
       shift + width * 1.1,
@@ -23351,11 +20285,11 @@ function prepareSticker(art, material, optical) {
     );
     if (holography > 0) {
       ["#edb2ef", "#aba5ef", "#96daea", "#d6efb0", "#ffe8bb", "#eab7e4", "#a3c6ed"].forEach(
-        (color3, i) => {
-          gradient3.addColorStop(i / 6, color3);
+        (color, i) => {
+          gradient2.addColorStop(i / 6, color);
         }
       );
-      coat.fillStyle = gradient3;
+      coat.fillStyle = gradient2;
       coat.globalAlpha = authored ? holography * 0.3 : finish === "holographic" ? 0.3 : 0.12;
       coat.fillRect(0, 0, width, height);
       if (foilMask) {
@@ -23512,19 +20446,19 @@ function effectiveRasterWidth(design2, dimensions) {
 }
 
 // ../renderer/src/sheet-layout.ts
-function placedOutline(shape2, item, holes = false) {
+function placedOutline(shape, item, holes = false) {
   const angle = item.rotation * Math.PI / 180;
   const cos = Math.cos(angle);
   const sin = Math.sin(angle);
-  return shape2.paths.filter((path2) => holes || !path2.hole).map(
+  return shape.paths.filter((path2) => holes || !path2.hole).map(
     (path2) => path2.points.map(([px, py]) => {
-      const dx = px - shape2.widthMm / 2;
-      const dy = py - shape2.heightMm / 2;
+      const dx = px - shape.widthMm / 2;
+      const dy = py - shape.heightMm / 2;
       return [item.x + dx * cos - dy * sin, item.y + dx * sin + dy * cos];
     })
   );
 }
-function box2(loops) {
+function box(loops) {
   let minX = Infinity;
   let minY = Infinity;
   let maxX = -Infinity;
@@ -23578,7 +20512,7 @@ function outlineDistance(a, b) {
 }
 function sheetViolations(spec, bounds, items) {
   const violations = [];
-  const boxes = items.map((item) => box2(item.outline));
+  const boxes = items.map((item) => box(item.outline));
   for (const [index, item] of items.entries()) {
     const b = boxes[index];
     const m = spec.marginMm;
@@ -23634,7 +20568,7 @@ function rasterize(loops, columns, rows, originX, originY) {
   return mask;
 }
 function footprint(outline) {
-  const b = box2(outline);
+  const b = box(outline);
   const columns = Math.ceil((b.maxX - b.minX) / cellMm) + 1;
   const rows = Math.ceil((b.maxY - b.minY) / cellMm) + 1;
   const mask = rasterize(outline, columns, rows, b.minX, b.minY);
@@ -23691,9 +20625,9 @@ var Occupancy = class {
         return [column * cellMm - print.offsetX, row * cellMm - print.offsetY];
   }
 };
-function area(shape2) {
+function area(shape) {
   let total = 0;
-  for (const path2 of shape2.paths)
+  for (const path2 of shape.paths)
     for (let i = 0; i < path2.points.length; i++) {
       const [ax, ay] = path2.points[i];
       const [bx, by] = path2.points[(i + 1) % path2.points.length];
@@ -23701,23 +20635,23 @@ function area(shape2) {
     }
   return Math.abs(total);
 }
-function placeOne(occupancy, { item, shape: shape2 }, target, rotations) {
+function placeOne(occupancy, { item, shape }, target, rotations) {
   for (const rotation of rotations) {
-    const at = occupancy.nearest(footprint(placedOutline(shape2, { x: 0, y: 0, rotation })), target);
+    const at = occupancy.nearest(footprint(placedOutline(shape, { x: 0, y: 0, rotation })), target);
     if (at) return { ...item, x: at[0], y: at[1], rotation };
   }
 }
-function packSheet(spec, bounds, inputs2, hero) {
+function packSheet(spec, bounds, inputs, hero) {
   const occupancy = new Occupancy(bounds, spec);
   const placed = /* @__PURE__ */ new Map();
-  const anchor = inputs2.find((input) => input.item.id === hero);
+  const anchor = inputs.find((input) => input.item.id === hero);
   let target = [bounds.widthMm / 2, bounds.heightMm / 2];
   if (anchor) {
     occupancy.add(placedOutline(anchor.shape, anchor.item));
     placed.set(anchor.item.id, anchor.item);
     target = [anchor.item.x, anchor.item.y];
   }
-  const rest = inputs2.filter((input) => input !== anchor).sort((a, b) => area(b.shape) - area(a.shape));
+  const rest = inputs.filter((input) => input !== anchor).sort((a, b) => area(b.shape) - area(a.shape));
   const missing = [];
   for (const input of rest) {
     const rotations = [
@@ -23732,15 +20666,15 @@ function packSheet(spec, bounds, inputs2, hero) {
     placed.set(item.id, item);
   }
   return {
-    items: inputs2.map((input) => placed.get(input.item.id) ?? input.item),
+    items: inputs.map((input) => placed.get(input.item.id) ?? input.item),
     missing
   };
 }
-function placeNear(spec, bounds, inputs2, id3, target) {
+function placeNear(spec, bounds, inputs, id, target) {
   const occupancy = new Occupancy(bounds, spec);
-  for (const input of inputs2)
-    if (input.item.id !== id3) occupancy.add(placedOutline(input.shape, input.item));
-  const moving = inputs2.find((input) => input.item.id === id3);
+  for (const input of inputs)
+    if (input.item.id !== id) occupancy.add(placedOutline(input.shape, input.item));
+  const moving = inputs.find((input) => input.item.id === id);
   if (!moving) return;
   return placeOne(occupancy, moving, target, [moving.item.rotation]);
 }
@@ -23833,7 +20767,7 @@ function placement(item, heightMm) {
   ].map(number).join(" ");
 }
 async function sheetPdf(input) {
-  const encoder2 = new TextEncoder();
+  const encoder = new TextEncoder();
   const objects = [];
   const add = (...parts) => {
     objects.push(parts);
@@ -23896,17 +20830,17 @@ S`),
     "Q EMC"
   ].join("\n");
   const contents = add(
-    ...stream("/Filter /FlateDecode", await input.deflate(encoder2.encode(content)))
+    ...stream("/Filter /FlateDecode", await input.deflate(encoder.encode(content)))
   );
   const W = number(input.widthMm * points);
   const Hp = number(H * points);
-  const box3 = `[0 0 ${W} ${Hp}]`;
-  const xobjects = images.map((id3, i) => `/Im${i} ${id3} 0 R`).join(" ");
+  const box2 = `[0 0 ${W} ${Hp}]`;
+  const xobjects = images.map((id, i) => `/Im${i} ${id} 0 R`).join(" ");
   objects[page - 1] = [
-    `<< /Type /Page /Parent ${pages} 0 R /MediaBox ${box3} /TrimBox ${box3} /BleedBox ${box3} /Resources << /XObject << ${xobjects} >> /ExtGState << /GSop ${overprint} 0 R >> /ColorSpace << /CSc ${cutSpace} 0 R${white ? ` /CSw ${whiteSpace} 0 R` : ""} >> /Properties << /oArt ${ocArt} 0 R /oCut ${ocCut} 0 R${white ? ` /oWhite ${ocWhite} 0 R` : ""} >> >> /Contents ${contents} 0 R >>`
+    `<< /Type /Page /Parent ${pages} 0 R /MediaBox ${box2} /TrimBox ${box2} /BleedBox ${box2} /Resources << /XObject << ${xobjects} >> /ExtGState << /GSop ${overprint} 0 R >> /ColorSpace << /CSc ${cutSpace} 0 R${white ? ` /CSw ${whiteSpace} 0 R` : ""} >> /Properties << /oArt ${ocArt} 0 R /oCut ${ocCut} 0 R${white ? ` /oWhite ${ocWhite} 0 R` : ""} >> >> /Contents ${contents} 0 R >>`
   ];
   objects[pages - 1] = [`<< /Type /Pages /Kids [${page} 0 R] /Count 1 >>`];
-  const groups = [ocArt, ...white ? [ocWhite] : [], ocCut].map((id3) => `${id3} 0 R`).join(" ");
+  const groups = [ocArt, ...white ? [ocWhite] : [], ocCut].map((id) => `${id} 0 R`).join(" ");
   objects[catalog - 1] = [
     `<< /Type /Catalog /Pages ${pages} 0 R /OCProperties << /OCGs [${groups}] /D << /Order [${groups}] /ON [${groups}] >> >> >>`
   ];
@@ -23914,7 +20848,7 @@ S`),
   const chunks = [];
   let length = 0;
   const push = (part) => {
-    const bytes = typeof part === "string" ? encoder2.encode(part) : part;
+    const bytes = typeof part === "string" ? encoder.encode(part) : part;
     chunks.push(bytes);
     length += bytes.length;
   };
@@ -23982,9 +20916,9 @@ function prepareSheetItem(sheet, widthMm, source, design2) {
   const flat = padArt(source, border + (spec.bleedMm + 1) * source.width / widthMm);
   const padded = widthMm * flat.width / source.width;
   const pixelsPerMm = flat.width / padded;
-  const shape2 = stickerCut(flat.rgba, flat.width, flat.height, border, padded);
+  const shape = stickerCut(flat.rgba, flat.width, flat.height, border, padded);
   const mask = stickerCutMask(flat.rgba, flat.width, flat.height, border, padded).mask;
-  const issues2 = [...shape2.issues];
+  const issues2 = [...shape.issues];
   const dpi = Math.min(source.width, source.effectiveWidth ?? source.width) / widthMm * 25.4;
   if (dpi < minPrintDpi)
     issues2.push({
@@ -24020,7 +20954,7 @@ function prepareSheetItem(sheet, widthMm, source, design2) {
     preview = { width: art.width, height: art.height, rgba };
   }
   return {
-    shape: shape2,
+    shape,
     art,
     preview,
     widthMm: padded,
@@ -24031,9 +20965,9 @@ function prepareSheetItem(sheet, widthMm, source, design2) {
 }
 function sheetPrintFrom(sheet, prepared) {
   const spec = sheetSpec(sheet);
-  const get = (id3) => {
-    const entry = prepared.get(id3);
-    if (!entry) throw new Error(`Missing prepared sticker for ${id3}.`);
+  const get = (id) => {
+    const entry = prepared.get(id);
+    if (!entry) throw new Error(`Missing prepared sticker for ${id}.`);
     return entry;
   };
   const shapes = new Map(sheet.items.map((item) => [item.id, get(item.id).shape]));
@@ -24125,11 +21059,11 @@ function registerBadgeFonts(root) {
 async function renderBadgeFacePng(input) {
   installCanvasGlobals();
   const marks = ["front", "back"].flatMap(
-    (face2) => input.design[face2].layers.flatMap(
+    (face) => input.design[face].layers.flatMap(
       (layer) => layer.kind === "card-mark" ? [[cardMarkImageId(layer.id), Buffer.from(cardMarkSvg(layer))]] : []
     )
   );
-  const [portrait2, images] = await Promise.all([
+  const [portrait, images] = await Promise.all([
     input.portrait ? loadImage(input.portrait) : void 0,
     Promise.all(
       [
@@ -24137,10 +21071,10 @@ async function renderBadgeFacePng(input) {
         ...marks,
         ...await Promise.all(
           Object.entries(designSvgImages(input.design, input.side, false)).map(
-            async ([id3, svg2]) => [id3, await sharp(Buffer.from(svg2)).png().toBuffer()]
+            async ([id, svg]) => [id, await sharp(Buffer.from(svg)).png().toBuffer()]
           )
         )
-      ].map(async ([id3, bytes]) => [id3, await loadImage(bytes)])
+      ].map(async ([id, bytes]) => [id, await loadImage(bytes)])
     )
   ]);
   const data = {
@@ -24152,7 +21086,7 @@ async function renderBadgeFacePng(input) {
   const canvas2 = createDesignFace(
     data,
     input.side,
-    portrait2,
+    portrait,
     new Map(images)
   );
   return canvas2.toBuffer("image/png");
@@ -24165,7 +21099,7 @@ async function renderStickerPng(input) {
   const images = new Map(
     await Promise.all(
       Object.entries(input.images ?? {}).map(
-        async ([id3, bytes]) => [id3, await loadImage(bytes)]
+        async ([id, bytes]) => [id, await loadImage(bytes)]
       )
     )
   );
@@ -24173,9 +21107,9 @@ async function renderStickerPng(input) {
     { ...input.person, document: input.design, eventName: input.design.event, portraitUrl: "" },
     images,
     async (design2) => {
-      const image2 = await loadImage(await renderBadgeFacePng({ ...input, design: design2, side: "front" }));
-      const isolated = createCanvas(image2.width, image2.height);
-      isolated.getContext("2d").drawImage(image2, 0, 0);
+      const image = await loadImage(await renderBadgeFacePng({ ...input, design: design2, side: "front" }));
+      const isolated = createCanvas(image.width, image.height);
+      isolated.getContext("2d").drawImage(image, 0, 0);
       return isolated;
     }
   );
@@ -24220,8 +21154,8 @@ function side(value) {
 }
 function summarizeBadgeLayers(design2) {
   return ["front", "back"].flatMap(
-    (face2) => design2[face2].layers.map((layer) => ({
-      side: face2,
+    (face) => design2[face].layers.map((layer) => ({
+      side: face,
       id: layer.id,
       kind: layer.kind,
       x: layer.x,
@@ -24233,29 +21167,29 @@ function summarizeBadgeLayers(design2) {
     }))
   );
 }
-function setBadgeLayer(design2, face2, id3, changes) {
-  const index = design2[face2].layers.findIndex((layer) => layer.id === id3);
-  if (index < 0) throw new InputError(`No ${face2} layer with id ${id3}. Run makeables layer list.`);
+function setBadgeLayer(design2, face, id, changes) {
+  const index = design2[face].layers.findIndex((layer) => layer.id === id);
+  if (index < 0) throw new InputError(`No ${face} layer with id ${id}. Run makeables layer list.`);
   for (const key of ["id", "kind"])
     if (key in changes) throw new InputError(`A layer's ${key} can't change.`);
-  const layers = [...design2[face2].layers];
+  const layers = [...design2[face].layers];
   const merged = badgeLayerSchema.safeParse({ ...layers[index], ...changes });
   if (!merged.success) throw new InputError(issues(merged.error));
   const next = merged.data;
   layers[index] = next.kind === "card-mark" ? cardMarkLayer(next.id, next) : next;
-  return parseBadge(pruneAssets({ ...design2, [face2]: { ...design2[face2], layers } }));
+  return parseBadge(pruneAssets({ ...design2, [face]: { ...design2[face], layers } }));
 }
-function removeBadgeLayer(design2, face2, id3) {
-  const layers = design2[face2].layers.filter((layer) => layer.id !== id3);
-  if (layers.length === design2[face2].layers.length)
-    throw new InputError(`No ${face2} layer with id ${id3}. Run makeables layer list.`);
-  return parseBadge(pruneAssets({ ...design2, [face2]: { ...design2[face2], layers } }));
+function removeBadgeLayer(design2, face, id) {
+  const layers = design2[face].layers.filter((layer) => layer.id !== id);
+  if (layers.length === design2[face].layers.length)
+    throw new InputError(`No ${face} layer with id ${id}. Run makeables layer list.`);
+  return parseBadge(pruneAssets({ ...design2, [face]: { ...design2[face], layers } }));
 }
 async function renderBadge(design2, options) {
   const root = badgeAssets();
   registerBadgeFonts(root);
   const usesSample = !options.photo;
-  const portrait2 = await readFile2(
+  const portrait = await readFile2(
     options.photo ? resolve2(options.photo) : join3(root, "prism", "demo", "alex-cutout.webp")
   ).catch((error) => {
     throw new InputError(`Cannot read --photo: ${error.message}`);
@@ -24264,8 +21198,8 @@ async function renderBadge(design2, options) {
   const images = {};
   const stickers = cardAssets().stickers;
   const canvas2 = designProfile(design2);
-  for (const [id3, asset] of Object.entries(design2.assets ?? {}))
-    images[id3] = asset.source === "petdex" ? await readFile2(join3(stickers, "petdex", `${asset.slug}.webp`)) : asset.source === "sticker" ? await readFile2(
+  for (const [id, asset] of Object.entries(design2.assets ?? {}))
+    images[id] = asset.source === "petdex" ? await readFile2(join3(stickers, "petdex", `${asset.slug}.webp`)) : asset.source === "sticker" ? await readFile2(
       join3(
         stickers,
         asset.collection,
@@ -24279,19 +21213,19 @@ async function renderBadge(design2, options) {
     throw new InputError(
       "Static material export supports sticker fronts. Use flat for other products."
     );
-  const input = { design: design2, side: options.face, person, portrait: portrait2, images };
+  const input = { design: design2, side: options.face, person, portrait, images };
   const png = options.appearance === "material" ? await renderStickerPng(input) : await renderBadgeFacePng(input);
   const dimensions = Object.fromEntries(
     await Promise.all(
-      Object.entries(images).map(async ([id3, bytes]) => {
+      Object.entries(images).map(async ([id, bytes]) => {
         const info = await sharp2(bytes).metadata();
-        return [id3, { width: info.width ?? 0, height: info.height ?? 0 }];
+        return [id, { width: info.width ?? 0, height: info.height ?? 0 }];
       })
     )
   );
   return { png, person, samplePortrait: usesSample, dimensions };
 }
-async function addBadgeSticker(design2, face2, src, base) {
+async function addBadgeSticker(design2, face, src, base) {
   let asset;
   let bytes;
   if (src.startsWith("petdex:")) {
@@ -24324,7 +21258,7 @@ async function addBadgeSticker(design2, face2, src, base) {
   }
   const { width = 1, height = 1 } = await sharp2(bytes).metadata();
   try {
-    return addSticker(design2, face2, asset, { width, height }, crypto.randomUUID().slice(0, 8));
+    return addSticker(design2, face, asset, { width, height }, crypto.randomUUID().slice(0, 8));
   } catch (error) {
     throw new InputError(error.message);
   }
@@ -24398,17 +21332,17 @@ async function startStudio(options = {}) {
   const send = (value) => peer?.stream.write(`data: ${JSON.stringify(value)}
 
 `);
-  function settle(id3, output) {
-    const call = pending.get(id3);
+  function settle(id, output) {
+    const call = pending.get(id);
     if (!call) return;
     clearTimeout(call.timer);
-    pending.delete(id3);
+    pending.delete(id);
     call.finish(output);
   }
   function disconnect() {
-    for (const id3 of pending.keys())
+    for (const id of pending.keys())
       settle(
-        id3,
+        id,
         failure("DISCONNECTED", "Preview disconnected. Reconnect and inspect before retrying.")
       );
     peer?.stream.end();
@@ -24451,14 +21385,14 @@ async function startStudio(options = {}) {
           json(409, failure("PREVIEW_IN_USE", "Keep the original preview tab open."));
           return;
         }
-        const id3 = url.searchParams.get("client");
-        if (!id3 || !/^[a-f0-9-]{36}$/.test(id3)) throw new Error("Invalid preview client.");
+        const id = url.searchParams.get("client");
+        if (!id || !/^[a-f0-9-]{36}$/.test(id)) throw new Error("Invalid preview client.");
         response.writeHead(200, {
           "Content-Type": "text/event-stream",
           Connection: "keep-alive"
         });
         response.write(": connected\n\n");
-        peer = { id: id3, stream: response, tools: [] };
+        peer = { id, stream: response, tools: [] };
         const heartbeat = setInterval(() => response.write(": heartbeat\n\n"), 15e3);
         response.on("close", () => {
           clearInterval(heartbeat);
@@ -24499,22 +21433,22 @@ async function startStudio(options = {}) {
           json(429, failure("BUSY", "Too many active calls. Wait for the current operation."));
           return;
         }
-        const id3 = randomUUID();
+        const id = randomUUID();
         const timer = setTimeout(() => {
-          send({ type: "cancel", id: id3 });
+          send({ type: "cancel", id });
           settle(
-            id3,
+            id,
             failure("TIMEOUT", "Call timed out. Inspect before retrying; it may have completed.")
           );
         }, options.timeout ?? 4e4);
-        pending.set(id3, { timer, finish: (output) => json(200, output) });
+        pending.set(id, { timer, finish: (output) => json(200, output) });
         response.on("close", () => {
-          if (pending.has(id3)) {
-            send({ type: "cancel", id: id3 });
-            settle(id3, failure("CANCELLED", "Caller disconnected."));
+          if (pending.has(id)) {
+            send({ type: "cancel", id });
+            settle(id, failure("CANCELLED", "Caller disconnected."));
           }
         });
-        send({ type: "call", id: id3, name: body.name, params: body.params });
+        send({ type: "call", id, name: body.name, params: body.params });
         return;
       }
       if (request.method === "POST" && url.pathname === "/stop") {
@@ -24561,7 +21495,7 @@ async function studioRequest(url, endpoint, body) {
 }
 
 // src/cloud.ts
-import { z as z8 } from "zod";
+import { z as z2 } from "zod";
 import { createHash } from "crypto";
 import { mkdir } from "fs/promises";
 import { homedir } from "os";
@@ -24576,11 +21510,11 @@ var CloudError = class extends InputError {
   code;
   status;
 };
-var credentialsSchema = z8.object({
-  accessToken: z8.string().min(1),
-  refreshToken: z8.string().optional(),
-  expiresAt: z8.number(),
-  clientId: z8.string()
+var credentialsSchema = z2.object({
+  accessToken: z2.string().min(1),
+  refreshToken: z2.string().optional(),
+  expiresAt: z2.number(),
+  clientId: z2.string()
 });
 function coordinatedCredentials(store, site, directory = join4(homedir(), ".config", "makeables", "credential-locks")) {
   async function mutate(work) {
@@ -24667,10 +21601,10 @@ async function cloudRequest(site, path2, token, body, operation) {
   );
 }
 async function oauthConfiguration(site) {
-  const config = z8.object({
-    clientId: z8.string().min(1),
-    issuer: z8.string().url(),
-    scopes: z8.literal("profile offline_access")
+  const config = z2.object({
+    clientId: z2.string().min(1),
+    issuer: z2.string().url(),
+    scopes: z2.literal("profile offline_access")
   }).parse(await cloudRequest(site, ""));
   const issuer = new URL(config.issuer);
   if (issuer.protocol !== "https:" || issuer.username || issuer.password || issuer.pathname !== "/" || issuer.search || issuer.hash || issuer.hostname !== "clerk.makeables.dev" && !(editorOrigin(site).startsWith("http://") && issuer.hostname.endsWith(".clerk.accounts.dev")))
@@ -24684,10 +21618,10 @@ async function oauthConfiguration(site) {
       signal: AbortSignal.timeout(15e3)
     })
   );
-  const endpoints = z8.object({
-    device_authorization_endpoint: z8.string().url(),
-    token_endpoint: z8.string().url(),
-    revocation_endpoint: z8.string().url()
+  const endpoints = z2.object({
+    device_authorization_endpoint: z2.string().url(),
+    token_endpoint: z2.string().url(),
+    revocation_endpoint: z2.string().url()
   }).parse(discovery);
   for (const endpoint of Object.values(endpoints))
     if (new URL(endpoint).origin !== issuer.origin)
@@ -24706,11 +21640,11 @@ async function oauthRequest(url, values) {
   return { ok: response.ok, data };
 }
 function tokenCredentials(data, clientId, previous) {
-  const value = z8.object({
-    access_token: z8.string().min(1),
-    token_type: z8.string().refine((type) => type.toLowerCase() === "bearer"),
-    expires_in: z8.number().positive(),
-    refresh_token: z8.string().optional()
+  const value = z2.object({
+    access_token: z2.string().min(1),
+    token_type: z2.string().refine((type) => type.toLowerCase() === "bearer"),
+    expires_in: z2.number().positive(),
+    refresh_token: z2.string().optional()
   }).parse(data);
   return {
     accessToken: value.access_token,
@@ -24725,13 +21659,13 @@ async function deviceLogin(config, store, options = {}) {
     scope: config.scopes
   });
   if (!start.ok) throw new CloudError("LOGIN_UNAVAILABLE", "Clerk could not start device login.");
-  const device = z8.object({
-    device_code: z8.string().min(1),
-    user_code: z8.string().min(1),
-    verification_uri: z8.string().url(),
-    verification_uri_complete: z8.string().url().optional(),
-    expires_in: z8.number().positive(),
-    interval: z8.number().positive().default(5)
+  const device = z2.object({
+    device_code: z2.string().min(1),
+    user_code: z2.string().min(1),
+    verification_uri: z2.string().url(),
+    verification_uri_complete: z2.string().url().optional(),
+    expires_in: z2.number().positive(),
+    interval: z2.number().positive().default(5)
   }).parse(start.data);
   const url = device.verification_uri_complete ?? device.verification_uri;
   const verification = new URL(url);
@@ -24739,17 +21673,21 @@ async function deviceLogin(config, store, options = {}) {
   const allowedHost = issuer.hostname === "clerk.makeables.dev" ? "accounts.makeables.dev" : issuer.hostname.replace(".clerk.accounts.dev", ".accounts.dev");
   if (verification.protocol !== "https:" || verification.username || verification.password || ![issuer.hostname, allowedHost].includes(verification.hostname))
     throw new CloudError("INVALID_AUTHORITY", "The device verification page changed origin.");
+  const waitSeconds = Math.round(
+    Math.min(device.expires_in * 1e3, options.timeout ?? 18e4) / 1e3
+  );
   options.progress?.({
     state: "authorization_required",
     url,
     code: device.user_code,
-    message: "Sign in once to connect makeables. Publication continues automatically."
+    expiresInSeconds: waitSeconds,
+    message: `Show this URL and code to the user now. This command waits ${waitSeconds}s for them to sign in, then continues automatically.`
   });
   if (!options.noOpen)
     await openBrowser(url).catch(() => {
       options.progress?.({ state: "open_browser", url, code: device.user_code });
     });
-  const deadline = Date.now() + Math.min(device.expires_in * 1e3, options.timeout ?? 18e4);
+  const deadline = Date.now() + waitSeconds * 1e3;
   let interval = Math.max(device.interval * 1e3, 1e3);
   while (Date.now() < deadline) {
     await (options.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms))))(interval);
@@ -24776,7 +21714,7 @@ async function deviceLogin(config, store, options = {}) {
   }
   throw new CloudError(
     "LOGIN_REQUIRED",
-    "Login timed out. Your badge is still saved. Run the same command to reconnect."
+    "Login timed out before the user signed in. Nothing was published. Run makeables login in the background, show its code to the user, then repeat this command."
   );
 }
 async function accessToken(site, options = {}) {
@@ -24825,7 +21763,7 @@ async function connectAccount(site, options = {}) {
   }
   return {
     token,
-    account: z8.object({ id: z8.string().startsWith("user_"), name: z8.string() }).parse(account)
+    account: z2.object({ id: z2.string().startsWith("user_"), name: z2.string() }).parse(account)
   };
 }
 async function logout(site, providedStore) {
@@ -24863,7 +21801,7 @@ async function logout(site, providedStore) {
 import { constants } from "fs";
 import { open as open2, readFile as readFile3 } from "fs/promises";
 import { basename as basename2, join as join5, resolve as resolve3 } from "path";
-import { z as z9 } from "zod";
+import { z as z3 } from "zod";
 async function packageFile(file) {
   const handle = await open2(resolve3(file), constants.O_RDONLY | constants.O_NOFOLLOW);
   try {
@@ -24884,21 +21822,30 @@ async function readSubmission(file, allowKit = true) {
       basename2(file).replace(/\.svg$/i, "").slice(0, 60)
     );
   const value = parseJson(bytes);
+  if (value && typeof value === "object" && "format" in value && value.format === "makeables-brand")
+    throw new InputError(
+      "A brand references kits. Use makeables submit --file brand.json, which submits its kits first."
+    );
   if (value && typeof value === "object" && "format" in value && value.format === "makeables-kit") {
     if (!allowKit) throw new InputError("Nested kits are not supported.");
-    return (await import("./kit-YXOYCN6F.js")).prepareKit(file);
+    return (await import("./kit-IEWHMBS2.js")).prepareKit(file);
   }
   if (value && typeof value === "object" && "format" in value && value.format === "makeables-package")
     return readPackageJson(value);
   return renderSubmission(await localSubmissionDraft(value));
 }
-async function localSubmissionDraft(value) {
+async function localSubmissionDraft(value, portrait) {
   const draft = await importDraft(value);
+  if (portrait) {
+    draft.portrait = portrait.path;
+    draft.files[portrait.path] = portrait.bytes;
+    draft.mime[portrait.path] = portrait.mime;
+  }
   const roots = cardAssets();
-  for (const id3 of requiredAssets(draft.design).assets) {
-    const asset = draft.design.assets?.[id3];
+  for (const id of requiredAssets(draft.design).assets) {
+    const asset = draft.design.assets?.[id];
     if (!asset || asset.source === "image") continue;
-    const path2 = `assets/${id3}.${asset.source === "gallery" ? "svg" : "webp"}`;
+    const path2 = `assets/${id}.${asset.source === "gallery" ? "svg" : "webp"}`;
     draft.files[path2] = await readFile3(
       asset.source === "gallery" ? join5(roots.designs, asset.slug, asset.file ?? "artwork.svg") : asset.source === "sticker" ? join5(
         roots.stickers,
@@ -24907,7 +21854,7 @@ async function localSubmissionDraft(value) {
       ) : join5(roots.stickers, "petdex", `${asset.slug}.webp`)
     );
     draft.mime[path2] = asset.source === "gallery" ? "image/svg+xml" : "image/webp";
-    draft.assets[id3] = path2;
+    draft.assets[id] = path2;
   }
   if (missingAssets(draft).length)
     throw new InputError(
@@ -24918,10 +21865,10 @@ async function localSubmissionDraft(value) {
 async function renderInput(draft) {
   registerBadgeFonts(badgeAssets());
   const images = {};
-  for (const [id3, asset] of Object.entries(draft.design.assets ?? {}))
-    if (asset.source === "image") images[id3] = Buffer.from(asset.data.split(",")[1], "base64");
-  for (const [id3, path2] of Object.entries(draft.assets))
-    images[id3] = Buffer.from(draft.files[path2]);
+  for (const [id, asset] of Object.entries(draft.design.assets ?? {}))
+    if (asset.source === "image") images[id] = Buffer.from(asset.data.split(",")[1], "base64");
+  for (const [id, path2] of Object.entries(draft.assets))
+    images[id] = Buffer.from(draft.files[path2]);
   if (draft.artwork) images.art = Buffer.from(draft.files[draft.artwork]);
   return {
     design: draft.design,
@@ -24949,14 +21896,14 @@ async function renderSubmission(draft) {
     back: await renderDraftFace(draft, "back", "flat")
   });
 }
-var receiptSchema = z9.object({
-  id: z9.string().uuid(),
-  state: z9.enum(["draft", "pending", "approved", "rejected", "withdrawn"]),
-  url: z9.string(),
-  product: z9.enum(["card", "badge", "sticker", "kit"]),
-  title: z9.string(),
-  uploaded: z9.array(z9.string()).optional(),
-  reviewNote: z9.string().nullable().optional()
+var receiptSchema = z3.object({
+  id: z3.string().uuid(),
+  state: z3.enum(["draft", "pending", "approved", "rejected", "withdrawn"]),
+  url: z3.string(),
+  product: z3.enum(["card", "badge", "sticker", "kit", "brand"]),
+  title: z3.string(),
+  uploaded: z3.array(z3.string()).optional(),
+  reviewNote: z3.string().nullable().optional()
 });
 function receipt(value, site) {
   const result = receiptSchema.parse(value);
@@ -24981,7 +21928,7 @@ async function submissionRequest(site, path2, token, body) {
   );
 }
 async function submitDesign(options) {
-  const pkg = await readSubmission(options.file), site = editorOrigin(options.site);
+  const pkg = options.pkg ?? await readSubmission(options.file), site = editorOrigin(options.site);
   const disclosure = {
     product: pkg.manifest.product,
     title: options.title ?? pkg.manifest.title,
@@ -24991,8 +21938,9 @@ async function submitDesign(options) {
         `${pkg.manifest.items.length} editable pieces with included images, attribution and participant details`,
         `${pkg.manifest.sheets.length} print sheets`
       ] : [],
+      ...pkg.manifest.product === "brand" ? [`brand page, logos and palette for ${pkg.manifest.kits.length} submitted kits`] : [],
       ...pkg.manifest.back ? ["back"] : [],
-      ...pkg.manifest.product === "kit" ? [] : pkg.manifest.document ? [
+      ...pkg.manifest.product === "kit" || pkg.manifest.product === "brand" ? [] : pkg.manifest.document ? [
         pkg.manifest.product === "badge" ? "editable layers and participant details" : "editable layers"
       ] : ["original artwork"],
       "included images and attribution"
@@ -25064,20 +22012,6 @@ async function submitDesign(options) {
 }
 
 export {
-  checkSubmittedSvg,
-  designProfile,
-  stickerMaterialSchema,
-  defaultStickerMaterial,
-  svgNodeSchema,
-  svgNodeXml,
-  badgeDesignObjectSchema,
-  badgeDesignSchema,
-  sheetSizes,
-  sheetTypes,
-  sheetTypeIds,
-  stickerSheetSchema,
-  sheetSpec,
-  createStickerSheet,
   cardStyles,
   findCardStyle,
   designEditsSchema,
@@ -25086,18 +22020,6 @@ export {
   createStickerDesign,
   designCatalog,
   findDesign,
-  kitDocumentSchema,
-  PACKAGE_LIMIT,
-  designManifestSchema,
-  jsonBytes,
-  hashBytes,
-  assemblePackage,
-  readPackageZip,
-  packageZip,
-  draftFromPackage,
-  packageJson,
-  readPackageJson,
-  kitMemberPackage,
   stickerCut,
   stickerCutSvg,
   effectiveRasterWidth,
@@ -25117,6 +22039,7 @@ export {
   removeBadgeLayer,
   renderBadge,
   addBadgeSticker,
+  editorOrigin,
   openBrowser,
   startStudio,
   studioRequest,