@@ -210,7 +210,8 @@ out/
 `dump/` is the disc as the game sees it; `browse` then builds a
 human-readable mirror next to it (PNG/WAV/MP4/UTF-8) — including a
 disc-wide sweep that pulls ~1,400 more textures out of the effect/scene/UI
-containers (`browse/textures_png/_embedded/`), the PS2 memory-card icon
+containers (`browse/textures_png/_embedded/`; scene archives are
+ARX-packed in place and get decompressed first), the PS2 memory-card icon
 resource, and string tables sniffed out of binary files. A guided tour of
 what's in there — including the **eight developers' personal folders that
 shipped on the retail disc** — is in [docs/BROWSING.md](docs/BROWSING.md).
 
@@ -31,9 +31,14 @@
   count 1-64, in-bounds header table). Effect libraries (``.esd``/``.esp``),
   scene archives (``.a``), battle data (``.bin``) and the NLNK/NBGL/NBXX UI
   containers (``.npr``/``.rbg``/``.bxx``) carry ~3,000 textures this way —
-  more than the standalone set. Blobs byte-identical to an already-decoded
-  texture are recorded as duplicates, not re-written; the sweep is logged
-  per-carrier in ``browse/embedded_textures.csv``.
+  more than the standalone set. Scene archives, ``.fpk`` packs and ``.arc``
+  bundles keep their members **ARX-compressed in place**; those are
+  decompressed first (``iter_arx_containers``) and the XTX inside are
+  paletted by the ``lex`` models packed beside them, nearest member first.
+  Blobs byte-identical to an already-decoded texture are recorded as
+  duplicates, not re-written; the sweep is logged per-carrier in
+  ``browse/embedded_textures.csv`` (``packed`` = "arx" for members that
+  only exist after decompression).
 
 * ``audio`` — decode ``.vds``/``.vdm`` streamed audio to 16-bit WAV.
 
@@ -689,6 +694,41 @@ def iter_embedded_xtx(data: bytes) -> Iterable[tuple[int, bytes]]:
         i += 4
 
 
+def iter_arx_containers(data: bytes) -> Iterable[tuple[int, int, bytes]]:
+    """Yield ``(offset, span, payload)`` for every ARX container inside ``data``.
+
+    Scene archives (``.a``), ``.fpk`` packs, ``.arc`` bundles and a few
+    ``.bin``/``.npr`` files store their members ARX-compressed in place:
+    a 16-byte header (magic, uncompressed size, container size including
+    the header, 0), the 30-word LUT, then the bit stream. The members —
+    XTX textures, the ``lex`` models that bind their palettes, FPK packs,
+    FL00 event containers — only exist after decompression. Because the
+    ARX coder passes literal words through verbatim, the *header* of a
+    packed XTX still reads as ``XTX\0`` + sane sizes inside the stream,
+    which is exactly the "undecodable in-``.a`` variant" the raw sweep used
+    to report (528 on the retail disc): callers must skip raw hits that
+    fall inside a container's span. A hit must carry a sane header and
+    decompress to exactly the announced size; anything else is skipped.
+    """
+    i, n = 0, len(data)
+    while True:
+        i = data.find(arx.MAGIC, i)
+        if i < 0:
+            return
+        if i + 16 <= n:
+            usize, csize, zero = struct.unpack_from("<III", data, i + 4)
+            if zero == 0 and usize > 0 and 16 + 30 * 4 < csize <= n - i:
+                try:
+                    payload = arx.decompress(data[i:i + csize])
+                except (arx.ARXError, struct.error, ValueError):
+                    payload = b""
+                if len(payload) == usize:
+                    yield i, csize, payload
+                    i += csize
+                    continue
+        i += 4
+
+
 # extensions that never carry embedded XTX art (movies, audio, plain media);
 # everything else in the dump gets swept
 _NO_XTX_CARRIER = (".xtx", ".pss", ".ipu", ".vds", ".vdm", ".jpg", ".jpeg", ".txt")
@@ -1136,29 +1176,55 @@ def bump(key: str, n: int = 1) -> None:
             if not data:
                 continue
             rel = src.relative_to(dump)
+            # members compressed in place (scene archives, packs) come first:
+            # their XTX only exist after decompression, and the literal
+            # header words inside a compressed stream must not be taken for
+            # raw hits (that was the old "undecodable in-.a variant")
+            containers = list(iter_arx_containers(data))
+            spans = [(o, o + span) for o, span, _ in containers]
+            lex_pool = [(o, pay) for o, _, pay in containers
+                        if pay[:4] == b"lex\x00"]
+            # (offset label, png stem, blob, lex models, packed?)
+            hits: list[tuple[str, str, bytes, list[bytes], bool]] = []
             for off, blob in iter_embedded_xtx(data):
+                if any(a <= off < b for a, b in spans):
+                    continue
+                hits.append((f"0x{off:x}", f"{off:06x}", blob, [], False))
+            for o, _, pay in containers:
+                bump("textures_embedded_arx")
+                # a scene's textures are paletted by the lex models packed
+                # beside them: nearest member first (its material 0 seeds
+                # the base palette), the rest merged as companions
+                lexes = [lp for _, lp in
+                         sorted(lex_pool, key=lambda t: abs(t[0] - o))]
+                for k, blob in iter_embedded_xtx(pay):
+                    label = f"0x{o:x}" + (f"+0x{k:x}" if k else "")
+                    stem = f"{o:06x}" + (f"_{k:x}" if k else "")
+                    hits.append((label, stem, blob, lexes, True))
+            for label, stem, blob, lexes, packed in hits:
+                pk = "arx" if packed else ""
                 sha = hashlib.sha1(blob).hexdigest()
                 dup = seen.get(sha)
                 if dup is not None:
                     bump("textures_embedded_dup")
-                    rows.append([str(rel), f"0x{off:x}", len(blob), sha[:12],
-                                 "", dup])
+                    rows.append([str(rel), label, len(blob), sha[:12],
+                                 "", dup, pk])
                     continue
-                decoded = decode_xtx(blob)
+                decoded = decode_xtx(blob, lexes)
                 if decoded is None:
                     bump("textures_embedded_undecodable")
-                    rows.append([str(rel), f"0x{off:x}", len(blob), sha[:12],
-                                 "", "(undecodable)"])
+                    rows.append([str(rel), label, len(blob), sha[:12],
+                                 "", "(undecodable)", pk])
                     continue
                 w, h, rgba, source = decoded
-                dest = edir / rel.parent / f"{rel.name}_{off:06x}.png"
+                dest = edir / rel.parent / f"{rel.name}_{stem}.png"
                 dest.parent.mkdir(parents=True, exist_ok=True)
                 write_png(dest, w, h, rgba)
                 seen[sha] = str(dest.relative_to(browse))
                 bump("textures_embedded_png")
                 bump(f"textures_pal_{source}")
-                rows.append([str(rel), f"0x{off:x}", len(blob), sha[:12],
-                             str(dest.relative_to(browse)), ""])
+                rows.append([str(rel), label, len(blob), sha[:12],
+                             str(dest.relative_to(browse)), "", pk])
             if i % 500 == 0:
                 log(f"  {i}/{len(carriers)}  "
                     f"({stats.get('textures_embedded_png', 0)} embedded PNGs so far)")
@@ -1167,12 +1233,13 @@ def bump(key: str, n: int = 1) -> None:
             with open(browse / "embedded_textures.csv", "w", newline="") as fh:
                 w = _csv.writer(fh)
                 w.writerow(["carrier", "offset", "size", "sha1",
-                            "written", "duplicate_of"])
+                            "written", "duplicate_of", "packed"])
                 w.writerows(rows)
         log(f"textures: {stats.get('textures_embedded_png', 0)} embedded PNGs "
             f"({stats.get('textures_embedded_dup', 0)} duplicates skipped, "
-            f"{stats.get('textures_embedded_undecodable', 0)} undecodable) "
-            f"-> textures_png/_embedded/ + embedded_textures.csv")
+            f"{stats.get('textures_embedded_undecodable', 0)} undecodable; "
+            f"{stats.get('textures_embedded_arx', 0)} ARX-packed members "
+            f"decompressed) -> textures_png/_embedded/ + embedded_textures.csv")
 
     if "audio" in kinds:
         adir = browse / "audio"
 
@@ -34,7 +34,8 @@
 ``browse`` converts the extracted dump into viewable/playable formats under
 ``OUTDIR/browse/``: .xtx textures -> PNG (pure Python) plus a disc-wide
 sweep for XTX blobs embedded in effect/scene/UI containers (~3,000 more,
-written to textures_png/_embedded + embedded_textures.csv), .vds/.vdm
+ARX-packed scene members decompressed first; written to
+textures_png/_embedded + embedded_textures.csv), .vds/.vdm
 voice -> 48 kHz WAV (pure Python), battle voice/SE banks
 (yamamoto/snd/sed/*.bin) -> per-sample WAVs, .jpg copied + PS2ICON3D .res
 unpacked (icon.sys / .ico), .txt recoded to UTF-8 + string tables sniffed
 
@@ -86,7 +86,7 @@ Each `browse` kind writes one subtree, preserving `dump/` paths:
 | Directory | Count | From | Open with |
 |---|---|---|---|
 | `textures_png/` | 1,269 PNGs | `.xtx` (+ sibling `.lex` palettes) | anything |
-| `textures_png/_embedded/` | 1,365 PNGs (+ CSV manifest) | XTX blobs inside `.esd`/`.esp`/`.a`/`.bin`/`.npr`/`.rbg`/`.bxx` | anything |
+| `textures_png/_embedded/` | 1,363 PNGs (+ CSV manifest) | XTX blobs inside `.esd`/`.esp`/`.a`/`.bin`/`.npr`/`.rbg`/`.bxx` (ARX-packed members decompressed) | anything |
 | `audio/` | 104 WAVs | `.vds`/`.vdm`/`.vda` streams | anything |
 | `soundbanks/` | per-bank WAVs + `smd_catalog.csv` | `.swd`/`.smd` | anything |
 | `text/` | 588 UTF-8 files + 6 sniffed string tables | Shift-JIS `.txt`, text-bearing `.dat`/`.info`/`.res`/… | your editor |
@@ -107,9 +107,12 @@ Highlights per subtree:
   (`title.npr`, `help.npr`, the `.rbg` room backdrops). Each PNG is named
   `<carrier>_<hex offset>.png`; `browse/embedded_textures.csv` maps every
   find (including blobs skipped as byte-identical duplicates of an
-  already-decoded texture). The ~500 "undecodable" rows are all in `.a`
-  archives — an in-engine XTX variant whose sub-image pointers are GS
-  addresses, with pixel data streamed separately.
+  already-decoded texture); `packed` = `arx` marks members that only
+  exist after in-place ARX decompression (the `scene/cf*.a` archives).
+  Those 603 are each scene's private copies of NPC, enemy, object and
+  map textures — every one byte-identical to a standalone `.xtx`, so the
+  CSV records them as duplicates and doubles as a per-scene provenance
+  map (the rows an older build reported as "undecodable").
 * **`text/chain0/karakama/evtitem.dat.strings.txt`** — every event-item
   description; **`text/chain0/tanaka/CASINO.res.strings.txt`** — the casino
   dialogue; the `nisimori/*.info.strings.txt` dev configs keep their
 
@@ -78,16 +78,22 @@ Header size_comp = whole blob length incl. header; unk = 0.
   `scene/cf0210.a`, `cf0740.a`, `cf1800.a`, `cf3140.a` — 12 hair-palette
   carriers total (verified by disc-wide sweep; quarter-row sweep confirms
   no others).
-* **cf*.a re-frames the texture**: XTX magic + sub-header present but the
-  entry layout differs and the canvas is stored with 4-byte inserts at a
-  ~2020-byte effective row stride, so only some 64-byte CLUT rows survive
+* **cf*.a members are ARX-compressed in place** (understood 2026-09-24;
+  see "Scene archives" below). What earlier looked like a "re-framed"
+  canvas with 4-byte inserts at a ~2020-byte stride is the ARX bit
+  stream: the coder passes literal 32-bit words through verbatim with
+  control words interleaved, so only *some* 64-byte CLUT rows survive
   contiguously (cf0210.a: 26/32 half-rows intact, 6 split). A row-level
   sweep alone therefore *partially* patches them — caught in the act via
   PINE RAM forensics: the running game builds the opening-sim KOS-MOS
   from cf0210.a, and its in-RAM CLUT showed exactly the 30 row-patched
-  entries pink and 91 blue. Fix: anchored entry-level (aligned 4-byte
-  value) replacement; safe because the hair ramp shares no exact RGBA
-  word with any other tile in the canvas (verified 0 overlap).
+  entries pink and 91 blue. The shipped fix — anchored entry-level
+  (aligned 4-byte value) replacement — works because every hair-ramp
+  word is a stream literal (none is one of the container's 30 LUT
+  words) and shares no exact RGBA word with any other tile (verified 0
+  overlap). The principled route is decompress → patch → `arx.compress`
+  → write back, which needs the `.a` TOC re-pointed when the container
+  size changes; not built.
 * The engine also bakes scene lighting into CLUTs at load time (RAM
   copies differ from disc in RGB but not alpha), so RAM-vs-file palette
   comparisons must expect tinted variants.
@@ -182,6 +188,51 @@ as CT32 is more coherent, the block is drawn straight from the canvas
 finally renders the KOS-MOS hair band as hair instead of noise.
 Regions failing both readings stay garbled — the remaining static limit.
 
+## Scene archives `.a` (+ `.fpk`, `.arc`) — ARX-packed members (`browse.py: iter_arx_containers`)
+
+`scene/cf*.a` (112 files, one per field scene) is a flat bundle:
+
+```
+u32 count; u32 offset[count]      16-byte-aligned; some entries point INTO a
+                                  member (streaming pages), not all are starts
+record: 0x100 bytes of float data (placement/lighting; not parsed), then
+        the member — usually an ARX container:
+  "ARX\0" u32 usize u32 csize(includes this 16-byte header + 30-word LUT)
+  u32 0; LUT[30]; bit stream          -> arx.decompress(data[o:o+csize])
+member kinds (retail, 112 archives): 1,864 containers = lex 778,
+XTX 603, FPK 483. Uncompressed members exist too (JNT\0 joint tables,
+raw XTX sprites with their own 16x16 palette, raw 256x256 backdrops).
+(`.fpk`, `.arc` and a few `.bin`/`.npr` are whole-file ARX objects the
+TOC layer already decompresses; the 44 `mtnpack/*.arc` are FL00 wrappers
+of motion data, not Java — `carve_classes` finds nothing in them.)
+```
+
+The ARX coder passes literal words through verbatim, so a packed XTX's
+**header survives inside the compressed stream**: `XTX\0`, a plausible
+total size and a sub-image table whose `file_addr` reads as a VIF DIRECT
+code (`0x5000xx01`) — that is what the raw sweep used to report as an
+"in-`.a` XTX variant with GS pointers, pixels streamed separately" (528
+undecodable hits on retail; all of them). There is no such variant. The
+sweep now decompresses every container first (`iter_arx_containers`:
+sane header + decompresses to exactly `usize`), skips raw hits that fall
+inside a container's span, and decodes the XTX members with the `lex`
+members packed beside them as their palette source (nearest member
+first — its material 0 seeds the base palette — the rest merged as
+companions, same as `kosmos_face.lex` on the standalone atlases).
+Result on retail: all 603 decode (0 undecodable) and every one is
+byte-identical to a standalone `char/`, `enemy/`, `obj/`, `map/` or
+`robo/` `.xtx` — each scene packs private copies of what it draws. The
+sweep therefore adds no new art, but `embedded_textures.csv` now maps
+every scene archive to the textures it carries (the "12 copies of the
+KOS-MOS palette" hunt in the Repack notes, answered disc-wide).
+
+Dead ends worth not repeating: the "GS pointer" fields ARE consistent
+(`size` = (w*h*4+32)/16 qwords, addresses chain with no gaps) because
+they are the real header words; decoding the bytes after them as pixels
+finds coherent-looking art for the first ~60 KB (the stream's literal
+words are mostly pixel data) and then noise — the compressed stream is
+shorter than the texture, so the "pixels" run into the next member.
+
 ## LEX models — materials only (`browse.py: lex_materials`) — via xenotool
 
 ```
 
@@ -3,6 +3,43 @@
 Newest first. Each entry lists what changed, why, and what you have to do
 to benefit from it.
 
+## 2026-09-24 — scene-archive textures: the "undecodable variant" was ARX
+
+The ~500 embedded XTX hits the sweep reported as *undecodable* (all in
+`scene/cf*.a`) were never a texture variant. Scene archives, `.fpk`
+packs and `.arc` bundles keep their members **ARX-compressed in place**,
+and the ARX coder passes literal words through verbatim — so a packed
+texture's *header* still reads as `XTX\0` plus sane sizes inside the
+compressed stream, while its pixels do not exist until decompression.
+
+* `browse --kinds textures` now decompresses every in-file ARX container
+  first (`browse.py: iter_arx_containers`; 1,864 inside the 112 retail
+  scene archives: 603 XTX, 778 `lex` models, 483 FPK packs), decodes
+  the XTX members, and palettes them with the `lex` models packed beside
+  them (nearest member first). Raw hits inside a container's span are
+  skipped, so the bogus rows are gone — and so are two "textures" the
+  old sweep had decoded out of the middle of a compressed stream
+  (`cf3021.a_208e4c`, `cf3070.a_61690c`: garbage).
+* Retail result: **1,363 embedded PNGs, 1,696 duplicates skipped, 0
+  undecodable** (was 1,365 / 1,095 / 528). Nothing new to *look at*:
+  all 603 packed textures are byte-identical copies of standalone
+  `.xtx` you already have — the NPC skins (`char/`, 266), enemies
+  (`enemy/`, 197), objects (`obj/`, 66), map atlases (`map/`, 65) and
+  mechs (`robo/`, 9) each field scene packs for itself. What is new is
+  the **provenance map**: `browse/embedded_textures.csv` now lists, per
+  scene archive, every texture it carries and which standalone PNG it
+  equals (`packed` = `arx`). That is the query the recolor tooling
+  needed by hand ("which `cf*.a` carry KOS-MOS's palette?"), answered
+  for every texture on the disc.
+* `docs/FORMATS.md` gets the `.a` archive layout (TOC + 0x100-byte
+  record header + ARX member) and corrects the repack note: the
+  "re-framed canvas with 4-byte inserts" that `pinkhair.py` works around
+  is the ARX bit stream (the entry-level sweep works because the hair
+  words are stream literals).
+
+To pick this up: re-run `browse --kinds textures` on an existing dump
+(no re-extract). Pure-Python ARX adds ~2 minutes to the sweep.
+
 ## 2026-08-21 — texture decode overhaul, embedded content sweep, BGM tempo fix
 
 Full retest of the extractor against the retail USA ISO (two complete