(function () {
  const $ = (sel, root = document) => root.querySelector(sel);
  const $$ = (sel, root = document) => Array.from(root.querySelectorAll(sel));
  const shuffle = (items) => items.map((value) => ({ value, sort: Math.random() })).sort((a, b) => a.sort - b.sort).map((item) => item.value);
  const quips = [
    "A margin note blinks, then pretends it did not.",
    "Somewhere, a bookmark changes its mind.",
    "The archive is pleased by unnecessary curiosity.",
    "A tiny bell rings in a room you have not built yet.",
    "The page remembers that you came here."
  ];

  document.addEventListener("DOMContentLoaded", () => {
    const root = $(".play-root[data-play-page]");
    if (!root) return;
    const page = root.dataset.playPage;
    const inits = { hub, memory, constellation, poem, bookshelf, recipe, timeline, ink, terminal, study, sigil, rpg };
    if (inits[page]) inits[page](root);
  });

  function hub(root) {
    const links = $$(".play-grid a", root);
    const nodes = $$(".play-orbit__node", root);
    const title = $("#play-hub-title", root);
    const kind = $("#play-hub-kind", root);
    const desc = $("#play-hub-desc", root);
    const cta = $("#play-hub-link", root);
    const whisper = document.createElement("p");
    let active = 0;

    whisper.className = "play-whisper";
    whisper.setAttribute("aria-live", "polite");
    $(".play-console__screen", root).appendChild(whisper);

    nodes.forEach((node, index) => {
      const angle = (index / nodes.length) * Math.PI * 2 - Math.PI / 2;
      node.style.left = `${50 + Math.cos(angle) * 43}%`;
      node.style.top = `${50 + Math.sin(angle) * 43}%`;
      node.addEventListener("click", () => setActive(index));
    });

    function setActive(index) {
      active = (index + links.length) % links.length;
      const link = links[active];
      links.forEach((item, i) => item.classList.toggle("is-active", i === active));
      nodes.forEach((item, i) => item.classList.toggle("is-active", i === active));
      title.textContent = link.querySelector("strong").textContent;
      kind.textContent = link.dataset.kind;
      desc.textContent = link.dataset.desc;
      cta.href = link.href;
      whisper.textContent = quips[active % quips.length];
    }

    links.forEach((link, index) => {
      link.addEventListener("mouseenter", () => setActive(index));
      link.addEventListener("focus", () => setActive(index));
    });
    $("[data-play-prev]", root).addEventListener("click", () => setActive(active - 1));
    $("[data-play-next]", root).addEventListener("click", () => setActive(active + 1));
    $("[data-play-random]", root).addEventListener("click", () => setActive(Math.floor(Math.random() * links.length)));
    $(".play-orbit", root).addEventListener("dblclick", () => {
      whisper.textContent = "You knocked twice. The cabinet knocked once back.";
      root.classList.toggle("is-odd");
    });
    root.addEventListener("keydown", (event) => {
      if (event.key === "ArrowLeft") setActive(active - 1);
      if (event.key === "ArrowRight") setActive(active + 1);
    });
    setActive(0);
  }

  function memory(root) {
    const symbols = ["Ink", "Lamp", "Tea", "Book", "Map", "Key"];
    const board = $("[data-memory-board]", root);
    const turnsEl = $("[data-memory-turns]", root);
    const matchesEl = $("[data-memory-matches]", root);
    const messageEl = $("[data-memory-message]", root);
    let open = [];
    let turns = 0;
    let matches = 0;
    let deck = [];

    function render() {
      board.innerHTML = "";
      open = [];
      turns = 0;
      matches = 0;
      deck = shuffle([...symbols, ...symbols]);
      turnsEl.textContent = "0";
      matchesEl.textContent = "0";
      messageEl.textContent = "Cards are shuffled.";
      deck.forEach((symbol, index) => {
        const card = document.createElement("button");
        card.type = "button";
        card.className = "memory-card";
        card.dataset.symbol = symbol;
        card.textContent = "?";
        card.style.setProperty("--tilt", `${(index % 5) - 2}deg`);
        card.setAttribute("aria-label", "Hidden card");
        card.addEventListener("click", () => flip(card));
        board.appendChild(card);
      });
    }

    function flip(card) {
      if (card.classList.contains("is-open") || card.classList.contains("is-matched") || open.length === 2) return;
      card.classList.add("is-open");
      card.textContent = card.dataset.symbol;
      card.setAttribute("aria-label", card.dataset.symbol);
      open.push(card);
      if (open.length !== 2) return;
      turns += 1;
      turnsEl.textContent = String(turns);
      const [a, b] = open;
      if (a.dataset.symbol === b.dataset.symbol) {
        a.classList.add("is-matched");
        b.classList.add("is-matched");
        open = [];
        matches += 1;
        matchesEl.textContent = String(matches);
        messageEl.textContent = matches === symbols.length ? `Cabinet solved in ${turns} turns.` : "A drawer clicks open.";
      } else {
        messageEl.textContent = "No match. The cabinet quietly re-files them.";
        setTimeout(() => {
          a.classList.remove("is-open");
          b.classList.remove("is-open");
          a.textContent = "?";
          b.textContent = "?";
          a.setAttribute("aria-label", "Hidden card");
          b.setAttribute("aria-label", "Hidden card");
          open = [];
        }, 650);
      }
    }

    $("[data-memory-reset]", root).addEventListener("click", render);
    $("[data-memory-peek]", root).addEventListener("click", () => {
      const hidden = $$(".memory-card:not(.is-open):not(.is-matched)", root);
      hidden.forEach((card) => {
        card.textContent = card.dataset.symbol;
        card.classList.add("is-peeking");
      });
      messageEl.textContent = "A very brief lapse in scholarly discipline.";
      setTimeout(() => {
        hidden.forEach((card) => {
          if (!card.classList.contains("is-open") && !card.classList.contains("is-matched")) card.textContent = "?";
          card.classList.remove("is-peeking");
        });
      }, 900);
    });
    render();
  }

  function constellation(root) {
    const canvas = $("[data-star-canvas]", root);
    const ctx = canvas.getContext("2d");
    const linesEl = $("[data-star-lines]", root);
    const nameEl = document.createElement("strong");
    const stars = Array.from({ length: 18 }, () => ({ x: 50 + Math.random() * 800, y: 45 + Math.random() * 430 }));
    const lines = [];
    let selected = null;
    nameEl.className = "play-live-note";
    linesEl.closest(".play-scorebar").appendChild(nameEl);

    function draw() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);
      ctx.fillStyle = "#18130f";
      ctx.fillRect(0, 0, canvas.width, canvas.height);
      ctx.strokeStyle = "rgba(219, 184, 104, 0.65)";
      ctx.lineWidth = 2;
      lines.forEach(([a, b]) => {
        ctx.beginPath();
        ctx.moveTo(stars[a].x, stars[a].y);
        ctx.lineTo(stars[b].x, stars[b].y);
        ctx.stroke();
      });
      stars.forEach((star, index) => {
        ctx.beginPath();
        ctx.fillStyle = index === selected ? "#f6d889" : "#fff8e8";
        ctx.arc(star.x, star.y, index === selected ? 7 : 4, 0, Math.PI * 2);
        ctx.fill();
      });
      linesEl.textContent = String(lines.length);
      if (lines.length >= 3) nameEl.textContent = `Named: ${pick(["The Patient Spoon", "The South Window", "The Tired Comet", "The Fifth Errand"])}`;
    }

    canvas.addEventListener("click", (event) => {
      const rect = canvas.getBoundingClientRect();
      const x = ((event.clientX - rect.left) / rect.width) * canvas.width;
      const y = ((event.clientY - rect.top) / rect.height) * canvas.height;
      const hit = stars.findIndex((star) => Math.hypot(star.x - x, star.y - y) < 22);
      if (hit < 0) return;
      if (selected === null) selected = hit;
      else if (selected !== hit) {
        lines.push([selected, hit]);
        selected = hit;
      }
      draw();
    });
    $("[data-star-reset]", root).addEventListener("click", () => {
      lines.length = 0;
      selected = null;
      nameEl.textContent = "";
      draw();
    });
    draw();
  }

  function poem(root) {
    const output = $("[data-poem-output]", root);
    const a = ["In the margin", "By the kettle", "Under the desk lamp", "Between two errands", "After the house quiets"];
    const b = ["a careful thought", "an old joke", "a stubborn question", "a useful mistake", "a bright scrap"];
    const c = ["learns to wait.", "asks for a second reading.", "finds its proper shelf.", "becomes tomorrow's note.", "keeps the page warm."];
    let count = 0;
    function make() {
      count += 1;
      output.innerHTML = `${pick(a)}<br>${pick(b)}<br>${pick(c)}`;
      output.dataset.stamp = count % 5 === 0 ? "approved by the margin" : "";
    }
    $("[data-poem-generate]", root).addEventListener("click", make);
    make();
  }

  function bookshelf(root) {
    const titles = ["Algebra at Breakfast", "Cabinet of Weather", "Domestic Orbits", "Evening Margins", "Household Engines", "Zettels and Tea"];
    const shelf = $("[data-bookshelf]", root);
    const status = $("[data-bookshelf-status]", root);
    let sortedOnce = false;
    setupSortable(shelf, render, check);
    $("[data-bookshelf-shuffle]", root).addEventListener("click", () => render(shuffle(titles)));
    render(shuffle(titles));

    function render(items) {
      shelf.innerHTML = "";
      items.forEach((title) => {
        const book = document.createElement("div");
        book.className = "book-spine";
        book.draggable = true;
        book.dataset.value = title;
        book.textContent = title;
        shelf.appendChild(book);
      });
      check();
    }
    function check() {
      const current = $$(".book-spine", shelf).map((book) => book.dataset.value);
      const sorted = current.join("|") === titles.join("|");
      status.textContent = sorted ? "Shelf sorted. A secret pamphlet slides out." : "Unsorted";
      if (sorted && !sortedOnce) {
        sortedOnce = true;
        const pamphlet = document.createElement("div");
        pamphlet.className = "booklet";
        pamphlet.textContent = "Pamphlet: On the Correct Order of Small Things";
        shelf.appendChild(pamphlet);
      }
    }
  }

  function recipe(root) {
    const wheel = $("[data-recipe-spin]", root);
    const result = $("[data-recipe-result]", root);
    const groups = [
      ["Rice", "Flatbread", "Roast potatoes", "Noodles"],
      ["Lemon chicken", "Spiced lentils", "Tomato eggs", "Pepper stew"],
      ["Cucumber salad", "Mint yoghurt", "Pickled onions", "Charred greens"],
      ["Serve with stories", "Eat outside", "Use the blue plates", "Make extra tea"]
    ];
    let spin = 0;
    let feast = 0;
    wheel.addEventListener("click", () => {
      spin += 540 + Math.floor(Math.random() * 540);
      feast += 1;
      wheel.style.transform = `rotate(${spin}deg)`;
      result.innerHTML = groups.map((group) => `<li>${pick(group)}</li>`).join("") + (feast % 4 === 0 ? "<li>Bonus: someone gets the last crispy bit.</li>" : "");
    });
    wheel.click();
  }

  function timeline(root) {
    const items = [
      { year: "2022", text: "The personal web habit begins." },
      { year: "2025", text: "Org publishing becomes the main site engine." },
      { year: "2025", text: "Weekly reviews and career notes grow into a library." },
      { year: "2026", text: "Dashboards, services, and authoring tools join the site." },
      { year: "2026", text: "The play wing opens." }
    ];
    const list = $("[data-timeline-list]", root);
    const status = $("[data-timeline-status]", root);
    const paradox = document.createElement("button");
    paradox.type = "button";
    paradox.textContent = "Paradox";
    $("[data-timeline-shuffle]", root).insertAdjacentElement("afterend", paradox);
    setupSortable(list, render, check);
    $("[data-timeline-shuffle]", root).addEventListener("click", () => render(shuffle(items)));
    paradox.addEventListener("click", () => render([...items].reverse()));
    render(shuffle(items));

    function render(source) {
      list.innerHTML = "";
      source.forEach((item, index) => {
        const card = document.createElement("div");
        card.className = "timeline-card";
        card.draggable = true;
        card.dataset.value = String(items.indexOf(item));
        card.innerHTML = `<span>${item.year}</span><strong>${item.text}</strong>`;
        list.appendChild(card);
      });
      check();
    }
    function check() {
      const current = $$(".timeline-card", list).map((card) => Number(card.dataset.value));
      status.textContent = current.every((value, index) => value === index) ? "Timeline restored" : "Arrange the cards";
    }
  }

  function ink(root) {
    const canvas = $("[data-ink-canvas]", root);
    const ctx = canvas.getContext("2d");
    const drops = [];
    let moon = false;
    function addDrop(x, y, heavy) {
      drops.push({ x, y, r: heavy ? 18 : 8, life: heavy ? 1.8 : 1, hue: 28 + Math.random() * 35 });
    }
    function pointer(event, heavy) {
      const rect = canvas.getBoundingClientRect();
      addDrop(((event.clientX - rect.left) / rect.width) * canvas.width, ((event.clientY - rect.top) / rect.height) * canvas.height, heavy);
    }
    canvas.addEventListener("pointermove", (event) => pointer(event, false));
    canvas.addEventListener("click", (event) => pointer(event, true));
    canvas.addEventListener("dblclick", () => {
      moon = !moon;
    });
    function frame() {
      ctx.fillStyle = "rgba(24, 19, 15, 0.16)";
      ctx.fillRect(0, 0, canvas.width, canvas.height);
      if (moon) {
        ctx.beginPath();
        ctx.fillStyle = "rgba(246, 216, 137, 0.72)";
        ctx.arc(760, 88, 34, 0, Math.PI * 2);
        ctx.fill();
      }
      drops.forEach((drop) => {
        drop.r += 0.7;
        drop.life -= 0.012;
        ctx.beginPath();
        ctx.strokeStyle = `hsla(${drop.hue}, 65%, 68%, ${Math.max(drop.life, 0)})`;
        ctx.lineWidth = 2;
        ctx.arc(drop.x, drop.y, drop.r, 0, Math.PI * 2);
        ctx.stroke();
      });
      for (let i = drops.length - 1; i >= 0; i -= 1) if (drops[i].life <= 0) drops.splice(i, 1);
      requestAnimationFrame(frame);
    }
    frame();
  }

  function terminal(root) {
    const log = $("[data-terminal-log]", root);
    const form = $("[data-terminal-form]", root);
    const input = $("[data-terminal-input]", root);
    let kindness = 0;
    const responses = {
      help: "Commands: help, look, map, open drawer, read note, brew tea, hum, knock, save, inventory, clear",
      look: "A narrow archive room. A lamp hums. A drawer is labelled MAYBE IMPORTANT.",
      map: "You are between the reading desk, the family shelf, and the door back to Play.",
      "open drawer": "Inside: a brass key, a receipt, and a note folded twice.",
      "read note": "The note says: keep the site useful, but leave a few doors ajar.",
      "brew tea": "The room smells briefly of cardamom. Nothing else changes, which is enough.",
      hum: "You hum four careful notes. Something behind the wall hums five back.",
      knock: "Knock. Knock. ... A polite pause. Knock.",
      save: "You save your place in the archive. The archive saves its place in you.",
      inventory: "You are carrying: a brass key, a warm cup, and one unreasonable hope."
    };
    function write(text) {
      log.textContent += `${text}\n`;
      log.scrollTop = log.scrollHeight;
    }
    form.addEventListener("submit", (event) => {
      event.preventDefault();
      const cmd = input.value.trim().toLowerCase();
      if (!cmd) return;
      input.value = "";
      if (cmd === "clear") {
        log.textContent = "";
        return;
      }
      write(`> ${cmd}`);
      if (cmd === "pet book") {
        kindness += 1;
        write(kindness > 2 ? "The book follows you for exactly three pages." : "The book accepts this with suspicious dignity.");
      } else {
        write(responses[cmd] || "The archive declines to understand that command.");
      }
    });
    write("Archive terminal ready. Type help. The cursor is listening.");
    input.focus();
  }

  function study(root) {
    const time = $("[data-study-time]", root);
    const scene = $("[data-study-scene]", root);
    let total = 300;
    let left = total;
    let timer = null;
    const note = document.createElement("div");
    note.className = "play-live-note";
    note.textContent = "The lamp is cold.";
    time.insertAdjacentElement("afterend", note);
    function draw() {
      const done = 1 - left / total;
      scene.style.setProperty("--lamp", String(0.18 + done * 0.72));
      scene.style.setProperty("--glow", `${done * 70}px`);
      const m = String(Math.floor(left / 60)).padStart(2, "0");
      const s = String(left % 60).padStart(2, "0");
      time.textContent = `${m}:${s}`;
      if (left === 0) note.textContent = "Focus complete. The desk looks proud.";
      else if (done > 0.66) note.textContent = "The page has warmed through.";
      else if (done > 0.33) note.textContent = "The lamp has settled into its work.";
    }
    function start() {
      if (timer) return;
      timer = setInterval(() => {
        left = Math.max(0, left - 1);
        draw();
        if (left === 0) pause();
      }, 1000);
    }
    function pause() {
      clearInterval(timer);
      timer = null;
    }
    $("[data-study-start]", root).addEventListener("click", start);
    $("[data-study-pause]", root).addEventListener("click", pause);
    $("[data-study-reset]", root).addEventListener("click", () => {
      pause();
      left = total;
      draw();
    });
    draw();
  }

  function sigil(root) {
    const canvas = $("[data-sigil-canvas]", root);
    const ctx = canvas.getContext("2d");
    const initials = $("[data-sigil-initials]", root);
    const motto = $("[data-sigil-motto]", root);
    let wax = "#9c6b2f";
    const waxButton = document.createElement("button");
    waxButton.type = "button";
    waxButton.textContent = "New wax";
    $("[data-sigil-form]", root).appendChild(waxButton);
    function draw() {
      const text = (initials.value || "ZXH").toUpperCase();
      const phrase = motto.value || "Learn, make, remember";
      ctx.clearRect(0, 0, canvas.width, canvas.height);
      ctx.fillStyle = "#fbf7ec";
      ctx.fillRect(0, 0, canvas.width, canvas.height);
      ctx.translate(260, 260);
      ctx.strokeStyle = wax;
      ctx.lineWidth = 10;
      ctx.beginPath();
      ctx.arc(0, 0, 190, 0, Math.PI * 2);
      ctx.stroke();
      ctx.lineWidth = 2;
      for (let i = 0; i < 12; i += 1) {
        ctx.rotate(Math.PI / 6);
        ctx.beginPath();
        ctx.moveTo(0, -150);
        ctx.lineTo(0, -185);
        ctx.stroke();
      }
      ctx.rotate(-Math.PI * 2);
      ctx.fillStyle = "#2a2118";
      ctx.textAlign = "center";
      ctx.textBaseline = "middle";
      ctx.font = "900 94px Georgia, serif";
      ctx.fillText(text.slice(0, 4), 0, -10);
      ctx.font = "700 22px Georgia, serif";
      ctx.fillText(phrase.slice(0, 34), 0, 88);
      ctx.setTransform(1, 0, 0, 1, 0, 0);
    }
    waxButton.addEventListener("click", () => {
      wax = pick(["#9c6b2f", "#8a3f3f", "#486b57", "#3e5f8a", "#5f4b8b"]);
      draw();
    });
    $("[data-sigil-form]", root).addEventListener("submit", (event) => {
      event.preventDefault();
      draw();
    });
    initials.addEventListener("input", draw);
    motto.addEventListener("input", draw);
    draw();
  }

  function rpg(root) {
    if (window.AshBelowLakeRpg) return window.AshBelowLakeRpg(root);
    const canvas = $("[data-rpg-canvas]", root);
    const ctx = canvas.getContext("2d");
    const els = {
      speaker: $("[data-rpg-speaker]", root),
      line: $("[data-rpg-line]", root),
      room: $("[data-rpg-room]", root),
      route: $("[data-rpg-route]", root),
      hearts: $("[data-rpg-hearts]", root),
      quests: $("[data-rpg-quests]", root),
      inventory: $("[data-rpg-inventory]", root),
      status: $("[data-rpg-status]", root)
    };
    const tile = 32;
    const saveSlot = "hollow-archive";
    const fallbackKey = "play:rpg:hollow-archive";
    const items = {
      lamp: { label: "Desk Lamp", room: "entrance", x: 10, y: 8, color: "#f2c94c" },
      page: { label: "Loose Page", room: "stacks", x: 18, y: 5, color: "#f7efe0" },
      key: { label: "Basement Key", room: "garden", x: 4, y: 11, color: "#d59b45" }
    };
    const npcs = {
      archivist: { name: "Archivist", room: "entrance", x: 6, y: 6, color: "#b98bff" },
      shade: { name: "Shy Shade", room: "stacks", x: 17, y: 9, color: "#6ed0d4" },
      gate: { name: "Iron Door", room: "garden", x: 19, y: 10, color: "#8a8f98" }
    };
    const rooms = {
      entrance: {
        name: "Entrance",
        floor: "#353029",
        exits: [{ x: 22, y: 7, to: "stacks", px: 1, py: 7 }],
        walls: rects([[0, 0, 24, 1], [0, 15, 24, 1], [0, 0, 1, 16], [23, 0, 1, 6], [23, 9, 1, 7], [8, 3, 1, 8], [14, 7, 5, 1]])
      },
      stacks: {
        name: "Stacks",
        floor: "#242d35",
        exits: [{ x: 0, y: 7, to: "entrance", px: 22, py: 7 }, { x: 23, y: 12, to: "garden", px: 1, py: 12 }],
        walls: rects([[0, 0, 24, 1], [0, 15, 24, 1], [0, 0, 1, 6], [0, 9, 1, 7], [23, 0, 1, 11], [23, 14, 1, 2], [4, 3, 2, 10], [10, 2, 2, 11], [16, 3, 2, 5]])
      },
      garden: {
        name: "Moon Garden",
        floor: "#21362e",
        exits: [{ x: 0, y: 12, to: "stacks", px: 22, py: 12 }],
        walls: rects([[0, 0, 24, 1], [0, 15, 24, 1], [0, 0, 1, 11], [0, 14, 1, 2], [23, 0, 1, 16], [7, 4, 10, 1], [7, 10, 1, 4], [13, 10, 1, 4]])
      }
    };
    let state = freshState();
    let running = false;

    function freshState() {
      return {
        room: "entrance",
        player: { x: 3, y: 7, facing: "down" },
        inventory: [],
        flags: {},
        route: "Undecided",
        hearts: 3,
        ending: null,
        message: { speaker: "Archivist", line: "The archive waits. Find the lamp, help the shade, then decide what to do with the locked door." }
      };
    }

    function rects(sources) {
      const set = new Set();
      sources.forEach(([x, y, w, h]) => {
        for (let yy = y; yy < y + h; yy += 1) for (let xx = x; xx < x + w; xx += 1) set.add(`${xx},${yy}`);
      });
      return set;
    }

    function draw() {
      const room = rooms[state.room];
      ctx.fillStyle = "#14110e";
      ctx.fillRect(0, 0, canvas.width, canvas.height);
      for (let y = 0; y < 16; y += 1) {
        for (let x = 0; x < 24; x += 1) {
          ctx.fillStyle = room.walls.has(`${x},${y}`) ? "#181716" : room.floor;
          ctx.fillRect(x * tile, y * tile, tile, tile);
          ctx.strokeStyle = "rgba(255,255,255,0.035)";
          ctx.strokeRect(x * tile, y * tile, tile, tile);
        }
      }
      room.exits.forEach((exit) => drawGlyph(exit.x, exit.y, "#c48a41", "door"));
      Object.entries(items).forEach(([id, item]) => {
        if (item.room === state.room && !state.inventory.includes(id)) drawGlyph(item.x, item.y, item.color, "item");
      });
      Object.values(npcs).forEach((npc) => {
        if (npc.room === state.room) drawGlyph(npc.x, npc.y, npc.color, npc.name === "Iron Door" ? "doorNpc" : "npc");
      });
      drawPlayer();
      renderHud();
      requestAnimationFrame(draw);
    }

    function drawGlyph(x, y, color, kind) {
      const px = x * tile;
      const py = y * tile;
      ctx.fillStyle = color;
      if (kind === "item") {
        ctx.fillRect(px + 10, py + 10, 12, 12);
        ctx.fillStyle = "rgba(255,255,255,0.45)";
        ctx.fillRect(px + 13, py + 7, 6, 6);
      } else if (kind === "door" || kind === "doorNpc") {
        ctx.fillRect(px + 7, py + 4, 18, 25);
        ctx.fillStyle = "#211812";
        ctx.fillRect(px + 20, py + 16, 3, 3);
      } else {
        ctx.beginPath();
        ctx.arc(px + 16, py + 12, 9, 0, Math.PI * 2);
        ctx.fill();
        ctx.fillRect(px + 8, py + 20, 16, 8);
      }
    }

    function drawPlayer() {
      const px = state.player.x * tile;
      const py = state.player.y * tile;
      ctx.fillStyle = "#f35f5f";
      ctx.beginPath();
      ctx.moveTo(px + 16, py + 7);
      ctx.bezierCurveTo(px + 2, py + 2, px + 1, py + 22, px + 16, py + 28);
      ctx.bezierCurveTo(px + 31, py + 22, px + 30, py + 2, px + 16, py + 7);
      ctx.fill();
      ctx.fillStyle = "#fff8e8";
      ctx.fillRect(px + 11, py + 13, 4, 4);
      ctx.fillRect(px + 18, py + 13, 4, 4);
    }

    function renderHud() {
      els.speaker.textContent = state.message.speaker;
      els.line.textContent = state.ending ? endingLine() : state.message.line;
      els.room.textContent = rooms[state.room].name;
      els.route.textContent = state.route;
      els.hearts.textContent = String(state.hearts);
      els.inventory.innerHTML = state.inventory.length
        ? state.inventory.map((id) => `<li>${items[id].label}</li>`).join("")
        : "<li>Empty</li>";
      const questRows = [
        ["Find a light", state.inventory.includes("lamp")],
        ["Return the loose page to the shade", state.flags.shadeHelped],
        ["Open, force, or leave the iron door", Boolean(state.ending)]
      ];
      els.quests.innerHTML = questRows.map(([text, done]) => `<li class="${done ? "is-done" : ""}">${done ? "Done: " : ""}${text}</li>`).join("");
    }

    function move(dx, dy, facing) {
      if (!running || state.ending) return;
      state.player.facing = facing;
      const nx = state.player.x + dx;
      const ny = state.player.y + dy;
      const room = rooms[state.room];
      const exit = room.exits.find((candidate) => candidate.x === nx && candidate.y === ny);
      if (exit) {
        state.room = exit.to;
        state.player.x = exit.px;
        state.player.y = exit.py;
        say("Narrator", `You enter ${rooms[state.room].name}.`);
        autosave();
        return;
      }
      if (nx < 0 || ny < 0 || nx > 23 || ny > 15 || room.walls.has(`${nx},${ny}`) || npcAt(nx, ny)) return;
      state.player.x = nx;
      state.player.y = ny;
      const item = itemAt(nx, ny);
      if (item) take(item);
    }

    function act() {
      if (!running) return start();
      if (state.ending) return;
      const front = inFront();
      const npc = npcAt(front.x, front.y);
      if (npc) talk(npc);
      else {
        const here = itemAt(state.player.x, state.player.y);
        if (here) take(here);
        else say("Narrator", "Dust moves in the light. Nothing asks to be changed here.");
      }
      autosave();
    }

    function inFront() {
      const delta = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] }[state.player.facing] || [0, 1];
      return { x: state.player.x + delta[0], y: state.player.y + delta[1] };
    }

    function itemAt(x, y) {
      return Object.keys(items).find((id) => {
        const item = items[id];
        return item.room === state.room && item.x === x && item.y === y && !state.inventory.includes(id);
      });
    }

    function npcAt(x, y) {
      return Object.keys(npcs).find((id) => {
        const npc = npcs[id];
        return npc.room === state.room && npc.x === x && npc.y === y;
      });
    }

    function take(id) {
      state.inventory.push(id);
      if (id === "lamp") state.route = "Gentle";
      if (id === "key" && !state.flags.shadeHelped) state.route = "Power";
      say("Found", `${items[id].label} joined your inventory.`);
    }

    function talk(id) {
      if (id === "archivist") {
        if (!state.inventory.includes("lamp")) say("Archivist", "Take the lamp from the lower desk. The stacks dislike being crossed in the dark.");
        else if (!state.flags.shadeHelped) say("Archivist", "A loose page has gone missing. The quiet reader in the stacks knows where it belongs.");
        else say("Archivist", "You have been kind to a forgotten page. The garden door will remember that.");
      }
      if (id === "shade") {
        if (!state.inventory.includes("page")) say("Shy Shade", "I lost the page with my name on it. It fell somewhere nearby.");
        else {
          state.flags.shadeHelped = true;
          state.inventory = state.inventory.filter((item) => item !== "page");
          state.route = "Mercy";
          say("Shy Shade", "You returned my page instead of keeping it. Take the honest route through the garden.");
        }
      }
      if (id === "gate") {
        if (state.flags.shadeHelped) end("mercy");
        else if (state.inventory.includes("key")) end("power");
        else end("quiet");
      }
    }

    function end(kind) {
      state.ending = kind;
      state.route = kind === "mercy" ? "Mercy" : kind === "power" ? "Power" : "Quiet";
      say("Ending", endingLine());
      save();
    }

    function endingLine() {
      if (state.ending === "mercy") return "Mercy ending: the iron door opens without a sound, and every returned page remembers your name.";
      if (state.ending === "power") return "Power ending: the key turns, but the archive grows colder around the missing page.";
      if (state.ending === "quiet") return "Quiet ending: you leave the locked door alone. Some mysteries stay intact.";
      return state.message.line;
    }

    function say(speaker, line) {
      state.message = { speaker, line };
    }

    function start() {
      running = true;
      say("Archivist", "Walk the archive. Speak gently, or take what you need. The route will notice.");
      els.status.textContent = "Started. Progress autosaves after room changes and actions.";
    }

    async function save() {
      localStorage.setItem(fallbackKey, JSON.stringify(state));
      try {
        const response = await fetch(`/api/play/rpg/save/${saveSlot}`, {
          method: "PUT",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ payload: state })
        });
        if (!response.ok) throw new Error(`Save failed: ${response.status}`);
        els.status.textContent = "Saved to backend.";
      } catch (_error) {
        els.status.textContent = "Saved locally. Backend save API was not reachable.";
      }
    }

    async function load() {
      try {
        const response = await fetch(`/api/play/rpg/save/${saveSlot}`);
        if (response.ok) {
          const data = await response.json();
          state = normalizeState(data.payload);
          running = true;
          els.status.textContent = "Loaded from backend.";
          return;
        }
      } catch (_error) {
        /* Fall through to local save. */
      }
      const local = localStorage.getItem(fallbackKey);
      if (local) {
        state = normalizeState(JSON.parse(local));
        running = true;
        els.status.textContent = "Loaded local save.";
      } else {
        els.status.textContent = "No save found.";
      }
    }

    function normalizeState(candidate) {
      return Object.assign(freshState(), candidate || {}, {
        player: Object.assign(freshState().player, (candidate && candidate.player) || {}),
        inventory: Array.isArray(candidate && candidate.inventory) ? candidate.inventory.filter((id) => items[id]) : [],
        flags: Object.assign({}, (candidate && candidate.flags) || {}),
        message: Object.assign(freshState().message, (candidate && candidate.message) || {})
      });
    }

    function autosave() {
      save();
    }

    $("[data-rpg-start]", root).addEventListener("click", start);
    $("[data-rpg-save]", root).addEventListener("click", save);
    $("[data-rpg-load]", root).addEventListener("click", load);
    $("[data-rpg-reset]", root).addEventListener("click", async () => {
      state = freshState();
      running = false;
      localStorage.removeItem(fallbackKey);
      try {
        await fetch(`/api/play/rpg/save/${saveSlot}`, { method: "DELETE" });
        els.status.textContent = "Reset and cleared backend save.";
      } catch (_error) {
        els.status.textContent = "Reset locally. Backend save API was not reachable.";
      }
    });
    $("[data-rpg-act]", root).addEventListener("click", act);
    $$("[data-rpg-move]", root).forEach((button) => {
      const moves = { up: [0, -1, "up"], down: [0, 1, "down"], left: [-1, 0, "left"], right: [1, 0, "right"] };
      button.addEventListener("click", () => move(...moves[button.dataset.rpgMove]));
    });
    window.addEventListener("keydown", (event) => {
      if (!root.isConnected) return;
      const tag = event.target.tagName;
      if (tag === "INPUT" || tag === "TEXTAREA") return;
      const keys = {
        ArrowUp: [0, -1, "up"], w: [0, -1, "up"],
        ArrowDown: [0, 1, "down"], s: [0, 1, "down"],
        ArrowLeft: [-1, 0, "left"], a: [-1, 0, "left"],
        ArrowRight: [1, 0, "right"], d: [1, 0, "right"]
      };
      if (keys[event.key]) {
        event.preventDefault();
        move(...keys[event.key]);
      }
      if (event.key === " " || event.key === "Enter") {
        event.preventDefault();
        act();
      }
    });
    draw();
    load();
  }

  function setupSortable(container, _render, after) {
    let dragged = null;
    container.addEventListener("dragstart", (event) => {
      dragged = event.target.closest("[draggable='true']");
      if (dragged) event.dataTransfer.effectAllowed = "move";
    });
    container.addEventListener("dragover", (event) => {
      event.preventDefault();
      const target = event.target.closest("[draggable='true']");
      if (!dragged || !target || target === dragged) return;
      const rect = target.getBoundingClientRect();
      const before = event.clientY < rect.top + rect.height / 2 || event.clientX < rect.left + rect.width / 2;
      container.insertBefore(dragged, before ? target : target.nextSibling);
      after();
    });
    container.addEventListener("dragend", () => {
      dragged = null;
      after();
    });
  }

  function pick(items) {
    return items[Math.floor(Math.random() * items.length)];
  }
})();
