bireactive 0.3.0 → 0.3.2

package/dist/core/values/str.d.ts

@@ -1,76 +1,32 @@
 import { Cell, type Init, type Writable } from "../cell.js";
+import { Arr } from "./arr.js";
 type V = string;
 export declare const equals: (a: V, b: V) => boolean;
 /** Reverse a string by Unicode code points. */
 export declare const reverseStr: (s: V) => V;
-/** ROT13 cipher. Involutive: `rot13(rot13(s)) === s`. */
-export declare const rot13Str: (s: V) => V;
-/** Per-character case mask: `U` upper letter, `L` lower letter,
- *  `" "` non-letter. Length matches the source. */
-export declare function caseMaskOf(s: V): string;
-/** Apply a case mask to `target`, position by position. Mask positions
- *  beyond `target.length` are ignored; target positions beyond the
- *  mask keep their native case (e.g. user appended a longer word). */
-export declare function applyCaseMask(target: V, mask: string): V;
-/** Apply the case pattern of a source word to a target word. Detects
- *  all-upper / all-lower / title case, else falls back to position-wise
- *  `applyCaseMask`. Non-letter target chars always pass through unchanged
- *  (title-casing "-gng" → "-Gng"); this letter-awareness is what makes
- *  GetPut hold when source words contain non-letters. */
-export declare function applyCasePattern(target: V, mask: string): V;
-/** Split `s` into words and separators. Returns:
- *
- *    words[i] — the i-th run of word characters
- *    seps[0]  — leading non-word characters (possibly empty)
- *    seps[i]  — for 1 ≤ i ≤ words.length-1, the separator BETWEEN
- *               `words[i-1]` and `words[i]`
- *    seps[words.length] — trailing non-word characters
- *
- *  Always satisfies `seps.length === words.length + 1`. */
-export declare function parseWords(s: V): {
-    words: V[];
-    seps: V[];
-};
-/** Inverse of `parseWords`. Interleaves words with `seps`; added words
- *  get `" "` gaps, removed words keep the original trailing separator.
- *  A zero-word original (`seps.length === 1`) treats its one entry as
- *  lead only, so words append after it without double-counting as trail. */
-export declare function rebuildWords(words: V[], seps: V[]): V;
 export declare class Str extends Cell<V> {
     static traits: {
         equals: (a: V, b: V) => boolean;
     };
     readonly _t: typeof Str.traits;
     constructor(v?: V);
-    /** Reverse. Involution. */
+    /** Reverse. */
     reverse(): this;
-    /** ROT13. Involution. */
-    rot13(): this;
-    /** Trim edge whitespace; the complement restores the original padding
-     *  on write. Edge whitespace in a write is stripped first (the view's
-     *  contract is "no edge whitespace", else the complement grows). */
+    /** Trim edge whitespace; the complement restores the original padding on
+     *  write. A write's own edge whitespace is stripped first. */
     trim(): Writable<Str>;
-    /** Lowercase view with word-aware case recovery on write. Lookup
-     *  priority: (1) content match — recover the source mask by word
-     *  (FIFO across duplicates); (2) per-position fallback for new content;
-     *  (3) native for content beyond the source structure. */
-    lowercase(): Writable<Str>;
-    /** Uppercase view. Dual of `lowercase`; same per-word case recovery. */
-    uppercase(): Writable<Str>;
-    /** Words view, one word per line. Read splits on non-word chars; the
-     *  complement is the separator layout, restored on write (added words
-     *  get single spaces). Non-word chars typed into a line are stripped —
-     *  edit `Trimmed` / `Lowercased` / `Source` to add punctuation. */
-    words(): Writable<Str>;
-    /** Sorted, case-insensitively-unique words, one per line. The
-     *  complement records each entry's source positions and original case,
-     *  so editing one line broadcasts to every occurrence in the source —
-     *  each rebuilt with its own original casing. */
-    sortedUnique(): Writable<Str>;
+    /** Windowed view `s.slice(start, end)` (JS semantics). A write splices the
+     *  text back into `[start, end)` of the live source, which grows or shrinks
+     *  to fit; no stored complement. */
+    slice(start: number, end?: number): Writable<Str>;
+    /** Split into an editable `Arr<string>`. Each segment is a positional lens:
+     *  reading index `i` re-splits the live source, writing it splices that piece
+     *  back, so separators need no complement. Structural edits (insert/remove/
+     *  move) re-split and rebuild the source; added boundaries use `joiner`
+     *  (defaults to `sep`, or `" "` for a pattern). Identity is by position. */
+    split(sep: V | RegExp, joiner?: V): Arr<V>;
 }
-/** Writable `Str`. Strict factory: literal seeds a fresh cell;
- *  existing `Writable<Str>` passes through by identity. RO sources
- *  are rejected at the type level — use `Str.derive(...)` for
- *  reactive RO tracking, or `cell.value` to snapshot. */
+/** Writable `Str` from a literal (new cell) or existing writable (passed
+ *  through). For read-only sources use `Str.derive`. */
 export declare function str(v?: Init<Str>): Writable<Str>;
 export {};

package/dist/core/values/str.js

@@ -1,344 +1,162 @@
-// str.ts — reactive string with a symmetric lens chain.
-//
-// String projections are the canonical use of the engine's stateful-lens
-// primitive (`statefulLens`). Every useful view loses information the
-// engine recovers on write via a per-cell `complement`, so editing through
-// ANY view round-trips with case, whitespace, separators, and duplicate
-// positions preserved (the Foster/Pierce case-preserving find-and-replace
-// demo).
-//
-// `reverse()` and `rot13()` are involutions on the plain endo
-// `.lens(fwd, bwd)` — no complement; they chain like any endo lens.
-// Everything else is `Str.lens(parent, spec)` with a complement:
-//
-//   trim         — leading + trailing whitespace
-//   lowercase    — per-character case mask of the source
-//   uppercase    — dual of lowercase
-//   words        — separator pattern between words
-//   sortedUnique — source positions + original case per unique word
 import { Cell } from "../cell.js";
-// Complement-carrying endo lens.
-//
-// The complement is state recorded forward from the source and consumed
-// on write-back. It persists across the lens's own writes (so `trim`
-// keeps its padding even when the view is emptied) and refreshes on
-// external source changes — the engine's `external` flag drives `step`.
-/** Endo lens backed by a complement recorded from the source. `record`
- *  rebuilds the complement (kept on the lens's own writes), `project`
- *  is the forward view, `reconstruct` is the backward source. */
-function complementLens(parent, record, project, reconstruct) {
-    return Str.lens([parent], {
-        init: ([s]) => record(s),
-        step: ([s], c, external) => (external ? record(s) : c),
-        fwd: ([s]) => project(s),
-        bwd: (target, _s, c) => ({ updates: [reconstruct(target, c)], complement: c }),
-    });
-}
+import { Arr } from "./arr.js";
 export const equals = (a, b) => a === b;
 /** Reverse a string by Unicode code points. */
 export const reverseStr = (s) => [...s].reverse().join("");
-/** ROT13 cipher. Involutive: `rot13(rot13(s)) === s`. */
-export const rot13Str = (s) => s.replace(/[a-zA-Z]/g, c => {
-    const code = c.charCodeAt(0);
-    const base = code >= 97 ? 97 : 65;
-    return String.fromCharCode(((code - base + 13) % 26) + base);
-});
-/** Per-character case mask: `U` upper letter, `L` lower letter,
- *  `" "` non-letter. Length matches the source. */
-export function caseMaskOf(s) {
-    let mask = "";
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (c >= "A" && c <= "Z")
-            mask += "U";
-        else if (c >= "a" && c <= "z")
-            mask += "L";
-        else
-            mask += " ";
-    }
-    return mask;
-}
-/** Apply a case mask to `target`, position by position. Mask positions
- *  beyond `target.length` are ignored; target positions beyond the
- *  mask keep their native case (e.g. user appended a longer word). */
-export function applyCaseMask(target, mask) {
-    let out = "";
-    for (let i = 0; i < target.length; i++) {
-        const c = target[i];
-        const m = i < mask.length ? mask[i] : " ";
-        if (m === "U")
-            out += c.toUpperCase();
-        else if (m === "L")
-            out += c.toLowerCase();
-        else
-            out += c;
-    }
-    return out;
-}
-const ASCII_LETTER = (c) => (c >= "a" && c <= "z") || (c >= "A" && c <= "Z");
-/** Apply the case pattern of a source word to a target word. Detects
- *  all-upper / all-lower / title case, else falls back to position-wise
- *  `applyCaseMask`. Non-letter target chars always pass through unchanged
- *  (title-casing "-gng" → "-Gng"); this letter-awareness is what makes
- *  GetPut hold when source words contain non-letters. */
-export function applyCasePattern(target, mask) {
-    if (target.length === 0 || mask.length === 0)
-        return target;
-    const letters = [...mask].filter(c => c === "U" || c === "L");
-    if (letters.length === 0)
-        return target;
-    if (letters.every(c => c === "U"))
-        return target.toUpperCase();
-    if (letters.every(c => c === "L"))
-        return target.toLowerCase();
-    if (letters[0] === "U" && letters.slice(1).every(c => c === "L")) {
-        // Title case: uppercase the first letter (skipping leading
-        // non-letters), lowercase the rest, pass non-letters through.
-        let out = "";
-        let firstLetterDone = false;
-        for (let i = 0; i < target.length; i++) {
-            const c = target[i];
-            if (ASCII_LETTER(c)) {
-                out += firstLetterDone ? c.toLowerCase() : c.toUpperCase();
-                firstLetterDone = true;
-            }
-            else {
-                out += c;
-            }
-        }
-        return out;
-    }
-    return applyCaseMask(target, mask);
-}
-/** A "word" character: letters, digits, underscore, apostrophe, hyphen
- *  (handles "don't", "co-op"). Everything else is a separator. */
-const WORD_CHAR = /[\p{L}\p{N}_'-]/u;
-/** Strip every non-word character. Keeps user-typed punctuation in the
- *  `words` / `sortedUnique` views from leaking into the source via the
- *  separator complement (where it would accumulate across edits). */
-const stripNonWord = (s) => s.replace(/[^\p{L}\p{N}_'-]/gu, "");
-/** Split `s` into words and separators. Returns:
- *
- *    words[i] — the i-th run of word characters
- *    seps[0]  — leading non-word characters (possibly empty)
- *    seps[i]  — for 1 ≤ i ≤ words.length-1, the separator BETWEEN
- *               `words[i-1]` and `words[i]`
- *    seps[words.length] — trailing non-word characters
- *
- *  Always satisfies `seps.length === words.length + 1`. */
-export function parseWords(s) {
-    const words = [];
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Resolve a (possibly negative / out-of-range) index against `len`,
+ *  JS `slice`-style: negatives count from the end, then clamp to [0, len]. */
+const resolveIndex = (i, len) => i < 0 ? Math.max(len + i, 0) : Math.min(i, len);
+/** Split `s` on `sep`, keeping matched separators so it round-trips
+ *  (`seps.length === parts.length - 1`). Zero-width matches are skipped, so
+ *  `parts` is never empty. */
+function scanSplit(s, sep) {
+    const flags = sep.flags.includes("g") ? sep.flags : `${sep.flags}g`;
+    const re = new RegExp(sep.source, flags);
+    const parts = [];
     const seps = [];
-    let cur = "";
-    let inWord = false;
-    for (let i = 0; i < s.length; i++) {
-        const c = s[i];
-        if (WORD_CHAR.test(c)) {
-            if (!inWord) {
-                seps.push(cur);
-                cur = "";
-                inWord = true;
-            }
-            cur += c;
+    let last = 0;
+    let m = re.exec(s);
+    while (m !== null) {
+        if (m[0].length === 0) {
+            re.lastIndex++;
+            if (re.lastIndex > s.length)
+                break;
+            m = re.exec(s);
+            continue;
         }
-        else {
-            if (inWord) {
-                words.push(cur);
-                cur = "";
-                inWord = false;
-            }
-            cur += c;
-        }
-    }
-    if (inWord) {
-        words.push(cur);
-        seps.push("");
+        parts.push(s.slice(last, m.index));
+        seps.push(m[0]);
+        last = m.index + m[0].length;
+        m = re.exec(s);
     }
-    else {
-        seps.push(cur);
-    }
-    return { words, seps };
+    parts.push(s.slice(last));
+    return { parts, seps };
 }
-/** Inverse of `parseWords`. Interleaves words with `seps`; added words
- *  get `" "` gaps, removed words keep the original trailing separator.
- *  A zero-word original (`seps.length === 1`) treats its one entry as
- *  lead only, so words append after it without double-counting as trail. */
-export function rebuildWords(words, seps) {
-    const n = words.length;
-    if (n === 0)
-        return seps[0] ?? "";
-    const lead = seps[0] ?? "";
-    const trail = seps.length > 1 ? (seps[seps.length - 1] ?? "") : "";
-    let out = lead;
-    for (let i = 0; i < n; i++) {
-        out += words[i];
-        if (i < n - 1) {
-            const idx = i + 1;
-            // Interior separators only; the final `seps` entry is the trail.
-            const sep = idx < seps.length - 1 ? seps[idx] : undefined;
-            out += sep !== undefined ? sep : " ";
-        }
-        else {
-            out += trail;
-        }
-    }
+/** Interleave `parts` with `seps`; boundaries with no recorded separator use
+ *  `joiner`. */
+function joinParts(parts, seps, joiner) {
+    if (parts.length === 0)
+        return "";
+    let out = parts[0];
+    for (let i = 1; i < parts.length; i++)
+        out += (seps[i - 1] ?? joiner) + parts[i];
     return out;
 }
-/** (Re)build the case complement: positional `wordMasks` and content-keyed
- *  `byContent` in one pass. `byContent` lists stay in source order for FIFO
- *  consumption in `putl`. */
-function refreshCaseComplement(s, c) {
-    const { words } = parseWords(s);
-    const wordMasks = words.map(caseMaskOf);
-    const byContent = new Map();
-    for (let i = 0; i < words.length; i++) {
-        const key = words[i].toLowerCase();
-        let arr = byContent.get(key);
-        if (arr === undefined) {
-            arr = [];
-            byContent.set(key, arr);
-        }
-        arr.push(wordMasks[i]);
-    }
-    c.wordMasks = wordMasks;
-    c.byContent = byContent;
-}
-/** Apply the case complement to a target string and rebuild. Each
- *  target word goes through three lookup tiers — content match
- *  (FIFO-consumed from a per-call clone), positional fallback, then
- *  native pass-through. */
-function applyCaseComplement(target, c) {
-    const { words, seps } = parseWords(target);
-    // Per-call clone: consume FIFO without mutating the stored map, so
-    // repeated `putl` calls start from the same state.
-    const remaining = new Map();
-    for (const [k, arr] of c.byContent)
-        remaining.set(k, arr.slice());
-    const cased = words.map((w, i) => {
-        const key = w.toLowerCase();
-        const matches = remaining.get(key);
-        if (matches !== undefined && matches.length > 0) {
-            return applyCasePattern(w, matches.shift());
-        }
-        const mask = i < c.wordMasks.length ? c.wordMasks[i] : "";
-        return mask.length === 0 ? w : applyCasePattern(w, mask);
-    });
-    return rebuildWords(cased, seps);
-}
-/** Build a fresh case complement from a source string. */
-function buildCaseComplement(s) {
-    const c = { wordMasks: [], byContent: new Map() };
-    refreshCaseComplement(s, c);
-    return c;
-}
 export class Str extends Cell {
     static traits = { equals };
     constructor(v = "") {
         super(v, { equals });
     }
-    /** Reverse. Involution. */
+    /** Reverse. */
     reverse() {
         return this.lens(reverseStr, reverseStr);
     }
-    /** ROT13. Involution. */
-    rot13() {
-        return this.lens(rot13Str, rot13Str);
-    }
-    /** Trim edge whitespace; the complement restores the original padding
-     *  on write. Edge whitespace in a write is stripped first (the view's
-     *  contract is "no edge whitespace", else the complement grows). */
+    /** Trim edge whitespace; the complement restores the original padding on
+     *  write. A write's own edge whitespace is stripped first. */
     trim() {
-        return complementLens(this, s => {
-            const lead = /^\s*/.exec(s)?.[0] ?? "";
-            // Slice lead off first so trail can't overlap it on all-whitespace.
-            const remain = s.slice(lead.length);
-            const trail = /\s*$/.exec(remain)?.[0] ?? "";
-            return { lead, trail };
-        }, s => {
-            const lead = /^\s*/.exec(s)?.[0] ?? "";
-            const remain = s.slice(lead.length);
-            const trail = /\s*$/.exec(remain)?.[0] ?? "";
-            return remain.slice(0, remain.length - trail.length);
-        }, 
-        // Edge whitespace in the write is dropped; complement restores pad.
-        (target, c) => c.lead + target.replace(/^\s+/, "").replace(/\s+$/, "") + c.trail);
-    }
-    /** Lowercase view with word-aware case recovery on write. Lookup
-     *  priority: (1) content match — recover the source mask by word
-     *  (FIFO across duplicates); (2) per-position fallback for new content;
-     *  (3) native for content beyond the source structure. */
-    lowercase() {
-        return complementLens(this, s => buildCaseComplement(s), s => s.toLowerCase(), (target, c) => applyCaseComplement(target, c));
-    }
-    /** Uppercase view. Dual of `lowercase`; same per-word case recovery. */
-    uppercase() {
-        return complementLens(this, s => buildCaseComplement(s), s => s.toUpperCase(), (target, c) => applyCaseComplement(target, c));
+        return Str.lens(this, {
+            init: (s) => {
+                const lead = /^\s*/.exec(s)?.[0] ?? "";
+                // Slice lead off first so trail can't overlap it on all-whitespace.
+                const remain = s.slice(lead.length);
+                const trail = /\s*$/.exec(remain)?.[0] ?? "";
+                return { lead, trail };
+            },
+            fwd: (s) => {
+                const lead = /^\s*/.exec(s)?.[0] ?? "";
+                const remain = s.slice(lead.length);
+                const trail = /\s*$/.exec(remain)?.[0] ?? "";
+                return remain.slice(0, remain.length - trail.length);
+            },
+            bwd: (target, _s, c) => ({
+                update: c.lead + target.replace(/^\s+/, "").replace(/\s+$/, "") + c.trail,
+                complement: c,
+            }),
+        });
     }
-    /** Words view, one word per line. Read splits on non-word chars; the
-     *  complement is the separator layout, restored on write (added words
-     *  get single spaces). Non-word chars typed into a line are stripped —
-     *  edit `Trimmed` / `Lowercased` / `Source` to add punctuation. */
-    words() {
-        return complementLens(this, s => ({ separators: parseWords(s).seps }), s => parseWords(s).words.join("\n"), (target, c) => {
-            const words = target
-                .split(/\n/)
-                .map(stripNonWord)
-                .filter(w => w.length > 0);
-            return rebuildWords(words, c.separators);
+    /** Windowed view `s.slice(start, end)` (JS semantics). A write splices the
+     *  text back into `[start, end)` of the live source, which grows or shrinks
+     *  to fit; no stored complement. */
+    slice(start, end) {
+        return Str.lens(this, (s) => s.slice(start, end), (target, s) => {
+            const len = s.length;
+            const a = resolveIndex(start, len);
+            const b = end === undefined ? len : resolveIndex(end, len);
+            const hi = b < a ? a : b;
+            return s.slice(0, a) + target + s.slice(hi);
         });
     }
-    /** Sorted, case-insensitively-unique words, one per line. The
-     *  complement records each entry's source positions and original case,
-     *  so editing one line broadcasts to every occurrence in the source —
-     *  each rebuilt with its own original casing. */
-    sortedUnique() {
-        return complementLens(this, s => {
-            const { words, seps } = parseWords(s);
-            const buckets = new Map();
-            for (let i = 0; i < words.length; i++) {
-                const w = words[i];
-                const key = w.toLowerCase();
-                let arr = buckets.get(key);
-                if (arr === undefined) {
-                    arr = [];
-                    buckets.set(key, arr);
-                }
-                arr.push({ index: i, sourceCase: w });
-            }
-            const unique = [...buckets.keys()].sort();
-            return {
-                unique,
-                positions: unique.map(k => buckets.get(k)),
-                separators: seps,
-                sourceWords: words,
-            };
-        }, s => {
-            const { words } = parseWords(s);
-            return [...new Set(words.map(w => w.toLowerCase()))].sort().join("\n");
-        }, (target, c) => {
-            // Strip non-word chars typed into the view, same as `words`.
-            const edited = target
-                .split(/\n/)
-                .map(stripNonWord)
-                .filter(w => w.length > 0);
-            const sourceWords = c.sourceWords.slice();
-            const n = Math.min(edited.length, c.unique.length);
-            for (let i = 0; i < n; i++) {
-                const newWord = edited[i];
-                for (const { index, sourceCase } of c.positions[i]) {
-                    if (index >= sourceWords.length)
-                        continue;
-                    sourceWords[index] = applyCasePattern(newWord, caseMaskOf(sourceCase));
-                }
+    /** Split into an editable `Arr<string>`. Each segment is a positional lens:
+     *  reading index `i` re-splits the live source, writing it splices that piece
+     *  back, so separators need no complement. Structural edits (insert/remove/
+     *  move) re-split and rebuild the source; added boundaries use `joiner`
+     *  (defaults to `sep`, or `" "` for a pattern). Identity is by position. */
+    split(sep, joiner) {
+        const re = typeof sep === "string" ? new RegExp(escapeRegExp(sep)) : sep;
+        const join = joiner ?? (typeof sep === "string" ? sep : " ");
+        const source = this;
+        const segCache = new Map();
+        const indexOfCell = new WeakMap();
+        const seg = (i) => {
+            let c = segCache.get(i);
+            if (c === undefined) {
+                c = Str.lens(source, (s) => scanSplit(s, re).parts[i] ?? "", (target, s) => {
+                    const { parts, seps } = scanSplit(s, re);
+                    if (i >= parts.length)
+                        return s;
+                    parts[i] = target;
+                    return joinParts(parts, seps, join);
+                });
+                segCache.set(i, c);
+                indexOfCell.set(c, i);
             }
-            return rebuildWords(sourceWords, c.separators);
+            return c;
+        };
+        const write = (parts, seps) => {
+            source.value = joinParts(parts, seps, join);
+        };
+        return Arr.fromSource(source, (s) => scanSplit(s, re).parts.map((_, i) => seg(i)), {
+            insert: (v, at) => {
+                const text = v instanceof Cell ? v.value : v;
+                const { parts, seps } = scanSplit(source.peek(), re);
+                const idx = at == null || at > parts.length ? parts.length : Math.max(0, at);
+                parts.splice(idx, 0, text);
+                if (parts.length > 1)
+                    seps.splice(Math.min(idx, seps.length), 0, join);
+                write(parts, seps);
+                return seg(idx);
+            },
+            remove: e => {
+                const idx = indexOfCell.get(e);
+                if (idx === undefined)
+                    return;
+                const { parts, seps } = scanSplit(source.peek(), re);
+                if (idx >= parts.length)
+                    return;
+                parts.splice(idx, 1);
+                if (seps.length > 0)
+                    seps.splice(Math.min(idx, seps.length - 1), 1);
+                write(parts, seps);
+            },
+            moveBefore: (e, anchor) => {
+                const from = indexOfCell.get(e);
+                if (from === undefined)
+                    return;
+                const { parts, seps } = scanSplit(source.peek(), re);
+                if (from >= parts.length)
+                    return;
+                const [moved] = parts.splice(from, 1);
+                const ai = anchor == null ? undefined : indexOfCell.get(anchor);
+                const at = ai === undefined ? parts.length : ai > from ? ai - 1 : ai;
+                parts.splice(at, 0, moved);
+                write(parts, seps);
+            },
         });
     }
 }
-/** Writable `Str`. Strict factory: literal seeds a fresh cell;
- *  existing `Writable<Str>` passes through by identity. RO sources
- *  are rejected at the type level — use `Str.derive(...)` for
- *  reactive RO tracking, or `cell.value` to snapshot. */
+/** Writable `Str` from a literal (new cell) or existing writable (passed
+ *  through). For read-only sources use `Str.derive`. */
 export function str(v = "") {
     if (v instanceof Str)
         return v;

package/dist/core/values/template.js

@@ -1,25 +1,3 @@
-// template.ts — bidirectional text templates: typed slots ⇄ rendered string.
-//
-// A template is `lit₀ slot₀ lit₁ slot₁ … litₙ` — a multi-parent `Str.lens`
-// over the slot cells. Forward RENDERS (interleave literals with each
-// slot's formatted value); backward PARSES (split the edited string on the
-// literal delimiters, decode each segment, write the changed slots back).
-// Slots-as-source: the typed cells are canonical and the string is one
-// view, so the same slots can drive several renderings at once (edit any,
-// all stay in sync) — the thing `Str`'s views can't do.
-//
-// Each slot carries a `Codec<T>` (string ⇄ T). That codec is the textual
-// dual of the `pack` trait: `pack : factor :: codec : template` — both
-// serialize a value class into a medium (Float64Array vs string) so one
-// generic lens (LSQ-solve vs parse/print) works over any class that
-// supplies it. Kept local here rather than as a `TraitDict` entry; it can
-// graduate to a trait once a second consumer wants it.
-//
-// Parse is rejection-tolerant: a segment that fails its codec (typing
-// "banana" into a number slot) yields `undefined`, the engine's GetPut
-// stop prunes the no-op, and that slot stays put. A missing delimiter
-// rejects the whole edit. Adjacent slots with no literal between them are
-// ambiguous to split — avoid empty inter-slot literals.
 import { SKIP } from "../cell.js";
 import { num } from "./num.js";
 import { Str, str } from "./str.js";
@@ -101,8 +79,7 @@ export function template(literals, slots) {
         return str(literals.join(""));
     const cells = slots.map(s => s.cell);
     // Heterogeneous, dynamic-length parents don't fit the static N-tuple
-    // overload; bind a flat signature at the boundary. `.bind(Str)` keeps the
-    // static `this` (the lens reads it as the constructor).
+    // overload; bind a flat signature. `.bind(Str)` keeps the static `this`.
     const lensN = Str.lens.bind(Str);
     return lensN(cells, vals => render(literals, slots, vals), edited => parse(literals, slots, edited));
 }

package/dist/core/values/transform.d.ts

@@ -25,8 +25,6 @@ export declare class Transform extends Cell<V> {
         equals: (a: V, b: V) => boolean;
     };
     readonly _t: typeof Transform.traits;
-    /** Scalar `scale` is the `.scale` Vec field lens, not an eager method;
-     *  scalar-multiply via `Transform.lens(...)` or field writes. */
     constructor(v?: V);
     add(b: Val<V>): this;
     sub(b: Val<V>): this;
@@ -36,13 +34,13 @@ export declare class Transform extends Cell<V> {
     get origin(): this extends import("../index.js").WritableBrand ? Writable<Vec> : Vec;
     get rotate(): this extends import("../index.js").WritableBrand ? Writable<Num> : Num;
     get opacity(): this extends import("../index.js").WritableBrand ? Writable<Num> : Num;
-    /** Tween-builder, implied by the lerp trait. */
+    /** Tween-builder. */
     to(this: Writable<Transform>, target: V, dur: Val<number>, ease?: Easing): Tween<V>;
 }
 export type TransformInit = {
     [K in keyof V]?: V[K];
 };
-/** Seed a `Writable<Transform>` from literal values. For reactive
- *  sources, use `Transform.lens(...)` or field-write composition. */
+/** Writable `Transform` from literal fields. For reactive sources use
+ *  `Transform.lens` or field writes. */
 export declare function transform(init?: TransformInit): Writable<Transform>;
 export {};