feat(aux): ENC aux files (TXTDSC/PICREP) for the pick report

Bundle the external resources ENC features reference by filename (TXTDSC/NTXTDS
text, PICREP pictures) so the cursor-pick report can show them:
- cmd/chartplotter/aux.go + bake.go: collect referenced aux files during the bake
  and ship them in a companion "<stem>-aux.zip" (TIFF→PNG, index.json).
- web/aux-store.mjs: client loads the companion aux.zip and serves files by name.
- web/pick-report.mjs: render TXTDSC text + PICREP pictures inline.
- web/pmtiles-source.mjs: minor supporting tweak.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: beetlebugorg

cmd/chartplotter/aux.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"image/png"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/image/tiff"
+)
+
+// Aux ("auxiliary") files are the external resources an ENC feature points at by
+// filename rather than carrying inline: TXTDSC/NTXTDS textual descriptions (.TXT)
+// and PICREP pictures (.TIF/.JPG). They ship in the exchange set alongside the
+// .000 cells. The baked tiles carry only the *filename* (in the s57 blob), so we
+// bundle the referenced files into a single companion archive — "<stem>-aux.zip"
+// — that the client fetches once and reads by filename for the pick report.
+
+// isAuxContent reports whether a non-cell file is aux *content* we ship. It keys
+// off the content extensions (text + pictures) and excludes the exchange-set
+// catalogue (CATALOG.031) and readmes, which are set plumbing, not feature data.
+func isAuxContent(name string) bool {
+	base := strings.ToUpper(filepath.Base(name))
+	if strings.HasPrefix(base, "README") || strings.HasPrefix(base, "CATALOG") {
+		return false
+	}
+	switch strings.ToLower(filepath.Ext(name)) {
+	case ".txt", ".tif", ".tiff", ".jpg", ".jpeg", ".png":
+		return true
+	}
+	return false
+}
+
+// auxKey normalises an aux filename to the form features reference it by: the
+// bare basename, upper-cased (S-57 stores TXTDSC/PICREP values upper-cased, and
+// exchange sets are case-inconsistent across platforms).
+func auxKey(name string) string { return strings.ToUpper(filepath.Base(name)) }
+
+// auxEntry is one file's record in the companion zip's index.json.
+type auxEntry struct {
+	Stored string `json:"stored"`         // entry name inside the zip
+	Type   string `json:"type"`           // MIME type the client should make a Blob with
+	From   string `json:"from,omitempty"` // original filename, when transcoded (TIFF→PNG)
+}
+
+// contentType maps a stored filename to the MIME type the pick report renders.
+func contentType(name string) string {
+	switch strings.ToLower(filepath.Ext(name)) {
+	case ".txt":
+		return "text/plain"
+	case ".png":
+		return "image/png"
+	case ".jpg", ".jpeg":
+		return "image/jpeg"
+	case ".tif", ".tiff":
+		return "image/tiff"
+	}
+	return "application/octet-stream"
+}
+
+// writeAuxZip packages the collected aux files into "<stem>-aux.zip" next to the
+// baked archive(s), transcoding TIFF pictures to PNG (browsers can't render TIFF)
+// and writing an index.json mapping each referenced filename to its stored entry.
+// Returns the zip's basename (for the manifest), or "" when there's nothing to ship.
+func writeAuxZip(stem string, aux map[string][]byte) (string, error) {
+	if len(aux) == 0 {
+		return "", nil
+	}
+	out := stem + "-aux.zip"
+	f, err := os.Create(out)
+	if err != nil {
+		return "", err
+	}
+	zw := zip.NewWriter(f)
+
+	index := map[string]auxEntry{}
+	for key, data := range aux {
+		stored := filepath.Base(key)
+		typ := contentType(stored)
+		from := ""
+
+		// Browsers have no TIFF decoder; transcode to PNG so the picture renders
+		// inline. On failure, ship the original and let the client offer a download.
+		if ext := strings.ToLower(filepath.Ext(stored)); ext == ".tif" || ext == ".tiff" {
+			if png, e := tiffToPNG(data); e == nil {
+				from = stored
+				stored = strings.TrimSuffix(stored, filepath.Ext(stored)) + ".png"
+				typ = "image/png"
+				data = png
+			} else {
+				fmt.Fprintf(os.Stderr, "  aux: keeping %s as TIFF (transcode failed: %v)\n", stored, e)
+			}
+		}
+
+		w, err := zw.Create(stored)
+		if err != nil {
+			zw.Close()
+			f.Close()
+			return "", err
+		}
+		if _, err := w.Write(data); err != nil {
+			zw.Close()
+			f.Close()
+			return "", err
+		}
+		index[key] = auxEntry{Stored: stored, Type: typ, From: from}
+	}
+
+	iw, err := zw.Create("index.json")
+	if err != nil {
+		zw.Close()
+		f.Close()
+		return "", err
+	}
+	enc := json.NewEncoder(iw)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(map[string]any{"version": 1, "files": index}); err != nil {
+		zw.Close()
+		f.Close()
+		return "", err
+	}
+
+	if err := zw.Close(); err != nil {
+		f.Close()
+		return "", err
+	}
+	if err := f.Close(); err != nil {
+		return "", err
+	}
+	st, _ := os.Stat(out)
+	fmt.Printf("wrote %d aux file(s) → %s (%.1f KB)\n", len(index), out, float64(st.Size())/1024)
+	return filepath.Base(out), nil
+}
+
+// tiffToPNG decodes a TIFF image and re-encodes it as PNG.
+func tiffToPNG(data []byte) ([]byte, error) {
+	img, err := tiff.Decode(bytes.NewReader(data))
+	if err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	if err := png.Encode(&buf, img); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}

cmd/chartplotter/bake.go

@@ -28,7 +28,7 @@ type bakeCmd struct {
 }
 
 func (c bakeCmd) Run() error {
-	cells, err := collectCells(c.In)
+	cells, aux, err := collectCells(c.In)
 	if err != nil {
 		return err
 	}
@@ -44,7 +44,7 @@ func (c bakeCmd) Run() error {
 	// Per-band streaming holds only one band's geometry at a time, so it skips the
 	// all-cells BuildBakerWithUpdates entirely.
 	if c.Bands {
-		return c.runBands(cells)
+		return c.runBands(cells, aux)
 	}
 
 	b, ok, err := baker.BuildBakerWithUpdates(cells, c.Overzoom, func(name string, err error) {
@@ -86,6 +86,12 @@ func (c bakeCmd) Run() error {
 	st, _ := os.Stat(c.Out)
 	fmt.Printf("baked %d cell(s) → %s (%d tiles, %.1f MB)\n", len(ok), c.Out, pb.Count(), float64(st.Size())/(1<<20))
 
+	stem := strings.TrimSuffix(c.Out, filepath.Ext(c.Out))
+	auxFile, err := writeAuxZip(stem, aux)
+	if err != nil {
+		return err
+	}
+
 	if c.Manifest != "" {
 		file := c.BaseURL
 		if file == "" {
@@ -99,6 +105,9 @@ func (c bakeCmd) Run() error {
 				"bounds": []float64{bb.MinLon, bb.MinLat, bb.MaxLon, bb.MaxLat},
 			}},
 		}
+		if auxFile != "" {
+			man["aux"] = auxFile
+		}
 		mf, err := os.Create(c.Manifest)
 		if err != nil {
 			return err
@@ -118,7 +127,7 @@ func (c bakeCmd) Run() error {
 // runBands writes one gap-clipped PMTiles archive per navigational band
 // (<out-stem>-<slug>.pmtiles) plus a manifest tagging each with its band slug, so
 // the frontend loads each into its own chart-<slug> source.
-func (c bakeCmd) runBands(cells map[string]baker.CellData) error {
+func (c bakeCmd) runBands(cells map[string]baker.CellData, aux map[string][]byte) error {
 	ext := filepath.Ext(c.Out)
 	stem := strings.TrimSuffix(c.Out, ext)
 	var entries []map[string]any
@@ -171,14 +180,23 @@ func (c bakeCmd) runBands(cells map[string]baker.CellData) error {
 	}
 	fmt.Printf("baked %d cell(s) → %d band archive(s)\n", nCells, len(entries))
 
+	auxFile, err := writeAuxZip(stem, aux)
+	if err != nil {
+		return err
+	}
+
 	if c.Manifest != "" {
 		mf, err := os.Create(c.Manifest)
 		if err != nil {
 			return err
 		}
 		enc := json.NewEncoder(mf)
 		enc.SetIndent("", "  ")
-		if err := enc.Encode(map[string]any{"districts": entries}); err != nil {
+		man := map[string]any{"districts": entries}
+		if auxFile != "" {
+			man["aux"] = auxFile
+		}
+		if err := enc.Encode(man); err != nil {
 			mf.Close()
 			return err
 		}
@@ -201,12 +219,21 @@ func encExt(p string) string {
 // collectCells gathers each cell's base (.000) plus its update files (.001…) from
 // the inputs (zip bundles, directories, and/or individual cell files), grouped by
 // cell name. First base wins on a duplicate; updates accumulate.
-func collectCells(paths []string) (map[string]baker.CellData, error) {
+func collectCells(paths []string) (map[string]baker.CellData, map[string][]byte, error) {
 	type acc struct {
 		base    []byte
 		updates map[string][]byte
 	}
-	byCell := map[string]*acc{} // keyed by cell stem (e.g. US4MD81M)
+	byCell := map[string]*acc{}  // keyed by cell stem (e.g. US4MD81M)
+	aux := map[string][]byte{}   // referenced aux files, keyed by auxKey (UPPER basename)
+	addAux := func(name string, data []byte) {
+		if !isAuxContent(name) {
+			return
+		}
+		if k := auxKey(name); aux[k] == nil {
+			aux[k] = data
+		}
+	}
 	add := func(name string, data []byte) {
 		ext := encExt(name)
 		if ext == "" {
@@ -232,7 +259,7 @@ func collectCells(paths []string) (map[string]baker.CellData, error) {
 	for _, p := range paths {
 		info, err := os.Stat(p)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		switch {
 		case info.IsDir():
@@ -247,23 +274,27 @@ func collectCells(paths []string) (map[string]baker.CellData, error) {
 				} else if strings.EqualFold(filepath.Ext(path), ".zip") {
 					// A directory of per-cell .zip bundles (e.g. an IENC download) — unpack
 					// each in place rather than requiring the cells be extracted first.
-					if e := addZipCells(path, add); e != nil {
+					if e := addZipCells(path, add, addAux); e != nil {
 						fmt.Fprintf(os.Stderr, "  skip zip %s: %v\n", path, e)
 					}
+				} else if isAuxContent(path) {
+					if b, e := os.ReadFile(path); e == nil {
+						addAux(path, b)
+					}
 				}
 				return nil
 			})
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 		case strings.EqualFold(filepath.Ext(p), ".zip"):
-			if err := addZipCells(p, add); err != nil {
-				return nil, err
+			if err := addZipCells(p, add, addAux); err != nil {
+				return nil, nil, err
 			}
 		case encExt(p) != "":
 			b, e := os.ReadFile(p)
 			if e != nil {
-				return nil, e
+				return nil, nil, e
 			}
 			add(p, b)
 		default:
@@ -278,17 +309,18 @@ func collectCells(paths []string) (map[string]baker.CellData, error) {
 		}
 		cells[stem+".000"] = baker.CellData{Base: a.base, Updates: a.updates}
 	}
-	return cells, nil
+	return cells, aux, nil
 }
 
-func addZipCells(zipPath string, add func(name string, data []byte)) error {
+func addZipCells(zipPath string, add, addAux func(name string, data []byte)) error {
 	zr, err := zip.OpenReader(zipPath)
 	if err != nil {
 		return err
 	}
 	defer zr.Close()
 	for _, e := range zr.File {
-		if encExt(e.Name) == "" {
+		isCell := encExt(e.Name) != ""
+		if !isCell && !isAuxContent(e.Name) {
 			continue
 		}
 		rc, err := e.Open()
@@ -300,7 +332,11 @@ func addZipCells(zipPath string, add func(name string, data []byte)) error {
 		if err != nil {
 			return err
 		}
-		add(e.Name, data)
+		if isCell {
+			add(e.Name, data)
+		} else {
+			addAux(e.Name, data)
+		}
 	}
 	return nil
 }

web/aux-store.mjs

@@ -0,0 +1,65 @@
+// AuxStore — loads the companion "<stem>-aux.zip" the baker ships next to the
+// hosted .pmtiles. It holds the external resources an ENC feature points at by
+// *filename* rather than carrying inline: TXTDSC/NTXTDS textual descriptions and
+// PICREP pictures. The baked tiles carry only the filename (in the s57 blob), so
+// the pick report resolves it here, by the (upper-cased) referenced name.
+//
+// The zip is fetched whole once (it's small — the texts plus PNG-transcoded
+// pictures) and parsed with the same dependency-free reader the .zip import uses.
+// No server: it's a static file beside the charts, so it updates with them.
+
+import { readCentralDirectory, extractEntry } from "./zip-import.mjs";
+
+export class AuxStore {
+  constructor() {
+    this._index = null;      // referencedName(UPPER) → { stored, type, from }
+    this._entries = null;    // stored entry name → central-directory entry
+    this._blob = null;
+    this._cache = new Map(); // stored → resolved { type, text|url }
+  }
+
+  // Fetch + parse the aux zip. Best-effort: any failure leaves the store empty
+  // and the pick report degrades to showing the raw filename. Returns true on load.
+  async load(url) {
+    try {
+      const r = await fetch(url);
+      if (!r.ok) throw new Error("HTTP " + r.status);
+      const blob = await r.blob();
+      const byName = new Map((await readCentralDirectory(blob)).map((e) => [e.name, e]));
+      const idx = byName.get("index.json");
+      if (!idx) throw new Error("aux zip has no index.json");
+      const meta = JSON.parse(new TextDecoder("utf-8").decode(await extractEntry(blob, idx)));
+      this._index = meta.files || {};
+      this._entries = byName;
+      this._blob = blob;
+      return true;
+    } catch (e) {
+      console.warn("[aux] load failed:", e.message);
+      return false;
+    }
+  }
+
+  // Is `ref` (a TXTDSC/PICREP filename) present in this set?
+  has(ref) { return !!(this._index && this._index[String(ref).toUpperCase()]); }
+
+  // Resolve a referenced filename to { type:"text", text } or { type:"image", url }.
+  // Text is decoded ISO-8859-1 (the ENC text charset — degree signs etc.); images
+  // become object URLs for an <img>. Cached, so repeat picks are instant.
+  async resolve(ref) {
+    if (!this._index) return null;
+    const meta = this._index[String(ref).toUpperCase()];
+    if (!meta) return null;
+    if (this._cache.has(meta.stored)) return this._cache.get(meta.stored);
+    const entry = this._entries.get(meta.stored);
+    if (!entry) return null;
+    const bytes = await extractEntry(this._blob, entry);
+    let out;
+    if ((meta.type || "").startsWith("image/")) {
+      out = { type: "image", url: URL.createObjectURL(new Blob([bytes], { type: meta.type })) };
+    } else {
+      out = { type: "text", text: new TextDecoder("iso-8859-1").decode(bytes) };
+    }
+    this._cache.set(meta.stored, out);
+    return out;
+  }
+}