From 93bc6e7a07e40b4d566ae817c422f2e238bed444 Mon Sep 17 00:00:00 2001
From: MaddoScientisto <maddo.science@gmail.com>
Date: Sat, 18 Apr 2026 14:38:40 +0200
Subject: [PATCH 1/4] Fixed palettes

---
 psx-map-exporter/docs/spec.md      |  93 ++++++++++++++++++-----
 psx-map-exporter/src/bundles.js    |  40 ++++++++--
 psx-map-exporter/src/cli.js        |  10 +--
 psx-map-exporter/src/export-map.js | 115 +++++++++++++++++++++++++----
 psx-map-exporter/src/render.js     |  62 ++++++++++++++--
 psx-map-exporter/src/wdl.js        | 102 ++++++++++++++-----------
 6 files changed, 325 insertions(+), 97 deletions(-)

diff --git a/psx-map-exporter/docs/spec.md b/psx-map-exporter/docs/spec.md
index dbccc85..f796d09 100644
--- a/psx-map-exporter/docs/spec.md
+++ b/psx-map-exporter/docs/spec.md
@@ -201,27 +201,81 @@ For each record:
   - `screenX - originX`
   - `screenY - originY`
 
-Current draw order is conservative:
+### Projection sign convention
 
-- main-visible before special-visible
-- then ascending `screenY`
-- then ascending `screenX`
+`psx_project_object_main_visible @ 0x80040d44` writes `proj_x = Y - X` and
+`proj_y = 2*Z - (X + Y) / 2` to `obj+0x78/0x7c`. The engine's draw step at
+`0x80040e3c/0x80040e5c` then computes `screen = (cam - proj) - origin`, which
+flips the sign of the projection relative to canvas Y-down space. For a
+camera-less full-map export the exporter bakes that flip into
+`projectCtorPlacement`, so higher world-Z and smaller (X+Y) sit visibly higher
+on the output PNG. The same projection is applied to both constructor
+placements and dispatch-root records; dispatch-root X/Y fields are in world
+coordinates, not pre-projected screen coordinates, despite the runtime
+`camera +/- 0x140` cull comparing against them directly.
 
-This is a probe approximation. The later graph-based stage-1 ordering still belongs to a future pass.
+### Authored layer semantics
 
-The rendered PNG uses a neutral opaque background by default so probe silhouettes are legible without relying on transparency.
+The two authored lanes carry different responsibilities:
+
+- `constructors`: static level geometry — walls, floors, architecture placed
+  by `psx_dispatch_section0_constructor_placements`.
+- `roots`: interactive / dynamic objects — crates, terminals, doors, pickups
+  placed by `psx_dispatch_section0_dispatch_roots`.
+
+Despite the dispatcher name, the `roots` lane is not the map background; it is
+the live-object seed list. For the exporter, "constructors" is the geometry
+layer and "roots" is the object layer.
+
+### Painter's order
+
+The exporter sorts items before blitting using the following keys, in order:
+
+1. `stage` ascending. `stage = 1` when `typeWord === 4` or `laneWord & 0x0400`
+   is set; those overlays draw last.
+2. Authored-layer priority: `constructors` (0) before `roots` (1). Static
+   geometry draws first so interactive props in the same room do not get
+   hidden behind the floor or wall pieces that occupy the same cell.
+3. Isometric depth ascending: back-to-front by world `X + Y` (isometric
+   ground-depth axis). Falls back to projected `screenY` when world
+   coordinates are unavailable.
+4. World `Z` ascending within the same ground cell so lower elevations draw
+   before taller objects sharing the same footprint.
+5. `screenX` ascending as a stable tie-breaker.
+
+This is still an approximation of the engine's stage-1 graph order but is
+closer to what an isometric painter's algorithm would produce than the earlier
+screenY-only sort.
+
+The rendered PNG uses a neutral opaque background by default so probe
+silhouettes are legible without relying on transparency.
 
 ## Color Rule
 
-`v0` emits grayscale art from raw pixel indices.
+The exporter resolves palettes entirely from the WDL contents. It does not
+require any RAM or VRAM dump; those paths are now optional research overrides.
 
-Reason:
+The map-local palette blob lives at `headerWords[2] .. headerWords[2] + 0x1000`
+(4096 bytes = 2048 colors = 128 × 16-entry CLUTs). The blob is what the engine
+uploads to VRAM rows `0xf0 .. 0xf7` on map load; each VRAM row is 16 CLUTs
+wide so the 128 CLUTs tile exactly 8 rows of 16 CLUTs.
 
-- bundle frame decode is already well constrained
-- full CLUT parity is not
-- grayscale preserves shape/variant evidence without pretending the palette problem is solved
+Resolution rules by bundle mode:
 
-Transparent index `0` stays transparent.
+- **Mode 2 (4bpp)**: the bundle header's `paletteIndex` at `+0x14` is the
+  16-entry CLUT index into the WDL `palettes16` bank. When that index points
+  at a sparse/empty CLUT the exporter falls back to a per-bundle palette sweep
+  that picks a CLUT covering the pixel-index set used by the bundle frames.
+- **Mode 1 (8bpp)**: the 256-color CLUT is the concatenation of 16 consecutive
+  16-entry CLUTs from the WDL bank. The bundle's `paletteIndex` is treated as
+  the starting CLUT index. For the current L0 dataset every mode-1 bundle
+  stores `paletteIndex = 0`, which is the top-left 256-color bank. Mode-1
+  color fidelity is therefore approximate until the level-specific 256-CLUT
+  source (suspected to live in the `stateBank` block) is decoded — tracked as
+  a follow-up.
+
+Transparent pixel index `0` stays transparent during blit regardless of the
+color value stored at CLUT index 0.
 
 ## CLI
 
@@ -254,8 +308,13 @@ Supported options:
 
 ## Planned Follow-Ups
 
-- extend `sceneInterpretation` so it reflects the landed loader-faithful binding instead of the older repeated-wrong-art warning
-- identify and parse the separate static-world or subordinate level substrate that complements the constructor-fed live-object lane, instead of treating section-0 constructor placements as the whole map
-- add palette/CLUT reconstruction
-- add stage-1 graph ordering recovery
-- compare the probe scene against fixed live samples such as `map 104` without reintroducing viewer-side donor assumptions
+- decode the `stateBank` and `stateBank2` blocks to recover the level-specific
+  256-color CLUT used by mode-1 sprites. Current mode-1 palettes default to
+  CLUT-bank start 0, which produces plausible colors for some sprites but
+  renders many indoor floor tiles as solid green plates.
+- extend `sceneInterpretation` so it reflects the landed loader-faithful
+  binding instead of the older repeated-wrong-art warning.
+- recover the engine's stage-1 graph ordering instead of approximating with
+  isometric `(X + Y, Z, screenX)` sort keys.
+- compare the probe scene against fixed live samples such as `map 104` without
+  reintroducing viewer-side donor assumptions.
diff --git a/psx-map-exporter/src/bundles.js b/psx-map-exporter/src/bundles.js
index 7c8bb16..2d8ffb7 100644
--- a/psx-map-exporter/src/bundles.js
+++ b/psx-map-exporter/src/bundles.js
@@ -26,17 +26,45 @@ function psx555ToRgba(color) {
 }
 
 export function extractPaletteSets(buffer, headerWords) {
-  if (!Array.isArray(headerWords) || headerWords.length < 4) {
+  if (!Array.isArray(headerWords) || headerWords.length < 9) {
     return { palettes16: [], palettes256: [] };
   }
 
-  const paletteOffset = headerWords[2];
-  const paletteSize = headerWords[3];
-  if (paletteSize !== 0x1000 || paletteOffset < 0 || paletteOffset + paletteSize > buffer.length) {
+  // The runtime CLUT table is the LAST chunk of the level "section pack" that
+  // wdl_resource_bundle_load_by_index @ 0x80039918 reads from the per-map .WDL
+  // file. The 0x38-byte header is an array of 14 u32 sizes:
+  //   [c8, c4, c0, bc, b8, b4, b0, ac, a8, a4, a0, 9c, 98, 94]
+  // The section pack covers the first sum(headerWords[0..9]) bytes after the
+  // header. Within it, the engine derives section pointers as:
+  //   dispatch_roots          @ +headerWords[0]
+  //   ctor_placement_records  @ +headerWords[1]
+  //   ctor_placement_section  @ +headerWords[2]
+  //   (local_bc scratch gap)  @ headerWords[3]   <-- SKIPPED in pointer math
+  //   section_pack_base       @ +headerWords[4]
+  //   type_policy_table       @ +headerWords[5]
+  //   8006754c table          @ +headerWords[6]
+  //   control_opcode_stream   @ +headerWords[7]
+  //   psx_level_clut_table    @ +headerWords[8]   <-- CLUT starts here
+  // Note that the engine's chain skips headerWords[3] (`local_bc`); that field
+  // is a separate scratch reservation released by psx_level_heap_rewind after
+  // level_palette_header_apply returns. The CLUT absolute file offset is
+  // therefore 0x38 plus the sum of headerWords[0..2, 4..8].
+  // The CLUT spans 0x1000 bytes (128 x 32-byte 16-color CLUTs) which matches
+  // the engine's psx_clut_table_by_resource_bank layout (8 rows x 16 cols).
+  // The exporter previously used headerWords[2] / headerWords[3] which are
+  // actually section sizes, not a palette offset; that mismatch produced the
+  // wrong colors (e.g. neon-green floors instead of grey concrete).
+  let clutOffset = 0x38;
+  for (let i = 0; i < 9 && i < headerWords.length; i += 1) {
+    if (i === 3) continue; // skip local_bc scratch reservation
+    clutOffset += headerWords[i] >>> 0;
+  }
+  const paletteSize = 0x1000;
+  if (clutOffset < 0 || clutOffset + paletteSize > buffer.length) {
     return { palettes16: [], palettes256: [] };
   }
 
-  const blob = buffer.subarray(paletteOffset, paletteOffset + paletteSize);
+  const blob = buffer.subarray(clutOffset, clutOffset + paletteSize);
   const palettes16 = [];
   const palettes256 = [];
 
@@ -56,7 +84,7 @@ export function extractPaletteSets(buffer, headerWords) {
     palettes256.push(palette);
   }
 
-  return { palettes16, palettes256 };
+  return { palettes16, palettes256, clutOffset };
 }
 
 export function buildMode1RuntimePaletteForIndex(palettes16, startIndex = 0) {
diff --git a/psx-map-exporter/src/cli.js b/psx-map-exporter/src/cli.js
index 101a870..23cb793 100644
--- a/psx-map-exporter/src/cli.js
+++ b/psx-map-exporter/src/cli.js
@@ -12,17 +12,11 @@ function parseArgs(argv) {
       '..',
       '..',
       '..',
-      'Crusader-Map-Viewer',
+      'crusader_map_viewer',
       'map_renderer',
       'STATIC_PSX'
     ),
-    gpuRamDump: path.resolve(
-      moduleDir,
-      '..',
-      '..',
-      'binary',
-      'Crusader - No Remorse (USA) GPU RAM 2.bin'
-    ),
+    gpuRamDump: null,
     mapSource: 'auto',
     bindingMode: 'raw',
     sceneScope: 'probe',
diff --git a/psx-map-exporter/src/export-map.js b/psx-map-exporter/src/export-map.js
index 49a7455..b6a18ac 100644
--- a/psx-map-exporter/src/export-map.js
+++ b/psx-map-exporter/src/export-map.js
@@ -525,7 +525,15 @@ function summarizeRenderedLayers(items) {
 }
 
 function derivePaletteDiagnostics(record, bundle) {
-  const rawWords = Array.isArray(record.rawWords) ? record.rawWords : [];
+  // For dispatch-root records the meaningful per-record palette token lives
+  // in the full 24-byte raw row (12 u16 words), not the projected 6-word
+  // record we keep for shared scene math. Constructor placements only have
+  // the 12-byte form, so falling back to record.rawWords is correct there.
+  const rawWords = Array.isArray(record.dispatchRootRawWords)
+    ? record.dispatchRootRawWords
+    : Array.isArray(record.rawWords)
+      ? record.rawWords
+      : [];
   const token06HighByte = rawWords.length >= 4 ? ((rawWords[3] >>> 8) & 0xff) : null;
   const token0cHighByte = rawWords.length >= 7 ? ((rawWords[6] >>> 8) & 0xff) : null;
 
@@ -1008,29 +1016,57 @@ function resolveBundlePalettes(bundles, paletteSets, options = {}) {
     let paletteFormula = null;
 
     if (bundle.mode === 2) {
-      if (!Number.isInteger(resolvedPaletteIndex) || resolvedPaletteIndex < 0 || resolvedPaletteIndex >= paletteSets.palettes16.length) {
-        resolvedPaletteIndex = choosePalette(paletteSets.palettes16, bundle.frames, bundle.mode);
+      // Mode 2 (4bpp) descriptor binder at psx_resource_bind_single_image_vram_slot
+      // (0x800444e4) takes the bundle's `paletteIndex` from descriptor+0x14
+      // and ADDS 0x10 (= 16) before storing it as the resource's CLUT bank
+      // index at resource+0x08. The submitters then read
+      // psx_clut_table_by_resource_bank[resource+8] which is identical to
+      // palettes16[paletteIndex + 16]. The exporter therefore offsets the
+      // bundle index by +16 for mode-2 art.
+      const baseIndex = Number.isInteger(bundle.paletteIndex) ? bundle.paletteIndex : null;
+      const adjustedIndex = baseIndex !== null ? baseIndex + 16 : null;
+      if (adjustedIndex !== null && adjustedIndex >= 0 && adjustedIndex < paletteSets.palettes16.length) {
+        resolvedPaletteIndex = adjustedIndex;
+        palette = paletteSets.palettes16[adjustedIndex];
+        paletteFormula = 'mode2-bundle-index-plus-16';
       }
-      if (Number.isInteger(resolvedPaletteIndex) && resolvedPaletteIndex >= 0 && resolvedPaletteIndex < paletteSets.palettes16.length) {
-        palette = paletteSets.palettes16[resolvedPaletteIndex];
-        paletteFormula = 'mode2-bundle-or-usage-index';
+      if (!palette) {
+        if (!Number.isInteger(resolvedPaletteIndex) || resolvedPaletteIndex < 0 || resolvedPaletteIndex >= paletteSets.palettes16.length) {
+          resolvedPaletteIndex = choosePalette(paletteSets.palettes16, bundle.frames, bundle.mode);
+        }
+        if (Number.isInteger(resolvedPaletteIndex) && resolvedPaletteIndex >= 0 && resolvedPaletteIndex < paletteSets.palettes16.length) {
+          palette = paletteSets.palettes16[resolvedPaletteIndex];
+          paletteFormula = 'mode2-bundle-or-usage-index-fallback';
+        }
       }
     } else if (bundle.mode === 1) {
-      if (options.mode1RuntimePalette?.length === 256) {
+      // Mode 1 is an 8bpp image with a 256-entry CLUT. In this engine the
+      // 256-color CLUT is NOT a dedicated palette-256 block — it is the
+      // concatenation of 16 consecutive 16-entry CLUTs taken from the
+      // `palettes16` bank. The bundle header's `paletteIndex` is the starting
+      // CLUT index into `palettes16`. Falling back to `0` matches the legacy
+      // behavior but is almost always wrong for mode-1 art; the per-bundle
+      // index is the real engine-equivalent rule.
+      const bankStart = Number.isInteger(bundle.paletteIndex) && bundle.paletteIndex >= 0
+        ? bundle.paletteIndex
+        : 0;
+      const fromBundleIndex = mode1PaletteBank[bankStart];
+      if (fromBundleIndex?.length === 256) {
+        resolvedPaletteIndex = bankStart;
+        palette = fromBundleIndex;
+        paletteFormula = 'mode1-palette16-bank-start-index-bundle';
+      } else if (options.mode1RuntimePalette?.length === 256) {
         resolvedPaletteIndex = 0;
         palette = options.mode1RuntimePalette;
+        paletteFormula = 'mode1-live-gpu-ram-row-f0-x0';
       } else if (mode1PaletteBank[0]?.length) {
         resolvedPaletteIndex = 0;
         palette = mode1PaletteBank[0];
+        paletteFormula = 'mode1-palette16-bank-start-index-0-fallback';
       } else {
         resolvedPaletteIndex = null;
         palette = mode1RuntimePalette;
-      }
-
-      if (palette) {
-        paletteFormula = options.mode1RuntimePalette?.length === 256
-          ? 'mode1-live-gpu-ram-row-f0-x0'
-          : 'mode1-runtime-clut-band-start-index-0';
+        paletteFormula = palette ? 'mode1-runtime-clut-band-start-index-0' : null;
       }
     }
 
@@ -1050,7 +1086,14 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
   const skippedRecords = [];
 
   const nonMapFacingRootTypes = new Set([0x42, 0x49]);
-  const nonMapFacingBundleOffsets = new Set([0x000d84f4]);
+  // Bundles that bind via dispatch_roots but are HUD/UI artwork, not authored
+  // map placements. They surface in the scene because they share the dispatch
+  // table format with world objects, but rendering them produces a stray UI
+  // panel floating in the middle of an empty area.
+  //   0x000d84f4 - portrait/talk panel (already known)
+  //   0x00074f44 - type 0xAC (172) full-screen UI panel, 216x126, kind-4
+  //                mode-2; user-confirmed as the lone "TAC:b4f44" leak.
+  const nonMapFacingBundleOffsets = new Set([0x000d84f4, 0x00074f44]);
   for (const record of records) {
     if (record.sourceFamily === 'section0_dispatch_roots' && nonMapFacingRootTypes.has(record.typeWord)) {
       skippedRecords.push({
@@ -1102,6 +1145,9 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
       rowIndex: record.rowIndex,
       typeWord: record.typeWord,
       laneWord: record.laneWord,
+      worldX: record.xWord ?? null,
+      worldY: record.yWord ?? null,
+      worldZ: record.zWord ?? null,
       screenX: record.screenX,
       screenY: record.screenY,
       bundleSlot: bundle.slot,
@@ -1134,12 +1180,49 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
     });
   }
 
+  // Painter's order for an isometric top-down full-map render.
+  // 1. `stage`: runtime sub-stage flag (0 = default, 1 = overlays flagged via
+  //    typeWord===4 or laneWord bit 0x0400). Overlays always on top.
+  // 2. `authoredLayer`: `constructors` is the static geometry lane (walls,
+  //    floors, architecture placed by `psx_dispatch_section0_constructor_placements`).
+  //    `roots` is the dispatch-root lane — interactive/dynamic objects such as
+  //    crates, terminals, doors, pickups placed by
+  //    `psx_dispatch_section0_dispatch_roots`. Geometry draws first so that
+  //    props (roots) sit ON TOP of the room they occupy.
+  // 3. Isometric depth within a layer: back-to-front by world `X + Y` (ground
+  //    depth along the engine's isometric axis), then by `Z` ascending so a
+  //    lower object at the same ground cell does not occlude a taller one
+  //    behind it. Falls back to screenY when world coords are unavailable.
+  // 4. `screenX` ascending: stable tie-breaker left-to-right.
+  const layerPriority = (item) => {
+    if (item.authoredLayer === 'constructors') return 0;
+    if (item.authoredLayer === 'roots') return 1;
+    return 2;
+  };
+  const depthKey = (item) => {
+    if (Number.isFinite(item.worldX) && Number.isFinite(item.worldY)) {
+      return item.worldX + item.worldY;
+    }
+    return item.screenY;
+  };
   items.sort((left, right) => {
     if (left.stage !== right.stage) {
       return left.stage - right.stage;
     }
-    if (left.screenY !== right.screenY) {
-      return left.screenY - right.screenY;
+    const leftLayer = layerPriority(left);
+    const rightLayer = layerPriority(right);
+    if (leftLayer !== rightLayer) {
+      return leftLayer - rightLayer;
+    }
+    const leftDepth = depthKey(left);
+    const rightDepth = depthKey(right);
+    if (leftDepth !== rightDepth) {
+      return leftDepth - rightDepth;
+    }
+    const leftZ = Number.isFinite(left.worldZ) ? left.worldZ : 0;
+    const rightZ = Number.isFinite(right.worldZ) ? right.worldZ : 0;
+    if (leftZ !== rightZ) {
+      return leftZ - rightZ;
     }
     return left.screenX - right.screenX;
   });
diff --git a/psx-map-exporter/src/render.js b/psx-map-exporter/src/render.js
index 0b2881e..b163a0c 100644
--- a/psx-map-exporter/src/render.js
+++ b/psx-map-exporter/src/render.js
@@ -13,6 +13,18 @@ const GLYPHS = {
   '7': ['111', '001', '001', '001', '001'],
   '8': ['111', '101', '111', '101', '111'],
   '9': ['111', '101', '111', '001', '111'],
+  'a': ['010', '101', '111', '101', '101'],
+  'b': ['110', '101', '110', '101', '110'],
+  'c': ['111', '100', '100', '100', '111'],
+  'd': ['110', '101', '101', '101', '110'],
+  'e': ['111', '100', '110', '100', '111'],
+  'f': ['111', '100', '110', '100', '100'],
+  'p': ['110', '101', '110', '100', '100'],
+  't': ['111', '010', '010', '010', '010'],
+  '#': ['101', '111', '101', '111', '101'],
+  ':': ['000', '010', '000', '010', '000'],
+  '/': ['001', '001', '010', '100', '100'],
+  '-': ['000', '000', '111', '000', '000'],
 };
 
 function clearCanvas(width, height, background = null) {
@@ -87,6 +99,18 @@ function drawLabel(canvas, canvasWidth, canvasHeight, text, x, y) {
   }
 }
 
+function drawBoundingBox(canvas, canvasWidth, canvasHeight, x, y, width, height, alpha = 220) {
+  if (width <= 0 || height <= 0) {
+    return;
+  }
+  // Top + bottom edges
+  fillRect(canvas, canvasWidth, canvasHeight, x, y, width, 1, 255, 255, 255, alpha);
+  fillRect(canvas, canvasWidth, canvasHeight, x, y + height - 1, width, 1, 255, 255, 255, alpha);
+  // Left + right edges
+  fillRect(canvas, canvasWidth, canvasHeight, x, y, 1, height, 255, 255, 255, alpha);
+  fillRect(canvas, canvasWidth, canvasHeight, x + width - 1, y, 1, height, 255, 255, 255, alpha);
+}
+
 function blitRgba(canvas, canvasWidth, canvasHeight, sprite, dstX, dstY, flipped = false) {
   for (let y = 0; y < sprite.height; y += 1) {
     const canvasY = dstY + y;
@@ -148,15 +172,37 @@ export function renderMap(items, options = {}) {
   }
 
   if (options.drawLabels) {
+    // Cap labels at 10 instances per (typeWord, bundleAbsoluteOffset) pair so
+    // dense root layers (e.g. floor tiles) do not bury the labels we actually
+    // need to read. The bounding box is also suppressed once the label budget
+    // is exhausted so duplicate-instance clusters do not redraw white outlines
+    // on every tile and obscure surrounding art.
+    const labelBudgetPerBundle = 10;
+    const labelTally = new Map();
     for (const item of items) {
-      drawLabel(
-        canvas,
-        width,
-        height,
-        item.labelId ?? item.id,
-        item.drawX - bounds.minX + padding,
-        item.drawY - bounds.minY + padding
-      );
+      const tallyKey = `${item.typeWord ?? '?'}|${item.bundleAbsoluteOffset ?? '?'}`;
+      const used = labelTally.get(tallyKey) ?? 0;
+      if (used >= labelBudgetPerBundle) {
+        continue;
+      }
+      labelTally.set(tallyKey, used + 1);
+      const boxX = item.drawX - bounds.minX + padding;
+      const boxY = item.drawY - bounds.minY + padding;
+      const boxW = item.width ?? item.sprite?.width ?? 0;
+      const boxH = item.height ?? item.sprite?.height ?? 0;
+      drawBoundingBox(canvas, width, height, boxX, boxY, boxW, boxH);
+      // Compose a useful label: typeWord (hex) + bundle absolute offset (last 4 hex)
+      const labelParts = [];
+      if (Number.isInteger(item.typeWord)) {
+        labelParts.push('t' + item.typeWord.toString(16));
+      }
+      if (Number.isInteger(item.bundleAbsoluteOffset)) {
+        labelParts.push('b' + (item.bundleAbsoluteOffset & 0xffff).toString(16).padStart(4, '0'));
+      }
+      if (labelParts.length === 0 && (item.labelId ?? item.id) !== undefined) {
+        labelParts.push('#' + (item.labelId ?? item.id));
+      }
+      drawLabel(canvas, width, height, labelParts.join(':'), boxX, boxY);
     }
   }
 
diff --git a/psx-map-exporter/src/wdl.js b/psx-map-exporter/src/wdl.js
index 25b6ecb..1df5ad8 100644
--- a/psx-map-exporter/src/wdl.js
+++ b/psx-map-exporter/src/wdl.js
@@ -286,14 +286,34 @@ function isStructuredCandidate(words) {
   return true;
 }
 
+function projectCtorPlacement(xWord, yWord, zWord) {
+  // Engine-accurate projection, matching `psx_project_object_main_visible`
+  // (0x80040d44) followed by the camera subtraction at 0x80040e3c/0x80040e5c.
+  //
+  // The projection step writes to obj+0x78/0x7c:
+  //   proj_x = Y - X
+  //   proj_y = 2*Z - (X+Y)/2
+  // The draw step then writes to obj+0x20/0x22:
+  //   screen_x = (cam_X - proj_x) - origin_X
+  //   screen_y = (cam_Y - proj_y) - origin_Y
+  // i.e. the engine renders the world with the sign flipped relative to the
+  // raw projection. For a camera-less full-map export we fold that flip into
+  // the projection so higher world Z appears higher on the canvas (Y-down).
+  const projX = yWord - xWord;
+  const projY = (2 * zWord) - Math.floor((xWord + yWord) / 2);
+  return {
+    screenX: -projX * PSX_SCREEN_SCALE,
+    screenY: -projY * PSX_SCREEN_SCALE,
+  };
+}
+
 function buildRecord(words, source, offset, rawWords = words) {
   if (!isPlausibleRecord(words)) {
     return null;
   }
 
   const [typeWord, xWord, yWord, zWord, selectorWord, laneWord] = words;
-  const screenX = (yWord - xWord) * PSX_SCREEN_SCALE;
-  const screenY = ((2 * zWord) - Math.floor((xWord + yWord) / 2)) * PSX_SCREEN_SCALE;
+  const { screenX, screenY } = projectCtorPlacement(xWord, yWord, zWord);
 
   return {
     index: -1,
@@ -595,11 +615,17 @@ export function parseRegion01Records(region) {
 
 // Loader-faithful 12-byte constructor-placement records straight out of the
 // `ctorPlacements` subrange of the section pack. Layout per
-// `psx_dispatch_section0_constructor_placements @ 0x800258cc`:
-//   [u32 count][count * { u16 typeWord; u16 X; u16 Y; u16 Z; u16 selector;
-//                         u16 flags }]
-// Each record is called as `descriptor_table[typeWord].slot0(record, 0)` and
-// `psx_object_create_compound_record` then reads exactly those 6 u16 fields.
+// `psx_object_create_compound_record @ 0x80025040`:
+//   +0x00 u16 typeWord          -> descriptor_table index
+//   +0x02 u16 X                 -> obj world X (<<16 seed)
+//   +0x04 u16 Y                 -> obj world Y (<<16 seed)
+//   +0x06 u8  Z (low byte only!)-> obj world Z (<<16 seed). The high byte at
+//                                  +0x07 is not read as part of Z.
+//   +0x08 u8  selector          -> state-script seed
+//   +0x09 u8  (padding/unknown)
+//   +0x0a u16 laneWord          -> OR'd into obj+0x1c (flags/lane)
+// The previous implementation decoded Z as a u16 from +0x06, which mixed the
+// selector byte into Z and produced large bogus elevations.
 export function parseCtorPlacementsBlock(block, variant = 'lset') {
   if (!block || !block.buffer || block.size < 4) {
     return { source: 'ctorPlacements', records: [], count: 0 };
@@ -614,11 +640,17 @@ export function parseCtorPlacementsBlock(block, variant = 'lset') {
     if (recordOffset + 12 > block.buffer.length) {
       break;
     }
-    const words = [];
-    for (let cursor = 0; cursor < 12; cursor += 2) {
-      words.push(readU16LE(block.buffer, recordOffset + cursor));
-    }
-    const record = buildRecord(words, 'ctorPlacements', recordOffset, words);
+    const typeWord = readU16LE(block.buffer, recordOffset + 0x00);
+    const xWord = readU16LE(block.buffer, recordOffset + 0x02);
+    const yWord = readU16LE(block.buffer, recordOffset + 0x04);
+    const zWord = block.buffer[recordOffset + 0x06];
+    const z2Byte = block.buffer[recordOffset + 0x07];
+    const selectorWord = block.buffer[recordOffset + 0x08];
+    const selectorHighByte = block.buffer[recordOffset + 0x09];
+    const laneWord = readU16LE(block.buffer, recordOffset + 0x0a);
+    const rawWords = [typeWord, xWord, yWord, (z2Byte << 8) | zWord, (selectorHighByte << 8) | selectorWord, laneWord];
+    const words = [typeWord, xWord, yWord, zWord, selectorWord, laneWord];
+    const record = buildRecord(words, 'ctorPlacements', recordOffset, rawWords);
     if (!record) {
       continue;
     }
@@ -646,17 +678,17 @@ export function parseCtorPlacementsBlock(block, variant = 'lset') {
 // `psx_dispatch_section0_dispatch_roots @ 0x800256b0`:
 //   [u32 count][count * 24 bytes]
 // Within each record the dispatcher reads:
-//   +4 u16  typeId  (argument to descriptor_table[typeId])
-//   +8 u16  screenX (for +/-0x140 cull)
-//   +10 u16 screenY (for +/-0x140 cull)
-//   +16 u16 flags   (bit 3 = skip this record)
-// Z, selector and lane are not universally used by the dispatcher. The empirical
-// best mapping that matches constructor-placement convention is:
-//   +6  u16 zeta     (often 0)
-//   +12 u16 selector/rotation
-//   +14 u16 lane/flags-lo
-// We keep them in rawWords so downstream consumers can probe further, but
-// buildRecord uses the cull-verified X/Y/typeId for positioning.
+//   +0x04 u16 typeId    (descriptor_table index)
+//   +0x08 u16 worldX    (compared to cam+0x3e +/- 0x140 — cam+0x3e is the
+//                        camera's world-X short, not the projected integer
+//                        part; proof: root worldX values overlap constructor
+//                        placement worldX values in the same map)
+//   +0x0a u16 worldY    (compared to cam+0x42 +/- 0x140)
+//   +0x10 u16 flags     (bit 3 = skip this record)
+// We therefore project root worldX/worldY through the same projection as
+// constructor placements (with Z=0 since dispatch roots do not carry a Z byte
+// at a known offset) and render them on the same canvas. The trailing raw
+// fields are preserved as `dispatchRootRawWords` for future probes.
 export function parseDispatchRootsBlock(block, variant = 'lset') {
   if (!block || !block.buffer || block.size < 4) {
     return { source: 'dispatchRoots', records: [], count: 0 };
@@ -675,17 +707,6 @@ export function parseDispatchRootsBlock(block, variant = 'lset') {
     for (let cursor = 0; cursor < 24; cursor += 2) {
       rawWords.push(readU16LE(block.buffer, recordOffset + cursor));
     }
-    // Project into buildRecord's 6-word ctor-placement shape using the fields
-    // the live dispatcher reads. rawWords indices:
-    //   [0..1] (+0..+3)   prefix
-    //   [2]    (+4)       typeId (dispatch)
-    //   [3]    (+6)       zeta / z-ish
-    //   [4]    (+8)       X  (cull)
-    //   [5]    (+10)      Y  (cull)
-    //   [6]    (+12)      selector-ish
-    //   [7]    (+14)      lane-ish
-    //   [8]    (+16)      flags (bit 3 skip)
-    //   [9..11]           trailing
     const flags = rawWords[8];
     if ((flags & 0x8) !== 0) {
       continue;
@@ -693,14 +714,12 @@ export function parseDispatchRootsBlock(block, variant = 'lset') {
     const typeWord = rawWords[2];
     const xWord = rawWords[4];
     const yWord = rawWords[5];
-    const zWord = rawWords[3] & 0xff;
+    // Dispatch roots do not carry a Z byte at a well-known offset; they are
+    // treated as floor-plane (Z=0) until a Z field is recovered from the
+    // descriptor's slot0 callback.
+    const zWord = 0;
     const selectorWord = rawWords[6];
     const laneWord = rawWords[7];
-    // Relaxed plausibility: dispatch-root records can have lane==0 or large
-    // selectors (e.g. behavior opcodes) because the dispatcher only reads
-    // typeId, X, Y, and the +0x10 skip flag. We only require typeId in the
-    // scene-relevant range and X/Y not both zero. This is looser than
-    // `isPlausibleRecord` on purpose.
     if (typeWord < 0x20 || typeWord > 0x1ff) {
       continue;
     }
@@ -708,8 +727,7 @@ export function parseDispatchRootsBlock(block, variant = 'lset') {
       continue;
     }
     const words = [typeWord, xWord, yWord, zWord, selectorWord, laneWord];
-    const screenX = (yWord - xWord) * PSX_SCREEN_SCALE;
-    const screenY = ((2 * zWord) - Math.floor((xWord + yWord) / 2)) * PSX_SCREEN_SCALE;
+    const { screenX, screenY } = projectCtorPlacement(xWord, yWord, zWord);
     const record = {
       index: -1,
       source: 'dispatchRoots',

From 2b1f1a0191b22c3fec6548c04f042cbd2742fe95 Mon Sep 17 00:00:00 2001
From: MaddoScientisto <maddo.science@gmail.com>
Date: Sat, 18 Apr 2026 16:34:35 +0200
Subject: [PATCH 2/4] map viewer

---
 psx-map-exporter/.gitignore               |    6 +-
 psx-map-exporter/scripts/export-all.mjs   |  170 +++
 psx-map-exporter/src/bundles.js           |    8 +-
 psx-map-exporter/src/cli.js               |   45 +-
 psx-map-exporter/src/export-map.js        |  157 ++-
 psx-map-exporter/src/render.js            |   81 +-
 psx-map-exporter/src/wdl.js               |   12 +-
 psx-map-exporter/viewer/index.html        |   12 +
 psx-map-exporter/viewer/package-lock.json | 1207 +++++++++++++++++++++
 psx-map-exporter/viewer/package.json      |   18 +
 psx-map-exporter/viewer/src/App.vue       |  424 ++++++++
 psx-map-exporter/viewer/src/ItemPanel.vue |  102 ++
 psx-map-exporter/viewer/src/main.js       |    5 +
 psx-map-exporter/viewer/src/style.css     |   38 +
 psx-map-exporter/viewer/vite.config.js    |  110 ++
 15 files changed, 2355 insertions(+), 40 deletions(-)
 create mode 100644 psx-map-exporter/scripts/export-all.mjs
 create mode 100644 psx-map-exporter/viewer/index.html
 create mode 100644 psx-map-exporter/viewer/package-lock.json
 create mode 100644 psx-map-exporter/viewer/package.json
 create mode 100644 psx-map-exporter/viewer/src/App.vue
 create mode 100644 psx-map-exporter/viewer/src/ItemPanel.vue
 create mode 100644 psx-map-exporter/viewer/src/main.js
 create mode 100644 psx-map-exporter/viewer/src/style.css
 create mode 100644 psx-map-exporter/viewer/vite.config.js

diff --git a/psx-map-exporter/.gitignore b/psx-map-exporter/.gitignore
index 7d70366..da86674 100644
--- a/psx-map-exporter/.gitignore
+++ b/psx-map-exporter/.gitignore
@@ -1,3 +1,7 @@
 .cache/**
 .output/**
-node_modules/**
\ No newline at end of file
+.output-render/**
+.tmp/**
+node_modules/**
+viewer/dist/**
+viewer/.vite/**
\ No newline at end of file
diff --git a/psx-map-exporter/scripts/export-all.mjs b/psx-map-exporter/scripts/export-all.mjs
new file mode 100644
index 0000000..3735207
--- /dev/null
+++ b/psx-map-exporter/scripts/export-all.mjs
@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// Batch-export every LSET*/L*.WDL found under the PSX disc root into a
+// permanent .output-render/<mapStem>/<variant>/ directory tree. Each export
+// runs as a separate child process so an OOM or crash on one map cannot kill
+// the batch.
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(SCRIPT_DIR, '..');
+const CLI_PATH = path.join(PROJECT_ROOT, 'src', 'cli.js');
+
+const VARIANTS = [
+  { label: 'auto', mapSource: 'auto' },
+  { label: 'region01', mapSource: 'region01' },
+];
+
+function parseArgs(argv) {
+  const options = {
+    discRoot: 'E:/emu/psx/Crusader - No Remorse',
+    outputRoot: path.join(PROJECT_ROOT, '.output-render'),
+    debugLabels: true,
+    only: null,
+    timeoutMs: 300000,
+  };
+  for (let index = 2; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (arg === '--disc-root') { options.discRoot = path.resolve(next); index += 1; }
+    else if (arg === '--output-root') { options.outputRoot = path.resolve(next); index += 1; }
+    else if (arg === '--no-debug-labels') { options.debugLabels = false; }
+    else if (arg === '--only') {
+      options.only = String(next).split(',').map((v) => v.trim()).filter(Boolean);
+      index += 1;
+    } else if (arg === '--timeout-ms') {
+      options.timeoutMs = Number(next); index += 1;
+    }
+  }
+  return options;
+}
+
+async function discoverMaps(discRoot) {
+  const entries = await fs.readdir(discRoot, { withFileTypes: true });
+  const maps = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!/^LSET\d+$/i.test(entry.name)) continue;
+    const dir = path.join(discRoot, entry.name);
+    const files = await fs.readdir(dir);
+    for (const file of files) {
+      if (!/^L\d+\.WDL$/i.test(file)) continue;
+      maps.push({
+        set: entry.name,
+        name: path.parse(file).name,
+        wdlPath: path.join(dir, file),
+        sourceRel: `${entry.name}/${file}`,
+      });
+    }
+  }
+  maps.sort((a, b) => {
+    const an = Number.parseInt(a.name.replace(/^L/i, ''), 10);
+    const bn = Number.parseInt(b.name.replace(/^L/i, ''), 10);
+    return an - bn;
+  });
+  return maps;
+}
+
+function runExport(mapEntry, variant, options) {
+  return new Promise((resolve) => {
+    const outDir = path.join(options.outputRoot, mapEntry.name, variant.label);
+    const args = [
+      '--max-old-space-size=4096',
+      CLI_PATH,
+      '--disc-root', options.discRoot,
+      '--source', mapEntry.sourceRel,
+      '--map-source', variant.mapSource,
+      '--output-root', outDir,
+    ];
+    if (options.debugLabels) args.push('--debug-labels');
+
+    const started = Date.now();
+    const child = spawn(process.execPath, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill('SIGKILL');
+    }, options.timeoutMs);
+
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      const ms = Date.now() - started;
+      resolve({ outDir, code, signal, killed, ms, stdout, stderr });
+    });
+  });
+}
+
+async function main() {
+  const options = parseArgs(process.argv);
+  const maps = await discoverMaps(options.discRoot);
+  const filtered = options.only ? maps.filter((m) => options.only.includes(m.name)) : maps;
+
+  console.log(`Found ${filtered.length} maps under ${options.discRoot}`);
+  await fs.mkdir(options.outputRoot, { recursive: true });
+
+  const summary = [];
+  let okCount = 0;
+  let failCount = 0;
+  for (const mapEntry of filtered) {
+    for (const variant of VARIANTS) {
+      const tag = `[${mapEntry.set}/${mapEntry.name}] variant=${variant.label}`;
+      process.stdout.write(`${tag} ... `);
+      const result = await runExport(mapEntry, variant, options);
+      if (result.code === 0) {
+        okCount += 1;
+        process.stdout.write(`OK (${result.ms}ms)\n`);
+        summary.push({
+          set: mapEntry.set,
+          map: mapEntry.name,
+          variant: variant.label,
+          ms: result.ms,
+          ok: true,
+          outDir: path.relative(options.outputRoot, result.outDir),
+        });
+      } else {
+        failCount += 1;
+        const reason = result.killed
+          ? `TIMEOUT after ${result.ms}ms`
+          : `exit ${result.code}${result.signal ? ' signal ' + result.signal : ''}`;
+        process.stdout.write(`FAIL (${reason})\n`);
+        if (result.stderr) {
+          process.stdout.write(`  stderr: ${result.stderr.trim().split(/\r?\n/).slice(-5).join('\n  stderr: ')}\n`);
+        }
+        summary.push({
+          set: mapEntry.set,
+          map: mapEntry.name,
+          variant: variant.label,
+          ms: result.ms,
+          ok: false,
+          reason,
+          stderrTail: result.stderr.trim().split(/\r?\n/).slice(-10).join('\n'),
+          outDir: path.relative(options.outputRoot, result.outDir),
+        });
+      }
+    }
+  }
+
+  const indexPath = path.join(options.outputRoot, 'index.json');
+  await fs.writeFile(indexPath, JSON.stringify({
+    discRoot: options.discRoot,
+    generatedAt: new Date().toISOString(),
+    variants: VARIANTS.map((v) => v.label),
+    okCount,
+    failCount,
+    maps: summary,
+  }, null, 2));
+  console.log(`\nWrote index ${indexPath} (ok=${okCount} fail=${failCount})`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
diff --git a/psx-map-exporter/src/bundles.js b/psx-map-exporter/src/bundles.js
index 2d8ffb7..147552e 100644
--- a/psx-map-exporter/src/bundles.js
+++ b/psx-map-exporter/src/bundles.js
@@ -8,6 +8,10 @@ function readU16LE(buffer, offset) {
   return buffer.readUInt16LE(offset);
 }
 
+function readS16LE(buffer, offset) {
+  return buffer.readInt16LE(offset);
+}
+
 function rowByteWidth(width, mode) {
   return mode === 2 ? Math.ceil(width / 2) : width;
 }
@@ -314,8 +318,8 @@ export function extractBundleFromHeader(payloadBuffer, absoluteHeaderOffset) {
     const relativeDataOffset = readU32LE(payloadBuffer, entryOffset + 0x08);
     const frameWidth = readU16LE(payloadBuffer, entryOffset + 0x0c);
     const frameHeight = readU16LE(payloadBuffer, entryOffset + 0x0e);
-    const originX = readU16LE(payloadBuffer, entryOffset + 0x10);
-    const originY = readU16LE(payloadBuffer, entryOffset + 0x12);
+    const originX = readS16LE(payloadBuffer, entryOffset + 0x10);
+    const originY = readS16LE(payloadBuffer, entryOffset + 0x12);
 
     const dataStart = dataOffset + (((flags & 1) === 1) ? relativeDataOffset * 4 : relativeDataOffset);
     const rawSize = rowByteWidth(frameWidth, mode) * frameHeight;
diff --git a/psx-map-exporter/src/cli.js b/psx-map-exporter/src/cli.js
index 23cb793..661a9f9 100644
--- a/psx-map-exporter/src/cli.js
+++ b/psx-map-exporter/src/cli.js
@@ -1,21 +1,37 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
 import { exportMap } from './export-map.js';
 
+// Resolve the on-disc PSX asset root. We prefer the ORIGINAL extracted disc
+// files so the exporter never depends on a pre-processed cache; the cached
+// STATIC_PSX copy in the sibling viewer workspace is kept only as a fallback
+// for environments without the disc mounted.
+function resolveDefaultDiscRoot(moduleDir) {
+  const candidates = [
+    'E:/emu/psx/Crusader - No Remorse',
+    'E:/emu/psx/Crusader 2 Pre-Pre Alpha',
+    path.resolve(moduleDir, '..', '..', '..', 'crusader_map_viewer', 'map_renderer', 'STATIC_PSX'),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const stat = fs.statSync(candidate);
+      if (stat.isDirectory()) {
+        return candidate;
+      }
+    } catch {
+      // try next
+    }
+  }
+  return candidates[candidates.length - 1];
+}
+
 function parseArgs(argv) {
   const moduleDir = path.dirname(fileURLToPath(import.meta.url));
   const options = {
-    discRoot: path.resolve(
-      moduleDir,
-      '..',
-      '..',
-      '..',
-      'crusader_map_viewer',
-      'map_renderer',
-      'STATIC_PSX'
-    ),
+    discRoot: resolveDefaultDiscRoot(moduleDir),
     gpuRamDump: null,
     mapSource: 'auto',
     bindingMode: 'raw',
@@ -75,6 +91,15 @@ function parseArgs(argv) {
       index += 1;
       continue;
     }
+    if (arg === '--output-root') {
+      options.outputRoot = path.resolve(next);
+      index += 1;
+      continue;
+    }
+    if (arg === '--no-reset-output') {
+      options.resetOutputRoot = false;
+      continue;
+    }
     if (arg === '--debug-labels') {
       options.debugLabels = true;
       continue;
@@ -140,6 +165,8 @@ async function main() {
     gpuRamDumpPath: options.gpuRamDump,
     validationBundles: options.validationBundles,
     outName: options.outName,
+    outputRoot: options.outputRoot,
+    resetOutputRoot: options.resetOutputRoot,
     debugLabels: Boolean(options.debugLabels),
   });
 
diff --git a/psx-map-exporter/src/export-map.js b/psx-map-exporter/src/export-map.js
index b6a18ac..3cfaa72 100644
--- a/psx-map-exporter/src/export-map.js
+++ b/psx-map-exporter/src/export-map.js
@@ -431,6 +431,21 @@ function chooseBundleBinding(record, bundles, options = {}) {
     return null;
   }
 
+  // Mark high-typeWord dispatch_root entries (>= 0xAC) as non-renderable
+  // placeholders rather than guessing art for them. The PSX engine switches
+  // its palette-token sourcing at typeWord 0xAC: types below use the 16-byte
+  // ctor record (renderable world objects) and types at or above use the
+  // 24-byte dispatch-root record (spawners, triggers, NPCs, UI panels) and
+  // typically have no sprite art at all. Without this guard the
+  // `bundles[typeWord]` fallback below picks an arbitrary bundle by raw scan
+  // order and produces wildly wrong sprites (e.g. invisible spawners
+  // rendered as brick walls / turrets / teleporters). The viewer still gets
+  // a placeholder so these entities remain inspectable.
+  // Cross-ref `/memories/repo/psx-typeword-renderable-boundary-2026-04-19.md`.
+  if (record.sourceFamily === 'section0_dispatch_roots' && record.typeWord >= 0xAC) {
+    return { bundle: null, mappingSource: 'placeholder-dispatch-root-high-typeword', runtimeBinding: null, placeholder: true };
+  }
+
   const rawTypeBundle = chooseBundleForType(bundles, record.typeWord);
   if (!rawTypeBundle) {
     return null;
@@ -1093,7 +1108,11 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
   //   0x000d84f4 - portrait/talk panel (already known)
   //   0x00074f44 - type 0xAC (172) full-screen UI panel, 216x126, kind-4
   //                mode-2; user-confirmed as the lone "TAC:b4f44" leak.
-  const nonMapFacingBundleOffsets = new Set([0x000d84f4, 0x00074f44]);
+  //   0x00086810 - "ceiling" tile (T0x43, kind-5 mode-2, 128x65). Engine uses
+  //                it at runtime to temporarily obscure rooms the player has
+  //                not entered yet; for static map rendering it just hides
+  //                the geometry the user wants to see, so it is suppressed.
+  const nonMapFacingBundleOffsets = new Set([0x000d84f4, 0x00074f44, 0x00086810]);
   for (const record of records) {
     if (record.sourceFamily === 'section0_dispatch_roots' && nonMapFacingRootTypes.has(record.typeWord)) {
       skippedRecords.push({
@@ -1107,7 +1126,62 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
 
     const binding = chooseBundleBinding(record, bundles, options);
     const bundle = binding?.bundle ?? null;
-    if (!bundle || !binding) {
+    if (!binding) {
+      continue;
+    }
+    if (binding.placeholder) {
+      // Non-renderable entity (spawner, trigger, NPC, UI marker). Emit a small
+      // square footprint so the viewer can still display and inspect it.
+      const PLACEHOLDER_SIZE = 12;
+      items.push({
+        id: record.index,
+        instanceId: record.index,
+        recordIndex: record.index,
+        recordSource: record.source,
+        sourceFamily: record.sourceFamily,
+        authoredLayer: record.authoredLayer ?? record.sourceRole ?? null,
+        recordSide: record.recordSide,
+        rowIndex: record.rowIndex,
+        typeWord: record.typeWord,
+        laneWord: record.laneWord,
+        worldX: record.xWord ?? null,
+        worldY: record.yWord ?? null,
+        worldZ: record.zWord ?? null,
+        screenX: record.screenX,
+        screenY: record.screenY,
+        bundleSlot: null,
+        bundleAbsoluteOffset: null,
+        bundleSource: null,
+        requestedFrameIndex: record.selectorWord,
+        frameIndex: null,
+        defaultPaletteIndex: null,
+        resolvedPaletteIndex: null,
+        paletteFormula: null,
+        mappingSource: binding.mappingSource,
+        templateTypeId: null,
+        donorTypeId: null,
+        runtimeBindingMaskedAbsoluteOffset: null,
+        runtimeBindingOffsetDelta: null,
+        runtimeBindingVisibleCount: null,
+        runtimeBindingRawRecordCount: null,
+        rawWords: record.rawWords ?? record.words,
+        flipped: false,
+        width: PLACEHOLDER_SIZE,
+        height: PLACEHOLDER_SIZE,
+        originX: PLACEHOLDER_SIZE / 2,
+        originY: PLACEHOLDER_SIZE / 2,
+        drawX: record.screenX - PLACEHOLDER_SIZE / 2,
+        drawY: record.screenY - PLACEHOLDER_SIZE / 2,
+        stage: 1, // overlays so placeholders sit on top of geometry
+        isFlat: false,
+        resourceKey: 'placeholder',
+        paletteDiagnostics: null,
+        sprite: null,
+        placeholder: true,
+      });
+      continue;
+    }
+    if (!bundle) {
       continue;
     }
     if (nonMapFacingBundleOffsets.has(bundle.absoluteOffset)) {
@@ -1171,9 +1245,27 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
       height: sprite.height,
       originX: sprite.originX,
       originY: sprite.originY,
-      drawX: record.screenX - sprite.originX,
+      // Engine-accurate anchor selection per psx_project_object_main_visible
+      // (0x80040d44 / 0x80040ddc): when laneWord bit 0x0002 is set the engine
+      // mirrors the horizontal anchor from origin_x to (frame_w - origin_x).
+      // The blit step then flips the sprite. Applying both keeps the visible
+      // anchor on the same world point, fixing flipped walls that previously
+      // landed (frame_w - 2*origin_x) px too far left.
+      drawX: ((record.laneWord & 0x0002) !== 0)
+        ? record.screenX - (sprite.width - sprite.originX)
+        : record.screenX - sprite.originX,
       drawY: record.screenY - sprite.originY,
       stage: record.typeWord === 4 || (record.laneWord & 0x0400) !== 0 ? 1 : 0,
+      // Heuristic: flat floor/ceiling decals are tile-sized sprites whose
+      // anchor sits at the bottom edge AND whose silhouette is wider than
+      // tall (i.e. matches the engine's 2:1 isometric ground footprint).
+      // Upright sprites (walls, crates, terminals, props) extend well above
+      // the anchor and have height >= width.
+      isFlat:
+        sprite.width >= 48 &&
+        sprite.height > 0 &&
+        sprite.height / sprite.width <= 0.6 &&
+        sprite.originY >= sprite.height - 4,
       resourceKey,
       paletteDiagnostics: derivePaletteDiagnostics(record, bundle),
       sprite,
@@ -1183,18 +1275,23 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
   // Painter's order for an isometric top-down full-map render.
   // 1. `stage`: runtime sub-stage flag (0 = default, 1 = overlays flagged via
   //    typeWord===4 or laneWord bit 0x0400). Overlays always on top.
-  // 2. `authoredLayer`: `constructors` is the static geometry lane (walls,
-  //    floors, architecture placed by `psx_dispatch_section0_constructor_placements`).
-  //    `roots` is the dispatch-root lane — interactive/dynamic objects such as
-  //    crates, terminals, doors, pickups placed by
-  //    `psx_dispatch_section0_dispatch_roots`. Geometry draws first so that
-  //    props (roots) sit ON TOP of the room they occupy.
-  // 3. Isometric depth within a layer: back-to-front by world `X + Y` (ground
-  //    depth along the engine's isometric axis), then by `Z` ascending so a
-  //    lower object at the same ground cell does not occlude a taller one
-  //    behind it. Falls back to screenY when world coords are unavailable.
-  // 4. `screenX` ascending: stable tie-breaker left-to-right.
-  const layerPriority = (item) => {
+  // 2. Isometric depth: back-to-front by world `X + Y` (ground depth along the
+  //    engine's isometric axis). Constructors (static geometry: walls, floors,
+  //    architecture) and roots (dynamic props: crates, terminals, doors) are
+  //    interleaved by depth so a crate placed in front of a wall does not get
+  //    painted over by a wall placed further back. Falls back to screenY when
+  //    world coords are unavailable.
+  // 3. `isFlat`: at the SAME depth, flat ground decals (floor/ceiling tiles)
+  //    must draw BEFORE upright sprites (walls, crates, props) so the props
+  //    standing on the tile sit visually on top of it. Without this bias,
+  //    floors painted on the same world tile as a prop will overpaint the
+  //    prop whenever screenX happens to sort the floor last.
+  // 4. `worldZ` ascending: lower objects at the same ground cell draw before
+  //    taller ones at that cell.
+  // 5. `authoredLayer`: when world coords + flatness tie, draw constructors
+  //    (geometry) before roots (props) so props sit on top of their floor.
+  // 6. `screenX` ascending: stable tie-breaker left-to-right.
+  const layerTieBreak = (item) => {
     if (item.authoredLayer === 'constructors') return 0;
     if (item.authoredLayer === 'roots') return 1;
     return 2;
@@ -1209,10 +1306,13 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
     if (left.stage !== right.stage) {
       return left.stage - right.stage;
     }
-    const leftLayer = layerPriority(left);
-    const rightLayer = layerPriority(right);
-    if (leftLayer !== rightLayer) {
-      return leftLayer - rightLayer;
+    // Two-pass painter: ALL flat ground decals first (back-to-front by depth),
+    // then ALL upright sprites (back-to-front by depth). This avoids the
+    // floor-anchor problem where a flat tile's authored anchor sits at its
+    // FRONT tip (largest world X+Y in the footprint), which a single-pass
+    // depth sort would draw AFTER walls/props that visually stand on it.
+    if (left.isFlat !== right.isFlat) {
+      return left.isFlat ? -1 : 1;
     }
     const leftDepth = depthKey(left);
     const rightDepth = depthKey(right);
@@ -1224,6 +1324,11 @@ async function buildSceneItems(region04, records, bundles, options = {}) {
     if (leftZ !== rightZ) {
       return leftZ - rightZ;
     }
+    const leftLayer = layerTieBreak(left);
+    const rightLayer = layerTieBreak(right);
+    if (leftLayer !== rightLayer) {
+      return leftLayer - rightLayer;
+    }
     return left.screenX - right.screenX;
   });
 
@@ -1283,13 +1388,19 @@ export async function exportMap(options) {
   const cacheBaseRoot = path.join(options.projectRoot, '.cache');
   const cacheRoot = path.join(options.projectRoot, '.cache', mapStem);
   const spriteRoot = path.join(cacheRoot, 'sprites');
-  const outputRoot = path.join(options.projectRoot, '.output');
+  const outputRoot = options.outputRoot
+    ? path.resolve(options.outputRoot)
+    : path.join(options.projectRoot, '.output');
 
   await ensureDirectory(cacheBaseRoot);
   await resetDirectory(cacheRoot);
   await ensureDirectory(cacheRoot);
   await ensureDirectory(spriteRoot);
-  await resetDirectory(outputRoot);
+  if (options.resetOutputRoot === false) {
+    await ensureDirectory(outputRoot);
+  } else {
+    await resetDirectory(outputRoot);
+  }
 
   const recordSet = chooseRecordSet(wdl, options.mapSource);
   const region04 = wdl.regions.find((region) => region.name === 'post_audio_region_04');
@@ -1446,6 +1557,9 @@ export async function exportMap(options) {
       rawWords: item.rawWords,
       typeWord: item.typeWord,
       laneWord: item.laneWord,
+      worldX: item.worldX ?? null,
+      worldY: item.worldY ?? null,
+      worldZ: item.worldZ ?? null,
       screenX: item.screenX,
       screenY: item.screenY,
       bundleSlot: item.bundleSlot,
@@ -1478,6 +1592,7 @@ export async function exportMap(options) {
       originX: item.originX,
       originY: item.originY,
       stage: item.stage,
+      placeholder: item.placeholder === true,
     })),
   };
 
diff --git a/psx-map-exporter/src/render.js b/psx-map-exporter/src/render.js
index b163a0c..44608a1 100644
--- a/psx-map-exporter/src/render.js
+++ b/psx-map-exporter/src/render.js
@@ -139,12 +139,68 @@ function blitRgba(canvas, canvasWidth, canvasHeight, sprite, dstX, dstY, flipped
   }
 }
 
+// Magenta diamond marker for placeholder (non-renderable) entities such as
+// spawners, triggers, NPCs, and UI panels. Drawn in place of a sprite blit so
+// the viewer still surfaces the entity for inspection without guessing wrong
+// art. The diamond is 12x12 by default (caller passes the placeholder width).
+function drawPlaceholderMarker(canvas, canvasWidth, canvasHeight, dstX, dstY, w, h) {
+  const half = Math.max(2, Math.floor(Math.min(w, h) / 2));
+  const cx = Math.round(dstX + w / 2);
+  const cy = Math.round(dstY + h / 2);
+  // Filled diamond by scanline.
+  for (let dy = -half; dy <= half; dy += 1) {
+    const span = half - Math.abs(dy);
+    const y = cy + dy;
+    if (y < 0 || y >= canvasHeight) continue;
+    for (let dx = -span; dx <= span; dx += 1) {
+      const x = cx + dx;
+      if (x < 0 || x >= canvasWidth) continue;
+      // Magenta interior with darker outline on the diamond edge.
+      const onEdge = Math.abs(dx) + Math.abs(dy) === half;
+      const target = ((y * canvasWidth) + x) * 4;
+      canvas[target + 0] = onEdge ? 90 : 220;
+      canvas[target + 1] = onEdge ? 0 : 60;
+      canvas[target + 2] = onEdge ? 110 : 200;
+      canvas[target + 3] = 255;
+    }
+  }
+}
+
 export function renderMap(items, options = {}) {
   if (items.length === 0) {
     throw new Error('No renderable scene items were produced.');
   }
 
-  const bounds = items.reduce(
+  // Guard against a single bad item (e.g. corrupt sprite origin) inflating the
+  // canvas to multiple gigabytes. We compute the median centroid of all items
+  // and drop anything farther than MAX_EXTENT px from it before computing
+  // bounds. This keeps render output sane even if the parser produces a few
+  // outliers, while preserving every real authored item (the playfield is
+  // never larger than a few thousand pixels in either axis).
+  const MAX_EXTENT = 4096;
+  const centroids = items.map((it) => ({ x: it.drawX + (it.width ?? 0) / 2, y: it.drawY + (it.height ?? 0) / 2 }));
+  const sortedX = centroids.map((c) => c.x).sort((a, b) => a - b);
+  const sortedY = centroids.map((c) => c.y).sort((a, b) => a - b);
+  const medianX = sortedX[sortedX.length >> 1];
+  const medianY = sortedY[sortedY.length >> 1];
+  const droppedOutliers = [];
+  const visibleItems = items.filter((it, idx) => {
+    const dx = Math.abs(centroids[idx].x - medianX);
+    const dy = Math.abs(centroids[idx].y - medianY);
+    if (dx > MAX_EXTENT || dy > MAX_EXTENT) {
+      droppedOutliers.push({ recordIndex: it.recordIndex, typeWord: it.typeWord, drawX: it.drawX, drawY: it.drawY, dx, dy });
+      return false;
+    }
+    return true;
+  });
+  if (droppedOutliers.length > 0 && process.env.PSX_TRACE) {
+    console.error('[renderMap] dropped ' + droppedOutliers.length + ' outlier item(s) beyond ' + MAX_EXTENT + 'px from median; first: ' + JSON.stringify(droppedOutliers[0]));
+  }
+  if (visibleItems.length === 0) {
+    throw new Error('All scene items were classified as outliers; nothing to render.');
+  }
+
+  const bounds = visibleItems.reduce(
     (state, item) => ({
       minX: Math.min(state.minX, item.drawX),
       minY: Math.min(state.minY, item.drawY),
@@ -157,9 +213,27 @@ export function renderMap(items, options = {}) {
   const padding = 16;
   const width = Math.max(1, (bounds.maxX - bounds.minX) + (padding * 2));
   const height = Math.max(1, (bounds.maxY - bounds.minY) + (padding * 2));
+  if (process.env.PSX_TRACE) {
+    console.error('[renderMap] items=' + visibleItems.length + ' bounds=' + JSON.stringify(bounds) + ' size=' + width + 'x' + height);
+  }
   const canvas = clearCanvas(width, height, options.background ?? DEFAULT_BACKGROUND);
 
-  for (const item of items) {
+  for (const item of visibleItems) {
+    if (item.placeholder || !item.sprite) {
+      // Draw a small magenta diamond marker for non-renderable entities
+      // (spawners, triggers, NPCs). Keeps them visible and inspectable in
+      // the viewer overlay without guessing wrong art.
+      drawPlaceholderMarker(
+        canvas,
+        width,
+        height,
+        item.drawX - bounds.minX + padding,
+        item.drawY - bounds.minY + padding,
+        item.width,
+        item.height
+      );
+      continue;
+    }
     blitRgba(
       canvas,
       width,
@@ -179,7 +253,7 @@ export function renderMap(items, options = {}) {
     // on every tile and obscure surrounding art.
     const labelBudgetPerBundle = 10;
     const labelTally = new Map();
-    for (const item of items) {
+    for (const item of visibleItems) {
       const tallyKey = `${item.typeWord ?? '?'}|${item.bundleAbsoluteOffset ?? '?'}`;
       const used = labelTally.get(tallyKey) ?? 0;
       if (used >= labelBudgetPerBundle) {
@@ -210,6 +284,7 @@ export function renderMap(items, options = {}) {
     width,
     height,
     bounds,
+    droppedOutlierCount: droppedOutliers.length,
     png: encodePng(canvas, width, height),
   };
 }
diff --git a/psx-map-exporter/src/wdl.js b/psx-map-exporter/src/wdl.js
index 1df5ad8..162dedf 100644
--- a/psx-map-exporter/src/wdl.js
+++ b/psx-map-exporter/src/wdl.js
@@ -714,10 +714,14 @@ export function parseDispatchRootsBlock(block, variant = 'lset') {
     const typeWord = rawWords[2];
     const xWord = rawWords[4];
     const yWord = rawWords[5];
-    // Dispatch roots do not carry a Z byte at a well-known offset; they are
-    // treated as floor-plane (Z=0) until a Z field is recovered from the
-    // descriptor's slot0 callback.
-    const zWord = 0;
+    // Engine reads Z from the LOW byte of the u16 at +0x06 of the shared
+    // authored prefix (constructor view), even when the record is iterated
+    // through the dispatcher view. Confirmed via psx_object_create_compound_record
+    // @ 0x80024eec (memory note psx-coordinate-decode-2026-04-18.md). The HIGH
+    // byte of the same u16 is a palette-override token, NOT a Z extension.
+    // The constructor-view u16 at +0x06 lives at rawWords[3] in this 12-u16
+    // expansion of the 24-byte dispatch-root record.
+    const zWord = rawWords[3] & 0xff;
     const selectorWord = rawWords[6];
     const laneWord = rawWords[7];
     if (typeWord < 0x20 || typeWord > 0x1ff) {
diff --git a/psx-map-exporter/viewer/index.html b/psx-map-exporter/viewer/index.html
new file mode 100644
index 0000000..08251b9
--- /dev/null
+++ b/psx-map-exporter/viewer/index.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>PSX Map Debug Viewer</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
diff --git a/psx-map-exporter/viewer/package-lock.json b/psx-map-exporter/viewer/package-lock.json
new file mode 100644
index 0000000..634f0dc
--- /dev/null
+++ b/psx-map-exporter/viewer/package-lock.json
@@ -0,0 +1,1207 @@
+{
+  "name": "psx-map-debug-viewer",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "psx-map-debug-viewer",
+      "version": "0.0.0",
+      "dependencies": {
+        "vue": "^3.4.0"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-vue": "^5.0.0",
+        "vite": "^5.4.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.1.tgz",
+      "integrity": "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.1.tgz",
+      "integrity": "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.1.tgz",
+      "integrity": "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.1.tgz",
+      "integrity": "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.1.tgz",
+      "integrity": "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.1.tgz",
+      "integrity": "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.1.tgz",
+      "integrity": "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.1.tgz",
+      "integrity": "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.1.tgz",
+      "integrity": "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.1.tgz",
+      "integrity": "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.1.tgz",
+      "integrity": "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.1.tgz",
+      "integrity": "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.1.tgz",
+      "integrity": "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.1.tgz",
+      "integrity": "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.1.tgz",
+      "integrity": "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.1.tgz",
+      "integrity": "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.1.tgz",
+      "integrity": "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.1.tgz",
+      "integrity": "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.1.tgz",
+      "integrity": "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.1.tgz",
+      "integrity": "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.1.tgz",
+      "integrity": "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.1.tgz",
+      "integrity": "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.1.tgz",
+      "integrity": "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.1.tgz",
+      "integrity": "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.1.tgz",
+      "integrity": "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.32.tgz",
+      "integrity": "sha512-4x74Tbtqnda8s/NSD6e1Dr5p1c8HdMU5RWSjMSUzb8RTcUQqevDCxVAitcLBKT+ie3o0Dl9crc/S/opJM7qBGQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.2",
+        "@vue/shared": "3.5.32",
+        "entities": "^7.0.1",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.32.tgz",
+      "integrity": "sha512-ybHAu70NtiEI1fvAUz3oXZqkUYEe5J98GjMDpTGl5iHb0T15wQYLR4wE3h9xfuTNA+Cm2f4czfe8B4s+CCH57Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-core": "3.5.32",
+        "@vue/shared": "3.5.32"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.32.tgz",
+      "integrity": "sha512-8UYUYo71cP/0YHMO814TRZlPuUUw3oifHuMR7Wp9SNoRSrxRQnhMLNlCeaODNn6kNTJsjFoQ/kqIj4qGvya4Xg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.2",
+        "@vue/compiler-core": "3.5.32",
+        "@vue/compiler-dom": "3.5.32",
+        "@vue/compiler-ssr": "3.5.32",
+        "@vue/shared": "3.5.32",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.21",
+        "postcss": "^8.5.8",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.32.tgz",
+      "integrity": "sha512-Gp4gTs22T3DgRotZ8aA/6m2jMR+GMztvBXUBEUOYOcST+giyGWJ4WvFd7QLHBkzTxkfOt8IELKNdpzITLbA2rw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.32",
+        "@vue/shared": "3.5.32"
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.32.tgz",
+      "integrity": "sha512-/ORasxSGvZ6MN5gc+uE364SxFdJ0+WqVG0CENXaGW58TOCdrAW76WWaplDtECeS1qphvtBZtR+3/o1g1zL4xPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/shared": "3.5.32"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.32.tgz",
+      "integrity": "sha512-pDrXCejn4UpFDFmMd27AcJEbHaLemaE5o4pbb7sLk79SRIhc6/t34BQA7SGNgYtbMnvbF/HHOftYBgFJtUoJUQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.32",
+        "@vue/shared": "3.5.32"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.32.tgz",
+      "integrity": "sha512-1CDVv7tv/IV13V8Nip1k/aaObVbWqRlVCVezTwx3K07p7Vxossp5JU1dcPNhJk3w347gonIUT9jQOGutyJrSVQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.32",
+        "@vue/runtime-core": "3.5.32",
+        "@vue/shared": "3.5.32",
+        "csstype": "^3.2.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.32.tgz",
+      "integrity": "sha512-IOjm2+JQwRFS7W28HNuJeXQle9KdZbODFY7hFGVtnnghF51ta20EWAZJHX+zLGtsHhaU6uC9BGPV52KVpYryMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.32",
+        "@vue/shared": "3.5.32"
+      },
+      "peerDependencies": {
+        "vue": "3.5.32"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.32.tgz",
+      "integrity": "sha512-ksNyrmRQzWJJ8n3cRDuSF7zNNontuJg1YHnmWRJd2AMu8Ij2bqwiiri2lH5rHtYPZjj4STkNcgcmiQqlOjiYGg==",
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT"
+    },
+    "node_modules/entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "license": "MIT"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.10",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.10.tgz",
+      "integrity": "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz",
+      "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.1",
+        "@rollup/rollup-android-arm64": "4.60.1",
+        "@rollup/rollup-darwin-arm64": "4.60.1",
+        "@rollup/rollup-darwin-x64": "4.60.1",
+        "@rollup/rollup-freebsd-arm64": "4.60.1",
+        "@rollup/rollup-freebsd-x64": "4.60.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.1",
+        "@rollup/rollup-linux-arm64-musl": "4.60.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.1",
+        "@rollup/rollup-linux-loong64-musl": "4.60.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.1",
+        "@rollup/rollup-linux-x64-gnu": "4.60.1",
+        "@rollup/rollup-linux-x64-musl": "4.60.1",
+        "@rollup/rollup-openbsd-x64": "4.60.1",
+        "@rollup/rollup-openharmony-arm64": "4.60.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.1",
+        "@rollup/rollup-win32-x64-gnu": "4.60.1",
+        "@rollup/rollup-win32-x64-msvc": "4.60.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue": {
+      "version": "3.5.32",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.32.tgz",
+      "integrity": "sha512-vM4z4Q9tTafVfMAK7IVzmxg34rSzTFMyIe0UUEijUCkn9+23lj0WRfA83dg7eQZIUlgOSGrkViIaCfqSAUXsMw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.32",
+        "@vue/compiler-sfc": "3.5.32",
+        "@vue/runtime-dom": "3.5.32",
+        "@vue/server-renderer": "3.5.32",
+        "@vue/shared": "3.5.32"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    }
+  }
+}
diff --git a/psx-map-exporter/viewer/package.json b/psx-map-exporter/viewer/package.json
new file mode 100644
index 0000000..61bd95d
--- /dev/null
+++ b/psx-map-exporter/viewer/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "psx-map-debug-viewer",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "vue": "^3.4.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.0.0",
+    "vite": "^5.4.0"
+  }
+}
diff --git a/psx-map-exporter/viewer/src/App.vue b/psx-map-exporter/viewer/src/App.vue
new file mode 100644
index 0000000..c6f6a2a
--- /dev/null
+++ b/psx-map-exporter/viewer/src/App.vue
@@ -0,0 +1,424 @@
+<script setup>
+import { computed, onMounted, ref, shallowRef, watch } from 'vue';
+import ItemPanel from './ItemPanel.vue';
+
+const PADDING = 16;
+
+const indexData = ref(null);
+const indexError = ref(null);
+const selectedMap = ref(null);
+const selectedVariant = ref(null);
+const scene = shallowRef(null);
+const sceneError = ref(null);
+const loading = ref(false);
+
+const imageRef = ref(null);
+const containerRef = ref(null);
+const imageNaturalWidth = ref(0);
+const imageNaturalHeight = ref(0);
+
+const zoom = ref(1);
+const pan = ref({ x: 0, y: 0 });
+const dragging = ref(null);
+
+const showHitboxes = ref(true);
+const showOnlyLayer = ref('all');
+const filterTypeHex = ref('');
+const filterBundleHex = ref('');
+
+const hovered = shallowRef(null);
+const selected = shallowRef(null);
+// Set of recordIndex values the user has manually hidden via shift+click. We
+// rebuild the visible item list against this set so painted sprites and SVG
+// hitboxes both disappear together. Hidden items are restored via the
+// "Show hidden" button or by selecting them in the unfiltered "Hidden list".
+const hiddenIds = ref(new Set());
+const hiddenList = computed(() => {
+  if (!scene.value || hiddenIds.value.size === 0) return [];
+  return scene.value.json.items.filter((it) => hiddenIds.value.has(it.recordIndex));
+});
+
+function hideItem(item) {
+  if (!item || !Number.isInteger(item.recordIndex)) return;
+  const next = new Set(hiddenIds.value);
+  next.add(item.recordIndex);
+  hiddenIds.value = next;
+  if (selected.value?.recordIndex === item.recordIndex) selected.value = null;
+}
+function unhideItem(item) {
+  if (!item || !Number.isInteger(item.recordIndex)) return;
+  const next = new Set(hiddenIds.value);
+  next.delete(item.recordIndex);
+  hiddenIds.value = next;
+}
+function clearHidden() { hiddenIds.value = new Set(); }
+
+async function loadIndex() {
+  try {
+    const res = await fetch('/api/index');
+    if (!res.ok) throw new Error('Index HTTP ' + res.status);
+    indexData.value = await res.json();
+  } catch (error) {
+    indexError.value = error.message;
+  }
+}
+
+const mapList = computed(() => {
+  if (!indexData.value) return [];
+  const seen = new Set();
+  const list = [];
+  for (const entry of indexData.value.maps) {
+    if (entry.error) continue;
+    if (seen.has(entry.map)) continue;
+    seen.add(entry.map);
+    list.push(entry.map);
+  }
+  return list;
+});
+
+const variantList = computed(() => indexData.value?.variants ?? []);
+
+watch(mapList, (list) => {
+  if (!selectedMap.value && list.length) selectedMap.value = list[0];
+});
+watch(variantList, (list) => {
+  if (!selectedVariant.value && list.length) selectedVariant.value = list[0];
+});
+
+async function loadScene() {
+  if (!selectedMap.value || !selectedVariant.value) return;
+  loading.value = true;
+  sceneError.value = null;
+  scene.value = null;
+  selected.value = null;
+  hovered.value = null;
+  try {
+    const base = `/render/${selectedMap.value}/${selectedVariant.value}/${selectedMap.value}`;
+    const json = await fetch(`${base}.json`).then((r) => {
+      if (!r.ok) throw new Error('Scene JSON HTTP ' + r.status);
+      return r.json();
+    });
+    scene.value = {
+      json,
+      pngUrl: `${base}.png`,
+      labelsPngUrl: `${base}_labels.png`,
+    };
+  } catch (error) {
+    sceneError.value = error.message;
+  } finally {
+    loading.value = false;
+  }
+}
+
+watch([selectedMap, selectedVariant], loadScene);
+
+function onImageLoad() {
+  if (!imageRef.value) return;
+  imageNaturalWidth.value = imageRef.value.naturalWidth;
+  imageNaturalHeight.value = imageRef.value.naturalHeight;
+  fitToContainer();
+}
+
+function fitToContainer() {
+  if (!containerRef.value || !imageNaturalWidth.value) return;
+  const c = containerRef.value.getBoundingClientRect();
+  const sx = c.width / imageNaturalWidth.value;
+  const sy = c.height / imageNaturalHeight.value;
+  const z = Math.min(sx, sy) * 0.95;
+  pan.value = {
+    x: (c.width - imageNaturalWidth.value * z) / 2,
+    y: (c.height - imageNaturalHeight.value * z) / 2,
+  };
+  zoom.value = z;
+}
+
+function onWheel(event) {
+  if (!containerRef.value) return;
+  event.preventDefault();
+  const rect = containerRef.value.getBoundingClientRect();
+  const mx = event.clientX - rect.left;
+  const my = event.clientY - rect.top;
+  const factor = event.deltaY < 0 ? 1.15 : 1 / 1.15;
+  const newZoom = Math.max(0.05, Math.min(16, zoom.value * factor));
+  pan.value = {
+    x: mx - (mx - pan.value.x) * (newZoom / zoom.value),
+    y: my - (my - pan.value.y) * (newZoom / zoom.value),
+  };
+  zoom.value = newZoom;
+}
+
+function onMouseDown(event) {
+  if (event.button !== 0 && event.button !== 1) return;
+  dragging.value = { x: event.clientX, y: event.clientY, startPan: { ...pan.value }, moved: false };
+}
+function onMouseMove(event) {
+  if (dragging.value) {
+    const dx = event.clientX - dragging.value.x;
+    const dy = event.clientY - dragging.value.y;
+    if (Math.abs(dx) + Math.abs(dy) > 3) dragging.value.moved = true;
+    pan.value = {
+      x: dragging.value.startPan.x + dx,
+      y: dragging.value.startPan.y + dy,
+    };
+    return;
+  }
+  if (!scene.value || !containerRef.value) return;
+  const rect = containerRef.value.getBoundingClientRect();
+  const px = (event.clientX - rect.left - pan.value.x) / zoom.value;
+  const py = (event.clientY - rect.top - pan.value.y) / zoom.value;
+  hovered.value = pickItem(px, py);
+}
+function onMouseUp() { dragging.value = null; }
+function onMouseLeave() { dragging.value = null; hovered.value = null; }
+
+function onClick(event) {
+  if (dragging.value?.moved) return;
+  if (!scene.value || !containerRef.value) return;
+  const rect = containerRef.value.getBoundingClientRect();
+  const px = (event.clientX - rect.left - pan.value.x) / zoom.value;
+  const py = (event.clientY - rect.top - pan.value.y) / zoom.value;
+  const item = pickItem(px, py);
+  // Shift+click hides the picked item (overlay rect AND painted sprite still
+  // shows since the .png is baked, but the SVG hitbox vanishes so you can
+  // click through to whatever is underneath; combine with the hidden list
+  // panel to restore visibility).
+  if (event.shiftKey && item) {
+    hideItem(item);
+    return;
+  }
+  selected.value = item;
+}
+
+function itemPixelRect(item) {
+  const b = scene.value.json.bounds;
+  return {
+    x: (item.drawX - b.minX) + PADDING,
+    y: (item.drawY - b.minY) + PADDING,
+    w: item.width,
+    h: item.height,
+  };
+}
+
+function visibleItems() {
+  if (!scene.value) return [];
+  let items = scene.value.json.items;
+  if (hiddenIds.value.size) {
+    items = items.filter((it) => !hiddenIds.value.has(it.recordIndex));
+  }
+  if (showOnlyLayer.value !== 'all') {
+    items = items.filter((it) => (it.authoredLayer ?? 'unknown') === showOnlyLayer.value);
+  }
+  if (filterTypeHex.value.trim()) {
+    const t = parseInt(filterTypeHex.value, 16);
+    if (Number.isFinite(t)) items = items.filter((it) => it.typeWord === t);
+  }
+  if (filterBundleHex.value.trim()) {
+    const b = parseInt(filterBundleHex.value, 16);
+    if (Number.isFinite(b)) items = items.filter((it) => it.bundleAbsoluteOffset === b);
+  }
+  return items;
+}
+
+function pickItem(px, py) {
+  if (!scene.value) return null;
+  const items = visibleItems();
+  for (let i = items.length - 1; i >= 0; i -= 1) {
+    const it = items[i];
+    const r = itemPixelRect(it);
+    if (px >= r.x && py >= r.y && px <= r.x + r.w && py <= r.y + r.h) {
+      return it;
+    }
+  }
+  return null;
+}
+
+const layerOptions = computed(() => {
+  if (!scene.value) return ['all'];
+  const set = new Set(['all']);
+  for (const it of scene.value.json.items) set.add(it.authoredLayer ?? 'unknown');
+  return [...set];
+});
+
+const visibleCount = computed(() => visibleItems().length);
+
+const transformStyle = computed(() => ({
+  transform: `translate(${pan.value.x}px, ${pan.value.y}px) scale(${zoom.value})`,
+  transformOrigin: '0 0',
+}));
+
+const overlayBoxes = computed(() => {
+  if (!scene.value || !showHitboxes.value) return [];
+  return visibleItems().map((it) => ({ item: it, rect: itemPixelRect(it) }));
+});
+
+// Black-out rects for shift+click-hidden items: the rendered .png is baked,
+// so we paint an opaque rectangle over each hidden sprite using the same
+// background colour the renderer used (DEFAULT_BACKGROUND in render.js =
+// rgb(18,18,18)). This lets the user see whatever real sprite lives behind
+// the obscuring one without re-running the exporter.
+const hiddenMasks = computed(() => {
+  if (!scene.value || hiddenIds.value.size === 0) return [];
+  return scene.value.json.items
+    .filter((it) => hiddenIds.value.has(it.recordIndex))
+    .map((it) => ({ item: it, rect: itemPixelRect(it) }));
+});
+
+function strokeFor(item) {
+  if (item === selected.value) return '#4ea1ff';
+  if (item === hovered.value) return '#ffb24a';
+  if (item.placeholder) return 'rgba(220, 80, 220, 0.6)';
+  return 'rgba(255,255,255,0.13)';
+}
+function strokeWidthFor(item) {
+  return (item === selected.value || item === hovered.value) ? 2 : 1;
+}
+function reset11() { zoom.value = 1; pan.value = { x: 0, y: 0 }; }
+
+onMounted(loadIndex);
+</script>
+
+<template>
+  <div class="app">
+    <header class="topbar">
+      <div class="title">PSX Map Debug Viewer</div>
+      <label>Map
+        <select v-model="selectedMap">
+          <option v-for="m in mapList" :key="m" :value="m">{{ m }}</option>
+        </select>
+      </label>
+      <label>Variant
+        <select v-model="selectedVariant">
+          <option v-for="v in variantList" :key="v" :value="v">{{ v }}</option>
+        </select>
+      </label>
+      <label>Layer
+        <select v-model="showOnlyLayer">
+          <option v-for="l in layerOptions" :key="l" :value="l">{{ l }}</option>
+        </select>
+      </label>
+      <label>typeWord <input v-model="filterTypeHex" placeholder="hex" size="6" /></label>
+      <label>bundle <input v-model="filterBundleHex" placeholder="hex" size="8" /></label>
+      <label class="check"><input type="checkbox" v-model="showHitboxes" /> hitboxes</label>
+      <button @click="fitToContainer">Fit</button>
+      <button @click="reset11">1:1</button>
+      <button v-if="hiddenIds.size" @click="clearHidden" title="Restore all shift+click-hidden items">Show hidden ({{ hiddenIds.size }})</button>
+      <span class="muted">visible: {{ visibleCount }} · zoom {{ zoom.toFixed(2) }}× · shift+click to hide</span>
+    </header>
+
+    <main class="layout">
+      <section
+        class="canvas"
+        ref="containerRef"
+        @wheel="onWheel"
+        @mousedown="onMouseDown"
+        @mousemove="onMouseMove"
+        @mouseup="onMouseUp"
+        @mouseleave="onMouseLeave"
+        @click="onClick"
+      >
+        <div v-if="indexError" class="error">Index error: {{ indexError }}</div>
+        <div v-else-if="sceneError" class="error">{{ sceneError }}</div>
+        <div v-else-if="loading" class="muted center">Loading…</div>
+        <div v-else-if="scene" class="stage" :style="transformStyle">
+          <img
+            ref="imageRef"
+            :src="scene.pngUrl"
+            @load="onImageLoad"
+            draggable="false"
+            class="map-img"
+          />
+          <svg
+            v-if="imageNaturalWidth"
+            class="overlay"
+            :width="imageNaturalWidth"
+            :height="imageNaturalHeight"
+            :viewBox="`0 0 ${imageNaturalWidth} ${imageNaturalHeight}`"
+          >
+            <rect
+              v-for="entry in hiddenMasks"
+              :key="'mask-' + entry.item.recordIndex"
+              :x="entry.rect.x"
+              :y="entry.rect.y"
+              :width="entry.rect.w"
+              :height="entry.rect.h"
+              fill="rgb(18,18,18)"
+              stroke="rgba(255, 80, 80, 0.6)"
+              stroke-width="1"
+              vector-effect="non-scaling-stroke"
+              stroke-dasharray="4 2"
+            />
+            <rect
+              v-for="entry in overlayBoxes"
+              :key="entry.item.recordIndex"
+              :x="entry.rect.x"
+              :y="entry.rect.y"
+              :width="entry.rect.w"
+              :height="entry.rect.h"
+              fill="none"
+              :stroke="strokeFor(entry.item)"
+              :stroke-width="strokeWidthFor(entry.item)"
+              vector-effect="non-scaling-stroke"
+            />
+          </svg>
+        </div>
+      </section>
+
+      <aside class="sidebar">
+        <h3>Hover</h3>
+        <ItemPanel :item="hovered" :map-stem="selectedMap" />
+        <h3>Selected
+          <button v-if="selected" class="mini" @click="hideItem(selected)">hide</button>
+        </h3>
+        <ItemPanel :item="selected" :map-stem="selectedMap" :show-copy="true" />
+        <template v-if="hiddenList.length">
+          <h3>Hidden ({{ hiddenList.length }})
+            <button class="mini" @click="clearHidden">restore all</button>
+          </h3>
+          <ul class="hidden-list">
+            <li v-for="it in hiddenList" :key="it.recordIndex">
+              #{{ it.recordIndex }} t0x{{ it.typeWord.toString(16) }} {{ it.authoredLayer }}
+              <button class="mini" @click="unhideItem(it)">show</button>
+            </li>
+          </ul>
+        </template>
+      </aside>
+    </main>
+  </div>
+</template>
+
+<style scoped>
+.app { display: flex; flex-direction: column; height: 100vh; }
+.topbar {
+  display: flex; gap: 12px; align-items: center;
+  padding: 8px 12px; background: var(--panel); border-bottom: 1px solid var(--border);
+  flex-wrap: wrap;
+}
+.topbar label { display: flex; gap: 4px; align-items: center; font-size: 13px; color: var(--muted); }
+.topbar label.check { color: var(--text); }
+.topbar input { background: var(--panel-2); color: var(--text); border: 1px solid var(--border); border-radius: 4px; padding: 3px 6px; }
+.title { font-weight: bold; margin-right: 12px; }
+.muted { color: var(--muted); font-size: 12px; }
+
+.layout { display: flex; flex: 1; min-height: 0; }
+.canvas {
+  flex: 1; position: relative; overflow: hidden;
+  background: #0a0a0a;
+  cursor: grab;
+}
+.canvas:active { cursor: grabbing; }
+.stage { position: absolute; top: 0; left: 0; }
+.map-img { display: block; image-rendering: pixelated; user-select: none; -webkit-user-drag: none; }
+.overlay { position: absolute; top: 0; left: 0; pointer-events: none; }
+
+.sidebar {
+  width: 380px; background: var(--panel); border-left: 1px solid var(--border);
+  overflow: auto; padding: 12px;
+}
+.sidebar h3 { margin: 8px 0 4px; font-size: 12px; text-transform: uppercase; color: var(--muted); display: flex; align-items: center; gap: 6px; }
+.sidebar .mini { font-size: 10px; padding: 1px 6px; text-transform: none; }
+.hidden-list { list-style: none; padding: 0; margin: 0 0 8px; font-size: 11px; }
+.hidden-list li { display: flex; justify-content: space-between; align-items: center; padding: 2px 4px; border-bottom: 1px solid var(--border); }
+
+.error { color: #ff6b6b; padding: 16px; }
+.center { padding: 16px; }
+</style>
diff --git a/psx-map-exporter/viewer/src/ItemPanel.vue b/psx-map-exporter/viewer/src/ItemPanel.vue
new file mode 100644
index 0000000..1c7beca
--- /dev/null
+++ b/psx-map-exporter/viewer/src/ItemPanel.vue
@@ -0,0 +1,102 @@
+<script setup>
+import { computed } from 'vue';
+
+const props = defineProps({
+  item: { type: Object, default: null },
+  mapStem: { type: String, default: null },
+  showCopy: { type: Boolean, default: false },
+});
+
+function fmtHex(value, pad = 0) {
+  if (value === null || value === undefined) return '—';
+  const n = Number(value);
+  if (!Number.isFinite(n)) return String(value);
+  return '0x' + n.toString(16).padStart(pad, '0');
+}
+
+function copyJson() {
+  if (!props.item) return;
+  navigator.clipboard?.writeText(JSON.stringify(props.item, null, 2));
+}
+
+const rawWordsHex = computed(() => {
+  if (!props.item?.rawWords) return null;
+  return props.item.rawWords.map((w) => w.toString(16).padStart(4, '0')).join(' ');
+});
+
+// Sprite preview URL: matches the layout written by writeBundleCache and
+// served by vite.config.js /sprites middleware:
+//   /sprites/<mapStem>/bundle_<absoluteOffset:8x>/frame_<frameIndex:3d>.png
+const spriteUrl = computed(() => {
+  if (!props.item || !props.mapStem) return null;
+  const off = props.item.bundleAbsoluteOffset;
+  const frame = props.item.frameIndex;
+  if (!Number.isFinite(off) || !Number.isInteger(frame)) return null;
+  const offHex = off.toString(16).padStart(8, '0');
+  const frameStr = String(frame).padStart(3, '0');
+  return `/sprites/${props.mapStem}/bundle_${offHex}/frame_${frameStr}.png`;
+});
+</script>
+
+<template>
+  <div v-if="!item" class="muted">— nothing —</div>
+  <template v-else>
+    <div v-if="spriteUrl" class="preview">
+      <img :src="spriteUrl" :alt="`bundle ${fmtHex(item.bundleAbsoluteOffset, 8)} frame ${item.frameIndex}`" />
+      <div class="preview-caption">
+        bundle {{ fmtHex(item.bundleAbsoluteOffset, 8) }} · frame {{ item.frameIndex }}
+        · {{ item.width }}×{{ item.height }} (anchor {{ item.originX }},{{ item.originY }})
+      </div>
+    </div>
+    <table class="kv">
+      <tbody>
+        <tr><th>recordIndex</th><td>{{ item.recordIndex }}</td></tr>
+        <tr><th>instanceId</th><td>{{ item.instanceId }}</td></tr>
+        <tr><th>typeWord</th><td>{{ fmtHex(item.typeWord, 2) }} ({{ item.typeWord }})</td></tr>
+        <tr><th>laneWord</th><td>{{ fmtHex(item.laneWord, 4) }}</td></tr>
+        <tr><th>bundle abs offset</th><td>{{ fmtHex(item.bundleAbsoluteOffset, 8) }}</td></tr>
+        <tr><th>bundleSlot</th><td>{{ item.bundleSlot }}</td></tr>
+        <tr><th>bundleSource</th><td>{{ item.bundleSource }}</td></tr>
+        <tr><th>frameIndex</th><td>{{ item.frameIndex }} / req {{ item.requestedFrameIndex }}</td></tr>
+        <tr><th>palette</th><td>def {{ item.defaultPaletteIndex }} → res {{ item.resolvedPaletteIndex }} <span class="muted">({{ item.paletteFormula }})</span></td></tr>
+        <tr><th>mappingSource</th><td>{{ item.mappingSource }}</td></tr>
+        <tr><th>authoredLayer</th><td>{{ item.authoredLayer }}</td></tr>
+        <tr><th>sourceFamily</th><td>{{ item.sourceFamily }}</td></tr>
+        <tr><th>screen X,Y</th><td>{{ item.screenX }}, {{ item.screenY }}</td></tr>
+        <tr><th>world X,Y,Z</th><td>{{ item.worldX }}, {{ item.worldY }}, {{ item.worldZ }}</td></tr>
+        <tr><th>draw X,Y</th><td>{{ item.drawX }}, {{ item.drawY }}</td></tr>
+        <tr><th>size</th><td>{{ item.width }} × {{ item.height }} (origin {{ item.originX }},{{ item.originY }})</td></tr>
+        <tr><th>flipped</th><td>{{ item.flipped }}</td></tr>
+        <tr><th>stage</th><td>{{ item.stage }}</td></tr>
+        <tr v-if="rawWordsHex"><th>rawWords</th><td><code>{{ rawWordsHex }}</code></td></tr>
+      </tbody>
+    </table>
+    <button v-if="showCopy" @click="copyJson">Copy JSON</button>
+  </template>
+</template>
+
+<style scoped>
+.kv { width: 100%; border-collapse: collapse; }
+.kv th { text-align: left; color: var(--muted); font-weight: normal; padding: 2px 6px; vertical-align: top; width: 130px; font-size: 12px; }
+.kv td { padding: 2px 6px; word-break: break-all; font-size: 12px; }
+.kv code { font-size: 11px; }
+.muted { color: var(--muted); font-size: 12px; }
+button { margin-top: 6px; }
+.preview {
+  margin-bottom: 8px;
+  padding: 6px;
+  background: rgba(255, 255, 255, 0.04);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 4px;
+  text-align: center;
+}
+.preview img {
+  max-width: 100%;
+  max-height: 200px;
+  image-rendering: pixelated;
+  background:
+    linear-gradient(45deg, rgba(255,255,255,0.06) 25%, transparent 25%, transparent 75%, rgba(255,255,255,0.06) 75%) 0 0 / 16px 16px,
+    linear-gradient(45deg, rgba(255,255,255,0.06) 25%, transparent 25%, transparent 75%, rgba(255,255,255,0.06) 75%) 8px 8px / 16px 16px;
+}
+.preview-caption { font-size: 11px; color: var(--muted); margin-top: 4px; }
+</style>
diff --git a/psx-map-exporter/viewer/src/main.js b/psx-map-exporter/viewer/src/main.js
new file mode 100644
index 0000000..8dd6bc1
--- /dev/null
+++ b/psx-map-exporter/viewer/src/main.js
@@ -0,0 +1,5 @@
+import { createApp } from 'vue';
+import App from './App.vue';
+import './style.css';
+
+createApp(App).mount('#app');
diff --git a/psx-map-exporter/viewer/src/style.css b/psx-map-exporter/viewer/src/style.css
new file mode 100644
index 0000000..fc66b02
--- /dev/null
+++ b/psx-map-exporter/viewer/src/style.css
@@ -0,0 +1,38 @@
+:root {
+  color-scheme: dark;
+  font-family: ui-sans-serif, system-ui, sans-serif;
+  --bg: #121212;
+  --panel: #1c1c1f;
+  --panel-2: #25252a;
+  --border: #2f2f36;
+  --text: #e6e6e6;
+  --muted: #9aa0a6;
+  --accent: #4ea1ff;
+  --warn: #ffb24a;
+}
+
+* { box-sizing: border-box; }
+
+html, body, #app {
+  margin: 0;
+  height: 100%;
+  background: var(--bg);
+  color: var(--text);
+}
+
+button, select {
+  background: var(--panel-2);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 4px 8px;
+  font: inherit;
+  cursor: pointer;
+}
+
+button:hover, select:hover { border-color: var(--accent); }
+
+input[type="checkbox"] { accent-color: var(--accent); }
+
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
diff --git a/psx-map-exporter/viewer/vite.config.js b/psx-map-exporter/viewer/vite.config.js
new file mode 100644
index 0000000..28f4ac7
--- /dev/null
+++ b/psx-map-exporter/viewer/vite.config.js
@@ -0,0 +1,110 @@
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+const RENDER_ROOT = path.resolve(__dirname, '..', '.output-render');
+const CACHE_ROOT = path.resolve(__dirname, '..', '.cache');
+
+// Tiny dev plugin that exposes the .output-render directory at /render and
+// serves a /api/index endpoint enumerating maps and variants. Keeps the app
+// dependency-free of any external server.
+function renderRootPlugin() {
+  return {
+    name: 'psx-render-root',
+    configureServer(server) {
+      server.middlewares.use('/render', async (req, res, next) => {
+        try {
+          const url = decodeURIComponent(req.url.split('?')[0]);
+          const filePath = path.join(RENDER_ROOT, url);
+          if (!filePath.startsWith(RENDER_ROOT)) {
+            res.statusCode = 403;
+            res.end('Forbidden');
+            return;
+          }
+          const stat = await fs.stat(filePath);
+          if (stat.isDirectory()) {
+            const entries = await fs.readdir(filePath, { withFileTypes: true });
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify(entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }))));
+            return;
+          }
+          const ext = path.extname(filePath).toLowerCase();
+          const mime = ext === '.png' ? 'image/png'
+            : ext === '.json' ? 'application/json'
+            : ext === '.log' ? 'text/plain'
+            : 'application/octet-stream';
+          res.setHeader('Content-Type', mime);
+          res.setHeader('Cache-Control', 'no-cache');
+          const data = await fs.readFile(filePath);
+          res.end(data);
+        } catch (error) {
+          if (error.code === 'ENOENT') {
+            res.statusCode = 404;
+            res.end('Not found');
+            return;
+          }
+          next(error);
+        }
+      });
+
+      server.middlewares.use('/api/index', async (req, res) => {
+        try {
+          const indexPath = path.join(RENDER_ROOT, 'index.json');
+          const data = await fs.readFile(indexPath, 'utf8');
+          res.setHeader('Content-Type', 'application/json');
+          res.setHeader('Cache-Control', 'no-cache');
+          res.end(data);
+        } catch (error) {
+          res.statusCode = 500;
+          res.end(JSON.stringify({ error: error.message }));
+        }
+      });
+
+      // Serve per-map sprite cache: /sprites/<map>/bundle_<hex>/frame_NNN.png
+      // The exporter writes individual decoded sprite PNGs into
+      // <projectRoot>/.cache/<mapStem>/sprites/, sharing the cache between
+      // both the auto and region01 variants of the same map (bundle decoding
+      // is invariant to the record-set choice).
+      server.middlewares.use('/sprites', async (req, res, next) => {
+        try {
+          const url = decodeURIComponent(req.url.split('?')[0]);
+          // url like "/L2/bundle_00085c40/frame_000.png"
+          // map to "<CACHE_ROOT>/L2/sprites/bundle_00085c40/frame_000.png"
+          const segments = url.split('/').filter(Boolean);
+          if (segments.length < 2) {
+            res.statusCode = 404;
+            res.end('Not found');
+            return;
+          }
+          const [mapStem, ...rest] = segments;
+          const filePath = path.join(CACHE_ROOT, mapStem, 'sprites', ...rest);
+          if (!filePath.startsWith(CACHE_ROOT)) {
+            res.statusCode = 403;
+            res.end('Forbidden');
+            return;
+          }
+          const data = await fs.readFile(filePath);
+          res.setHeader('Content-Type', 'image/png');
+          res.setHeader('Cache-Control', 'no-cache');
+          res.end(data);
+        } catch (error) {
+          if (error.code === 'ENOENT') {
+            res.statusCode = 404;
+            res.end('Not found');
+            return;
+          }
+          next(error);
+        }
+      });
+    },
+  };
+}
+
+export default defineConfig({
+  plugins: [vue(), renderRootPlugin()],
+  server: {
+    port: 5180,
+    strictPort: false,
+  },
+});

From 399017ab45f7b7981d2d665013209c5cbeeba31c Mon Sep 17 00:00:00 2001
From: MaddoScientisto <maddo.science@gmail.com>
Date: Sat, 18 Apr 2026 16:53:43 +0200
Subject: [PATCH 3/4] Dynamic map viewer psx

---
 .gitignore                          |   9 +-
 check_type.cjs                      |   4 +
 inspect_l0.cjs                      |  15 ++
 psx-map-exporter/viewer/src/App.vue | 236 ++++++++++++++++++++--------
 temp_head.json                      |   0
 5 files changed, 201 insertions(+), 63 deletions(-)
 create mode 100644 check_type.cjs
 create mode 100644 inspect_l0.cjs
 create mode 100644 temp_head.json

diff --git a/.gitignore b/.gitignore
index f1d1d90..ca901c9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -44,4 +44,11 @@ bin/**
 USECODE/REGRET/REGRET_USECODE_extracted/chunks/**
 exports/**
 out/**
-binary/**
\ No newline at end of file
+binary/**
+psx-map-exporter/.output-render/**
+
+# JavaScript / Node
+**/node_modules/**
+**/dist/**
+**/.vite/**
+*.log
diff --git a/check_type.cjs b/check_type.cjs
new file mode 100644
index 0000000..65d1a48
--- /dev/null
+++ b/check_type.cjs
@@ -0,0 +1,4 @@
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync('psx-map-exporter/.output-render/L0/auto/L0.json', 'utf8'));
+console.log('Type of data:', Array.isArray(data) ? 'Array' : typeof data);
+if (!Array.isArray(data)) console.log('Keys:', Object.keys(data));
diff --git a/inspect_l0.cjs b/inspect_l0.cjs
new file mode 100644
index 0000000..d1b7495
--- /dev/null
+++ b/inspect_l0.cjs
@@ -0,0 +1,15 @@
+const fs = require('fs');
+const path = require('path');
+const jsonPath = 'psx-map-exporter/.output-render/L0/auto/L0.json';
+const cacheDir = 'psx-map-exporter/.cache/L0/sprites';
+const data = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+const items = (data.items || []).filter(item => item.bundleAbsoluteOffset !== undefined && item.frameIndex !== undefined && item.width > 0).slice(0, 5);
+items.forEach(item => {
+    const bundleHex = item.bundleAbsoluteOffset.toString(16).padStart(8, '0');
+    const frameIdx = item.frameIndex.toString().padStart(3, '0');
+    const fileName = `bundle_${bundleHex}/frame_${frameIdx}.png`;
+    const fullPath = path.join(cacheDir, fileName);
+    const exists = fs.existsSync(fullPath);
+    console.log(`recordIndex: ${item.recordIndex}, bundleAbsoluteOffset: ${item.bundleAbsoluteOffset}, frameIndex: ${item.frameIndex}, width: ${item.width}, height: ${item.height}`);
+    console.log(`File: ${fileName}, Exists: ${exists}`);
+});
diff --git a/psx-map-exporter/viewer/src/App.vue b/psx-map-exporter/viewer/src/App.vue
index c6f6a2a..1528afb 100644
--- a/psx-map-exporter/viewer/src/App.vue
+++ b/psx-map-exporter/viewer/src/App.vue
@@ -1,8 +1,12 @@
 <script setup>
-import { computed, onMounted, ref, shallowRef, watch } from 'vue';
+import { computed, nextTick, onMounted, ref, shallowRef, watch } from 'vue';
 import ItemPanel from './ItemPanel.vue';
 
 const PADDING = 16;
+// Match psx-map-exporter/src/render.js DEFAULT_BACKGROUND. The exporter still
+// produces a baked .png for offline reference, but the viewer composites each
+// sprite live so hide/filter operations no longer carve holes out of the map.
+const BACKGROUND = 'rgb(18, 18, 18)';
 
 const indexData = ref(null);
 const indexError = ref(null);
@@ -12,10 +16,11 @@ const scene = shallowRef(null);
 const sceneError = ref(null);
 const loading = ref(false);
 
-const imageRef = ref(null);
+const canvasRef = ref(null);
 const containerRef = ref(null);
-const imageNaturalWidth = ref(0);
-const imageNaturalHeight = ref(0);
+// Sprite image cache shared across redraws. Keyed by mapStem|bundleAbsHex|frameIdx
+// so swapping maps does not invalidate sprites still bound by other items.
+const spriteCache = new Map();
 
 const zoom = ref(1);
 const pan = ref({ x: 0, y: 0 });
@@ -28,10 +33,7 @@ const filterBundleHex = ref('');
 
 const hovered = shallowRef(null);
 const selected = shallowRef(null);
-// Set of recordIndex values the user has manually hidden via shift+click. We
-// rebuild the visible item list against this set so painted sprites and SVG
-// hitboxes both disappear together. Hidden items are restored via the
-// "Show hidden" button or by selecting them in the unfiltered "Hidden list".
+// Set of recordIndex values the user has manually hidden via shift+click.
 const hiddenIds = ref(new Set());
 const hiddenList = computed(() => {
   if (!scene.value || hiddenIds.value.size === 0) return [];
@@ -92,17 +94,18 @@ async function loadScene() {
   scene.value = null;
   selected.value = null;
   hovered.value = null;
+  hiddenIds.value = new Set();
   try {
     const base = `/render/${selectedMap.value}/${selectedVariant.value}/${selectedMap.value}`;
     const json = await fetch(`${base}.json`).then((r) => {
       if (!r.ok) throw new Error('Scene JSON HTTP ' + r.status);
       return r.json();
     });
-    scene.value = {
-      json,
-      pngUrl: `${base}.png`,
-      labelsPngUrl: `${base}_labels.png`,
-    };
+    scene.value = { json, mapStem: selectedMap.value };
+    // Eagerly preload all unique sprite frames referenced by this scene so
+    // the first canvas paint shows the full map instead of a half-loaded
+    // jumble. drawScene() is then called once all are settled.
+    await preloadSprites(json, selectedMap.value);
   } catch (error) {
     sceneError.value = error.message;
   } finally {
@@ -112,22 +115,135 @@ async function loadScene() {
 
 watch([selectedMap, selectedVariant], loadScene);
 
-function onImageLoad() {
-  if (!imageRef.value) return;
-  imageNaturalWidth.value = imageRef.value.naturalWidth;
-  imageNaturalHeight.value = imageRef.value.naturalHeight;
-  fitToContainer();
+function spriteKey(mapStem, bundleAbsoluteOffset, frameIndex) {
+  return `${mapStem}|${bundleAbsoluteOffset.toString(16)}|${frameIndex}`;
+}
+function spriteUrl(mapStem, bundleAbsoluteOffset, frameIndex) {
+  const bundleHex = bundleAbsoluteOffset.toString(16).padStart(8, '0');
+  const frameStr = String(frameIndex).padStart(3, '0');
+  return `/sprites/${mapStem}/bundle_${bundleHex}/frame_${frameStr}.png`;
+}
+function loadSprite(mapStem, bundleAbsoluteOffset, frameIndex) {
+  const key = spriteKey(mapStem, bundleAbsoluteOffset, frameIndex);
+  let entry = spriteCache.get(key);
+  if (entry) return entry;
+  entry = new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => {
+      // Replace the Promise with the resolved Image so drawScene's fast path
+      // (synchronous cache hit) sees a real HTMLImageElement instead of a
+      // Promise. The Promise is still returned from this call for any awaiter.
+      spriteCache.set(key, img);
+      resolve(img);
+    };
+    img.onerror = () => {
+      spriteCache.set(key, null); // Cache the miss so we do not retry forever
+      resolve(null);
+    };
+    img.src = spriteUrl(mapStem, bundleAbsoluteOffset, frameIndex);
+  });
+  spriteCache.set(key, entry);
+  return entry;
+}
+async function preloadSprites(json, mapStem) {
+  const seen = new Set();
+  const tasks = [];
+  for (const it of json.items) {
+    if (it.placeholder) continue;
+    if (!Number.isInteger(it.bundleAbsoluteOffset) || !Number.isInteger(it.frameIndex)) continue;
+    const key = spriteKey(mapStem, it.bundleAbsoluteOffset, it.frameIndex);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    tasks.push(loadSprite(mapStem, it.bundleAbsoluteOffset, it.frameIndex));
+  }
+  await Promise.all(tasks);
+}
+
+const canvasWidth = computed(() => {
+  if (!scene.value) return 0;
+  return scene.value.json.renderWidth ?? 0;
+});
+const canvasHeight = computed(() => {
+  if (!scene.value) return 0;
+  return scene.value.json.renderHeight ?? 0;
+});
+
+function drawPlaceholder(ctx, dstX, dstY, w, h) {
+  const half = Math.max(2, Math.floor(Math.min(w, h) / 2));
+  const cx = Math.round(dstX + w / 2);
+  const cy = Math.round(dstY + h / 2);
+  ctx.beginPath();
+  ctx.moveTo(cx, cy - half);
+  ctx.lineTo(cx + half, cy);
+  ctx.lineTo(cx, cy + half);
+  ctx.lineTo(cx - half, cy);
+  ctx.closePath();
+  ctx.fillStyle = 'rgb(220, 60, 200)';
+  ctx.fill();
+  ctx.lineWidth = 1;
+  ctx.strokeStyle = 'rgb(90, 0, 110)';
+  ctx.stroke();
+}
+
+function drawScene() {
+  if (!scene.value || !canvasRef.value) return;
+  const cv = canvasRef.value;
+  const w = canvasWidth.value;
+  const h = canvasHeight.value;
+  if (cv.width !== w) cv.width = w;
+  if (cv.height !== h) cv.height = h;
+  const ctx = cv.getContext('2d');
+  ctx.imageSmoothingEnabled = false;
+  ctx.fillStyle = BACKGROUND;
+  ctx.fillRect(0, 0, w, h);
+  const bounds = scene.value.json.bounds;
+  const mapStem = scene.value.mapStem;
+  for (const item of visibleItems()) {
+    const dx = (item.drawX - bounds.minX) + PADDING;
+    const dy = (item.drawY - bounds.minY) + PADDING;
+    if (item.placeholder || !Number.isInteger(item.bundleAbsoluteOffset)) {
+      drawPlaceholder(ctx, dx, dy, item.width, item.height);
+      continue;
+    }
+    const key = spriteKey(mapStem, item.bundleAbsoluteOffset, item.frameIndex);
+    let cached = spriteCache.get(key);
+    if (cached === undefined) {
+      // Not yet requested: kick a load and skip this paint. The load
+      // resolution will trigger a redraw via the .then handler below.
+      cached = loadSprite(mapStem, item.bundleAbsoluteOffset, item.frameIndex);
+    }
+    // Only synchronous cache hits are drawn this pass. Misses kick off a load
+    // and trigger a redraw when complete; this keeps the paint loop simple
+    // and avoids partial draws when scrolling.
+    if (cached && typeof cached.then === 'function') {
+      cached.then((img) => {
+        if (img && scene.value?.mapStem === mapStem) drawScene();
+      });
+      continue;
+    }
+    const img = cached;
+    if (!img) continue;
+    if (item.flipped) {
+      ctx.save();
+      ctx.translate(dx + item.width, dy);
+      ctx.scale(-1, 1);
+      ctx.drawImage(img, 0, 0);
+      ctx.restore();
+    } else {
+      ctx.drawImage(img, dx, dy);
+    }
+  }
 }
 
 function fitToContainer() {
-  if (!containerRef.value || !imageNaturalWidth.value) return;
+  if (!containerRef.value || !canvasWidth.value) return;
   const c = containerRef.value.getBoundingClientRect();
-  const sx = c.width / imageNaturalWidth.value;
-  const sy = c.height / imageNaturalHeight.value;
+  const sx = c.width / canvasWidth.value;
+  const sy = c.height / canvasHeight.value;
   const z = Math.min(sx, sy) * 0.95;
   pan.value = {
-    x: (c.width - imageNaturalWidth.value * z) / 2,
-    y: (c.height - imageNaturalHeight.value * z) / 2,
+    x: (c.width - canvasWidth.value * z) / 2,
+    y: (c.height - canvasHeight.value * z) / 2,
   };
   zoom.value = z;
 }
@@ -178,10 +294,9 @@ function onClick(event) {
   const px = (event.clientX - rect.left - pan.value.x) / zoom.value;
   const py = (event.clientY - rect.top - pan.value.y) / zoom.value;
   const item = pickItem(px, py);
-  // Shift+click hides the picked item (overlay rect AND painted sprite still
-  // shows since the .png is baked, but the SVG hitbox vanishes so you can
-  // click through to whatever is underneath; combine with the hidden list
-  // panel to restore visibility).
+  // Shift+click hides the picked item from the live canvas redraw, so the
+  // sprite vanishes instead of being masked over and you can see anything
+  // underneath. Clear via the "Show hidden" / "restore all" buttons.
   if (event.shiftKey && item) {
     hideItem(item);
     return;
@@ -251,17 +366,28 @@ const overlayBoxes = computed(() => {
   return visibleItems().map((it) => ({ item: it, rect: itemPixelRect(it) }));
 });
 
-// Black-out rects for shift+click-hidden items: the rendered .png is baked,
-// so we paint an opaque rectangle over each hidden sprite using the same
-// background colour the renderer used (DEFAULT_BACKGROUND in render.js =
-// rgb(18,18,18)). This lets the user see whatever real sprite lives behind
-// the obscuring one without re-running the exporter.
-const hiddenMasks = computed(() => {
-  if (!scene.value || hiddenIds.value.size === 0) return [];
-  return scene.value.json.items
-    .filter((it) => hiddenIds.value.has(it.recordIndex))
-    .map((it) => ({ item: it, rect: itemPixelRect(it) }));
-});
+// The scene canvas is inside the `v-else-if="scene"` template branch, which
+// does not mount until `loading` flips back to false. Painting during
+// `loadScene()` therefore races the DOM and leaves the canvas blank while the
+// SVG hitbox overlay still appears. Paint only after the scene branch exists.
+watch(
+  [scene, loading, canvasWidth, canvasHeight],
+  async ([nextScene, isLoading, width, height]) => {
+    if (!nextScene || isLoading || !width || !height) return;
+    await nextTick();
+    fitToContainer();
+    drawScene();
+  },
+  { immediate: true },
+);
+
+// Trigger a canvas repaint whenever any input that affects drawing changes.
+// `visibleItems()` is not wrapped in a computed (it returns a fresh array),
+// so we watch the underlying inputs explicitly.
+watch(
+  [hiddenIds, showOnlyLayer, filterTypeHex, filterBundleHex],
+  () => { drawScene(); },
+);
 
 function strokeFor(item) {
   if (item === selected.value) return '#4ea1ff';
@@ -320,33 +446,19 @@ onMounted(loadIndex);
         <div v-else-if="sceneError" class="error">{{ sceneError }}</div>
         <div v-else-if="loading" class="muted center">Loading…</div>
         <div v-else-if="scene" class="stage" :style="transformStyle">
-          <img
-            ref="imageRef"
-            :src="scene.pngUrl"
-            @load="onImageLoad"
-            draggable="false"
-            class="map-img"
+          <canvas
+            ref="canvasRef"
+            class="map-canvas"
+            :width="canvasWidth"
+            :height="canvasHeight"
           />
           <svg
-            v-if="imageNaturalWidth"
+            v-if="canvasWidth"
             class="overlay"
-            :width="imageNaturalWidth"
-            :height="imageNaturalHeight"
-            :viewBox="`0 0 ${imageNaturalWidth} ${imageNaturalHeight}`"
+            :width="canvasWidth"
+            :height="canvasHeight"
+            :viewBox="`0 0 ${canvasWidth} ${canvasHeight}`"
           >
-            <rect
-              v-for="entry in hiddenMasks"
-              :key="'mask-' + entry.item.recordIndex"
-              :x="entry.rect.x"
-              :y="entry.rect.y"
-              :width="entry.rect.w"
-              :height="entry.rect.h"
-              fill="rgb(18,18,18)"
-              stroke="rgba(255, 80, 80, 0.6)"
-              stroke-width="1"
-              vector-effect="non-scaling-stroke"
-              stroke-dasharray="4 2"
-            />
             <rect
               v-for="entry in overlayBoxes"
               :key="entry.item.recordIndex"
@@ -407,7 +519,7 @@ onMounted(loadIndex);
 }
 .canvas:active { cursor: grabbing; }
 .stage { position: absolute; top: 0; left: 0; }
-.map-img { display: block; image-rendering: pixelated; user-select: none; -webkit-user-drag: none; }
+.map-canvas { display: block; image-rendering: pixelated; user-select: none; -webkit-user-drag: none; background: rgb(18, 18, 18); }
 .overlay { position: absolute; top: 0; left: 0; pointer-events: none; }
 
 .sidebar {
diff --git a/temp_head.json b/temp_head.json
new file mode 100644
index 0000000..e69de29

From 6ca3b18c3eb85c03b9079ae5c591205dd2b4e9d1 Mon Sep 17 00:00:00 2001
From: MaddoScientisto <maddo.science@gmail.com>
Date: Mon, 20 Apr 2026 07:58:27 +0200
Subject: [PATCH 4/4] Decomp

---
 .../idata/01/~0000001b.db/change.data.gbf     | Bin 163840 -> 163840 bytes
 .../idata/01/~0000001b.db/change.map.gbf      | Bin 32768 -> 32768 bytes
 .../01/~0000001b.db/{db.66.gbf => db.68.gbf}  | Bin 8044544 -> 8044544 bytes
 .../00/~00000008.db/{db.60.gbf => db.62.gbf}  | Bin 81920 -> 81920 bytes
 .../00/~0000000d.db/{db.10.gbf => db.12.gbf}  | Bin 163840 -> 163840 bytes
 5 files changed, 0 insertions(+), 0 deletions(-)
 rename Crusader.rep/idata/01/~0000001b.db/{db.66.gbf => db.68.gbf} (99%)
 rename Crusader.rep/user/00/~00000008.db/{db.60.gbf => db.62.gbf} (99%)
 rename Crusader.rep/user/00/~0000000d.db/{db.10.gbf => db.12.gbf} (99%)

diff --git a/Crusader.rep/idata/01/~0000001b.db/change.data.gbf b/Crusader.rep/idata/01/~0000001b.db/change.data.gbf
index dc09744edba24e6c9e298f2797faffdf6f42328b..04590df855730e338e5f9d3e5ad7c7ebd65875b3 100644
GIT binary patch
literal 163840
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

literal 163840
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
F{s#q{B{u*7

diff --git a/Crusader.rep/idata/01/~0000001b.db/change.map.gbf b/Crusader.rep/idata/01/~0000001b.db/change.map.gbf
index 8acd9ec100729edbc7a12fae3e15fe9ca482aa4f..bfa28d6acb9e9b321dc8402e37d47ab2d86c8145 100644
GIT binary patch
delta 43
zcmZo@U}|V!63{m=)G^W2(fW5!@iDVbNYz9EC6+wfAF>n8LRo&Cmtxx3Usw+SFD(xn

delta 43
zcmZo@U}|V!63{m=)G^W2(Rwv4bIopPj$;!AlvsW%|Mi_{7RoZ|!n=Zv{e|@aM7R+A

diff --git a/Crusader.rep/idata/01/~0000001b.db/db.66.gbf b/Crusader.rep/idata/01/~0000001b.db/db.68.gbf
similarity index 99%
rename from Crusader.rep/idata/01/~0000001b.db/db.66.gbf
rename to Crusader.rep/idata/01/~0000001b.db/db.68.gbf
index f632e1e256170ed61a4263a6cdd96c5d904423fb..cf10513f62b2a5099381bd7df1511ad886ab1506 100644
GIT binary patch
delta 9354
zcmbW7d2|%lmBy=EEii~hLJ|_C?SVk*mbzQ56(O-m0<oDL0TPR)R(DBitJN*Ks@0Ng
z)55Gt>;T550JD4SFo_d`7YfJ5+jztA7CU3d8E5R+aVE~hu`}VE*e7_H?^e|l3NwG?
z%sc0P^sio3y?5Vo-z{Kh=sy#NV96z(QfGz3SrnS{b<WpsiPrPUvri{x3xbgS*y__y
zO}5NBIR4`L#A-pvoptc|Mf+p>FN!wHiG!i1#e*+By)N;%AlObE%)7L~GHXZd(w^8Q
z3(N{jfZ1S)uu-tlu$y3GU}IrPuyL^QunDk<uw*TEDdqLi6VuMj7c5no=md&r(;8k%
zsT-@^^HxgioaLw5*r7=uC5|y`bE~yac1?O^hW2E4O7o;WDbJ9l!qQ;ru*t9tSSD-=
zOoU~@vSB%}Tv#5A!KT8d!SZ3#VKZO_TFNtpUvIZ$t7GfzU&SXGof3ppL74M7hcv)N
z4(WjJaF`6J=a2zN;s6I`KgwYWU^xd7Fr7mdVECDAZJ^$MSB={Clr>2!yxpE;O`RX^
z=?w&>2<{&p4RwdYvCtm(HapA#D}oinoG=&64J(0pV5P7!SUIc$Rtc+u&4g9MX2EJ;
zwXoT+Ik35~d9XTIJ*)vXAGQG22wMnS1X~PS0$U2Z8MX|z9JT_s61EDq8ny<u7S;q?
z2U`!@0BeS|z&2{`ZJYk>dCPolY~AL(v?XoEu-FbW`e9w=H`uz{WW`|H5tIAP`aLG^
zH0zIQ4NaRzTgIF<S=AcWZGL&ep2hynur07#V6Ct=m>1R#^TGTu3DyDYgmu9Juv=l>
zu%Ncs-}6EidYm-W<4K4YqXqY0NdAT7C`purrrV7bA-KLEd68s4NfU`3;{2B6=Oolm
z=j|jnlN3UVzb1K;<Od|%NY;_KNX9{mej~)87wPBsNVbsB(sF!Ca)zXbWC;n@onZef
z3BA?+APKc;UrSO%Vu2L?lH?JR-6ZtVLh4b$f0Iyu3&_oaR!F>n24Dugbp{Q<j6)<L
zl6fS#km*-QE|ZX-({Cf8Hm5rv`PWFONBQJu{w|Vc67n;j{G9e5B+rr@CXq>&lN7|E
zQ@<ghUQd0DWIM?!5*mK?B?<M7-AA&Sgc{EK3&|xCYBP^|lt=x|{T<0qNCrt(lQ<zc
ze<FE?gxbhi2LFW|>}?_Yw<M2~+(|N@WFjQ%Ba$DJ43I1$NrQ;gh)9iy<c>%cBBF^f
z<uej;WJ-*LUNvO`B=a{U^r}p1Ba_xqX1s)SEF^;lAcH0*BTQ0HLg8%kuSiaiY$aJp
zG9HpnFHFBcLKB_7k|ZCJ_BF|KB($v3+DT~0QfaPI-y}Ik(kEb8Qs>go1jwYfNlub<
zlhlw{ASqOlvS0J=?wOgSzTVYasa-qJ(~(nN&@1=1`U7&WSMhbVM#5pGRSt#~Pb;p(
zLajaozi>3<$I~dHjYNGbPnoRFnW~K5v*VE-SV-IPNci6S;xs5!#6&?TbsN70ag-o<
z{++{Uzzz;K0dC<i1~7{QhSNiHL`6&zgpx0f--3wMSn?VNjA6-x9425TmJD&42%rr`
zMN9^uPkIqk5EVY=fa!5R#UT|yyN8O1=G`<~R79LOZmc!E&>C?Ua=-$2TMdW{VkQF1
zuXz=grHd9k6;TBA8ovb*M~>@e4%vVL4mkjtFDha#0@1U^Z$Zoh402$A5)M-lj6MXw
ze>^k|bT6;MS}I=70b!|_)+rTn2IABU#&1DH^F_mx2iJ<KcnzYYV|eVb03GLf4F=Z{
z=1>eM)Z51u5lhlOJV!3T@El=L*oXK-aKOHag9k9&YANE~2fU^X@HmHZz&;KYfLl3K
z!vDfXPIy%z<1iDU@^2if0q=3Zf-4yI2%DwgE?!d$=;SaP(7<610Mn!w5j$@N?Nusq
zaUSSh0|c=SKtY6xSP%HV@mmn_su>$N%m*+I3lNfj&jHR%KgVGqpr6Ac0NT=vxEO$)
zWX!*~1QGk^MvWjY1svso1()B>0gE{wGpH94D`eV#aaaKuUOy`V=%8`iDgc(G0jm+*
zzu~Y3@C#%8!Pm8*M|f2e;JX}fcuti#tOwL_z;H~(uF#9vjPv0g4lRHmbJz&j%K>YL
z`8aHb{|vLC7jX-!rf|3gr^*!$t$?>Uv;ls|!3)5xdJ!>Dc~~3<ppm>Z4t^X(Uvhvm
zxvz1EcYq$`gvFCP#Gwm-?&?Jh0EU<Pt$-9>(~TqTj~s%4S2*+l&Tt3;?%)sxV8BqY
z|3rkC9PAOjh+6>@I7DzBe$GJ#yvRWToa7J%407lLV9xX+#sJu*24E>>Cvh0SiTXQZ
z{h<qZI_r5}bsOLqhuZ;oi(W)HkcD+)z%~E^g#qv*OJC4HaR~OQQ6Y%i0nc!_6L5sX
z4nQ1^=tbNKTFGG-PVYZ+*bR7{!ydqQIAB>#8Fmj>rwqG?<(v63zwLVfOrT!Gy8y!r
z<8Jgj<7d1In>_;;jQjQhoE-M!@c%W31AvPh?g1R+fFF}F(RvZ@1uWr!GiCC04u_C2
zTr&XYj|%z~uR08Pf&)e>9WCocJPPRMa6e!n2h3IaR1U|HbX?_d0`NYElYmD#oC4ep
z(A^bJgRtE7B4Wv=&FAm{AeX~GA!GT512#?SFE~5|c!a|b08Jdu0!ldiGhi%-A0o~9
zY<ReT1bU8FJq&=0dJz#wCSg$<@Dspl4rp=G@D!axuJjSFIS;^)>qUgqDQh`A21w%Y
zxNwV*{01kCdomW0Uc?K4#T+z%`CAY%^%HSHFXEGcUJgG66mxh=5GH)4`d0MrvEfpV
zy3*d4qb08FjZZ852lF@e{MOzy+fID<@439S7q%4^fyvtCt;*nvc#U0P)SPt#`ZUYI
z;Z;GXe#wO9*9Bqbw<ff_4XEPqu^?3OXEtsYgv#5^noStf$|MeZ1)*XQ2fVHPj0v0L
zXsEo8)9(eL>{%1GbRn7CZo(~CpPuC=wBfdrpb1{|-My4U8q%mwIiL%!E)G|aIlX0q
z&jT>t78k6(7m*)*->mAy92Ge^)FC<Huj|6Q3%@dJy5MVpVuAv|*B3)i1gmlvj^+1F
zh%Ux)dxb+A&e2Cr*oINSHxtvBku^RJC(S3?&z@JZb1!_NT%d0f>y!m%b}mI&UqFhn
za0lZFyNeQb7Lk16h@aWZDjFO$Od05vmiX(6J^h{v76|#Jeo0pU{907>)-qo-7;M(7
zs+~Ht=ultFI)dI#nV{6e+5-wJXLFd`9q4s4G_M3gK81z*q)5;^z&aw~9;S3j%oh&H
zN+jx2!bZ<()a`%Vl&U^+sApoF*?rz%Q1YY8UZ#Ih%<=SBdpxD(Ri)JqblK~d^_Q%z
zU*5<)@XD;Ttbuu>N>@07XL}=3N1&f=B9}J6MfA^!?w2{y?F#3{U^rG+T;-IdphSJB
zE3S41y&;Lbh}Um%vt?ngAA{Br2nJ==u(D~fK7Mj7llptZ5d~E}QCVRtRyLsnQCVU%
zX4NI6^$dNv(Z}YJ7Upu{av1k|Ba(3gh7=>w8<1oti*?~|is&`7JZ1WODu(ZqCCT(y
z3UvlT5{pFwiiAeOEZlx89x3<H6BX+A-^SASym3|0-nbf_v%?a{Uvu>3TH<sFRv;D$
z6}OWtAi;7G%0D1MtQX4LNQxk3Uy&f#31u?L3X*(C>0e3cFe}9YC6ulwp_uIXn1o*M
z*-b(f9*RFD*GTl_uH<3*xswDdT_~v_nFw+JfdoNHa33J)CaEQv0C7>R3o%e|-A1yM
zBoE@G`0sp|<TOc$q>=<C6u(A7eigStI*N;+MPHIo3Q&Z@TPUJ#7E%8lpOa99;~)uw
zhTy>N5gd~scB-{sCOJv6j|BOHV2_e?lC+TAtZloq?`B(D10cJcWI9PY$tXw`jb9ex
zj*vyeo<)7kBFD36Y_f1*3RyI;S#gqH5--Ub5}LBCDiXWu*wfcysnPCvB{w!n9dop=
zK}$W_HzrGKdZO=%r55`WV`B>~@$p0O?zj;tY~w$KGf@*J_M@|n9QGn2?dPx`ki!8z
zEjVF93fiA>!GuY#0?deQqrWwn{xGjWJJa0+m?&E+8p=OwR;6O)P5Z)xv}Q!EznPHU
z1h8@lBKxl9fd1s2)23Ks$8xm2(_$};QIqpyqvDpdm63oHQoKqa976O7^wyaBpwy=a
zAZ$X9r;Hh!TV_3hNJNhb9T9I2c3;Sc5W(#7dT*qRxmYlaaMN1mLBNw0#1;yY{F=kf
z>Ul)rAuCQXi-N_-wy@t3aL|h0ADPL$v_%;j3JiwP)nIUdc@;#Z@T~|q)Ndt#z91xc
zSuoHop;`_{BR+{*_XY!<p&odM2%rQyygo%nc#!Z6BBzwjBM@#vgGQ`rSH0IZrN=EQ
zVqMVhnk)Mv5*`@Qo;?(1i<%m1S#K1*oWE)v{8gk*iez4;3yvD0WM(y@x4p&H?3g{f
zw2Ia8%RXE#E85tKpo-|~V)o|Z7P_U9F}q$v*Wz@sqzrF{dx&PyP(YFK>Sf^=>+%Ns
z(AgfZ+>IC53z(<B0|hhXaX8`p$i4<--Z_{49t3k=K*p%K+1hBkENzX_;P}FRsfHPz
zw)RuE<2X5b^mvHgaDN<Z?p#({<-jF<0kmRH5JmAsEq~ZNn2d)jJgkI2>~pjAbZ*k&
zSHoO5;wn6|=kO+H<6Oc8C*#+$LahU{;a4fMmzR0^%kU~XcIm`$Xm!rm<%5=a+Sun}
zdoA%(*oE&H3q9e`>i}~{C8*=D3-_5dst3C;j|2A5j0O`9XJfCu!GU&R0tf8e{J9*y
z!oI68;mA$cYCCj@3kgTCsoBfCYA^QM+Z-MT)Nr_h&&+cs9Q7lI{Fnn;%~{9+4P{3-
zT%|~5!m&DhQoX<dFTh{KF$!`*!todJu{6c3I)R2V&4`n5vI{W5tU38hd<5lkfP0fW
zO*n;T(s}1jBdnyaF>4;cV5L21!jH}(<2RG2gmW0+)XI9Z>d7Hw?`9^L@H7TB<*-?E
z34pAe={<cO?@pefRzA>pNwe4%I>u@H7RdPt+S2!9`^LpTS&K9(<frYr1VIG5owXx`
zbTj+1wT(@z9e)do-9Q<ZOcAKpI}k*E;qodj{Wh%FvYDmT4Dkbdk<y2?s~YFG*1Op%
zDdGxBeG=Xm4FoA&GopmdIweI9Sd=NX`5A>DC&dRNNXSNiDD8>_{M4c>Q~c5MsPb7}
zG)8r19wGN)dvyeSdj6+pT!=RTrHe(p*tZCYD(jFlwBi-=yB6)?&tkh0;+D<B@77(Y
z;Z9+zL}UcWIpzoyvubAd2e5$^3V|JzI#C#_cC`;6KpJTpLc{|7mT&}H(HI4cgs%$$
zW5k%=#-im2>w!TjUaS8!^3_^)2U-tAkVLgd5o3+fr6(n}rhWsQt~6Wo!y#`wrh=T3
zBJdJXTEUoI@1VjK)Hk&v+niZh?XT9;$0hzPI4xq#TQ)p|P35y@&h#N}@lgzfIuWA1
z3g#*@vdeU)7|E>UjRXTy#LYHJk+6%LFh|-KL=}yRddHt)nd;mZH{GO_e;%u~sHbWp
zIPG?f7y)xt8OwvOt9q;})9L>``o_|7vnGsr2gZoj02UiEbqv2urwz@9@m?A*WZb?8
z4ZS%=apv=49+3Ek6r8#;^GmoP&@Qp-vvK2Oc(E1!ZWie1jP@Yxo1r^E=b@W5;>|1+
z4!H&~Bzgk_458mktHNb0c)xmh<6tt==a<>L@lE0!-UO|^O2mQgV_mBsS8S>pWh`fP
z>$ZW61WcOd{X^{Rzgj90ar>LCZEc7s&Bk`t|7|i8VTks&b(MnfvWr7Mz{6oDVoin#
ztCJC4?%{y&lAg?A2(hMKd+bc(JPSpK#$>J9*7u%8UG>4HQR>^TZnDL%f9+5*Ut@l?
zVB>qL*s_%ySVK!wBeO^Gc{6)94lCxGYaT%r70e!^Go5X8qQZ@X%*_@DI=l1<r1?WF
zB9EeffmG4>(MQSfh$EP6WbGXT`ZV(t1{n-K+ptS%1F?3@myBiM@svw$H~r~tXZViu
zc@aEl2Zly`R(XRGc8qIy_bcIU>>qpq`OzWuj&EZ{>V#2!>&W%dUGn@9pLsVr4#%Q&
zEZ^v`hdbPI-QhKqm$iElQQ?nquvZ`wAiYw^549v0JI6PwZ<*e%y7bfj@$nnmEBn9O
zEBEpCny<GvBI%>iy`GPZ$ZKj@7fk~u3m?5kw4trUv#RoDJ}M(K8#{fy-rz|&A^~~g
zaH|_e_2p{yAN0Takj0JvOEIw8io=RZZZ*EPs<lpQ#(VDZjIQASU|8|TdNt+DR%b1J
z3;x6Z9GAG<>-UH8isPqV-uI4n{`^4m1j{CDlYxn&$DE><BYnSDoz$_paE!;q`?RuG
z1_~`>kS9>F9n#jkI&dMeh(0u^*zRZgAH#gy<PYgG>W^vGHwU~K>a$nMa<wO=;wr0_
zVPEn^#uK)|#5#*l8(TMcw@ptAsB!#<iN(f)g6%%QG!BOZVboO)D&Rd1hXLm}907cn
z!%+b84!zj!2h8Pg43NnIpJ3L+C)Lbd3m@uWbkR0`$a2jrz*+y_+`0x2j~w#{iy5xq
z_3HWk{aHz;Uf!9=FIWyJS>uK;SXb>-&yU+Ij=ZAiSFS%~U8Np4-A@ngxU9d$y5TIp
z<<2klD+x!`^V?!sNrx-u9WySd>VcNNtZ|1cJR#%4p;P)Zw!;-UMe2d>fmChxqQSxb
F{{cHK$k_k@

delta 5975
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

diff --git a/Crusader.rep/user/00/~00000008.db/db.60.gbf b/Crusader.rep/user/00/~00000008.db/db.62.gbf
similarity index 99%
rename from Crusader.rep/user/00/~00000008.db/db.60.gbf
rename to Crusader.rep/user/00/~00000008.db/db.62.gbf
index e10876c9033161fb2fe961bdeb4158028e24db72..392b73af9c61f438a166b6dd4b647fa3c29693b7 100644
GIT binary patch
delta 342
zcmZo@U~On%70@>@)G^W2(GuLfSg5aNo?4^8Q~^dFCR?_RioQ0}vuzj`OmDPdlxAYO
zF}>cF(TT&@$iT`V#UN?Ajy<EqG+RcI>G$mzc~OKVr}Nq~W{bO(<|UV8=H~^amXsFd
zg;W-#x@D&3q)e~3XAEX>3-xoJzR;FY0Y#?-SCDH+XpmogNMyitAD{)CrFki-X_<Mc
zDPa4iU$SSEn|{EaQHUeh)7{Szs1~fO9<EFwK0Y}mH95!7EG@A}!6mb}Ah9GlBi=c`
zpwch3q9iCaIlm~yttdY?C^Iiz1Fp?Tp&+p+F*n{&M*&032uaKYs?JzbNkQL^m&-=q
RC$YFBp3^5kIT7SnI{@v;Yo7oB

delta 232
zcmZo@U~On%70@>@)G^W2(NcLddFC0}_oa;jQw11#nC#p)D*D<?&$eM)z!?%5;A*Q>
zTv9Z>(S}i4l<B;UPhxRNyia~I0|SGok7IC1d;nOAnQ6Wan8C!<IDMWCqZ5Zgs)d!Y
zQA*-;0eeP?X|{~q)2G@pilGWmKW)pX1<}Sh9iq+1!otcRE!h}N8;USUTMm0bQGR++
cV(xT5JI3JY8upBG0yg?E*Cm!@=I7Y~05&>7+yDRo

diff --git a/Crusader.rep/user/00/~0000000d.db/db.10.gbf b/Crusader.rep/user/00/~0000000d.db/db.12.gbf
similarity index 99%
rename from Crusader.rep/user/00/~0000000d.db/db.10.gbf
rename to Crusader.rep/user/00/~0000000d.db/db.12.gbf
index e78bbc3d86e0bdbb10b51bf16cd3e191b4e2f228..e4d7f31bcffd930c947961e60818d7cfc7755d95 100644
GIT binary patch
delta 33
pcmZo@;A&{#63{m=)G^W2(PCwudHc+nJ&lb5tpbc&1(-h60|2eN3qk+@

delta 33
ocmZo@;A&{#63{m=)G^W2(fXp4*&gf47t<)vD!{l^faya$0HOd20{{R3