brane 0.1.1 → 0.3.1

package/dist/shared/membrane-palette.js

@@ -0,0 +1,253 @@
+/**
+ * The 膜 film's color schemes: which colors, in what order.
+ *
+ * The first palette (#465) was a cosine gradient whose three channel phases
+ * sat a third of a turn apart, so every scheme it could produce was the same
+ * rainbow — all hues, always in the same order — and the noise that walked it
+ * had a standard deviation of 0.097, too small to leave the rainbow. Across
+ * sixteen taps it read as about four schemes (claude-1cwe8u9p:22).
+ *
+ * A scheme here is two things, deliberately separate:
+ *
+ * - **Lightness** is today's banding, unchanged in character: a cosine in
+ *   film thickness at 2.4–3.7 cycles per unit, swinging L from about 0.35 to
+ *   0.95. It is what gives the film its detail density and contrast, and the
+ *   operator asked that those stay exactly as they were (claude-1cwe8u9p:28).
+ * - **Hue** comes from 3–5 anchor colors, randomly permuted — the same colors
+ *   in another order are another film (claude-1cwe8u9p:23) — cycled through
+ *   at their own rate, incommensurate with the lightness bands so the two
+ *   never lock. Transitions between anchors are eased so a color holds and
+ *   then turns, rather than smearing into its neighbor (claude-1cwe8u9p:29).
+ *
+ * No two anchors of one scheme may look alike (claude-1cwe8u9p:31–33). Hue
+ * angle alone does not guarantee that: where sRGB is narrow — the cyans — two
+ * hues 30° apart fit to nearly the same displayable color. So anchors are
+ * compared as they will render: gamut-fitted, in OKLab, at the lightnesses
+ * the bands pass through.
+ *
+ * Window-free, and every draw takes its random source as an argument, so
+ * `src/test/membrane-palette.test.ts` can pin all of this with a seeded one.
+ */
+export const MIN_ANCHORS = 3;
+export const MAX_ANCHORS = 5;
+/** Minimum hue separation between any two anchors, degrees. */
+export const MIN_HUE_SEP_DEG = 28;
+/** Minimum OKLab distance between any two anchors once fitted to sRGB. */
+export const MIN_ANCHOR_DE = 0.09;
+/** The lightnesses at which anchors are compared: the band's middle range. */
+export const DISTINCT_AT_L = [0.5, 0.65, 0.8];
+/** How far a keyframe must be from the one it replaces (mean OKLab a/b distance). */
+export const MIN_SCHEME_DISTANCE = 0.12;
+/**
+ * No color from the band between amber and green. The band from about 60°
+ * (amber) through yellow to about 130° (lime) reads as snot green and
+ * mustard at the lightnesses the film's bands pass through, and the
+ * operator wants it out of every scheme (claude-u6qlei0j:8, :17). Three
+ * measures:
+ *
+ * - No anchor in EXCLUDED_HUE_DEG. A draw that lands there is redrawn, not
+ *   remapped, so no hue on either side is over-represented and the families
+ *   keep their shape.
+ * - Anchors are joined by a straight line through OKLab a/b, not around the
+ *   hue wheel (abAt, the shader's anchorAB). Around the wheel, green to
+ *   magenta swept through yellow, orange and red — a small rainbow whose
+ *   yellow strip was a mustard band with hard edges. Along the line the two
+ *   fade through gray and pass through no hue they do not share. Neighboring
+ *   hues (30–45°) look the same either way.
+ * - What still lands in the band — two anchors that straddle it closely,
+ *   orange and green, say — is shown neutral: chroma fades to zero across
+ *   BAND_FADE_DEG (ramped inside the band, so an anchor just outside keeps
+ *   its color), and the film goes silvery there at the banding's lightness.
+ *   (Before this the shader *lifted* lightness through the band so amber
+ *   would glow, per claude-1cwe8u9p:38 — the opposite instinct.)
+ */
+export const EXCLUDED_HUE_DEG = [60, 130];
+/** Chroma is faded to nothing between the inner two, ramping over the outer pairs. */
+export const BAND_FADE_DEG = [60, 75, 115, 130];
+/** Whether a hue (degrees, 0–360) is one no anchor may take. */
+export function hueExcluded(hDeg) {
+    return hDeg >= EXCLUDED_HUE_DEG[0] && hDeg <= EXCLUDED_HUE_DEG[1];
+}
+/** How much of a hue's chroma the band takes away, 0 outside it, 1 in its middle. */
+export function bandFade(hDeg) {
+    const [b0, b1, b2, b3] = BAND_FADE_DEG;
+    return smoothstep(b0, b1, hDeg) * (1 - smoothstep(b2, b3, hDeg));
+}
+/** An OKLab a/b offset with the band's chroma taken out of it. */
+export function neutralizeBand(a, b) {
+    const hDeg = ((Math.atan2(b, a) * 180) / Math.PI + 360) % 360;
+    const k = 1 - bandFade(hDeg);
+    return [a * k, b * k];
+}
+// ---- OKLab (Björn Ottosson) ----
+export function oklabToLinearSrgb(L, a, b) {
+    const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+    const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+    const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+    const l = l_ * l_ * l_, m = m_ * m_ * m_, s = s_ * s_ * s_;
+    return [
+        4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+        -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+        -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
+    ];
+}
+const EPS = 1e-4;
+export function inSrgbGamut(L, a, b) {
+    return oklabToLinearSrgb(L, a, b).every((v) => v >= -EPS && v <= 1 + EPS);
+}
+/** OKLab of (L, C, h) with C reduced as far as needed to be displayable. The
+ *  shader does the same fit per pixel, with fewer bisection steps. */
+export function fitToGamut(L, C, h) {
+    const at = (c) => [L, c * Math.cos(h), c * Math.sin(h)];
+    if (inSrgbGamut(...at(C)))
+        return at(C);
+    let lo = 0, hi = C;
+    for (let i = 0; i < 20; i++) {
+        const mid = (lo + hi) / 2;
+        if (inSrgbGamut(...at(mid)))
+            lo = mid;
+        else
+            hi = mid;
+    }
+    return at(lo);
+}
+// ---- anchors ----
+const DEG = Math.PI / 180;
+const smoothstep = (a, b, x) => {
+    const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+    return t * t * (3 - 2 * t);
+};
+export function hueSeparationDeg(a, b) {
+    const d = Math.abs((((a - b) % 360) + 360) % 360);
+    return Math.min(d, 360 - d);
+}
+/** Whether no two of these hues (degrees) would render alike. */
+export function anchorsDistinct(huesDeg) {
+    for (let i = 0; i < huesDeg.length; i++) {
+        for (let j = i + 1; j < huesDeg.length; j++) {
+            if (hueSeparationDeg(huesDeg[i], huesDeg[j]) < MIN_HUE_SEP_DEG)
+                return false;
+            for (const L of DISTINCT_AT_L) {
+                const [, a1, b1] = fitToGamut(L, 0.3, huesDeg[i] * DEG);
+                const [, a2, b2] = fitToGamut(L, 0.3, huesDeg[j] * DEG);
+                if (Math.hypot(a1 - a2, b1 - b2) < MIN_ANCHOR_DE)
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+const range = (rng, lo, hi) => lo + (hi - lo) * rng();
+const pick = (rng, xs) => xs[Math.floor(rng() * xs.length)];
+/** Harmony families, each a base hue (degrees) → anchor hues (degrees). */
+const FAMILIES = {
+    analogous: (h, rng) => {
+        const n = pick(rng, [3, 4]), s = range(rng, 30, 45);
+        return Array.from({ length: n }, (_, i) => h + s * (i - (n - 1) / 2));
+    },
+    complementary: (h, rng) => {
+        const s = range(rng, 35, 60);
+        return pick(rng, [[h, h + 180, h + s], [h, h + 180, h + 180 + s], [h, h + s, h + 180, h + 180 + s]]);
+    },
+    split: (h, rng) => { const s = range(rng, 25, 45); return [h, h + 180 - s, h + 180 + s]; },
+    triadic: (h) => [h, h + 120, h + 240],
+    tetradic: (h, rng) => { const w = pick(rng, [60, 90]); return [h, h + w, h + 180, h + 180 + w]; },
+    accent: (h, rng) => { const s = range(rng, 30, 45); return [h, h + s, h + pick(rng, [150, 180, 210]) + s / 2]; },
+    wild: (_h, rng) => Array.from({ length: pick(rng, [3, 4, 5]) }, () => range(rng, 0, 360)),
+};
+export const SCHEME_FAMILIES = Object.keys(FAMILIES);
+function shuffle(xs, rng) {
+    for (let i = xs.length - 1; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        [xs[i], xs[j]] = [xs[j], xs[i]];
+    }
+    return xs;
+}
+/** One scheme: a family's hues, jittered, redrawn until all are distinct and
+ *  none is in the excluded band, then permuted. */
+export function sampleScheme(rng) {
+    let family, degs;
+    do {
+        family = pick(rng, SCHEME_FAMILIES);
+        degs = FAMILIES[family](range(rng, 0, 360), rng)
+            .map((h) => (((h + range(rng, -8, 8)) % 360) + 360) % 360);
+    } while (degs.length < MIN_ANCHORS || degs.length > MAX_ANCHORS || degs.some(hueExcluded) || !anchorsDistinct(degs));
+    const hues = shuffle(degs, rng).map((d) => d * DEG);
+    return {
+        family,
+        hues,
+        chromas: hues.map(() => range(rng, 0.15, 0.32)),
+        light: [range(rng, 2.4, 3.7), rng(), range(rng, 0.62, 0.68), range(rng, 0.27, 0.32)],
+        // At least one full pass through the anchors per unit thickness, so the
+        // glyph's range of thicknesses shows every one of them.
+        hue: [range(rng, 1.0, 1.5), rng(), range(rng, 0.18, 0.45)],
+    };
+}
+/** The scheme's color at position `x` through one pass of the anchors,
+ *  0 ≤ x < 1, as an OKLab a/b offset — the shader's anchor lookup (anchorAB),
+ *  for tests and tooling: each anchor holds, then turns into the next along
+ *  a straight line, and the band is neutralized. */
+export function abAt(s, x, w = s.hue[2]) {
+    const n = s.hues.length;
+    const pos = ((((x % 1) + 1) % 1) * n);
+    const i = Math.floor(pos) % n, j = (i + 1) % n;
+    const f = smoothstep(0.5 - w, 0.5 + w, pos - Math.floor(pos));
+    const ai = s.chromas[i] * Math.cos(s.hues[i]), bi = s.chromas[i] * Math.sin(s.hues[i]);
+    const aj = s.chromas[j] * Math.cos(s.hues[j]), bj = s.chromas[j] * Math.sin(s.hues[j]);
+    return neutralizeBand(ai + (aj - ai) * f, bi + (bj - bi) * f);
+}
+/** Hue (radians) and chroma at position `x`: abAt in polar form. */
+export function hueChromaAt(s, x, w = s.hue[2]) {
+    const [a, b] = abAt(s, x, w);
+    return [Math.atan2(b, a), Math.hypot(a, b)];
+}
+/** Mean a/b distance between two schemes' hue cycles, pass for pass. Order
+ *  matters: a permutation of the same anchors is far from the original. */
+export function schemeDistance(p, q) {
+    const N = 32;
+    let t = 0;
+    for (let i = 0; i < N; i++) {
+        const [h1, c1] = hueChromaAt(p, i / N, 0.5);
+        const [h2, c2] = hueChromaAt(q, i / N, 0.5);
+        t += Math.hypot(c1 * Math.cos(h1) - c2 * Math.cos(h2), c1 * Math.sin(h1) - c2 * Math.sin(h2));
+    }
+    return t / N;
+}
+/** The keyframe after `prev`: a fresh scheme far enough from it — from each
+ *  of them, when there are several, as a terrain cell's neighbors are — to
+ *  read as a different film rather than a nudge. */
+export function nextScheme(prev, rng) {
+    const prevs = prev === null ? [] : Array.isArray(prev) ? prev : [prev];
+    for (let tries = 0; tries < 200; tries++) {
+        const s = sampleScheme(rng);
+        if (prevs.every((p) => schemeDistance(s, p) >= MIN_SCHEME_DISTANCE))
+            return s;
+    }
+    return sampleScheme(rng);
+}
+/** Texels per scheme row in the shader's table (see packScheme). */
+export const SCHEME_TEXELS = 5;
+/**
+ * One scheme as a row of the shader's scheme table, SCHEME_TEXELS RGBA texels:
+ *   (anchor count, hue rate, hue phase, transition half-width),
+ *   (banding cycles, banding phase, L mid, L amplitude),
+ *   then the anchors as packAnchors lays them out, two per texel.
+ */
+export function packScheme(s) {
+    const out = new Float32Array(SCHEME_TEXELS * 4);
+    out.set([s.hues.length, ...s.hue, ...s.light]);
+    out.set(packAnchors(s), 8);
+    return out;
+}
+/** Anchors packed for the shader: (hue, chroma) pairs, with the first repeated
+ *  after the last so the lookup never needs a modulo, padded to MAX_ANCHORS + 1. */
+export function packAnchors(s) {
+    const out = new Float32Array((MAX_ANCHORS + 1) * 2);
+    for (let k = 0; k <= MAX_ANCHORS; k++) {
+        const j = k % s.hues.length;
+        out[2 * k] = s.hues[j];
+        out[2 * k + 1] = s.chromas[j];
+    }
+    return out;
+}
+//# sourceMappingURL=membrane-palette.js.map

package/dist/shared/membrane-terrain.js

@@ -0,0 +1,212 @@
+/**
+ * The 膜 film's scheme terrain: which colors the base film wears *where*.
+ *
+ * Until this, the unblotched film had one scheme, the incumbent, and only a
+ * wash could change it. Now the scheme is a property of place: glyph space —
+ * the frame the splotches live in, the one a held drag shifts — is divided
+ * into cells, each with a scheme of its own. A hold-and-drag therefore
+ * scrolls the film through color space (claude-xaj5pb9b:3, :4): the base
+ * noise itself turns as it comes across a seam, and turns back when dragged
+ * back, because the map is fixed (claude-xaj5pb9b:5). The lift never scrolls
+ * it; splotches don't ride the lift either, so what is painted and what is
+ * found stay in one frame.
+ *
+ * **The cells are irregular** (claude-xaj5pb9b:16). The first cut tiled a
+ * square grid, and its axis-aligned seams were plain to see while scrolling
+ * — the eye locks onto straight lines moving together. Now each cell of the
+ * underlying grid has a *seed point* jittered within it, and a point of the
+ * film wears the scheme of the nearest seed (a Voronoi partition): walls at
+ * every angle, three-way corners, no two alike. Every cell whose seed is
+ * within SEAM of the nearest gets a share of the point, falling smoothly
+ * with the excess (`blend`), so the color is continuous everywhere — a
+ * nearest-two blend was not: it jumped wherever the runner-up changed,
+ * along a straight line inside every three-way corner. What the shares
+ * blend is the scheme's *parameters*, and the film's noise is rendered
+ * through the blended scheme (claude-xaj5pb9b:27) — blending the rendered
+ * colors instead averaged two bandings against each other and washed the
+ * texture out of every seam (claude-xaj5pb9b:26). And the point is
+ * looked up at a position displaced by a static multi-octave noise, so the
+ * walls bend on the scale of the glyph and are dithered on every smaller
+ * one (claude-xaj5pb9b:21). The grid is still there underneath as the key
+ * space — it is what makes a cell findable and its scheme stable — but
+ * nothing of it is visible.
+ *
+ * Three properties, each pinned by `src/test/membrane-terrain.test.ts`:
+ *
+ * - **Stable.** A cell's seed point and scheme are drawn from a generator
+ *   seeded by (terrain seed, i, j) the first time the cell comes into reach,
+ *   and kept. Returning to a cell shows what it showed before, for the life
+ *   of the terrain (module scope in Membrane.web.tsx, so a rebuilt engine
+ *   keeps it).
+ * - **Very different.** A cell's scheme is drawn with rejection until it is
+ *   MIN_SCHEME_DISTANCE from every neighbor already drawn (the eight around
+ *   it, since a jittered cell can share a wall with a diagonal one), the
+ *   same rule `nextScheme` applies to one keyframe after another. Neighbors
+ *   drawn later are far from it by the same rule, so any wall is a real
+ *   change.
+ * - **Bounded.** The shader reads a BLOCK×BLOCK block of cells around the
+ *   one under the glyph's centre (`blockRows`, row-major). A point's nearest
+ *   seed lies in its own cell or one of the eight around it (JITTER keeps
+ *   every seed well inside its cell), and every point the window, its seams
+ *   and the seam warp can show lies within a cell of the centre, so a 5×5
+ *   block always holds every row a pixel can ask for.
+ *
+ * A wash that wins paints its scheme onto the cells it covered
+ * (`paintCells`, `cellsInView`): the paint sticks to the map, so a wash is
+ * a place you can drag away from and back to. Seed points ride to the
+ * shader in the scheme table (`packCell`), so the CPU's idea of which cell
+ * a point is in and the shader's come from one set of numbers. Window-free.
+ */
+import { SCHEME_TEXELS, nextScheme, packScheme } from "./membrane-palette.js";
+// ---- TUNING ----
+/** Cell side, glyph widths: a drag of about this far shows a new scheme. */
+export const CELL = 0.75;
+/** How far a cell's seed point sits from its centre, at most, in cells,
+ *  per axis. Below 0.5 it stays in its cell; the smaller, the squarer. */
+export const JITTER = 0.35;
+/** Blend across a wall: a cell whose seed is this much farther than the
+ *  nearest, glyph widths, gets no share; nearer, a share falling smoothly
+ *  from equal. A pixel a distance e from a wall differs by about 2e, so the
+ *  visible seam is about SEAM wide. */
+export const SEAM = 0.25;
+/** How far the lookup point is displaced, glyph widths, by a multi-octave
+ *  noise at this base frequency: the large octaves bend the walls, the
+ *  small ones dither them. Typical, not maximum — see VIEW_MARGIN. */
+export const WARP = 0.14;
+export const WARP_FREQ = 1.5;
+// ---- end TUNING ----
+/** Cells on a side of the block the shader reads, and its row count. */
+export const BLOCK = 5;
+export const TERRAIN_ROWS = BLOCK * BLOCK;
+/** Texels per row of the shader's scheme table: a scheme, then its cell's
+ *  seed point (x, y, 0, 0) in world coordinates — zero for a group's row. */
+export const TERRAIN_TEXELS = SCHEME_TEXELS + 1;
+/** Beyond the window's edge, the farthest the warp can carry a lookup: which
+ *  cells a point blends is decided at its warped position. The shader's fbm
+ *  runs to about ±0.7 of its half-range, so ±1.4 × WARP at the extreme. */
+export const VIEW_MARGIN = 1.5 * WARP;
+export const createTerrain = (seed) => ({ seed, cells: new Map() });
+const key = (i, j) => `${i},${j}`;
+/** mulberry32: a small seeded generator, the one the tests use. */
+export function seededRng(seed) {
+    let a = seed | 0;
+    return () => {
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** The generator for one cell: seed and coordinates hashed together. */
+export function cellRng(seed, i, j) {
+    let h = (seed | 0) ^ Math.imul(i | 0, 0x9e3779b1) ^ Math.imul(j | 0, 0x85ebca77);
+    h = Math.imul(h ^ (h >>> 16), 0x7feb352d);
+    h = Math.imul(h ^ (h >>> 15), 0x846ca68b);
+    return seededRng(h ^ (h >>> 16));
+}
+/** The grid cell along one axis of a world coordinate (glyph widths). */
+export const cellAt = (w) => Math.floor(w / CELL);
+/** A screen point's world coordinate: the glyph centre is at world `-drag`,
+ *  since a drag of `d` carried the film (and its map) by `d`. */
+export const toWorld = (p, drag) => p - drag;
+/** The grid cell under the glyph's centre after `drag` — the block's middle. */
+export function centreCell(drag) {
+    return [cellAt(toWorld(0, drag[0])), cellAt(toWorld(0, drag[1]))];
+}
+const NEIGHBORS = [[-1, -1], [0, -1], [1, -1], [-1, 0], [1, 0], [-1, 1], [0, 1], [1, 1]];
+/** The cell, drawn on first reach: its seed point jittered from the grid
+ *  cell's centre, its scheme far from every neighbor already drawn. */
+export function cell(t, i, j) {
+    const k = key(i, j);
+    const have = t.cells.get(k);
+    if (have)
+        return have;
+    const rng = cellRng(t.seed, i, j);
+    const seed = [(i + 0.5 + (2 * rng() - 1) * JITTER) * CELL, (j + 0.5 + (2 * rng() - 1) * JITTER) * CELL];
+    const neighbors = NEIGHBORS.map(([di, dj]) => t.cells.get(key(i + di, j + dj))?.scheme)
+        .filter((s) => !!s);
+    const c = { seed, scheme: nextScheme(neighbors, rng) };
+    t.cells.set(k, c);
+    return c;
+}
+export const cellScheme = (t, i, j) => cell(t, i, j).scheme;
+/** A cell's share of a world point, before normalizing: 1 for the nearest
+ *  seed, falling smoothly to 0 for a seed SEAM farther than it. */
+const share = (excess) => {
+    const t = Math.min(1, Math.max(0, excess / SEAM));
+    return 1 - t * t * (3 - 2 * t);
+};
+/** The cells a world point blends, by seed distance: every cell of the nine
+ *  around its own whose seed is within SEAM of the nearest, with its share
+ *  of the color, normalized — the shader's lookup, less its warp. The
+ *  nearest always shares; at a wall two share equally; nothing jumps as the
+ *  point moves, since every share is continuous in the distances. */
+export function blend(t, w) {
+    const ci = cellAt(w[0]), cj = cellAt(w[1]);
+    const dists = [];
+    for (let dj = -1; dj <= 1; dj++) {
+        for (let di = -1; di <= 1; di++) {
+            const seed = cell(t, ci + di, cj + dj).seed;
+            dists.push({ cell: [ci + di, cj + dj], d: Math.hypot(w[0] - seed[0], w[1] - seed[1]) });
+        }
+    }
+    const d1 = Math.min(...dists.map((x) => x.d));
+    const shares = dists.map((x) => ({ cell: x.cell, weight: share(x.d - d1) })).filter((x) => x.weight > 0);
+    const total = shares.reduce((a, x) => a + x.weight, 0);
+    return shares.map((x) => ({ cell: x.cell, weight: x.weight / total })).sort((a, b) => b.weight - a.weight);
+}
+/** The block's cells around `centre`, row-major (y outer, x inner), as the
+ *  shader's row order: row = (dj + R) * BLOCK + (di + R), R = (BLOCK - 1) / 2. */
+export function blockCells(centre) {
+    const out = [];
+    const r = (BLOCK - 1) / 2;
+    for (let dj = -r; dj <= r; dj++)
+        for (let di = -r; di <= r; di++)
+            out.push([centre[0] + di, centre[1] + dj]);
+    return out;
+}
+/** The block's cells after `drag`, materializing what is new, in row order. */
+export function blockRows(t, drag) {
+    return blockCells(centreCell(drag)).map(([i, j]) => cell(t, i, j));
+}
+/** Points of the window (glyph-normalized, -0.5..0.5) widened by VIEW_MARGIN,
+ *  on a grid fine beside the seam, as world coordinates after `drag`. */
+const VIEW_SAMPLES = 32;
+function viewPoints(drag) {
+    const out = [];
+    const lo = -0.5 - VIEW_MARGIN, hi = 0.5 + VIEW_MARGIN;
+    for (let j = 0; j <= VIEW_SAMPLES; j++) {
+        for (let i = 0; i <= VIEW_SAMPLES; i++) {
+            out.push([toWorld(lo + ((hi - lo) * i) / VIEW_SAMPLES, drag[0]), toWorld(lo + ((hi - lo) * j) / VIEW_SAMPLES, drag[1])]);
+        }
+    }
+    return out;
+}
+/** Every cell the window can show after `drag`: with a share of some point
+ *  of the window widened by VIEW_MARGIN. Sorted, row-major. */
+export function cellsInView(t, drag) {
+    const seen = new Map();
+    for (const w of viewPoints(drag))
+        for (const { cell: c } of blend(t, w))
+            seen.set(key(...c), c);
+    return [...seen.values()].sort((p, q) => p[1] - q[1] || p[0] - q[0]);
+}
+/** The schemes the window can show after `drag` — what a new color must be far from. */
+export function schemesInView(t, drag) {
+    return cellsInView(t, drag).map(([i, j]) => cellScheme(t, i, j));
+}
+/** Paint `scheme` onto these cells, seed points kept: what a wash that won
+ *  leaves on the map. */
+export function paintCells(t, cells, scheme) {
+    for (const [i, j] of cells)
+        t.cells.set(key(i, j), { seed: cell(t, i, j).seed, scheme });
+}
+/** One cell as a row of the shader's scheme table: packScheme's texels, then
+ *  the seed point. */
+export function packCell(c) {
+    const out = new Float32Array(TERRAIN_TEXELS * 4);
+    out.set(packScheme(c.scheme));
+    out.set([c.seed[0], c.seed[1], 0, 0], SCHEME_TEXELS * 4);
+    return out;
+}
+//# sourceMappingURL=membrane-terrain.js.map

package/dist/shared/message-selection.js

@@ -0,0 +1,123 @@
+/**
+ * The chat's message selection — which bubbles the operator has tapped.
+ *
+ * It lives outside React state on purpose. Held as `useState`, the selection
+ * made every tap a whole-screen event: a new `Set` re-rendered the `[nid]`
+ * screen, which rebuilt `handleTimestampPress`, which rebuilt `renderItem`,
+ * which handed every mounted `MessageBubble` a new callback prop and so missed
+ * `memo` on all of them. Two bubbles changed color; two hundred rows and the
+ * screen above them paid for it.
+ *
+ * So the store keeps its own listeners, and **per seq**: a toggle notifies the
+ * one row whose appearance changed, and a clear notifies exactly the rows that
+ * were selected — never a broadcast. The screen holds no selection state at
+ * all, which is what takes `renderItem` off the dependency treadmill.
+ *
+ * Pure, and in `shared/` rather than `expo/lib/` for the usual reason: the
+ * notification rules are the whole point and `src/test/message-selection.test.ts`
+ * can check them without a browser. The React binding — two
+ * `useSyncExternalStore` hooks — is the thin part, and lives in
+ * `expo/lib/selection.ts`.
+ */
+/** One stable empty array, so an untouched selection's snapshot keeps its
+ *  identity and `useSyncExternalStore` never sees a spurious change. */
+const NONE = Object.freeze([]);
+export class MessageSelection {
+    selected = new Set();
+    /** Ascending, rebuilt only on change — `useSyncExternalStore` compares
+     *  snapshots by identity and loops forever on a getter that allocates. */
+    snapshot = NONE;
+    perSeq = new Map();
+    whole = new Set();
+    /** Is this one selected? The question every bubble asks about itself. */
+    has = (seq) => this.selected.has(seq);
+    get size() {
+        return this.selected.size;
+    }
+    /** The selection, ascending — the `re` array for a signal, and the `seqs`
+     *  an export is scoped to. Identity is stable between changes. */
+    getSelected = () => this.snapshot;
+    /** Watch the selection as a whole: the header's count, the composer's `re`.
+     *  One component each, so re-rendering them on a tap is the point. */
+    subscribe = (listener) => {
+        this.whole.add(listener);
+        return () => { this.whole.delete(listener); };
+    };
+    /** Watch one row. This is the subscription that keeps a tap local. */
+    subscribeSeq = (seq, listener) => {
+        let set = this.perSeq.get(seq);
+        if (!set) {
+            set = new Set();
+            this.perSeq.set(seq, set);
+        }
+        set.add(listener);
+        return () => {
+            const current = this.perSeq.get(seq);
+            if (!current)
+                return;
+            current.delete(listener);
+            // Rows unmount as the list scrolls; an empty bucket left behind would
+            // make this map grow with every message ever scrolled past.
+            if (current.size === 0)
+                this.perSeq.delete(seq);
+        };
+    };
+    /** Select or deselect one. Returns whether it is now selected — the caller
+     *  writes `?scrollToSeq=` from that, and a mutator that says what it did
+     *  saves the caller a second read. */
+    toggle = (seq) => {
+        const selecting = !this.selected.has(seq);
+        if (selecting)
+            this.selected.add(seq);
+        else
+            this.selected.delete(seq);
+        this.commit([seq]);
+        return selecting;
+    };
+    /** Drop the whole selection. Returns what was dropped; notifies only those
+     *  rows, because they are the only ones whose appearance changed. */
+    clear = () => {
+        if (this.selected.size === 0)
+            return [];
+        const cleared = [...this.selected];
+        this.selected.clear();
+        this.commit(cleared);
+        return cleared;
+    };
+    /** Make the selection exactly this — used when a `?scrollToSeq=` arrives
+     *  with the route. Notifies the symmetric difference and nothing else. */
+    replace = (seqs) => {
+        const next = new Set();
+        for (const seq of seqs)
+            if (Number.isInteger(seq) && seq > 0)
+                next.add(seq);
+        const changed = [];
+        for (const seq of this.selected)
+            if (!next.has(seq))
+                changed.push(seq);
+        for (const seq of next)
+            if (!this.selected.has(seq))
+                changed.push(seq);
+        if (changed.length === 0)
+            return;
+        this.selected = next;
+        this.commit(changed);
+    };
+    /** Rebuild the snapshot, then notify — in that order, so a listener that
+     *  reads `getSelected()` during its own notification sees the new value
+     *  rather than the one it was woken about. */
+    commit(changed) {
+        this.snapshot = this.selected.size === 0
+            ? NONE
+            : [...this.selected].sort((a, b) => a - b);
+        for (const seq of changed) {
+            const listeners = this.perSeq.get(seq);
+            if (listeners)
+                for (const listener of [...listeners])
+                    listener();
+        }
+        for (const listener of [...this.whole])
+            listener();
+    }
+}
+//# sourceMappingURL=message-selection.js.map

package/dist/shared/mo-glyph.js

@@ -0,0 +1,57 @@
+/**
+ * The 膜 (mó, "membrane") outline that brane wears where it has nothing else to
+ * show — the list screen's empty state — and that `mo-membrane.svg` is cut
+ * from. One glyph, one source: the app draws this with `Path2D`, so it needs no
+ * web font, no network, and renders the same in the offline PWA as in the SVG.
+ *
+ * Provenance: Noto Serif SC Black (Google/Adobe Source Han Serif, weight 900),
+ * taken from Google Fonts' one-character subset
+ * (`css2?family=Noto+Serif+SC:wght@900&text=膜`, 1.9 KB TrueType) and read
+ * with opentype.js: `font.charToGlyph("膜").path` in font units (1000/em,
+ * y up), then scaled by 0.86 and centered in a `MO_GLYPH_BOX`-unit square
+ * with y flipped, so the coordinates below are already SVG-shaped. Noto fonts
+ * are OFL-licensed; the outline may be embedded.
+ *
+ * Window-free, like every module here, so `src/test/mo-glyph.test.ts` can pin
+ * that the data is a closed path inside its box.
+ */
+/** Side of the square the path is laid out in, in path units. */
+export const MO_GLYPH_BOX = 1000;
+/** SVG path data for 膜, y down, inside `[0, MO_GLYPH_BOX]²`. */
+export const MO_GLYPH_PATH = "M493.98 449.69L493.98 425.61L791.54 425.61L791.54 449.69L493.98 449.69ZM493.98 557.19L493.98 533.11" +
+    "L791.54 533.11L791.54 557.19L493.98 557.19ZM431.20 606.21L431.20 319.83L431.20 275.11L431.20 275.11" +
+    "L547.30 319.83L780.36 319.83L780.36 343.91L543.00 343.91L543.00 571.81Q543.00 576.11 528.81 584.71" +
+    "Q514.62 593.31 492.26 599.76Q469.90 606.21 446.68 606.21L446.68 606.21L431.20 606.21ZM733.92 583.85" +
+    "L733.92 319.83L726.18 319.83L776.92 266.51L878.40 343.05Q875.82 346.49 869.37 350.79" +
+    "Q862.92 355.09 851.74 357.67L851.74 357.67L851.74 552.03Q851.74 555.47 835.83 563.21" +
+    "Q819.92 570.95 797.56 577.40Q775.20 583.85 754.56 583.85L754.56 583.85L733.92 583.85ZM400.24 674.15" +
+    "L393.36 650.07L757.14 650.07L812.18 578.69Q812.18 578.69 829.38 592.02Q846.58 605.35 869.80 624.27" +
+    "Q893.02 643.19 911.08 660.39L911.08 660.39Q907.64 674.15 887.00 674.15L887.00 674.15L400.24 674.15Z" +
+    "M675.44 656.95L685.76 653.51Q694.36 680.17 723.17 703.82Q751.98 727.47 799.28 745.10" +
+    "Q846.58 762.73 911.94 773.05L911.94 773.05L911.94 783.37Q867.22 795.41 844.86 821.64" +
+    "Q822.50 847.87 820.78 904.63L820.78 904.63Q785.52 887.43 760.15 858.19Q734.78 828.95 717.58 793.69" +
+    "Q700.38 758.43 690.06 722.74Q679.74 687.05 675.44 656.95L675.44 656.95ZM132.78 417.01L132.78 148.69" +
+    "L132.78 140.09L132.78 104.83L259.20 148.69L242.86 148.69L242.86 417.01Q242.86 475.49 239.85 539.56" +
+    "Q236.84 603.63 223.94 668.56Q211.04 733.49 180.94 794.12Q150.84 854.75 96.66 906.35L96.66 906.35" +
+    "L87.20 901.19Q111.28 829.81 120.74 748.54Q130.20 667.27 131.49 582.13Q132.78 496.99 132.78 417.01" +
+    "L132.78 417.01ZM184.38 172.77L184.38 148.69L342.62 148.69L342.62 172.77L184.38 172.77ZM184.38 371.43" +
+    "L184.38 347.35L342.62 347.35L342.62 371.43L184.38 371.43ZM184.38 573.53L184.38 549.45L342.62 549.45" +
+    "L342.62 573.53L184.38 573.53ZM284.14 767.89L284.14 148.69L275.54 148.69L325.42 92.79L426.90 171.91" +
+    "Q423.46 176.21 415.72 180.94Q407.98 185.67 395.94 188.25L395.94 188.25L395.94 779.93" +
+    "Q395.94 817.77 387.77 844.43Q379.60 871.09 352.51 886.57Q325.42 902.05 269.52 907.21L269.52 907.21" +
+    "Q268.66 879.69 266.08 859.05Q263.50 838.41 256.62 827.23L256.62 827.23Q250.60 814.33 239.42 805.30" +
+    "Q228.24 796.27 205.02 791.97L205.02 791.97L205.02 779.93Q205.02 779.93 213.19 780.36" +
+    "Q221.36 780.79 232.54 781.65Q243.72 782.51 254.04 782.94Q264.36 783.37 269.52 783.37L269.52 783.37" +
+    "Q278.98 783.37 281.56 779.07Q284.14 774.77 284.14 767.89L284.14 767.89ZM499.14 291.45L499.14 99.67" +
+    "L639.32 110.85Q638.46 118.59 632.87 124.18Q627.28 129.77 610.94 132.35L610.94 132.35L610.94 265.65" +
+    "Q610.94 269.09 596.32 275.54Q581.70 281.99 560.20 286.72Q538.70 291.45 516.34 291.45L516.34 291.45" +
+    "L499.14 291.45ZM661.68 291.45L661.68 99.67L801.86 110.85Q801.00 118.59 795.41 124.18" +
+    "Q789.82 129.77 774.34 132.35L774.34 132.35L774.34 265.65Q774.34 269.09 759.72 275.54" +
+    "Q745.10 281.99 723.17 286.72Q701.24 291.45 678.88 291.45L678.88 291.45L661.68 291.45ZM407.98 219.21" +
+    "L401.10 195.13L797.56 195.13L838.84 133.21Q838.84 133.21 851.74 145.25Q864.64 157.29 882.27 174.06" +
+    "Q899.90 190.83 912.80 205.45L912.80 205.45Q910.22 219.21 890.44 219.21L890.44 219.21L407.98 219.21Z" +
+    "M573.10 533.11L573.10 533.11L695.22 533.11Q692.64 582.99 686.19 628.57Q679.74 674.15 662.54 714.57" +
+    "Q645.34 754.99 611.37 789.82Q577.40 824.65 521.07 853.89Q464.74 883.13 379.60 906.35L379.60 906.35" +
+    "L372.72 895.17Q447.54 858.19 488.39 817.77Q529.24 777.35 546.87 732.20Q564.50 687.05 568.37 637.60" +
+    "Q572.24 588.15 573.10 533.11Z";
+//# sourceMappingURL=mo-glyph.js.map