@festapp/venue-layout 0.0.0-stage → 0.3.6

package/dist/demo.js

@@ -0,0 +1,937 @@
+(() => {
+  // src/index.js
+  var defaultMessages = Object.freeze({
+    viewerLabel: "Venue layout",
+    places: "Places",
+    place: "Place",
+    standing: "Standing",
+    availableCount: "{count} available",
+    addOne: "Add one",
+    removeOne: "Remove one",
+    confirmQuantity: "Confirm quantity",
+    selectedQuantity: "Selected quantity {count}",
+    quantityRejected: "Quantity rejected",
+    placeUnavailable: "Place unavailable",
+    selectedPlaces: "Selected {count} places",
+    releasedPlaces: "Released {count} places",
+    selectionRejected: "Selection rejected",
+    backgroundUnavailable: "Background resource unavailable",
+    placesTogether: "{count} places together",
+    pending: "pending",
+    available: "available",
+    occupied: "occupied",
+    reserved: "reserved",
+    blocked: "blocked",
+    unavailable: "unavailable",
+    disabled: "disabled",
+    sold: "sold"
+  });
+  function message(options, key, values = {}) {
+    const template = options.messages?.[key] ?? defaultMessages[key] ?? key;
+    return String(template).replace(/\{(\w+)\}/g, (_, name) => String(values[name] ?? `{${name}}`));
+  }
+  var SVG = "http://www.w3.org/2000/svg";
+  var viewerSerial = 0;
+  var color = (value) => /^#[0-9a-f]{8}$/i.test(value || "") ? value : "#00000000";
+  var element = (tag, attributes = {}) => {
+    const node = document.createElementNS(SVG, tag);
+    for (const [key, value] of Object.entries(attributes)) if (value != null) node.setAttribute(key, String(value));
+    return node;
+  };
+  var pathData = (path) => path.map((command) => command.join(" ")).join(" ");
+  function visibleWorldBounds(svg, matrix) {
+    const rect = svg.getBoundingClientRect();
+    if (!matrix || rect.width <= 0 || rect.height <= 0) return null;
+    let inverse;
+    try {
+      inverse = matrix.inverse();
+    } catch {
+      return null;
+    }
+    const points = [[rect.left, rect.top], [rect.right, rect.top], [rect.left, rect.bottom], [rect.right, rect.bottom]].map(([x2, y2]) => new DOMPoint(x2, y2).matrixTransform(inverse));
+    if (points.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y))) return null;
+    const xs = points.map((p) => p.x), ys = points.map((p) => p.y);
+    const x = Math.min(...xs), y = Math.min(...ys);
+    return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+  }
+  function mount(container, options = {}) {
+    if (!container || !globalThis.VenueLayoutKernel) throw new Error("Container and VenueLayoutKernel are required");
+    const root = document.createElement("div");
+    root.className = "venue-layout-viewer";
+    root.style.position = "relative";
+    const previousTouchAction = container.style.touchAction;
+    container.style.touchAction = "none";
+    const svg = element("svg", { role: "img", "aria-label": options.accessibilityLabel || message(options, "viewerLabel"), width: "100%", height: "100%" });
+    svg.style.touchAction = "none";
+    svg.style.display = "block";
+    svg.style.minHeight = "240px";
+    const list = document.createElement("div");
+    list.setAttribute("role", "list");
+    list.setAttribute("aria-label", message(options, "places"));
+    const live = document.createElement("div");
+    live.setAttribute("role", "status");
+    live.setAttribute("aria-live", "polite");
+    for (const assistive of [list, live]) Object.assign(assistive.style, {
+      position: "absolute",
+      top: "0",
+      left: "0",
+      width: "1px",
+      height: "1px",
+      overflow: "hidden",
+      clipPath: "inset(50%)",
+      whiteSpace: "nowrap",
+      padding: "0",
+      margin: "-1px",
+      border: "0",
+      boxSizing: "border-box"
+    });
+    const detail = document.createElement("div");
+    root.append(svg, list, detail, live);
+    container.append(root);
+    const handle = { serial: ++viewerSerial, container, root, svg, list, detail, live, previousTouchAction, options: {}, pending: /* @__PURE__ */ new Set(), selected: /* @__PURE__ */ new Set(), quantities: /* @__PURE__ */ new Map(), disposed: false, generation: 0, update(next) {
+      return update(handle, next);
+    }, dispose() {
+      dispose(handle);
+    }, zoomBy(factor) {
+      if (handle.disposed) throw new Error("Viewer is disposed");
+      if (!Number.isFinite(factor) || factor <= 0) throw new Error("Zoom factor must be positive");
+      handle.hideTooltip?.();
+      const c = handle.camera, ratio = zoomFactor(handle, c, 1 / factor);
+      handle.camera = { ...c, x: c.x + c.width * (1 - ratio) / 2, y: c.y + c.height * (1 - ratio) / 2, width: c.width * ratio, height: c.height * ratio };
+      render(handle, []);
+    }, fitToScreen() {
+      if (handle.disposed) throw new Error("Viewer is disposed");
+      handle.hideTooltip?.();
+      handle.camera = null;
+      render(handle, []);
+    } };
+    handle.click = async (event) => {
+      if (!svg.contains(event.target)) {
+        if (event.target === root || event.target === container) handle.suppressClick = false;
+        return;
+      }
+      const inverse = svg.getScreenCTM()?.inverse();
+      if (!inverse) return;
+      const point = new DOMPoint(event.clientX, event.clientY).matrixTransform(inverse);
+      const id = globalThis.VenueLayoutKernel.hitTest(handle.json, point.x, point.y);
+      if (handle.suppressClick) {
+        handle.suppressClick = false;
+        return;
+      }
+      if (id) await requestSelection(handle, id);
+    };
+    container.addEventListener("click", handle.click);
+    installCamera(handle);
+    installTooltip(handle, options);
+    try {
+      update(handle, options);
+    } catch (error) {
+      dispose(handle);
+      throw error;
+    }
+    if (typeof ResizeObserver !== "undefined") {
+      handle.resizeObserver = new ResizeObserver(() => {
+        if (!handle.disposed) render(handle, []);
+      });
+      handle.resizeObserver.observe(svg);
+    }
+    return handle;
+  }
+  async function requestSelection(handle, id) {
+    const { options } = handle;
+    const node = options.document.nodes.find((n) => n.id === id);
+    if (!node) return;
+    if (node.kind === "capacityArea") {
+      if (handle.pending.has(id)) return;
+      const state = options.capacityPresentation?.[id] || {};
+      const selected2 = handle.quantities.get(id) ?? 0;
+      const maximum = Math.max(0, Number(state.available ?? state.capacity ?? 0));
+      const unavailable2 = maximum === 0 || ["occupied", "unavailable", "disabled", "blocked", "sold", "reserved"].includes(state.status) || state.selectable === false;
+      if (unavailable2 && selected2 === 0) {
+        handle.detail.replaceChildren();
+        handle.live.textContent = state.tooltip || message(options, "placeUnavailable");
+        return;
+      }
+      const generation2 = handle.generation, callback = options.onQuantityRequested;
+      handle.detail.replaceChildren();
+      const label = document.createElement("label");
+      label.textContent = `${node.label || message(options, "standing")} - ${message(options, "availableCount", { count: state.available ?? state.capacity ?? 0 })}`;
+      const quantity = document.createElement("input");
+      quantity.type = "number";
+      quantity.min = "0";
+      quantity.max = String(state.available ?? state.capacity ?? 0);
+      quantity.value = String(Math.min(maximum, handle.quantities.get(id) ?? 1));
+      const stepper = document.createElement("span");
+      Object.assign(stepper.style, { display: "inline-flex", alignItems: "center", gap: "8px" });
+      const minus = document.createElement("button"), plus = document.createElement("button");
+      minus.type = plus.type = "button";
+      minus.textContent = "\u2212";
+      plus.textContent = "+";
+      minus.setAttribute("aria-label", message(options, "removeOne"));
+      plus.setAttribute("aria-label", message(options, "addOne"));
+      for (const button of [minus, plus]) Object.assign(button.style, { minWidth: "48px", minHeight: "48px" });
+      const updateSteps = () => {
+        minus.disabled = Number(quantity.value) <= 0;
+        plus.disabled = Number(quantity.value) >= maximum || unavailable2;
+      };
+      minus.onclick = () => {
+        quantity.stepDown();
+        updateSteps();
+      };
+      plus.onclick = () => {
+        quantity.stepUp();
+        updateSteps();
+      };
+      quantity.oninput = updateSteps;
+      updateSteps();
+      const confirm = document.createElement("button");
+      confirm.textContent = message(options, "confirmQuantity");
+      confirm.onclick = async () => {
+        if (handle.disposed || generation2 !== handle.generation || handle.pending.has(id)) return;
+        const current = handle.options.capacityPresentation?.[id] || {};
+        const value = Number(quantity.value), available = Number(current.available ?? current.capacity ?? 0);
+        const unavailable3 = ["occupied", "unavailable", "disabled", "blocked", "sold", "reserved"].includes(current.status) || current.selectable === false;
+        if (!Number.isInteger(value) || value < 0 || value > available || value > 0 && unavailable3 || !callback) return;
+        confirm.disabled = true;
+        handle.pending.add(id);
+        render(handle, [id]);
+        try {
+          const result = await callback(id, value);
+          if (handle.disposed || generation2 !== handle.generation) return;
+          if (result?.accepted) handle.quantities.set(id, value);
+          handle.live.textContent = result?.accepted ? message(options, "selectedQuantity", { count: value }) : result?.message || message(options, "quantityRejected");
+        } catch (error) {
+          if (!handle.disposed && generation2 === handle.generation) handle.live.textContent = String(error.message || error);
+        } finally {
+          if (!handle.disposed && generation2 === handle.generation) {
+            handle.pending.delete(id);
+            confirm.disabled = false;
+            render(handle, [id]);
+          }
+        }
+      };
+      stepper.append(minus, quantity, plus);
+      label.append(stepper);
+      handle.detail.append(label, confirm);
+      quantity.focus();
+      return;
+    }
+    if (node.kind !== "seat" || !options.onSelectionRequested) return;
+    const unavailable = /* @__PURE__ */ new Set(["occupied", "unavailable", "disabled", "blocked", "sold", "reserved"]);
+    const unit = (options.document.selectionUnits || []).find((u) => u.nodeIds.includes(id));
+    const ids = unit?.nodeIds || [id];
+    if (ids.some((id2) => unavailable.has(options.seatPresentation?.[id2]?.status) || options.seatPresentation?.[id2]?.selectable === false)) {
+      handle.live.textContent = message(options, "placeUnavailable");
+      return;
+    }
+    if (ids.some((id2) => handle.pending.has(id2))) return;
+    const selecting = !ids.every((id2) => handle.selected.has(id2));
+    const previous = new Set(handle.selected);
+    ids.forEach((id2) => {
+      handle.pending.add(id2);
+      selecting ? handle.selected.add(id2) : handle.selected.delete(id2);
+    });
+    const generation = handle.generation;
+    render(handle, ids);
+    try {
+      const result = await options.onSelectionRequested(new Set(ids), selecting);
+      if (handle.disposed || generation !== handle.generation) return;
+      if (!result?.accepted) ids.forEach((id2) => previous.has(id2) ? handle.selected.add(id2) : handle.selected.delete(id2));
+      handle.live.textContent = result?.accepted ? message(options, selecting ? "selectedPlaces" : "releasedPlaces", { count: ids.length }) : result?.message || message(options, "selectionRejected");
+    } catch (error) {
+      if (!handle.disposed && generation === handle.generation) {
+        ids.forEach((id2) => previous.has(id2) ? handle.selected.add(id2) : handle.selected.delete(id2));
+        handle.live.textContent = String(error.message || error);
+      }
+    } finally {
+      if (!handle.disposed && generation === handle.generation) {
+        ids.forEach((id2) => handle.pending.delete(id2));
+        render(handle, ids);
+      }
+    }
+  }
+  function update(handle, options = {}) {
+    handle.hideTooltip?.();
+    if (handle.disposed) throw new Error("Viewer is disposed");
+    const resourcesChanged = options.resources && options.resources !== handle.options.resources;
+    if (options.document && options.document !== handle.options.document) {
+      const issues = JSON.parse(globalThis.VenueLayoutKernel.validate(JSON.stringify(options.document)));
+      if (issues.length) throw new Error(issues.map((i) => `${i.path}: ${i.reason}`).join("; "));
+    }
+    if (resourcesChanged && globalThis.VenueLayoutKernel.validateResources) {
+      const issues = JSON.parse(globalThis.VenueLayoutKernel.validateResources(JSON.stringify(options.resources)));
+      if (issues.length) throw new Error(issues.map((i) => `${i.path}: ${i.reason}`).join("; "));
+    }
+    const replacingDocument = options.document && options.document !== handle.options.document;
+    handle.options = { ...handle.options, ...options };
+    if (!handle.options.document) throw new Error("A document is required");
+    if (replacingDocument) {
+      handle.generation++;
+      handle.pending.clear();
+      handle.selected.clear();
+      handle.quantities.clear();
+      handle.detail.replaceChildren();
+      handle.scene = null;
+      handle.sceneItems = null;
+      handle.elements = null;
+      handle.listDocument = null;
+    }
+    if (options.seatPresentation) for (const [id, state] of Object.entries(options.seatPresentation)) {
+      if (!handle.pending.has(id) && typeof state.selected === "boolean") state.selected ? handle.selected.add(id) : handle.selected.delete(id);
+    }
+    if (options.capacityPresentation) for (const [id, state] of Object.entries(options.capacityPresentation)) {
+      if (!handle.pending.has(id) && Number.isInteger(state.quantity) && state.quantity >= 0 && (state.quantity > 0 || handle.quantities.has(id))) handle.quantities.set(id, state.quantity);
+    }
+    if (replacingDocument || !handle.json) handle.json = JSON.stringify(handle.options.document);
+    if (resourcesChanged || !handle.resourcesJson) {
+      handle.resourcesJson = JSON.stringify(handle.options.resources || {});
+      handle.sceneItems = null;
+      handle.elements = null;
+    }
+    render(handle);
+    return handle;
+  }
+  function render(handle, dirtyIds) {
+    const { options, svg } = handle;
+    const presentation2 = { ...options.seatPresentation, ...options.capacityPresentation };
+    for (const id of /* @__PURE__ */ new Set([...Object.keys(options.seatPresentation || {}), ...handle.selected])) presentation2[id] = { ...presentation2[id], selected: handle.selected.has(id) };
+    for (const id of handle.pending) presentation2[id] = { ...presentation2[id], pending: true };
+    let scene;
+    if (handle.sceneItems && globalThis.VenueLayoutKernel.compileSceneNodes) {
+      const changed = dirtyIds || [.../* @__PURE__ */ new Set([...Object.keys(presentation2), ...Object.keys(handle.previousPresentation || {})])].filter((id) => JSON.stringify(presentation2[id]) !== JSON.stringify(handle.previousPresentation?.[id]));
+      if (changed.length === 0) {
+        scene = handle.scene;
+      } else {
+        scene = JSON.parse(globalThis.VenueLayoutKernel.compileSceneNodes(handle.json, JSON.stringify(changed), handle.resourcesJson, JSON.stringify(presentation2)));
+        const changedSet = new Set(changed);
+        for (const [id, item] of handle.sceneItems) if (changedSet.has(item.nodeId || item.id)) handle.sceneItems.delete(id);
+        for (const item of scene.items) handle.sceneItems.set(item.id, item);
+        scene = { ...scene, items: [...handle.sceneItems.values()].sort((a, b) => a.paintOrder[0] - b.paintOrder[0] || a.paintOrder[1] - b.paintOrder[1]) };
+      }
+    } else {
+      scene = JSON.parse(globalThis.VenueLayoutKernel.compileScene(handle.json, handle.resourcesJson, JSON.stringify(presentation2)));
+      handle.sceneItems = new Map(scene.items.map((item) => [item.id, item]));
+    }
+    handle.previousPresentation = presentation2;
+    handle.scene = scene;
+    if (scene.issues.length) {
+      handle.live.textContent = scene.issues.map((i) => i.reason).join(", ");
+      options.onIssues?.(scene.issues);
+    }
+    const c = scene.canvas;
+    if (!handle.camera) handle.camera = { x: c.x || 0, y: c.y || 0, width: c.width, height: c.height };
+    handle.camera = boundCamera(handle, handle.camera);
+    svg.setAttribute("viewBox", `${handle.camera.x} ${handle.camera.y} ${handle.camera.width} ${handle.camera.height}`);
+    svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
+    updateCanvasFrame(handle, c);
+    const limits = cameraMetrics(handle, handle.camera);
+    options.onCameraChanged?.({ canZoomIn: handle.camera.width > limits.minWidth + 1e-3, canZoomOut: handle.camera.width < limits.maxWidth - 1e-3 });
+    if (!handle.elements) {
+      svg.replaceChildren(element("rect", { x: c.x || 0, y: c.y || 0, width: c.width, height: c.height, fill: color(c.fill) }));
+      handle.elements = /* @__PURE__ */ new Map();
+    }
+    const containers = [svg], previous = /* @__PURE__ */ new Map([[svg, svg.firstElementChild]]);
+    const placeNode = (node) => {
+      const parent = containers.at(-1), before = previous.get(parent) || null;
+      if (node.parentNode !== parent || node.previousSibling !== before) parent.insertBefore(node, before ? before.nextSibling : parent.firstChild);
+      previous.set(parent, node);
+    };
+    const wanted = /* @__PURE__ */ new Set(), screenMatrix = svg.getScreenCTM(), zoom = screenMatrix ? Math.hypot(screenMatrix.a, screenMatrix.b) : 1, viewport = visibleWorldBounds(svg, screenMatrix);
+    for (const item of scene.items) {
+      if (zoom < (item.minZoom || 0)) continue;
+      const b = item.cullingBounds || item.bounds, v = viewport;
+      if (b && v && (b.x + b.width < v.x || b.y + b.height < v.y || b.x > v.x + v.width || b.y > v.y + v.height)) continue;
+      if (item.kind === "vectorRestore") {
+        containers.pop();
+        continue;
+      }
+      wanted.add(item.id);
+      const old = handle.elements.get(item.id);
+      if (item.kind === "vectorClip" || item.kind === "vectorLayer") {
+        let group2 = old?.item === item ? old.node : null;
+        if (!group2) {
+          group2 = element("g", { "data-node-id": item.nodeId });
+          if (item.kind === "vectorLayer") group2.setAttribute("opacity", item.opacity);
+          else {
+            const id = `venue-${handle.serial}-${item.id.replace(/[^a-zA-Z0-9_-]/g, "-")}-clip`, defs = element("defs"), clip = element("clipPath", { id, clipPathUnits: "userSpaceOnUse" });
+            clip.append(element("path", { d: pathData(item.path), "clip-rule": item.fillRule, transform: `matrix(${item.matrix.join(" ")})` }));
+            defs.append(clip);
+            group2.append(defs);
+            group2.setAttribute("clip-path", `url(#${id})`);
+          }
+          if (old) old.node.replaceWith(group2);
+          handle.elements.set(item.id, { item, node: group2 });
+        }
+        placeNode(group2);
+        containers.push(group2);
+        previous.set(group2, item.kind === "vectorClip" ? group2.firstElementChild : null);
+        continue;
+      }
+      if (old?.item === item) {
+        placeNode(old.node);
+        continue;
+      }
+      const group = element("g", { transform: `matrix(${item.matrix.join(" ")})`, opacity: item.kind === "image" ? item.opacity ?? 1 : null, "data-node-id": item.nodeId || item.id });
+      if (item.kind === "image") {
+        const asset = options.resources?.assets?.[item.assetRef];
+        const href = asset?.url;
+        if (href && /^(data:image\/(png|jpeg|webp);base64,|blob:|https?:|file:|\.\.?\/)/i.test(href)) {
+          const source = item.sourceRect, destination = item.destinationRect;
+          const nested = element("svg", { x: destination.x, y: destination.y, width: destination.width, height: destination.height, viewBox: `${source.x} ${source.y} ${source.width} ${source.height}`, preserveAspectRatio: "none", overflow: "hidden" });
+          nested.append(element("image", { href, width: item.width, height: item.height }));
+          const local = element("g", { transform: group.getAttribute("transform") });
+          local.append(nested);
+          group.removeAttribute("transform");
+          if (item.clip) {
+            const clipId = `venue-${handle.serial}-background-clip`, defs = element("defs"), clip = element("clipPath", { id: clipId, clipPathUnits: "userSpaceOnUse" });
+            clip.append(element("rect", item.clip));
+            defs.append(clip);
+            group.append(defs);
+            group.setAttribute("clip-path", `url(#${clipId})`);
+          }
+          group.append(local);
+        } else {
+          handle.live.textContent = message(options, "backgroundUnavailable");
+          options.onIssues?.([{ reason: "asset_unavailable", path: "background", assetRef: item.assetRef }]);
+        }
+      } else {
+        const paint = (kind) => {
+          const gradient = item[kind + "Gradient"];
+          if (!gradient) return color(item[kind]);
+          const id = `venue-${handle.serial}-${item.id.replace(/[^a-zA-Z0-9_-]/g, "-")}-${kind}`, defs = element("defs");
+          const g = gradient.type === "linear" ? element("linearGradient", { id, gradientUnits: "userSpaceOnUse", x1: gradient.from[0], y1: gradient.from[1], x2: gradient.to[0], y2: gradient.to[1], spreadMethod: gradient.spread }) : element("radialGradient", { id, gradientUnits: "userSpaceOnUse", cx: gradient.center[0], cy: gradient.center[1], r: gradient.radius, fx: gradient.focal?.[0] ?? gradient.center[0], fy: gradient.focal?.[1] ?? gradient.center[1], gradientTransform: `matrix(${gradient.matrix.join(" ")})`, spreadMethod: gradient.spread });
+          gradient.colors.forEach((c2, i) => g.append(element("stop", { offset: gradient.stops[i], "stop-color": color(c2) })));
+          defs.append(g);
+          group.append(defs);
+          return `url(#${id})`;
+        };
+        if (item.localClip) {
+          const id = `venue-${handle.serial}-${item.id.replace(/[^a-zA-Z0-9_-]/g, "-")}-text-clip`, defs = element("defs"), clip = element("clipPath", { id, clipPathUnits: "userSpaceOnUse" });
+          clip.append(element("rect", item.localClip));
+          defs.append(clip);
+          group.append(defs);
+          group.setAttribute("clip-path", `url(#${id})`);
+        }
+        group.append(element("path", { d: pathData(item.path || []), fill: paint("fill"), stroke: paint("stroke"), "fill-rule": item.fillRule || "nonzero", "stroke-miterlimit": item.miterLimit || 4, "fill-opacity": item.opacity ?? 1, "stroke-opacity": item.opacity ?? 1, "stroke-width": item.strokeWidth || 0, "vector-effect": item.kind === "floor" ? "non-scaling-stroke" : null, "stroke-dasharray": item.dash?.join?.(" "), "stroke-linecap": item.kind === "state" ? "round" : item.strokeCap || "butt", "stroke-linejoin": item.kind === "state" ? "round" : item.strokeJoin || "miter" }));
+      }
+      const tooltip = options.seatPresentation?.[item.nodeId || item.id]?.tooltip ?? options.capacityPresentation?.[item.nodeId || item.id]?.tooltip ?? item.label;
+      if (tooltip) {
+        const title = element("title");
+        title.textContent = tooltip;
+        group.append(title);
+      }
+      if (old) old.node.replaceWith(group);
+      placeNode(group);
+      handle.elements.set(item.id, { item, node: group });
+    }
+    for (const [id, entry] of handle.elements) if (!wanted.has(id)) {
+      entry.node.remove();
+      handle.elements.delete(id);
+    }
+    if (dirtyIds?.length !== 0) renderList(handle);
+  }
+  function installTooltip(handle, options) {
+    const tooltip = document.createElement("aside");
+    tooltip.className = "venue-layout-tooltip";
+    tooltip.id = `venue-layout-tooltip-${handle.serial}`;
+    tooltip.setAttribute("role", "tooltip");
+    tooltip.hidden = true;
+    Object.assign(tooltip.style, {
+      position: "fixed",
+      zIndex: "2147483647",
+      pointerEvents: "none",
+      maxWidth: "min(280px, calc(100vw - 16px))",
+      boxSizing: "border-box",
+      padding: "8px 10px",
+      borderRadius: "6px",
+      background: "#202124",
+      color: "#fff",
+      font: "13px/1.4 system-ui, sans-serif",
+      whiteSpace: "pre-line",
+      overflowWrap: "anywhere",
+      boxShadow: "0 2px 8px #0004",
+      margin: "0"
+    });
+    Object.assign(tooltip.style, options.tooltipStyle || {});
+    handle.root.append(tooltip);
+    handle.tooltip = tooltip;
+    handle.hideTooltip = () => {
+      tooltip.hidden = true;
+      tooltip.textContent = "";
+    };
+    handle.hover = (event) => {
+      if (handle.disposed || event.buttons || event.pointerType === "touch") {
+        handle.hideTooltip();
+        return;
+      }
+      const inverse = handle.svg.getScreenCTM()?.inverse();
+      if (!inverse) {
+        handle.hideTooltip();
+        return;
+      }
+      const point = new DOMPoint(event.clientX, event.clientY).matrixTransform(inverse);
+      const id = globalThis.VenueLayoutKernel.hitTest(handle.json, point.x, point.y);
+      const node = handle.options.document.nodes.find((node2) => node2.id === id);
+      const content = handle.options.seatPresentation?.[id]?.tooltip ?? handle.options.capacityPresentation?.[id]?.tooltip ?? node?.label;
+      if (!content) {
+        handle.hideTooltip();
+        return;
+      }
+      tooltip.textContent = String(content);
+      tooltip.hidden = false;
+      const bounds = tooltip.getBoundingClientRect();
+      const width = globalThis.innerWidth || document.documentElement.clientWidth;
+      const height = globalThis.innerHeight || document.documentElement.clientHeight;
+      const offset = handle.options.tooltipOffset ?? 15;
+      tooltip.style.left = `${Math.max(8, event.clientX + offset + bounds.width > width ? event.clientX - bounds.width - offset : event.clientX + offset)}px`;
+      tooltip.style.top = `${Math.max(8, event.clientY + offset + bounds.height > height ? event.clientY - bounds.height - offset : event.clientY + offset)}px`;
+    };
+    handle.tooltipKey = (event) => {
+      if (event.key === "Escape") handle.hideTooltip();
+    };
+    handle.svg.addEventListener("pointermove", handle.hover);
+    for (const name of ["pointerleave", "pointerdown", "pointercancel", "wheel"]) {
+      handle.svg.addEventListener(name, handle.hideTooltip);
+    }
+    handle.tooltipWindow = document.defaultView || globalThis;
+    handle.tooltipWindow.addEventListener?.("keydown", handle.tooltipKey);
+    handle.tooltipWindow.addEventListener?.("scroll", handle.hideTooltip, true);
+    handle.tooltipWindow.addEventListener?.("resize", handle.hideTooltip);
+  }
+  function updateCanvasFrame(handle, canvas) {
+    const requested = Number(handle.options.canvasCornerRadius) || 0;
+    const svg = handle.svg, matrix = svg.getScreenCTM();
+    if (requested <= 0 || !matrix) {
+      svg.style.clipPath = "";
+      return;
+    }
+    const rect = svg.getBoundingClientRect();
+    const a = new DOMPoint(canvas.x || 0, canvas.y || 0).matrixTransform(matrix);
+    const b = new DOMPoint((canvas.x || 0) + canvas.width, (canvas.y || 0) + canvas.height).matrixTransform(matrix);
+    const radius = Math.min(requested, Math.abs(b.x - a.x) / 2, Math.abs(b.y - a.y) / 2);
+    svg.style.clipPath = `inset(${a.y - rect.top}px ${rect.right - b.x}px ${rect.bottom - b.y}px ${a.x - rect.left}px round ${radius}px)`;
+  }
+  function cameraMetrics(handle, camera) {
+    const canvas = handle.options.document.canvas, rect = handle.svg.getBoundingClientRect();
+    const width = rect.width || canvas.width, height = rect.height || canvas.height;
+    const fit = Math.min(width / canvas.width, height / canvas.height);
+    const aspect = camera.width / camera.height, fitWidth = Math.min(width, height * aspect) / fit;
+    return { canvas, width, height, minWidth: fitWidth / (handle.options.maxZoom || 20), maxWidth: fitWidth / (handle.options.minZoom || 0.9) };
+  }
+  function zoomFactor(handle, camera, factor) {
+    const limits = cameraMetrics(handle, camera);
+    return Math.min(limits.maxWidth, Math.max(limits.minWidth, camera.width * factor)) / camera.width;
+  }
+  function boundCamera(handle, camera) {
+    const factor = zoomFactor(handle, camera, 1);
+    camera = {
+      ...camera,
+      x: camera.x + camera.width * (1 - factor) / 2,
+      y: camera.y + camera.height * (1 - factor) / 2,
+      width: camera.width * factor,
+      height: camera.height * factor
+    };
+    const { canvas, width, height } = cameraMetrics(handle, camera);
+    const scale = Math.min(width / camera.width, height / camera.height);
+    const viewportWidth = width / scale, viewportHeight = height / scale;
+    const shiftX = (viewportWidth - camera.width) / 2, shiftY = (viewportHeight - camera.height) / 2;
+    const clampAxis = (position, start, extent, viewport) => {
+      const visible = viewport / 2;
+      return Math.min(start + extent - visible, Math.max(start + visible - viewport, position));
+    };
+    return {
+      ...camera,
+      x: clampAxis(camera.x - shiftX, canvas.x || 0, canvas.width, viewportWidth) + shiftX,
+      y: clampAxis(camera.y - shiftY, canvas.y || 0, canvas.height, viewportHeight) + shiftY
+    };
+  }
+  function installCamera(handle) {
+    const svg = handle.svg, surface = handle.container;
+    const onSurface = (event) => event.target === surface || event.target === handle.root || svg.contains(event.target);
+    handle.wheel = (event) => {
+      if (!handle.camera || !onSurface(event)) return;
+      handle.hideTooltip?.();
+      event.preventDefault();
+      const matrix = svg.getScreenCTM(), p = new DOMPoint(event.clientX, event.clientY).matrixTransform(matrix.inverse()), c = handle.camera;
+      if (event.shiftKey) {
+        const delta = new DOMPoint(event.deltaX || event.deltaY, event.deltaX ? event.deltaY : 0).matrixTransform(matrix.inverse());
+        const origin = new DOMPoint(0, 0).matrixTransform(matrix.inverse());
+        handle.camera = boundCamera(handle, { ...c, x: c.x + delta.x - origin.x, y: c.y + delta.y - origin.y });
+        render(handle, []);
+        return;
+      }
+      const factor = zoomFactor(handle, c, Math.exp(event.deltaY / 200));
+      handle.camera = { x: p.x + (c.x - p.x) * factor, y: p.y + (c.y - p.y) * factor, width: c.width * factor, height: c.height * factor };
+      render(handle, []);
+    };
+    let start, pinch;
+    const pointers = /* @__PURE__ */ new Map();
+    handle.pointerdown = (event) => {
+      if (!onSurface(event) || event.button !== 0 && event.button !== 1) return;
+      handle.hideTooltip?.();
+      pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
+      if (pointers.size === 2) {
+        const [a, b] = [...pointers.values()];
+        pinch = { distance: Math.max(1, Math.hypot(a.x - b.x, a.y - b.y)), center: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 }, camera: { ...handle.camera }, inverse: svg.getScreenCTM()?.inverse() };
+      }
+      start = { x: event.clientX, y: event.clientY, camera: { ...handle.camera }, inverse: svg.getScreenCTM()?.inverse() };
+      svg.setPointerCapture(event.pointerId);
+    };
+    handle.pointermove = (event) => {
+      if (!pointers.has(event.pointerId)) return;
+      pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
+      if (pointers.size === 2 && pinch?.inverse) {
+        const [a2, b2] = [...pointers.values()], factor = zoomFactor(handle, pinch.camera, pinch.distance / Math.max(1, Math.hypot(a2.x - b2.x, a2.y - b2.y))), origin = new DOMPoint(pinch.center.x, pinch.center.y).matrixTransform(pinch.inverse), current = new DOMPoint((a2.x + b2.x) / 2, (a2.y + b2.y) / 2).matrixTransform(pinch.inverse), c = pinch.camera;
+        handle.camera = { x: origin.x + (c.x - origin.x) * factor + (origin.x - current.x), y: origin.y + (c.y - origin.y) * factor + (origin.y - current.y), width: c.width * factor, height: c.height * factor };
+        handle.suppressClick = true;
+        render(handle, []);
+        return;
+      }
+      if (!start?.inverse) return;
+      const dx = event.clientX - start.x, dy = event.clientY - start.y;
+      if (Math.hypot(dx, dy) < 4) return;
+      const a = new DOMPoint(start.x, start.y).matrixTransform(start.inverse), b = new DOMPoint(event.clientX, event.clientY).matrixTransform(start.inverse);
+      handle.camera = { ...start.camera, x: start.camera.x + a.x - b.x, y: start.camera.y + a.y - b.y };
+      handle.suppressClick = true;
+      render(handle, []);
+    };
+    handle.pointerup = (event) => {
+      if (!pointers.delete(event.pointerId)) return;
+      start = null;
+      pinch = null;
+    };
+    surface.addEventListener("wheel", handle.wheel, { passive: false });
+    surface.addEventListener("pointerdown", handle.pointerdown);
+    surface.addEventListener("pointermove", handle.pointermove);
+    surface.addEventListener("pointerup", handle.pointerup);
+    surface.addEventListener("pointercancel", handle.pointerup);
+  }
+  function renderList(handle) {
+    const allNodes = handle.listDocument === handle.options.document ? handle.listNodes : handle.options.document.nodes.filter((n) => n.kind === "seat" || n.kind === "capacityArea");
+    handle.listDocument = handle.options.document;
+    handle.listNodes = allNodes;
+    const focusIndex = Math.max(0, allNodes.findIndex((n) => n.id === (document.activeElement?.dataset?.nodeId || handle.focused)));
+    const offset = Math.max(0, focusIndex - 25);
+    const nodes = allNodes.slice(offset, offset + 100);
+    const previousFocus = document.activeElement?.dataset?.nodeId;
+    handle.list.replaceChildren();
+    const focused = previousFocus || handle.focused || nodes[0]?.id;
+    nodes.forEach((node, index) => {
+      const button = document.createElement("button");
+      button.dataset.nodeId = node.id;
+      button.setAttribute("aria-posinset", String(offset + index + 1));
+      button.setAttribute("aria-setsize", String(allNodes.length));
+      const state = handle.options.seatPresentation?.[node.id] || handle.options.capacityPresentation?.[node.id] || {};
+      const unit = (handle.options.document.selectionUnits || []).find((u) => u.nodeIds.includes(node.id));
+      button.textContent = `${state.accessibilityLabel || state.label || node.label || message(handle.options, "place")}${unit ? ` - ${message(handle.options, "placesTogether", { count: unit.nodeIds.length })}` : ""} - ${message(handle.options, handle.pending.has(node.id) ? "pending" : state.status || "available")}`;
+      button.tabIndex = node.id === focused ? 0 : -1;
+      button.setAttribute("aria-pressed", String(handle.selected.has(node.id)));
+      if (node.kind === "capacityArea") {
+        const unavailable = Number(state.available ?? state.capacity ?? 0) <= 0 || state.selectable === false || ["occupied", "unavailable", "disabled", "blocked", "sold", "reserved"].includes(state.status);
+        button.setAttribute("aria-disabled", String(unavailable));
+        if (state.tooltip) button.title = state.tooltip;
+      }
+      button.onclick = () => requestSelection(handle, node.id);
+      button.onfocus = () => {
+        handle.focused = node.id;
+      };
+      button.onkeydown = (event) => {
+        const delta = ["ArrowRight", "ArrowDown"].includes(event.key) ? 1 : ["ArrowLeft", "ArrowUp"].includes(event.key) ? -1 : 0;
+        if (delta) {
+          event.preventDefault();
+          const direction = { ArrowRight: "right", ArrowLeft: "left", ArrowUp: "up", ArrowDown: "down" }[event.key];
+          const nearest = globalThis.VenueLayoutKernel.nearestNode?.(handle.json, node.id, direction);
+          const target = allNodes.find((n) => n.id === nearest) || node;
+          handle.focused = target.id;
+          button.blur();
+          renderList(handle);
+          handle.list.querySelector(`[data-node-id="${CSS.escape(target.id)}"]`)?.focus();
+        }
+      };
+      handle.list.append(button);
+    });
+    handle.list.style.maxHeight = "120px";
+    handle.list.style.overflow = "auto";
+    if (previousFocus) handle.list.querySelector(`[data-node-id="${CSS.escape(previousFocus)}"]`)?.focus({ preventScroll: true });
+  }
+  function dispose(handle) {
+    if (handle.disposed) return;
+    handle.disposed = true;
+    handle.generation++;
+    handle.container.removeEventListener("click", handle.click);
+    if (handle.container.style.touchAction === "none") handle.container.style.touchAction = handle.previousTouchAction;
+    handle.svg.removeEventListener("pointermove", handle.hover);
+    for (const name of ["pointerleave", "pointerdown", "pointercancel", "wheel"]) handle.svg.removeEventListener(name, handle.hideTooltip);
+    handle.tooltipWindow?.removeEventListener?.("keydown", handle.tooltipKey);
+    handle.tooltipWindow?.removeEventListener?.("scroll", handle.hideTooltip, true);
+    handle.tooltipWindow?.removeEventListener?.("resize", handle.hideTooltip);
+    handle.hideTooltip?.();
+    for (const name of ["wheel", "pointerdown", "pointermove", "pointerup", "pointercancel"]) handle.container.removeEventListener(name, handle[name === "pointercancel" ? "pointerup" : name]);
+    handle.resizeObserver?.disconnect();
+    handle.root.remove();
+    handle.pending.clear();
+  }
+
+  // demo/demo.js
+  var view;
+  var documentData;
+  var resources = {};
+  var prices = {};
+  var selected = /* @__PURE__ */ new Set();
+  var quantities = {};
+  var occupied = false;
+  var loadRequest = 0;
+  var activeGeneration = 0;
+  var el = (id) => document.getElementById(id);
+  var previewToken = new URLSearchParams(location.search).get("editor");
+  var fromEditor = !!previewToken && /^[a-f0-9-]{36}$/.test(previewToken);
+  if (fromEditor) {
+    document.documentElement.lang = "cs";
+    document.querySelector("h1").textContent = "Vyberte si m\xEDsta";
+    document.title = "V\xFDb\u011Br m\xEDst - webov\xFD n\xE1hled";
+    el("sample-label").textContent = "N\xE1hled va\u0161eho rozpracovan\xE9ho s\xE1lu";
+    el("back-to-editor").hidden = false;
+    el("back-to-editor").href = `/flutter/?fromPreview=${encodeURIComponent(previewToken)}`;
+    el("import-tools").hidden = true;
+    el("legend").hidden = false;
+    el("reset").textContent = "Zru\u0161it v\xFDb\u011Br";
+    el("status").textContent = "P\u0159ipravuji webov\xFD n\xE1hled\u2026";
+    el("preview-note").textContent = "Uk\xE1zkov\xFD v\xFDb\u011Br - nevytv\xE1\u0159\xED rezervaci ani objedn\xE1vku";
+  }
+  var status = (message2) => el("status").textContent = message2;
+  var maxBytes = 16 * 1024 * 1024;
+  async function digest(data) {
+    return [...new Uint8Array(await crypto.subtle.digest("SHA-256", data))].map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  async function decode(text) {
+    if (new TextEncoder().encode(text).length > maxBytes) throw Error("Import exceeds 16 MiB");
+    const value = JSON.parse(text);
+    if (value.schemaVersion === 2) return { layout: value, resources: resources2 };
+    if (Object.keys(value).some((k) => !["format", "version", "protocol", "layout", "host", "resources"].includes(k))) throw Error("Unknown portable bundle field");
+    if (value.format !== "venue-layout-demo" || value.version !== 2 || value.protocol !== 1) throw Error("Unsupported file version");
+    const loaded = {};
+    for (const item of value.resources) {
+      if (Object.keys(item).some((k) => !["path", "size", "sha256", "data"].includes(k)) || item.path !== "resources/fixtures.json") throw Error("Unknown portable resource");
+      if (!/^resources\/[a-zA-Z0-9_-]+\.json$/.test(item.path) || loaded[item.path]) throw Error("Invalid or duplicate resource path");
+      const bytes = Uint8Array.from(atob(item.data), (c) => c.charCodeAt(0));
+      if (bytes.length > maxBytes || bytes.length !== item.size || await digest(bytes) !== item.sha256) throw Error("Resource integrity failed");
+      loaded[item.path] = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    if (!loaded["resources/fixtures.json"]) throw Error("Missing bundled resources");
+    const resources2 = loaded["resources/fixtures.json"];
+    if (Object.keys(resources2).some((k) => !["protocol", "fontFamilies", "fontFaces", "textLayouts", "numberSymbols", "assets"].includes(k))) throw Error("Unknown portable resource field");
+    if ("assets" in resources2 && (!resources2.assets || typeof resources2.assets !== "object" || Array.isArray(resources2.assets))) throw Error("Embedded assets must be a map");
+    for (const [id, asset] of Object.entries(resources2.assets ?? {})) {
+      if (!id || !asset || typeof asset !== "object" || Array.isArray(asset) || Object.keys(asset).some((k) => !["hash", "url", "byteLength", "mimeType", "width", "height"].includes(k))) throw Error("Invalid embedded asset fields");
+      const prefix = `data:${asset.mimeType};base64,`;
+      if (!["image/png", "image/jpeg", "image/webp"].includes(asset.mimeType) || typeof asset.url !== "string" || !asset.url.startsWith(prefix)) throw Error("Embedded image required");
+      const bytes = Uint8Array.from(atob(asset.url.slice(prefix.length)), (c) => c.charCodeAt(0));
+      if (bytes.length > 800 * 1024 || bytes.length !== asset.byteLength || await digest(bytes) !== asset.hash) throw Error("Embedded asset integrity failed");
+    }
+    return { layout: value.layout, resources: resources2, host: value.host || {} };
+  }
+  function price(n) {
+    return prices[n.id] ?? prices[n.parentId] ?? 250;
+  }
+  function capacityStates() {
+    return Object.fromEntries(documentData.nodes.filter((n) => n.kind === "capacityArea").map((n) => [n.id, { capacity: n.capacity ?? 20, available: n.capacity ?? 20, selectedQuantity: quantities[n.id] ?? 0 }]));
+  }
+  function presentation() {
+    return Object.fromEntries(documentData.nodes.filter((n) => n.kind === "seat").map((n) => [n.id, { status: selected.has(n.id) ? "selected" : occupied ? "occupied" : "available", selected: selected.has(n.id), label: n.label || "Seat", accessibilityLabel: `${n.label || "Seat"} - ${price(n)} CZK`, price: price(n) }]));
+  }
+  async function response() {
+    const scenario = el("scenario").value;
+    await new Promise((r) => setTimeout(r, scenario === "timeout" ? 800 : 100));
+    if (scenario !== "success") {
+      status(`Demo ${scenario}: selection preserved. Retry with success.`);
+      return { accepted: false, message: `Demo ${scenario}` };
+    }
+    return { accepted: true };
+  }
+  function units(ids) {
+    const result = new Set(ids);
+    for (const unit of documentData.selectionUnits ?? []) {
+      if (unit.nodeIds.some((id) => result.has(id))) for (const id of unit.nodeIds) result.add(id);
+    }
+    return result;
+  }
+  function update2() {
+    const standing = Object.values(quantities).reduce((a, b) => a + b, 0), total = documentData.nodes.filter((n) => selected.has(n.id)).reduce((sum, n) => sum + price(n), 0);
+    el("selected").textContent = fromEditor ? `Sezen\xED: ${selected.size} \xB7 St\xE1n\xED: ${standing} \xB7 Cena sezen\xED: ${total.toLocaleString("cs-CZ")} K\u010D` : `${selected.size} seats selected; ${standing} standing selected - sample seat total ${total} CZK`;
+    view?.update({ document: documentData, resources, seatPresentation: presentation(), capacityPresentation: capacityStates() });
+  }
+  function capacities() {
+    el("capacity").replaceChildren();
+    for (const area of documentData.nodes.filter((n) => n.kind === "capacityArea")) {
+      const label = document.createElement("label");
+      label.textContent = `${area.label || "Standing"} - total capacity ${area.capacity}: `;
+      const input = document.createElement("input");
+      input.type = "number";
+      input.min = "0";
+      input.max = String(area.capacity);
+      input.value = String(quantities[area.id] ?? 0);
+      input.setAttribute("aria-label", `${area.label || "Standing"} selected quantity`);
+      input.onchange = async () => {
+        const count = Number(input.value);
+        if (!Number.isInteger(count) || count < 0 || count > area.capacity) {
+          input.value = String(quantities[area.id] ?? 0);
+          return;
+        }
+        const result = await response();
+        if (result.accepted) quantities[area.id] = count;
+        else input.value = String(quantities[area.id] ?? 0);
+        update2();
+      };
+      label.append(input);
+      el("capacity").append(label);
+    }
+  }
+  function validatePrices(values, layout) {
+    if (values == null) return;
+    if (typeof values !== "object" || Array.isArray(values)) throw Error("Invalid demo prices");
+    const ids = new Set(layout.nodes.filter((n) => ["seat", "table", "group", "furniture", "capacityArea"].includes(n.kind)).map((n) => n.id));
+    for (const [id, value] of Object.entries(values)) if (!ids.has(id) || !Number.isSafeInteger(value) || value < 0 || value > 1e8) throw Error("Invalid or orphaned sample price binding");
+  }
+  async function load(text) {
+    const request = ++loadRequest, parsed = await decode(text);
+    const issues = JSON.parse(VenueLayoutKernel.validate(JSON.stringify(parsed.layout)));
+    if (issues.length) throw Error(issues[0].reason);
+    const resourceIssues = JSON.parse(VenueLayoutKernel.validateResources(JSON.stringify(parsed.resources)));
+    if (resourceIssues.length) throw Error("Invalid font resource: " + resourceIssues[0].reason);
+    const host = parsed.host || {}, allowed = /* @__PURE__ */ new Set(["prices", "template", "revision", "label", "savedBaseline", "savedPrices"]);
+    if (Object.keys(host).some((k) => !allowed.has(k))) throw Error("Unknown demo metadata");
+    validatePrices(host.prices, parsed.layout);
+    if (host.savedBaseline) {
+      const errors = JSON.parse(VenueLayoutKernel.validate(JSON.stringify(host.savedBaseline)));
+      if (errors.length) throw Error("Invalid saved baseline");
+      validatePrices(host.savedPrices, host.savedBaseline);
+    }
+    for (const asset of Object.values(parsed.resources.assets ?? {})) {
+      const bytes = Uint8Array.from(atob(asset.url.split(",")[1]), (c) => c.charCodeAt(0));
+      const image = await createImageBitmap(new Blob([bytes], { type: asset.mimeType }));
+      const valid = image.width === asset.width && image.height === asset.height;
+      image.close();
+      if (!valid) throw Error("Embedded image dimensions differ");
+    }
+    if (parsed.layout.background && !parsed.resources.assets?.[parsed.layout.background.assetRef]) throw Error("Missing embedded background");
+    const scene = JSON.parse(VenueLayoutKernel.compileScene(JSON.stringify(parsed.layout), JSON.stringify(parsed.resources), "{}"));
+    if (scene.issues.length) throw Error("Missing or invalid prepared resource: " + scene.issues[0].reason);
+    if (request !== loadRequest) return;
+    const nextPrices = host.prices || {}, nextPresentation = Object.fromEntries(parsed.layout.nodes.filter((n) => n.kind === "seat").map((n) => [n.id, { label: n.label || "Seat", status: "available" }]));
+    const staging = document.createElement("div");
+    let next;
+    try {
+      next = mount(staging, {
+        document: parsed.layout,
+        resources: parsed.resources,
+        seatPresentation: nextPresentation,
+        onQuantityRequested: async (id, count) => {
+          const result = await response();
+          if (activeGeneration !== request) return { accepted: false, message: "Document changed" };
+          if (result.accepted) {
+            quantities[id] = count;
+            update2();
+          }
+          return result;
+        },
+        onSelectionRequested: async (ids, selecting) => {
+          const result = await response();
+          if (activeGeneration !== request) return { accepted: false, message: "Document changed" };
+          if (result.accepted) {
+            for (const id of units(ids)) {
+              if (selecting) selected.add(id);
+              else selected.delete(id);
+            }
+            update2();
+          }
+          return result;
+        }
+      });
+    } catch (error) {
+      next?.dispose();
+      throw error;
+    }
+    if (fromEditor) {
+      const list = staging.querySelector('[role="list"]');
+      if (list) {
+        const details = document.createElement("details"), summary = document.createElement("summary");
+        summary.textContent = "P\u0159\xEDstupn\xFD seznam m\xEDst";
+        list.before(details);
+        details.append(summary, list);
+      }
+    }
+    view?.dispose();
+    el("picker").replaceChildren(...staging.childNodes);
+    view = next;
+    activeGeneration = request;
+    documentData = parsed.layout;
+    resources = parsed.resources;
+    prices = nextPrices;
+    selected = /* @__PURE__ */ new Set();
+    quantities = {};
+    capacities();
+    update2();
+    status(fromEditor ? "Vyberte m\xEDsto kliknut\xEDm. Pl\xE1nek m\u016F\u017Eete p\u0159ibli\u017Eovat a posouvat." : "Same exported geometry loaded. Select seats or standing quantities.");
+  }
+  el("import").onchange = async () => {
+    try {
+      const file = el("import").files[0];
+      if (file) await load(await file.text());
+    } catch (error) {
+      status(`Import rejected; current plan preserved: ${error.message}`);
+    }
+  };
+  el("reset").onclick = () => {
+    selected.clear();
+    quantities = {};
+    capacities();
+    update2();
+  };
+  el("patch").onclick = () => {
+    occupied = !occupied;
+    update2();
+    status("Presentation patch applied; geometry unchanged.");
+  };
+  window.venueDemo = { load, get document() {
+    return documentData;
+  }, get selected() {
+    return [...selected];
+  } };
+  (async () => {
+    if (fromEditor) {
+      try {
+        const text = await new Promise((resolve, reject) => {
+          const request = indexedDB.open("venue-layout-preview", 1);
+          request.onupgradeneeded = () => request.result.createObjectStore("drafts");
+          request.onerror = () => reject(Error("\xDAlo\u017Ei\u0161t\u011B n\xE1hledu nen\xED dostupn\xE9."));
+          request.onblocked = () => reject(Error("\xDAlo\u017Ei\u0161t\u011B n\xE1hledu je zablokovan\xE9."));
+          request.onsuccess = () => {
+            const database = request.result;
+            const transaction = database.transaction("drafts");
+            const read = transaction.objectStore("drafts").get(previewToken);
+            read.onsuccess = () => resolve(read.result);
+            read.onerror = () => reject(Error("Pl\xE1nek se nepoda\u0159ilo na\u010D\xEDst."));
+            transaction.oncomplete = () => database.close();
+            transaction.onabort = () => {
+              database.close();
+              reject(Error("Na\u010Dten\xED pl\xE1nku bylo p\u0159eru\u0161eno."));
+            };
+          };
+        });
+        if (typeof text !== "string") throw Error("Chyb\xED pl\xE1nek z editoru. Vra\u0165te se a otev\u0159ete n\xE1hled znovu.");
+        await load(text);
+      } catch (error) {
+        status(`N\xE1hled se nepoda\u0159ilo otev\u0159\xEDt: ${error.message}`);
+      }
+      return;
+    }
+    if (globalThis.venueDemoSeed) {
+      const { layout, resources: resources2 } = globalThis.venueDemoSeed;
+      const bytes = new TextEncoder().encode(JSON.stringify(resources2));
+      let binary = "";
+      for (let i = 0; i < bytes.length; i += 8192) binary += String.fromCharCode(...bytes.subarray(i, i + 8192));
+      const data = btoa(binary);
+      load(JSON.stringify({ format: "venue-layout-demo", version: 2, protocol: 1, layout, host: {}, resources: [{ path: "resources/fixtures.json", size: bytes.length, sha256: await digest(bytes), data }] })).catch((error) => status(`Seed failed: ${error.message}`));
+    }
+  })();
+})();