venuekit 0.0.0-stage → 0.10.0

package/dist/chunk-5H5QKXPV.js

@@ -0,0 +1,1311 @@
+// ../core/src/labels.ts
+var LATIN_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var SPANISH_ALPHABET = "ABCDEFGHIJKLMN\xD1OPQRSTUVWXYZ";
+function letters(alphabet) {
+  return alphabet === "es" ? SPANISH_ALPHABET : LATIN_ALPHABET;
+}
+function letterLabel(index, alphabet) {
+  if (!Number.isSafeInteger(index) || index < 0) throw new RangeError(`\xCDndice de letra inv\xE1lido: ${index}`);
+  const abc = letters(alphabet);
+  let n = index + 1;
+  let out = "";
+  while (n > 0) {
+    const rem = (n - 1) % abc.length;
+    out = abc[rem] + out;
+    n = Math.floor((n - 1) / abc.length);
+  }
+  return out;
+}
+function letterIndex(label, alphabet) {
+  const abc = letters(alphabet);
+  const upper = label.toUpperCase();
+  if (upper.length === 0 || [...upper].some((ch) => !abc.includes(ch))) {
+    throw new RangeError(`Etiqueta de letras inv\xE1lida: ${label.slice(0, 20)}`);
+  }
+  let n = 0;
+  for (const ch of upper) {
+    n = n * abc.length + abc.indexOf(ch) + 1;
+    if (!Number.isSafeInteger(n)) throw new RangeError("Etiqueta de letras demasiado larga");
+  }
+  return n - 1;
+}
+function labelSequence(rule, count) {
+  const out = [];
+  if (rule.kind === "letters") {
+    const skip2 = new Set((rule.skip ?? []).map((s) => s.toUpperCase()));
+    let i = letterIndex(rule.start, rule.alphabet);
+    while (out.length < count) {
+      const label = letterLabel(i++, rule.alphabet);
+      if (!skip2.has(label)) out.push(label);
+    }
+    return out;
+  }
+  const skip = new Set(rule.skip ?? []);
+  let n = Number(rule.start);
+  if (!/^\d+$/.test(rule.start) || !Number.isSafeInteger(n)) throw new RangeError(`Inicio num\xE9rico inv\xE1lido: ${rule.start.slice(0, 20)}`);
+  const pattern = rule.pattern ?? "sequential";
+  const step = pattern === "odd" || pattern === "even" ? 2 : 1;
+  if (pattern === "odd" && n % 2 === 0 || pattern === "even" && n % 2 === 1) n++;
+  while (out.length < count) {
+    if (!Number.isSafeInteger(n)) throw new RangeError("La numeraci\xF3n pasa el rango seguro");
+    const label = String(n);
+    n += step;
+    if (!skip.has(label)) out.push(label);
+  }
+  return out;
+}
+function fromCentre(sequence) {
+  const out = new Array(sequence.length);
+  let right = Math.floor(sequence.length / 2);
+  let left = right - 1;
+  sequence.forEach((label, k) => {
+    if (k % 2 === 0) out[right++] = label;
+    else out[left--] = label;
+  });
+  return out;
+}
+function expandLabels(rule, count) {
+  const sequence = labelSequence(rule, count);
+  const out = rule.kind === "numbers" && rule.pattern === "center" ? fromCentre(sequence) : sequence;
+  return rule.direction === "rtl" ? out.reverse() : out;
+}
+
+// ../core/src/ids.ts
+var ID_SEP = ":";
+function seatUnitId(blockId, rowLabel, seatLabel) {
+  return `${blockId}${ID_SEP}${rowLabel}${ID_SEP}${seatLabel}`;
+}
+function placeUnitId(tableId, n) {
+  return `${tableId}${ID_SEP}${n}`;
+}
+function parseUnitId(id) {
+  return id.split(ID_SEP);
+}
+
+// ../core/src/landmarks.ts
+var landmarks = [
+  // Accesos y circulación
+  { id: "entrance", name: "Ingreso", group: "access", width: 140, height: 60 },
+  { id: "exit", name: "Salida", group: "access", width: 140, height: 60 },
+  {
+    id: "emergency-exit",
+    name: "Salida de emergencia",
+    group: "access",
+    width: 140,
+    height: 60
+  },
+  {
+    id: "vehicle-entrance",
+    name: "Ingreso vehicular",
+    group: "access",
+    width: 180,
+    height: 70
+  },
+  {
+    id: "box-office",
+    name: "Boleter\xEDa",
+    group: "access",
+    width: 140,
+    height: 70
+  },
+  {
+    id: "cloakroom",
+    name: "Guardarropa",
+    group: "access",
+    width: 140,
+    height: 70
+  },
+  {
+    id: "meeting-point",
+    name: "Punto de encuentro",
+    group: "access",
+    width: 120,
+    height: 70
+  },
+  // Barras y consumo
+  { id: "bar", name: "Barra", group: "bar", width: 300, height: 60 },
+  {
+    id: "drinks-bar",
+    name: "Barra de bebidas",
+    group: "bar",
+    width: 300,
+    height: 60
+  },
+  {
+    id: "food-bar",
+    name: "Barra de comida",
+    group: "bar",
+    width: 300,
+    height: 60
+  },
+  {
+    id: "food-trucks",
+    name: "Food trucks",
+    group: "bar",
+    width: 320,
+    height: 90
+  },
+  {
+    id: "top-up",
+    name: "Carga de cr\xE9dito",
+    group: "bar",
+    width: 140,
+    height: 70
+  },
+  { id: "merch", name: "Merchandising", group: "bar", width: 160, height: 70 },
+  // Servicios
+  { id: "toilets", name: "Ba\xF1os", group: "service", width: 120, height: 80 },
+  {
+    id: "accessible-toilets",
+    name: "Ba\xF1os accesibles",
+    group: "service",
+    width: 120,
+    height: 80
+  },
+  {
+    id: "first-aid",
+    name: "Primeros auxilios",
+    group: "service",
+    width: 130,
+    height: 80
+  },
+  {
+    id: "security",
+    name: "Seguridad",
+    group: "service",
+    width: 120,
+    height: 70
+  },
+  {
+    id: "smoking-area",
+    name: "Sector fumadores",
+    group: "service",
+    width: 200,
+    height: 120
+  },
+  // Escenario y producción
+  { id: "stage", name: "Escenario", group: "stage", width: 400, height: 70 },
+  {
+    id: "second-stage",
+    name: "Escenario secundario",
+    group: "stage",
+    width: 260,
+    height: 60
+  },
+  { id: "dj", name: "DJ", group: "stage", width: 200, height: 60 },
+  {
+    id: "sound-desk",
+    name: "Consola de sonido",
+    group: "stage",
+    width: 140,
+    height: 80
+  },
+  { id: "screen", name: "Pantalla", group: "stage", width: 240, height: 40 },
+  {
+    id: "dressing-rooms",
+    name: "Camarines",
+    group: "stage",
+    width: 180,
+    height: 100
+  },
+  // Espacios
+  {
+    id: "dance-floor",
+    name: "Pista de baile",
+    group: "space",
+    width: 400,
+    height: 260
+  },
+  {
+    id: "accessible-area",
+    name: "Sector accesible",
+    group: "space",
+    width: 200,
+    height: 120
+  },
+  { id: "tent", name: "Carpa", group: "space", width: 260, height: 180 },
+  { id: "pool", name: "Pileta", group: "space", width: 300, height: 180 },
+  {
+    id: "parking",
+    name: "Estacionamiento",
+    group: "space",
+    width: 360,
+    height: 220
+  }
+];
+function landmarkById(id) {
+  return landmarks.find((l) => l.id === id) ?? null;
+}
+
+// ../core/src/schema.ts
+import { z } from "zod";
+var MAX_UNITS = 1e5;
+var MAX_ID_LENGTH = 64;
+var MAX_NAME_LENGTH = 120;
+var MAX_REF_LENGTH = 120;
+var MAX_TABLE_LABEL_LENGTH = 20;
+var MAX_SRC_LENGTH = 4096;
+var MAX_ELEMENTS = 5e3;
+var MAX_LETTERS_START = 3;
+var MAX_SKIP = 100;
+var MIN_SCALE = 0.4;
+var MAX_SCALE = 2;
+var idSchema = z.string().max(MAX_ID_LENGTH).regex(/^[A-Za-z0-9_-]+$/, "El id s\xF3lo admite letras, n\xFAmeros, _ y -");
+var rotationSchema = z.union([z.literal(0), z.literal(90), z.literal(180), z.literal(270)]);
+var transformSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  rotation: rotationSchema.default(0)
+});
+var LETTERS_RE = /^[A-Za-z]{1,3}$/;
+var LETTERS_ES_RE = /^[A-Za-zÑñ]{1,3}$/;
+var NUMBERS_RE = /^\d{1,9}$/;
+var labelRuleSchema = z.object({
+  kind: z.enum(["letters", "numbers"]),
+  start: z.string().min(1),
+  direction: z.enum(["ltr", "rtl"]),
+  skip: z.array(z.string().max(9)).max(MAX_SKIP).optional(),
+  /** "es" suma la Ñ después de la N. */
+  alphabet: z.enum(["latin", "es"]).optional(),
+  /** Seguidas, sólo impares, sólo pares o desde el centro (ver `expandLabels`). */
+  pattern: z.enum(["sequential", "odd", "even", "center"]).optional()
+}).superRefine((rule, ctx) => {
+  const re = rule.kind === "numbers" ? NUMBERS_RE : rule.alphabet === "es" ? LETTERS_ES_RE : LETTERS_RE;
+  const lettersHint = rule.alphabet === "es" ? "letras A-Z o \xD1" : "letras A-Z";
+  const hint = rule.kind === "letters" ? `Con kind "letters", start debe ser s\xF3lo ${lettersHint} (hasta ${MAX_LETTERS_START})` : `Con kind "numbers", start debe ser s\xF3lo d\xEDgitos (hasta 9)`;
+  if (!re.test(rule.start)) {
+    ctx.addIssue({ code: "custom", path: ["start"], message: hint });
+  }
+  if (rule.kind === "letters" && rule.pattern !== void 0 && rule.pattern !== "sequential") {
+    ctx.addIssue({ code: "custom", path: ["pattern"], message: `Con kind "letters" la numeraci\xF3n s\xF3lo puede ser "sequential"` });
+  }
+  if (rule.kind === "numbers" && rule.alphabet !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["alphabet"], message: `alphabet s\xF3lo se usa con kind "letters"` });
+  }
+  rule.skip?.forEach((s, i) => {
+    if (!re.test(s)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["skip", i],
+        message: rule.kind === "letters" ? `Con kind "letters", skip debe contener s\xF3lo ${lettersHint} (hasta ${MAX_LETTERS_START})` : `Con kind "numbers", skip debe contener s\xF3lo d\xEDgitos (hasta 9)`
+      });
+    }
+  });
+});
+var placeTypeLinkSchema = z.object({
+  ref: z.string().max(MAX_REF_LENGTH),
+  name: z.string().max(MAX_NAME_LENGTH)
+});
+var seatBlockSchema = z.object({
+  id: idSchema,
+  type: z.literal("seatBlock"),
+  transform: transformSchema,
+  rows: z.number().int().min(1).max(500),
+  cols: z.number().int().min(1).max(1e3),
+  rowLabels: labelRuleSchema,
+  seatLabels: labelRuleSchema,
+  spacing: z.object({ x: z.number().positive(), y: z.number().positive() }),
+  curve: z.number().min(0).max(180).default(0),
+  scale: z.number().min(MIN_SCALE).max(MAX_SCALE).default(1),
+  removed: z.array(z.string().max(MAX_ID_LENGTH * 2)).max(MAX_UNITS).default([]),
+  placeType: placeTypeLinkSchema.nullable().default(null)
+});
+var tableSchema = z.object({
+  id: idSchema,
+  type: z.literal("table"),
+  transform: transformSchema,
+  shape: z.enum(["round", "rect"]),
+  places: z.number().int().min(1).max(64),
+  label: z.string().min(1).max(MAX_TABLE_LABEL_LENGTH),
+  mode: z.enum(["whole", "perPlace"]),
+  scale: z.number().min(MIN_SCALE).max(MAX_SCALE).default(1),
+  placeType: placeTypeLinkSchema.nullable().default(null)
+});
+var landmarkSchema = z.object({
+  id: idSchema,
+  type: z.literal("landmark"),
+  transform: transformSchema,
+  kind: z.string().refine((k) => landmarkById(k) !== null, "El tipo de referencia no existe en el cat\xE1logo"),
+  name: z.string().min(1).max(60),
+  width: z.number().positive(),
+  height: z.number().positive()
+});
+var zoneSchema = z.object({
+  id: idSchema,
+  type: z.literal("zone"),
+  transform: transformSchema,
+  width: z.number().positive(),
+  height: z.number().positive(),
+  /** Grados de arco, como `seatBlock.curve`: con curva la zona es una banda (tribuna curva). */
+  curve: z.number().min(0).max(180).default(0),
+  placeType: placeTypeLinkSchema.nullable().default(null)
+});
+var elementSchema = z.discriminatedUnion("type", [seatBlockSchema, tableSchema, landmarkSchema, zoneSchema]);
+var backgroundSchema = z.object({
+  src: z.string().min(1).max(MAX_SRC_LENGTH),
+  x: z.number(),
+  y: z.number(),
+  width: z.number().positive(),
+  height: z.number().positive(),
+  opacity: z.number().min(0.1).max(1),
+  locked: z.boolean()
+});
+var metaSchema = z.object({
+  id: idSchema,
+  name: z.string().max(MAX_NAME_LENGTH),
+  version: z.literal(2),
+  width: z.number().positive(),
+  height: z.number().positive(),
+  background: backgroundSchema.nullable().default(null)
+});
+var layoutSchema = z.object({
+  meta: metaSchema,
+  elements: z.array(elementSchema).max(MAX_ELEMENTS)
+}).superRefine((layout, ctx) => {
+  const elementIds = /* @__PURE__ */ new Set();
+  let totalUnits = 0;
+  for (const e of layout.elements) {
+    if (e.type === "table") totalUnits += e.places;
+    else if (e.type === "seatBlock") totalUnits += e.rows * e.cols;
+  }
+  const overLimit = totalUnits > MAX_UNITS;
+  if (overLimit) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["elements"],
+      message: `El documento supera el m\xE1ximo de unidades vendibles (${totalUnits} > ${MAX_UNITS})`
+    });
+  }
+  layout.elements.forEach((e, i) => {
+    if (elementIds.has(e.id)) {
+      ctx.addIssue({ code: "custom", path: ["elements", i, "id"], message: `Id de elemento duplicado: ${e.id}` });
+    }
+    elementIds.add(e.id);
+    if (e.type !== "seatBlock" || e.removed.length === 0 || overLimit) return;
+    if (!labelRuleSchema.safeParse(e.rowLabels).success || !labelRuleSchema.safeParse(e.seatLabels).success) return;
+    const rows = new Set(expandLabels(e.rowLabels, e.rows));
+    const seats = new Set(expandLabels(e.seatLabels, e.cols));
+    e.removed.forEach((id, j) => {
+      const [blockId, row, seat, ...extra] = parseUnitId(id);
+      const ok = blockId === e.id && extra.length === 0 && row !== void 0 && seat !== void 0 && rows.has(row) && seats.has(seat);
+      if (!ok) {
+        ctx.addIssue({ code: "custom", path: ["elements", i, "removed", j], message: `El bloque ${e.id} no genera la butaca ${id}` });
+      }
+    });
+  });
+});
+var spanishParseOptions = { error: z.locales.es().localeError };
+
+// ../core/src/geometry.ts
+var DEG = Math.PI / 180;
+function applyTransform(p, t) {
+  const r = t.rotation * DEG;
+  if (r === 0) return { x: p.x + t.x, y: p.y + t.y };
+  const cos = Math.cos(r);
+  const sin = Math.sin(r);
+  return { x: p.x * cos - p.y * sin + t.x, y: p.x * sin + p.y * cos + t.y };
+}
+function bbox(points) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of points) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function pointInPolygon(p, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const [xi, yi] = polygon[i];
+    const [xj, yj] = polygon[j];
+    const crosses = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
+    if (crosses) inside = !inside;
+  }
+  return inside;
+}
+function distance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+// ../core/src/bounds.ts
+function placeTypeBounds(_layout, units, ref) {
+  const points = units.filter((u) => u.placeTypeRef === ref).map((u) => ({ x: u.x, y: u.y }));
+  if (points.length === 0) return null;
+  return bbox(points);
+}
+
+// ../core/src/zone-shape.ts
+var DEG2 = Math.PI / 180;
+function zoneArc(zone) {
+  const curve = zone.curve ?? 0;
+  if (curve <= 0) return null;
+  const theta = curve * DEG2;
+  const mid = zone.width / theta;
+  return { half: theta / 2, mid, inner: Math.max(0, mid - zone.height / 2), outer: mid + zone.height / 2 };
+}
+function polar(arc, r, phi) {
+  return { x: r * Math.sin(phi), y: -arc.mid + r * Math.cos(phi) };
+}
+function localBox(zone) {
+  const arc = zoneArc(zone);
+  if (!arc) return { minX: -zone.width / 2, minY: -zone.height / 2, maxX: zone.width / 2, maxY: zone.height / 2 };
+  const hw = arc.half >= Math.PI / 2 ? arc.outer : arc.outer * Math.sin(arc.half);
+  const top = -arc.mid + arc.inner * Math.cos(arc.half);
+  return { minX: -hw, minY: top, maxX: hw, maxY: -arc.mid + arc.outer };
+}
+function zoneLocalSize(zone) {
+  const b = localBox(zone);
+  return { width: b.maxX - b.minX, height: b.maxY - b.minY };
+}
+function zoneBounds(zone) {
+  const b = localBox(zone);
+  const corners = [
+    { x: b.minX, y: b.minY },
+    { x: b.maxX, y: b.minY },
+    { x: b.maxX, y: b.maxY },
+    { x: b.minX, y: b.maxY }
+  ].map((p) => applyTransform(p, zone.transform));
+  return {
+    minX: Math.min(...corners.map((p) => p.x)),
+    minY: Math.min(...corners.map((p) => p.y)),
+    maxX: Math.max(...corners.map((p) => p.x)),
+    maxY: Math.max(...corners.map((p) => p.y))
+  };
+}
+function pointInZone(zone, p) {
+  const back = (360 - zone.transform.rotation) % 360;
+  const local = applyTransform({ x: p.x - zone.transform.x, y: p.y - zone.transform.y }, { x: 0, y: 0, rotation: back });
+  const arc = zoneArc(zone);
+  if (!arc) return Math.abs(local.x) <= zone.width / 2 && Math.abs(local.y) <= zone.height / 2;
+  const dx = local.x;
+  const dy = local.y + arc.mid;
+  const r = Math.hypot(dx, dy);
+  if (r < arc.inner || r > arc.outer) return false;
+  return Math.abs(Math.atan2(dx, dy)) <= arc.half + 1e-9;
+}
+function zoneOutline(zone, corner = 0) {
+  const arc = zoneArc(zone);
+  if (!arc) return [];
+  const steps2 = Math.max(8, Math.ceil(arc.half * 2 / (3 * DEG2)));
+  const r = Math.max(0, Math.min(corner, zone.height / 3, arc.outer * arc.half * 0.3));
+  const out = [];
+  const arcPoints = (radius, from, to) => {
+    for (let i = 0; i <= steps2; i++) out.push(polar(arc, radius, from + (to - from) * i / steps2));
+  };
+  const fillet = (a, control, b) => {
+    for (let i = 1; i < 4; i++) {
+      const t = i / 4;
+      const u = 1 - t;
+      out.push({ x: u * u * a.x + 2 * u * t * control.x + t * t * b.x, y: u * u * a.y + 2 * u * t * control.y + t * t * b.y });
+    }
+  };
+  const dOut = r / arc.outer;
+  const hasInner = arc.inner > r * 2;
+  const dIn = hasInner ? r / arc.inner : 0;
+  arcPoints(arc.outer, -arc.half + dOut, arc.half - dOut);
+  fillet(polar(arc, arc.outer, arc.half - dOut), polar(arc, arc.outer, arc.half), polar(arc, arc.outer - r, arc.half));
+  if (hasInner) {
+    out.push(polar(arc, arc.outer - r, arc.half), polar(arc, arc.inner + r, arc.half));
+    fillet(polar(arc, arc.inner + r, arc.half), polar(arc, arc.inner, arc.half), polar(arc, arc.inner, arc.half - dIn));
+    arcPoints(arc.inner, arc.half - dIn, -arc.half + dIn);
+    fillet(polar(arc, arc.inner, -arc.half + dIn), polar(arc, arc.inner, -arc.half), polar(arc, arc.inner + r, -arc.half));
+    out.push(polar(arc, arc.outer - r, -arc.half));
+  } else {
+    out.push(polar(arc, arc.outer - r, arc.half));
+    if (arc.inner > 0) arcPoints(arc.inner, arc.half, -arc.half);
+    else out.push(polar(arc, 0, 0));
+    out.push(polar(arc, arc.outer - r, -arc.half));
+  }
+  fillet(polar(arc, arc.outer - r, -arc.half), polar(arc, arc.outer, -arc.half), polar(arc, arc.outer, -arc.half + dOut));
+  return out.map((p) => applyTransform(p, zone.transform));
+}
+function zoneLabelSize(zone) {
+  const arc = zoneArc(zone);
+  if (!arc) return { width: zone.width, height: zone.height };
+  const byRadius = Math.sqrt(Math.max(0, arc.outer * arc.outer - arc.mid * arc.mid));
+  const byAngle = arc.half >= Math.PI / 2 ? Infinity : arc.mid * Math.tan(arc.half);
+  return { width: 2 * Math.min(byRadius, byAngle), height: arc.outer - arc.inner };
+}
+function zoneWithLocalSize(zone, width, height) {
+  const arc = zoneArc(zone);
+  if (!arc) return { ...zone, width, height };
+  const theta = arc.half * 2;
+  const sin = arc.half >= Math.PI / 2 ? 1 : Math.sin(arc.half);
+  const cos = Math.max(0, Math.cos(arc.half));
+  const outer = width / (2 * sin);
+  let inner;
+  if (cos > 1e-6) inner = (outer - height) / cos;
+  else inner = outer - (arc.outer - arc.inner) * (outer / arc.outer);
+  inner = Math.max(0, Math.min(inner, outer - 1));
+  const thickness = outer - inner;
+  const mid = inner === 0 ? outer / 2 : (outer + inner) / 2;
+  return { ...zone, width: mid * theta, height: inner === 0 ? outer : thickness };
+}
+
+// ../core/src/expand.ts
+var DEG3 = Math.PI / 180;
+function localSeatPosition(block, r, c) {
+  const curve = block.curve;
+  const sx = block.spacing.x * (block.scale ?? 1);
+  const sy = block.spacing.y * (block.scale ?? 1);
+  if (curve === 0 || block.cols === 1) {
+    return { x: c * sx, y: r * sy };
+  }
+  const theta = curve * DEG3;
+  const arcLen = (block.cols - 1) * sx;
+  const r0 = arcLen / theta;
+  const radius = r0 + r * sy;
+  const angle = -theta / 2 + theta * c / (block.cols - 1);
+  return { x: arcLen / 2 + radius * Math.sin(angle), y: -r0 + radius * Math.cos(angle) };
+}
+function expandSeatBlock(block) {
+  const rowLabels = expandLabels(block.rowLabels, block.rows);
+  const seatLabels = expandLabels(block.seatLabels, block.cols);
+  const removed = new Set(block.removed);
+  const out = [];
+  for (let r = 0; r < block.rows; r++) {
+    const row = rowLabels[r];
+    for (let c = 0; c < block.cols; c++) {
+      const seat = seatLabels[c];
+      const id = seatUnitId(block.id, row, seat);
+      if (removed.has(id)) continue;
+      const p = applyTransform(localSeatPosition(block, r, c), block.transform);
+      out.push({
+        id,
+        label: `${row}${seat}`,
+        kind: "seat",
+        x: p.x,
+        y: p.y,
+        elementId: block.id,
+        placeTypeRef: block.placeType?.ref || null,
+        row,
+        seat,
+        rowIndex: r,
+        colIndex: c
+      });
+    }
+  }
+  return out;
+}
+var TABLE_RADIUS = 30;
+var TABLE_WIDTH = 80;
+var TABLE_HEIGHT = 40;
+var PLACE_OFFSET = 10;
+function localPlacePositions(table) {
+  const s = table.scale ?? 1;
+  return basePlacePositions(table).map((p) => ({ x: p.x * s, y: p.y * s }));
+}
+function basePlacePositions(table) {
+  const n = table.places;
+  if (table.shape === "round") {
+    const r = TABLE_RADIUS + PLACE_OFFSET;
+    return Array.from({ length: n }, (_, i) => {
+      const a = 2 * Math.PI * i / n - Math.PI / 2;
+      return { x: r * Math.cos(a), y: r * Math.sin(a) };
+    });
+  }
+  const top = Math.ceil(n / 2);
+  const bottom = n - top;
+  const spread = (count, y) => Array.from({ length: count }, (_, i) => ({ x: -TABLE_WIDTH / 2 + TABLE_WIDTH * (i + 0.5) / count, y }));
+  return [...spread(top, -TABLE_HEIGHT / 2 - PLACE_OFFSET), ...spread(bottom, TABLE_HEIGHT / 2 + PLACE_OFFSET)];
+}
+function expandTable(table) {
+  const placeTypeRef = table.placeType?.ref || null;
+  if (table.mode === "whole") {
+    const centre = applyTransform({ x: 0, y: 0 }, table.transform);
+    return [{ id: table.id, label: table.label, kind: "table", x: centre.x, y: centre.y, elementId: table.id, placeTypeRef, table: table.label }];
+  }
+  return localPlacePositions(table).map((local, i) => {
+    const p = applyTransform(local, table.transform);
+    const n = i + 1;
+    return { id: placeUnitId(table.id, n), label: `${table.label} \xB7 ${n}`, kind: "place", x: p.x, y: p.y, elementId: table.id, placeTypeRef, table: table.label, place: n };
+  });
+}
+function expand(layout) {
+  const out = [];
+  for (const el of layout.elements) {
+    if (el.type === "seatBlock") out.push(...expandSeatBlock(el));
+    else if (el.type === "table") out.push(...expandTable(el));
+  }
+  return out;
+}
+
+// ../core/src/spatial.ts
+var Node = class _Node {
+  constructor(box, capacity) {
+    this.box = box;
+    this.capacity = capacity;
+  }
+  box;
+  capacity;
+  items = [];
+  children = null;
+  insert(item) {
+    if (this.children) {
+      this.childFor(item).insert(item);
+      return;
+    }
+    this.items.push(item);
+    if (this.items.length > this.capacity && this.canSplit()) this.split();
+  }
+  canSplit() {
+    return this.box.maxX - this.box.minX > 1e-6 || this.box.maxY - this.box.minY > 1e-6;
+  }
+  split() {
+    const { minX, minY, maxX, maxY } = this.box;
+    const mx = (minX + maxX) / 2;
+    const my = (minY + maxY) / 2;
+    this.children = [
+      new _Node({ minX, minY, maxX: mx, maxY: my }, this.capacity),
+      new _Node({ minX: mx, minY, maxX, maxY: my }, this.capacity),
+      new _Node({ minX, minY: my, maxX: mx, maxY }, this.capacity),
+      new _Node({ minX: mx, minY: my, maxX, maxY }, this.capacity)
+    ];
+    for (const it of this.items) this.childFor(it).items.push(it);
+    this.items = [];
+  }
+  childFor(p) {
+    const mx = (this.box.minX + this.box.maxX) / 2;
+    const my = (this.box.minY + this.box.maxY) / 2;
+    const i = (p.x >= mx ? 1 : 0) + (p.y >= my ? 2 : 0);
+    return this.children?.[i];
+  }
+  queryRect(q, out) {
+    if (q.maxX < this.box.minX || q.minX > this.box.maxX || q.maxY < this.box.minY || q.minY > this.box.maxY) return;
+    if (this.children) {
+      for (const c of this.children) c.queryRect(q, out);
+      return;
+    }
+    for (const it of this.items) {
+      if (it.x >= q.minX && it.x <= q.maxX && it.y >= q.minY && it.y <= q.maxY) out.push(it.id);
+    }
+  }
+  nearest(p, best) {
+    const dx = Math.max(this.box.minX - p.x, 0, p.x - this.box.maxX);
+    const dy = Math.max(this.box.minY - p.y, 0, p.y - this.box.maxY);
+    if (Math.hypot(dx, dy) > best.d) return;
+    if (this.children) {
+      for (const c of this.children) c.nearest(p, best);
+      return;
+    }
+    for (const it of this.items) {
+      const d = distance(p, it);
+      if (d < best.d) {
+        best.d = d;
+        best.id = it.id;
+      }
+    }
+  }
+};
+var SpatialIndex = class {
+  root;
+  size;
+  constructor(items, capacity = 16) {
+    this.size = items.length;
+    if (items.length === 0) {
+      this.root = null;
+      return;
+    }
+    const b = bbox(items);
+    this.root = new Node({ minX: b.minX - 1, minY: b.minY - 1, maxX: b.maxX + 1, maxY: b.maxY + 1 }, capacity);
+    for (const it of items) this.root.insert(it);
+  }
+  queryRect(box) {
+    const out = [];
+    this.root?.queryRect(box, out);
+    return out;
+  }
+  nearest(p, maxDistance) {
+    const best = { id: null, d: maxDistance };
+    this.root?.nearest(p, best);
+    return best.id;
+  }
+};
+
+// ../core/src/commands.ts
+var CommandError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CommandError";
+  }
+};
+function shift(el, dx, dy) {
+  return { ...el, transform: { ...el.transform, x: el.transform.x + dx, y: el.transform.y + dy } };
+}
+function requireElement(layout, id) {
+  const i = layout.elements.findIndex((e) => e.id === id);
+  if (i < 0) throw new CommandError(`No existe el elemento ${id}`);
+  return i;
+}
+function replaceAt(arr, i, value) {
+  return arr.map((v, j) => j === i ? value : v);
+}
+function reduce(layout, cmd) {
+  switch (cmd.type) {
+    case "addElement":
+      return { ...layout, elements: [...layout.elements, cmd.element] };
+    case "removeElement": {
+      const i = requireElement(layout, cmd.id);
+      return { ...layout, elements: layout.elements.filter((_, j) => j !== i) };
+    }
+    case "updateElement": {
+      const i = requireElement(layout, cmd.id);
+      const merged = { ...layout.elements[i], ...cmd.patch };
+      return { ...layout, elements: replaceAt(layout.elements, i, merged) };
+    }
+    case "moveElement": {
+      const i = requireElement(layout, cmd.id);
+      return { ...layout, elements: replaceAt(layout.elements, i, shift(layout.elements[i], cmd.dx, cmd.dy)) };
+    }
+    case "replaceElement": {
+      const i = requireElement(layout, cmd.element.id);
+      return { ...layout, elements: replaceAt(layout.elements, i, cmd.element) };
+    }
+    case "setBackground":
+      return { ...layout, meta: { ...layout.meta, background: cmd.background } };
+    case "batch":
+      return cmd.commands.reduce(reduce, layout);
+    default:
+      throw new CommandError(`Comando desconocido: ${cmd.type}`);
+  }
+}
+function applyCommand(layout, cmd) {
+  const next = reduce(layout, cmd);
+  const parsed = layoutSchema.safeParse(next, spanishParseOptions);
+  if (!parsed.success) {
+    const first = parsed.error.issues[0];
+    throw new CommandError(first ? `${first.path.join(".")}: ${first.message}` : "Documento inv\xE1lido");
+  }
+  return parsed.data;
+}
+var HISTORY_LIMIT = 100;
+var History = class {
+  past = [];
+  future = [];
+  /** La clave de agrupación del último `apply`. Ver `apply`. */
+  lastKey = null;
+  present;
+  constructor(initial) {
+    this.present = initial;
+  }
+  get canUndo() {
+    return this.past.length > 0;
+  }
+  get canRedo() {
+    return this.future.length > 0;
+  }
+  /**
+   * Aplica un comando y lo anota en la historia.
+   *
+   * `key` agrupa: escribir un nombre en un campo son quince comandos seguidos,
+   * no quince pasos. Con la misma clave que el anterior, el comando pisa al
+   * presente sin apilar otro paso — Deshacer vuelve al nombre de antes, no
+   * borra una letra. Sin clave, cada comando es su propio paso, que es lo que
+   * corresponde a dibujar, borrar o mover.
+   */
+  apply(cmd, key) {
+    const next = applyCommand(this.present, cmd);
+    if (key !== void 0 && key === this.lastKey) {
+      this.future = [];
+      this.present = next;
+      return next;
+    }
+    this.past.push(this.present);
+    if (this.past.length > HISTORY_LIMIT) this.past.shift();
+    this.future = [];
+    this.present = next;
+    this.lastKey = key ?? null;
+    return next;
+  }
+  /**
+   * Reemplaza el documento entero, y se puede deshacer.
+   *
+   * Es cargar un plano: elegir de qué forma partir, o abrir uno guardado. No es
+   * un comando porque no describe una edición — no hay un "cambio" que aplicar
+   * sobre lo anterior, hay un documento nuevo.
+   *
+   * Va a la historia igual, y ahí está la gracia: alguien que dibujó media hora
+   * y elige otra forma por error tiene que poder volver con Deshacer.
+   */
+  load(next) {
+    this.lastKey = null;
+    this.past.push(this.present);
+    if (this.past.length > HISTORY_LIMIT) this.past.shift();
+    this.future = [];
+    this.present = next;
+    return next;
+  }
+  /** El documento al que llevaría `undo`, sin moverse. Para chequearlo antes (el candado). */
+  peekUndo() {
+    return this.past[this.past.length - 1] ?? null;
+  }
+  peekRedo() {
+    return this.future[this.future.length - 1] ?? null;
+  }
+  undo() {
+    this.lastKey = null;
+    const prev = this.past.pop();
+    if (prev) {
+      this.future.push(this.present);
+      this.present = prev;
+    }
+    return this.present;
+  }
+  redo() {
+    this.lastKey = null;
+    const next = this.future.pop();
+    if (next) {
+      this.past.push(this.present);
+      this.present = next;
+    }
+    return this.present;
+  }
+  /**
+   * Pasa todos los documentos (pasado, presente y futuro) por `fn`, sin agregar
+   * un paso. Es para lo que cambia por fuera del plano, como una entrada que el
+   * host borró: deshacer no puede devolver una pieza a un tipo que ya no existe.
+   */
+  rewrite(fn) {
+    this.past = this.past.map(fn);
+    this.future = this.future.map(fn);
+    this.present = fn(this.present);
+    return this.present;
+  }
+};
+
+// ../core/src/lock.ts
+function samePlace(before, after) {
+  return after.label === before.label && after.placeTypeRef === before.placeTypeRef && after.elementId === before.elementId && after.kind === before.kind && after.rowIndex === before.rowIndex && after.colIndex === before.colIndex && after.place === before.place;
+}
+function findLockViolations(before, after, locked) {
+  if (locked.size === 0) return [];
+  const afterUnits = new Map(expand(after).map((u) => [u.id, u]));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const u of expand(before)) {
+    if (!locked.has(u.id)) continue;
+    const now = afterUnits.get(u.id);
+    if (now && samePlace(u, now)) continue;
+    const v = u.table !== void 0 ? { reason: "table", table: u.table } : { reason: "row", row: u.row ?? u.label, elementId: u.elementId };
+    const key = v.reason === "table" ? `t\0${v.table}` : `r\0${v.elementId}\0${v.row}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(v);
+  }
+  return out;
+}
+
+// ../core/src/pieces.ts
+var DEFAULT_BLOCK = { rows: 5, cols: 10 };
+var DEFAULT_TABLE_PLACES = 6;
+var DEFAULT_ZONE = { width: 240, height: 140 };
+var DEFAULT_ROW_LABELS = { kind: "letters", start: "A", direction: "ltr" };
+var DEFAULT_SEAT_LABELS = { kind: "numbers", start: "1", direction: "ltr" };
+var BLOCK_COLS = [10, 9, 8, 12, 7, 6];
+var BLOCK_COLS_MAX = 50;
+var DEFAULT_SPACING = { x: 26, y: 26 };
+var GAP = 20;
+var PLACE_PITCH = 22;
+function newElementId(layout, prefix) {
+  const used = new Set(layout.elements.map((e) => e.id));
+  for (let n = 1; ; n++) {
+    const id = `${prefix}-${n}`;
+    if (!used.has(id)) return id;
+  }
+}
+function tableSize(shape, places) {
+  if (shape === "round") {
+    const needed = PLACE_PITCH / (2 * Math.sin(Math.PI / Math.max(2, places))) - PLACE_OFFSET;
+    return { radius: Math.max(TABLE_RADIUS, Math.round(needed)) };
+  }
+  const perSide = Math.ceil(places / 2);
+  return { width: Math.max(80, perSide * PLACE_PITCH + 20), height: TABLE_HEIGHT };
+}
+function nextTableLabel(layout) {
+  const used = new Set(layout.elements.flatMap((e) => e.type === "table" ? [e.label] : []));
+  for (let n = 1; ; n++) if (!used.has(String(n))) return String(n);
+}
+function blockCols(n) {
+  if (n <= 60) return BLOCK_COLS.find((c) => n % c === 0) ?? 10;
+  const target = Math.min(BLOCK_COLS_MAX, Math.max(10, Math.round(Math.sqrt(n * 2.5))));
+  for (let d = 0; d <= 5; d++) {
+    for (const c of d === 0 ? [target] : [target - d, target + d]) {
+      if (c >= 10 && c <= BLOCK_COLS_MAX && n % c === 0) return c;
+    }
+  }
+  return target;
+}
+function blockShape(seats, blockId) {
+  const n = Math.max(1, Math.floor(seats));
+  if (n <= 10) return { rows: 1, cols: n, removed: [] };
+  const cols = blockCols(n);
+  if (n % cols === 0) return { rows: n / cols, cols, removed: [] };
+  const rows = Math.ceil(n / cols);
+  const lastRow = expandLabels(DEFAULT_ROW_LABELS, rows)[rows - 1];
+  const seatLabels = expandLabels(DEFAULT_SEAT_LABELS, cols);
+  const removed = seatLabels.slice(n - (rows - 1) * cols).map((seat) => seatUnitId(blockId, lastRow, seat));
+  return { rows, cols, removed };
+}
+function createPiece(kind, id, at, layout, opts = {}) {
+  if (kind === "seatBlock") {
+    const { rows, cols, removed } = opts.seats === void 0 ? { ...DEFAULT_BLOCK, removed: [] } : blockShape(opts.seats, id);
+    return {
+      id,
+      type: "seatBlock",
+      transform: { x: at.x - (cols - 1) * DEFAULT_SPACING.x / 2, y: at.y - (rows - 1) * DEFAULT_SPACING.y / 2, rotation: 0 },
+      rows,
+      cols,
+      rowLabels: { ...DEFAULT_ROW_LABELS },
+      seatLabels: { ...DEFAULT_SEAT_LABELS },
+      spacing: { ...DEFAULT_SPACING },
+      curve: 0,
+      scale: 1,
+      removed,
+      placeType: null
+    };
+  }
+  if (kind === "zone") {
+    return { id, type: "zone", transform: { x: at.x, y: at.y, rotation: 0 }, ...DEFAULT_ZONE, curve: 0, placeType: null };
+  }
+  if (kind === "roundTable" || kind === "rectTable") {
+    return {
+      id,
+      type: "table",
+      transform: { x: at.x, y: at.y, rotation: 0 },
+      shape: kind === "roundTable" ? "round" : "rect",
+      places: DEFAULT_TABLE_PLACES,
+      label: nextTableLabel(layout),
+      mode: "whole",
+      scale: 1,
+      placeType: null
+    };
+  }
+  const def = landmarkById(kind.slice("landmark:".length));
+  if (!def) throw new Error(`La referencia ${kind} no existe en el cat\xE1logo`);
+  return { id, type: "landmark", transform: { x: at.x, y: at.y, rotation: 0 }, kind: def.id, name: def.name, width: def.width, height: def.height };
+}
+function worldWidth(el) {
+  const swap = el.transform.rotation === 90 || el.transform.rotation === 270;
+  if (el.type === "seatBlock") {
+    const k = el.scale ?? 1;
+    const w = el.cols * el.spacing.x * k;
+    const h = el.rows * el.spacing.y * k;
+    return swap ? h : w;
+  }
+  if (el.type === "table") {
+    const k = el.scale ?? 1;
+    const s = tableSize(el.shape, el.places);
+    if ("radius" in s) return 2 * (s.radius + PLACE_OFFSET) * k;
+    return ((swap ? s.height : s.width) + 2 * PLACE_OFFSET) * k;
+  }
+  if (el.type === "zone") {
+    const size = zoneLocalSize(el);
+    return swap ? size.height : size.width;
+  }
+  return swap ? el.height : el.width;
+}
+function followingRows(rule, rows) {
+  const next = expandLabels({ ...rule, direction: "ltr" }, rows + 1)[rows];
+  const candidate = { ...rule, start: next };
+  return labelRuleSchema.safeParse(candidate).success ? candidate : null;
+}
+function duplicatePiece(el, id, layout) {
+  const transform = { ...el.transform, x: el.transform.x + worldWidth(el) + GAP };
+  if (el.type === "table") return { ...el, id, transform, label: nextTableLabel(layout) };
+  if (el.type === "seatBlock") {
+    const rowLabels = followingRows(el.rowLabels, el.rows) ?? el.rowLabels;
+    const before = expandLabels(el.rowLabels, el.rows);
+    const after = expandLabels(rowLabels, el.rows);
+    const removed = el.removed.map((r) => {
+      const [, row, seat] = parseUnitId(r);
+      const i = row === void 0 ? -1 : before.indexOf(row);
+      return i < 0 || seat === void 0 ? r : seatUnitId(id, after[i], seat);
+    });
+    return { ...el, id, transform, rowLabels, removed };
+  }
+  return { ...el, id, transform };
+}
+function rotatePiece(el) {
+  const rotation = (el.transform.rotation + 90) % 360;
+  return { ...el, transform: { ...el.transform, rotation } };
+}
+function toggleRemovedSeat(block, unitId) {
+  const removed = block.removed.includes(unitId) ? block.removed.filter((r) => r !== unitId) : [...block.removed, unitId];
+  return { ...block, removed };
+}
+function snapScale(scale, step = 0.05) {
+  const snapped = Math.round(scale / step) * step;
+  return Math.min(MAX_SCALE, Math.max(MIN_SCALE, Math.round(snapped * 100) / 100));
+}
+function scalePiece(el, scale) {
+  const next = snapScale(scale, 0.01);
+  if (el.type === "table") return { ...el, scale: next };
+  const block = el;
+  const base = expandSeatBlock({ ...block, removed: [], scale: 1, transform: { x: 0, y: 0, rotation: 0 } });
+  const b = bbox(base);
+  const centre = { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 };
+  const k = (block.scale ?? 1) - next;
+  const shift2 = applyTransform({ x: centre.x * k, y: centre.y * k }, { x: 0, y: 0, rotation: block.transform.rotation });
+  return { ...el, scale: next, transform: { ...el.transform, x: el.transform.x + shift2.x, y: el.transform.y + shift2.y } };
+}
+
+// ../core/src/place-types.ts
+function canAssign(el, option) {
+  if (el.type === "seatBlock") return option.accepts === "seats";
+  if (el.type === "table") return option.accepts === "tableWhole" || option.accepts === "tablePerPlace";
+  if (el.type === "zone") return option.accepts === "zone";
+  return false;
+}
+function steps(option) {
+  const positive = (option.capacitySteps ?? []).filter((n) => Number.isFinite(n) && n > 0);
+  return [...new Set(positive)].sort((a, b) => a - b);
+}
+function placeTypeCapacity(option) {
+  const s = steps(option);
+  return s.length > 0 ? s[s.length - 1] : null;
+}
+function nextBlockUnits(option, placed) {
+  const s = steps(option);
+  if (s.length === 0) return DEFAULT_BLOCK.rows * DEFAULT_BLOCK.cols;
+  const next = s.find((n) => n > placed);
+  return next === void 0 ? 0 : next - placed;
+}
+function capacityViolations(before, after, options) {
+  const capped = options.filter((o) => placeTypeCapacity(o) !== null);
+  if (capped.length === 0) return [];
+  const was = summarize(before).byRef;
+  const now = summarize(after).byRef;
+  const out = [];
+  for (const o of capped) {
+    const capacity = placeTypeCapacity(o);
+    const units = now[o.ref]?.units ?? 0;
+    if (units > (was[o.ref]?.units ?? 0) && units > capacity) out.push({ ref: o.ref, label: o.label, capacity, units });
+  }
+  return out;
+}
+function assignPlaceType(el, option) {
+  const placeType = option ? { ref: option.ref, name: option.label } : null;
+  if (el.type === "seatBlock" || el.type === "zone") return { ...el, placeType };
+  if (!option) return { ...el, placeType };
+  return { ...el, placeType, mode: option.accepts === "tablePerPlace" ? "perPlace" : "whole" };
+}
+function normalizeName(s) {
+  return s.normalize("NFD").replace(/\p{M}/gu, "").trim().replace(/\s+/g, " ").toLocaleLowerCase("es");
+}
+function rebindPlaceTypes(layout, options) {
+  const elements = layout.elements.map((el) => {
+    if (el.type === "landmark" || !el.placeType) return el;
+    const name = normalizeName(el.placeType.name);
+    const matches = options.filter((o) => canAssign(el, o) && normalizeName(o.label) === name);
+    if (matches.length === 1) return assignPlaceType(el, matches[0]);
+    return { ...el, placeType: { ref: "", name: el.placeType.name } };
+  });
+  return { ...layout, elements };
+}
+function summarize(layout) {
+  const byRef = {};
+  const slot = (ref) => byRef[ref] ??= { units: 0, seats: 0, tables: 0, places: 0, zones: 0, duplicates: { seats: [], tables: [] } };
+  const seen = /* @__PURE__ */ new Map();
+  const repeated = (ref, key, out, name) => {
+    let set = seen.get(ref);
+    if (!set) seen.set(ref, set = /* @__PURE__ */ new Set());
+    if (!set.has(key)) {
+      set.add(key);
+      return;
+    }
+    if (!out.includes(name)) out.push(name);
+  };
+  let seats = 0;
+  let places = 0;
+  for (const u of expand(layout)) {
+    const s = u.placeTypeRef ? slot(u.placeTypeRef) : null;
+    if (s) s.units++;
+    if (u.kind === "seat") {
+      seats++;
+      if (s) {
+        s.seats++;
+        const name = `${u.row}:${u.seat}`;
+        repeated(u.placeTypeRef, `s\0${name}`, s.duplicates.seats, name);
+      }
+    } else if (u.kind === "place") {
+      places++;
+      if (s) s.places++;
+    }
+  }
+  let tables = 0;
+  let zones = 0;
+  let unassignedPieces = 0;
+  for (const el of layout.elements) {
+    if (el.type === "landmark") continue;
+    const ref = el.placeType?.ref || null;
+    if (el.type === "table") {
+      tables++;
+      if (ref) {
+        const s = slot(ref);
+        s.tables++;
+        repeated(ref, `t\0${el.label}`, s.duplicates.tables, el.label);
+      }
+    }
+    if (el.type === "zone") {
+      zones++;
+      if (ref) slot(ref).zones++;
+    }
+    if (!ref) unassignedPieces++;
+  }
+  return { seats, tables, places, zones, types: Object.keys(byRef).length, unassignedPieces, byRef };
+}
+
+// ../core/src/selection.ts
+var DEFAULT_MAX_SELECTION = 10;
+function unitStates(units, taken, selection, held) {
+  const mine = new Set(selection);
+  const out = /* @__PURE__ */ new Map();
+  for (const u of units) {
+    if (held.has(u.id)) out.set(u.id, "held");
+    else if (mine.has(u.id)) out.set(u.id, "selected");
+    else if (taken.has(u.id)) out.set(u.id, "taken");
+    else out.set(u.id, "free");
+  }
+  return out;
+}
+function toggleUnit(selection, unitId, states, maxSelection) {
+  if (selection.includes(unitId)) {
+    return { selection: selection.filter((id) => id !== unitId) };
+  }
+  if (states.get(unitId) === "taken") return { selection: [...selection], rejected: "taken" };
+  if (selection.length >= maxSelection) return { selection: [...selection], rejected: "max" };
+  return { selection: [...selection, unitId] };
+}
+
+// ../core/src/migrate.ts
+import { z as z2 } from "zod";
+var CURRENT_VERSION = 2;
+var LayoutError = class extends Error {
+  issues;
+  constructor(message, issues = []) {
+    super(message);
+    this.name = "LayoutError";
+    this.issues = issues;
+  }
+};
+var versionProbe = z2.object({ meta: z2.object({ version: z2.number() }) });
+var migrations = {};
+function migrate(input) {
+  const probe = versionProbe.safeParse(input);
+  if (!probe.success) throw new LayoutError("El documento no tiene meta.version");
+  let version = probe.data.meta.version;
+  let doc = input;
+  if (version > CURRENT_VERSION) {
+    throw new LayoutError(`El documento es de una versi\xF3n m\xE1s nueva (${version}) que la librer\xEDa (${CURRENT_VERSION})`);
+  }
+  while (version < CURRENT_VERSION) {
+    const step = migrations[version];
+    if (!step) throw new LayoutError(`No hay migraci\xF3n desde la versi\xF3n ${version}`);
+    doc = step(doc);
+    version++;
+  }
+  const parsed = layoutSchema.safeParse(doc, spanishParseOptions);
+  if (!parsed.success) {
+    throw new LayoutError(
+      "El documento no es v\xE1lido",
+      parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+    );
+  }
+  return parsed.data;
+}
+
+// ../core/src/index.ts
+var VERSION = "0.10.0";
+
+export {
+  LATIN_ALPHABET,
+  SPANISH_ALPHABET,
+  letterLabel,
+  letterIndex,
+  labelSequence,
+  expandLabels,
+  ID_SEP,
+  seatUnitId,
+  placeUnitId,
+  parseUnitId,
+  landmarks,
+  landmarkById,
+  MAX_UNITS,
+  MAX_ID_LENGTH,
+  MAX_NAME_LENGTH,
+  MAX_REF_LENGTH,
+  MAX_TABLE_LABEL_LENGTH,
+  MAX_SRC_LENGTH,
+  MAX_ELEMENTS,
+  MAX_LETTERS_START,
+  MAX_SKIP,
+  MIN_SCALE,
+  MAX_SCALE,
+  idSchema,
+  rotationSchema,
+  transformSchema,
+  labelRuleSchema,
+  placeTypeLinkSchema,
+  seatBlockSchema,
+  tableSchema,
+  landmarkSchema,
+  zoneSchema,
+  elementSchema,
+  backgroundSchema,
+  metaSchema,
+  layoutSchema,
+  spanishParseOptions,
+  applyTransform,
+  bbox,
+  pointInPolygon,
+  distance,
+  placeTypeBounds,
+  zoneArc,
+  zoneLocalSize,
+  zoneBounds,
+  pointInZone,
+  zoneOutline,
+  zoneLabelSize,
+  zoneWithLocalSize,
+  expandSeatBlock,
+  TABLE_RADIUS,
+  TABLE_WIDTH,
+  TABLE_HEIGHT,
+  PLACE_OFFSET,
+  expandTable,
+  expand,
+  SpatialIndex,
+  CommandError,
+  applyCommand,
+  HISTORY_LIMIT,
+  History,
+  findLockViolations,
+  DEFAULT_BLOCK,
+  DEFAULT_TABLE_PLACES,
+  DEFAULT_ZONE,
+  newElementId,
+  tableSize,
+  blockShape,
+  createPiece,
+  duplicatePiece,
+  rotatePiece,
+  toggleRemovedSeat,
+  snapScale,
+  scalePiece,
+  canAssign,
+  placeTypeCapacity,
+  nextBlockUnits,
+  capacityViolations,
+  assignPlaceType,
+  rebindPlaceTypes,
+  summarize,
+  DEFAULT_MAX_SELECTION,
+  unitStates,
+  toggleUnit,
+  CURRENT_VERSION,
+  LayoutError,
+  migrate,
+  VERSION
+};