@feelgxxd/textel 0.0.0-stage → 0.2.0

package/dist/examples.js

@@ -0,0 +1,164 @@
+import { clamp, extrude, sdBox, sdCyl, sdfToMeshSteps, sdSphere, sdTorus } from "./sdf.js";
+const HARD_LIGHT = [-0.3, 0.35, 0.88];
+const SOFT_LIGHT = [-0.45, 0.6, 0.65];
+// material indices shared by the examples
+const BODY = 0, CARVED = 1, DIM = 2;
+const MATERIALS = ['body', 'carved', 'dim'];
+const LOOK = { materials: { carved: 'carved', dim: 'dim' } };
+const hard = (pitch) => ({ ...LOOK, charset: 'hard', light: HARD_LIGHT, pitch });
+const soft = (pitch) => ({ ...LOOK, charset: 'classic', light: SOFT_LIGHT, pitch });
+// ---------- donut: the classic ----------
+function* donut() {
+    // a torus is symmetric around its own axis, so spinning it flat would look still: the ring is
+    // tilted 60° off the spin axis, and the turntable makes it tumble like donut.c
+    const t = Math.PI / 3, c = Math.cos(t), s = Math.sin(t);
+    return yield* sdfToMeshSteps((x, y, z) => sdTorus(x, y * c - z * s, y * s + z * c, 1, 0.45), {
+        min: [-1.5, -1.5, -1.5], max: [1.5, 1.5, 1.5], step: 0.03,
+    });
+}
+// ---------- dice: carved pips ----------
+function* dice() {
+    const s = 1, pip = 0.17, off = 0.5;
+    // pip positions on a face, in face coordinates (u, v), for 1..6
+    const FACES = [
+        [[0, 0]],
+        [[-off, -off], [off, off]],
+        [[-off, -off], [0, 0], [off, off]],
+        [[-off, -off], [-off, off], [off, -off], [off, off]],
+        [[-off, -off], [-off, off], [0, 0], [off, -off], [off, off]],
+        [[-off, -off], [-off, 0], [-off, off], [off, -off], [off, 0], [off, off]],
+    ];
+    // face n: axis, sign, and which coordinates span it; opposite faces add up to 7
+    const SIDES = [[2, 1, 0, 1], [0, 1, 2, 1], [1, 1, 0, 2], [1, -1, 0, 2], [0, -1, 2, 1], [2, -1, 0, 1]];
+    const pipAt = (p) => {
+        for (let f = 0; f < 6; f++) {
+            const [ax, sg, u, v] = SIDES[f];
+            if (p[ax] * sg < s - 0.25)
+                continue;
+            for (const [pu, pv] of FACES[f])
+                if (Math.hypot(p[u] - pu, p[v] - pv) < pip)
+                    return true;
+        }
+        return false;
+    };
+    // pips are shallow dimples pressed into each face
+    const field = (x, y, z) => {
+        let d = sdBox(x, y, z, s, s, s, 0.18);
+        const p = [x, y, z];
+        for (let f = 0; f < 6; f++) {
+            const [ax, sg, u, v] = SIDES[f];
+            for (const [pu, pv] of FACES[f]) {
+                const c = [0, 0, 0];
+                c[ax] = sg * (s + 0.05);
+                c[u] = pu;
+                c[v] = pv;
+                d = Math.max(d, -(Math.hypot(p[0] - c[0], p[1] - c[1], p[2] - c[2]) - pip - 0.06));
+            }
+        }
+        return d;
+    };
+    return yield* sdfToMeshSteps(field, {
+        min: [-1.1, -1.1, -1.1], max: [1.1, 1.1, 1.1], step: 0.025, materials: MATERIALS,
+        material: (x, y, z) => (pipAt([x, y, z]) ? CARVED : BODY),
+    });
+}
+// ---------- rocket: thin fins, a dim window band ----------
+function* rocket() {
+    const body = (x, y, z) => {
+        const r = Math.hypot(x, z);
+        // ogive nose above y = 0.6, straight tube below
+        const radius = y > 0.6 ? 0.42 * Math.sqrt(Math.max(0, 1 - ((y - 0.6) / 1.1) ** 2)) : 0.42;
+        return Math.max(r - radius, Math.abs(y + 0.15) - 1.85 + (y > 0 ? 0.1 : 0)) * 0.9;
+    };
+    // three fins around the base
+    const fins = (x, y, z) => {
+        let d = 1e9;
+        for (let k = 0; k < 3; k++) {
+            const a = (k / 3) * Math.PI * 2, c = Math.cos(a), s = Math.sin(a);
+            const u = x * c + z * s, w = -x * s + z * c;
+            const profile = Math.max(-u + 0.3, u - 0.95 + (y + 1.6) * 0.45, -(y + 1.9), y + 0.9 - (0.95 - u) * 0.3);
+            d = Math.min(d, extrude(profile, w, 0.035, 0.01));
+        }
+        return d;
+    };
+    const nozzle = (x, y, z) => Math.max(sdCyl(x, y + 1.95, z, 0.3 + clamp(-(y + 1.85), 0, 0.2) * 0.6, 0.12), -(Math.hypot(x, z) - 0.2));
+    const field = (x, y, z) => Math.min(body(x, y, z), fins(x, y, z), nozzle(x, y, z));
+    return yield* sdfToMeshSteps(field, {
+        min: [-1.05, -2.1, -1.05], max: [1.05, 1.75, 1.05], step: 0.025, materials: MATERIALS,
+        material: (x, y, z) => {
+            if (fins(x, y, z) < body(x, y, z) || nozzle(x, y, z) < body(x, y, z))
+                return DIM;
+            // a porthole facing the viewer and a band below it
+            if (z > 0 && Math.hypot(x, y - 0.25) < 0.16)
+                return CARVED;
+            if (Math.abs(y + 0.55) < 0.06)
+                return DIM;
+            return BODY;
+        },
+    });
+}
+// ---------- planet: a tilted ring ----------
+function* planet() {
+    const t = 0.4, ct = Math.cos(t), st = Math.sin(t);
+    const ring = (x, y, z) => {
+        // ring plane tilted around z
+        const ry = x * st + y * ct, rx = x * ct - y * st;
+        const r = Math.hypot(rx, z);
+        return extrude(Math.abs(r - 1.6) - 0.35, ry, 0.025, 0.01);
+    };
+    const globe = (x, y, z) => sdSphere(x, y, z, 1);
+    return yield* sdfToMeshSteps((x, y, z) => Math.min(globe(x, y, z), ring(x, y, z)), {
+        min: [-2.05, -1.2, -2.05], max: [2.05, 1.2, 2.05], step: 0.03, materials: MATERIALS,
+        material: (x, y, z) => (ring(x, y, z) < globe(x, y, z) ? (Math.abs(Math.hypot(x * ct - y * st, z) - 1.6) < 0.06 ? CARVED : DIM) : BODY),
+    });
+}
+// ---------- mug: a hollow inside and a handle ----------
+function* mug() {
+    const cup = (x, y, z) => {
+        const outer = sdCyl(x, y, z, 0.8, 0.9) - 0.04;
+        const inner = sdCyl(x, y - 0.15, z, 0.68, 0.9);
+        return Math.max(outer, -inner);
+    };
+    // the handle is a torus standing up on the side
+    const handle = (x, y, z) => Math.max(Math.hypot(Math.hypot(x - 0.85, y) - 0.45, z) - 0.09, 0.78 - x);
+    return yield* sdfToMeshSteps((x, y, z) => Math.min(cup(x, y, z), handle(x, y, z)), {
+        min: [-0.9, -1, -0.9], max: [1.45, 1, 0.9], step: 0.022, materials: MATERIALS,
+        // the inside reads darker
+        material: (x, y, z) => (Math.hypot(x, z) < 0.71 && y > -0.7 ? DIM : BODY),
+    });
+}
+// ---------- gem: flat facets ----------
+function* gem() {
+    // a brilliant-ish cut: crown and pavilion made of planes
+    const N = 8;
+    const field = (x, y, z) => {
+        // snap to the nearest facet direction so every face is a plane
+        const k = Math.round((Math.atan2(z, x) / (Math.PI * 2)) * N), fa = (k / N) * Math.PI * 2;
+        const u = x * Math.cos(fa) + z * Math.sin(fa);
+        const girdle = u - 1;
+        const crown = u * 0.55 + y - 0.75;
+        const table = y - 0.42;
+        const pavilion = u * 0.75 - y * 0.66 - 0.75;
+        return Math.max(girdle, crown, table, pavilion);
+    };
+    return yield* sdfToMeshSteps(field, { min: [-1.1, -1.2, -1.1], max: [1.1, 0.5, 1.1], step: 0.02 });
+}
+export const EXAMPLES = [
+    { name: 'donut', title: 'DONUT', description: 'the classic torus', style: { charset: 'classic', pitch: 0.2 }, build: donut },
+    { name: 'dice', title: 'DICE', description: 'a die with carved pips', style: hard(0.45), build: dice },
+    { name: 'rocket', title: 'ROCKET', description: 'thin fins and a porthole', style: soft(0.15), build: rocket },
+    { name: 'planet', title: 'PLANET', description: 'a globe with a tilted ring', style: soft(0.25), build: planet },
+    { name: 'mug', title: 'MUG', description: 'a hollow cup with a handle', style: soft(0.5), build: mug },
+    { name: 'gem', title: 'GEM', description: 'flat facets, good with --shading flat', style: { ...hard(0.35), edges: 'depth' }, build: gem },
+];
+export function findExample(name) {
+    const n = name.toLowerCase();
+    return EXAMPLES.find((e) => e.name === n || e.title.toLowerCase() === n);
+}
+export function buildExample(e) {
+    const g = e.build();
+    let r = g.next();
+    while (!r.done)
+        r = g.next();
+    return r.value;
+}

package/dist/format.d.ts

@@ -0,0 +1,57 @@
+export declare const FORMAT_VERSION = 1;
+export declare const ENCODING = "rle-delta-1";
+/**
+ * Cell styles, by index. `""` is the default color, `"~"` the default color dimmed,
+ * `"#rrggbb"` a color. Index 0 is always `""`.
+ */
+export type CellStyle = string;
+/** per-cell palette indices; Uint8Array when the palette fits in a byte */
+export type CellArray = Uint8Array | Uint16Array;
+/** A recorded animation in memory: per frame, one glyph index and one style index per cell. */
+export interface Recording {
+    width: number;
+    height: number;
+    aspect: number;
+    fps: number;
+    glyphs: string[];
+    /** null when no cell has a color or dim style */
+    styles: CellStyle[] | null;
+    /** background color of the original style, if it had one */
+    bg: string | null;
+    frames: {
+        glyph: CellArray;
+        style: CellArray | null;
+    }[];
+    meta: Record<string, unknown>;
+}
+/** The JSON container. */
+export interface FramesFile {
+    textel: number;
+    encoding: string;
+    width: number;
+    height: number;
+    aspect: number;
+    fps: number;
+    frameCount: number;
+    glyphs: string[];
+    styles?: CellStyle[];
+    bg?: string;
+    /** base64 of the encoded stream */
+    data: string;
+    meta?: Record<string, unknown>;
+}
+/** The encoded stream for a recording. Each frame is stored as a delta or a key frame, whichever is smaller. */
+export declare function encodeStream(rec: Recording): Uint8Array;
+/**
+ * Decodes the stream. Palette sizes, when given, let the frames use one byte per cell instead of two.
+ */
+export declare function decodeStream(data: Uint8Array, width: number, height: number, frameCount: number, styled: boolean, glyphCount?: number, styleCount?: number): Recording['frames'];
+export declare function toFramesFile(rec: Recording): FramesFile;
+export declare function fromFramesFile(file: FramesFile): Recording;
+/** JSON text of a recording; this is what `.textel.json` holds. */
+export declare function stringifyFrames(rec: Recording): string;
+export declare function parseFrames(text: string): Recording;
+/** one frame as plain text */
+export declare function recordingText(rec: Recording, index: number): string;
+export declare function toBase64(bytes: Uint8Array): string;
+export declare function fromBase64(b64: string): Uint8Array;

package/dist/format.js

@@ -0,0 +1,262 @@
+// The frames format: types, the byte stream and the JSON container. No dependencies, so the web
+// player can use it without pulling in the renderer. See docs/format.md for the layout.
+export const FORMAT_VERSION = 1;
+export const ENCODING = 'rle-delta-1';
+// ---------- byte stream ----------
+class Writer {
+    buf = new Uint8Array(1024);
+    len = 0;
+    byte(b) {
+        if (this.len === this.buf.length) {
+            const nb = new Uint8Array(this.buf.length * 2);
+            nb.set(this.buf);
+            this.buf = nb;
+        }
+        this.buf[this.len++] = b;
+    }
+    /** unsigned LEB128 */
+    varint(v) {
+        while (v >= 0x80) {
+            this.byte((v & 0x7f) | 0x80);
+            v >>>= 7;
+        }
+        this.byte(v);
+    }
+    bytes() { return this.buf.slice(0, this.len); }
+}
+class Reader {
+    pos = 0;
+    buf;
+    constructor(buf) {
+        this.buf = buf;
+    }
+    byte() {
+        if (this.pos >= this.buf.length)
+            throw new Error('frames data ends early');
+        return this.buf[this.pos++];
+    }
+    varint() {
+        let v = 0, shift = 0, b;
+        do {
+            b = this.byte();
+            v += (b & 0x7f) * 2 ** shift;
+            shift += 7;
+            if (shift > 35)
+                throw new Error('bad varint in frames data');
+        } while (b & 0x80);
+        return v;
+    }
+    get done() { return this.pos >= this.buf.length; }
+}
+const KEY = 0, DELTA = 1;
+/** RLE over cells [from, to): (run, glyph[, style]) */
+function writeRuns(w, g, s, from, to) {
+    let i = from;
+    while (i < to) {
+        let j = i + 1;
+        while (j < to && g[j] === g[i] && (!s || s[j] === s[i]))
+            j++;
+        w.varint(j - i);
+        w.varint(g[i]);
+        if (s)
+            w.varint(s[i]);
+        i = j;
+    }
+}
+function readRuns(r, g, s, from, count) {
+    let i = from;
+    const end = from + count;
+    if (end > g.length)
+        throw new Error('frames data runs past the grid');
+    while (i < end) {
+        const run = r.varint(), gv = r.varint(), sv = s ? r.varint() : 0;
+        if (run === 0 || i + run > end)
+            throw new Error('bad run in frames data');
+        g.fill(gv, i, i + run);
+        if (s)
+            s.fill(sv, i, i + run);
+        i += run;
+    }
+}
+function keyFrame(w, g, s) {
+    w.byte(KEY);
+    writeRuns(w, g, s, 0, g.length);
+}
+/** gaps of unchanged cells shorter than this are resent inside a span; a new span costs more */
+const MIN_GAP = 3;
+/** span count, then per span: (skip, count, runs...) */
+function deltaFrame(w, g, s, pg, ps) {
+    const n = g.length, same = (i) => g[i] === pg[i] && (!s || s[i] === ps[i]);
+    const spans = [];
+    let i = 0;
+    while (i < n) {
+        while (i < n && same(i))
+            i++;
+        if (i >= n)
+            break;
+        const start = i;
+        let end = i + 1, j = i + 1;
+        while (j < n) {
+            if (!same(j)) {
+                end = ++j;
+                continue;
+            }
+            let k = j;
+            while (k < n && same(k))
+                k++;
+            if (k >= n || k - j >= MIN_GAP)
+                break;
+            j = k;
+        }
+        spans.push([start, end]);
+        i = end;
+    }
+    w.byte(DELTA);
+    w.varint(spans.length);
+    let cursor = 0;
+    for (const [a, b] of spans) {
+        w.varint(a - cursor);
+        w.varint(b - a);
+        writeRuns(w, g, s, a, b);
+        cursor = b;
+    }
+}
+/** The encoded stream for a recording. Each frame is stored as a delta or a key frame, whichever is smaller. */
+export function encodeStream(rec) {
+    const out = new Writer();
+    let prev = null;
+    for (const fr of rec.frames) {
+        const k = new Writer();
+        keyFrame(k, fr.glyph, fr.style);
+        let best = k;
+        if (prev) {
+            const d = new Writer();
+            deltaFrame(d, fr.glyph, fr.style, prev.glyph, prev.style);
+            if (d.len < k.len)
+                best = d;
+        }
+        for (let i = 0; i < best.len; i++)
+            out.byte(best.buf[i]);
+        prev = fr;
+    }
+    return out.bytes();
+}
+/**
+ * Decodes the stream. Palette sizes, when given, let the frames use one byte per cell instead of two.
+ */
+export function decodeStream(data, width, height, frameCount, styled, glyphCount = 0x10000, styleCount = 0x10000) {
+    const G = glyphCount <= 256 ? Uint8Array : Uint16Array, S = styleCount <= 256 ? Uint8Array : Uint16Array;
+    const n = width * height, r = new Reader(data), frames = [];
+    for (let f = 0; f < frameCount; f++) {
+        const type = r.byte(), prev = frames[f - 1];
+        const g = new G(n), s = styled ? new S(n) : null;
+        if (type === KEY) {
+            readRuns(r, g, s, 0, n);
+        }
+        else if (type === DELTA) {
+            if (!prev)
+                throw new Error('first frame cannot be a delta');
+            g.set(prev.glyph);
+            if (s)
+                s.set(prev.style);
+            const spans = r.varint();
+            let i = 0;
+            for (let k = 0; k < spans; k++) {
+                const skip = r.varint(), count = r.varint();
+                if (count === 0)
+                    throw new Error('empty span in frames data');
+                readRuns(r, g, s, i + skip, count);
+                i += skip + count;
+            }
+        }
+        else {
+            throw new Error(`unknown frame type ${type}`);
+        }
+        frames.push({ glyph: g, style: s });
+    }
+    if (!r.done)
+        throw new Error('extra bytes after the last frame');
+    return frames;
+}
+// ---------- containers ----------
+export function toFramesFile(rec) {
+    const file = {
+        textel: FORMAT_VERSION,
+        encoding: ENCODING,
+        width: rec.width,
+        height: rec.height,
+        aspect: rec.aspect,
+        fps: rec.fps,
+        frameCount: rec.frames.length,
+        glyphs: rec.glyphs,
+        // header fields first, so the file reads well when opened; the long data string goes last
+        ...(rec.styles ? { styles: rec.styles } : {}),
+        ...(rec.bg ? { bg: rec.bg } : {}),
+        ...(Object.keys(rec.meta).length ? { meta: rec.meta } : {}),
+        data: toBase64(encodeStream(rec)),
+    };
+    return file;
+}
+export function fromFramesFile(file) {
+    if (!file || typeof file !== 'object')
+        throw new Error('not a textel frames file');
+    if (file.textel !== FORMAT_VERSION)
+        throw new Error(`frames format ${file.textel} is not supported (this version reads ${FORMAT_VERSION})`);
+    if (file.encoding !== ENCODING)
+        throw new Error(`unknown frames encoding "${file.encoding}"`);
+    const { width, height, frameCount } = file;
+    if (!(width > 0 && height > 0 && frameCount > 0))
+        throw new Error('bad frames header');
+    if (!Array.isArray(file.glyphs) || !file.glyphs.length)
+        throw new Error('bad frames header');
+    const nG = file.glyphs.length, nS = file.styles?.length ?? 1;
+    const frames = decodeStream(fromBase64(file.data), width, height, frameCount, !!file.styles, nG, nS);
+    for (const fr of frames) {
+        for (let i = 0; i < fr.glyph.length; i++) {
+            if (fr.glyph[i] >= nG || (fr.style && fr.style[i] >= nS))
+                throw new Error('frames data points outside its palette');
+        }
+    }
+    return {
+        width, height, aspect: file.aspect, fps: file.fps,
+        glyphs: file.glyphs, styles: file.styles ?? null, bg: file.bg ?? null, frames, meta: file.meta ?? {},
+    };
+}
+/** JSON text of a recording; this is what `.textel.json` holds. */
+export function stringifyFrames(rec) {
+    return JSON.stringify(toFramesFile(rec));
+}
+export function parseFrames(text) {
+    let file;
+    try {
+        file = JSON.parse(text);
+    }
+    catch {
+        throw new Error('not a textel frames file (invalid JSON)');
+    }
+    return fromFramesFile(file);
+}
+/** one frame as plain text */
+export function recordingText(rec, index) {
+    const { width: W, height: H, glyphs } = rec, g = rec.frames[index].glyph, rows = [];
+    for (let r = 0; r < H; r++) {
+        let s = '';
+        for (let c = 0; c < W; c++)
+            s += glyphs[g[r * W + c]];
+        rows.push(s);
+    }
+    return rows.join('\n');
+}
+// ---------- base64 without Buffer, so the same code runs in browsers ----------
+export function toBase64(bytes) {
+    let s = '';
+    for (let i = 0; i < bytes.length; i += 0x8000)
+        s += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    return btoa(s);
+}
+export function fromBase64(b64) {
+    const s = atob(b64), out = new Uint8Array(s.length);
+    for (let i = 0; i < s.length; i++)
+        out[i] = s.charCodeAt(i);
+    return out;
+}

package/dist/frames.d.ts

@@ -0,0 +1,34 @@
+import { type ColorDepth } from './ansi.ts';
+import type { Recording } from './format.ts';
+import type { Frame, Renderer } from './render.ts';
+export * from './format.ts';
+export interface RecordOptions {
+    /** frames in one full turn (default 120) */
+    frames?: number;
+    /** playback rate (default 30) */
+    fps?: number;
+    /** turns over the whole loop; negative spins the other way (default 1) */
+    turns?: number;
+    /** starting yaw, radians */
+    yaw?: number;
+    /** colors are rounded to multiples of this per channel, which keeps the palette small (default 8) */
+    colorStep?: number;
+    meta?: Record<string, unknown>;
+    /** called after each frame, for progress */
+    onFrame?: (done: number, total: number) => void;
+}
+/** Renders a seamless turntable loop: the last frame leads straight back into the first. */
+export declare function recordLoop(renderer: Renderer, opts?: RecordOptions): Recording;
+/** Collects rendered frames into palettes and indices. */
+export declare class RecordingBuilder {
+    private glyphs;
+    private styles;
+    private frames;
+    private first;
+    private step;
+    constructor(colorStep?: number);
+    add(frame: Frame): void;
+    build(fps: number, meta: Record<string, unknown>): Recording;
+}
+/** one frame as ANSI lines */
+export declare function recordingANSI(rec: Recording, index: number, depth?: ColorDepth): string[];

package/dist/frames.js

@@ -0,0 +1,88 @@
+// Recording: renders a loop into a frames recording, and plays one back as ANSI.
+// The format itself lives in format.ts.
+import { bg, FAINT, fg, line } from "./ansi.js";
+import { cellColor } from "./output.js";
+export * from "./format.js";
+const hex = (c) => '#' + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, '0')).join('');
+/** Renders a seamless turntable loop: the last frame leads straight back into the first. */
+export function recordLoop(renderer, opts = {}) {
+    const n = Math.max(1, Math.round(opts.frames ?? 120)), turns = opts.turns ?? 1, yaw0 = opts.yaw ?? 0;
+    const rec = new RecordingBuilder(opts.colorStep ?? 8);
+    for (let i = 0; i < n; i++) {
+        rec.add(renderer.render({ yaw: yaw0 + (i / n) * turns * Math.PI * 2 }));
+        opts.onFrame?.(i + 1, n);
+    }
+    return rec.build(opts.fps ?? 30, opts.meta ?? {});
+}
+/** Collects rendered frames into palettes and indices. */
+export class RecordingBuilder {
+    glyphs = new Map([[' ', 0]]);
+    styles = new Map([['', 0]]);
+    frames = [];
+    first = null;
+    step;
+    constructor(colorStep = 8) {
+        this.step = Math.max(1, colorStep);
+    }
+    add(frame) {
+        if (!this.first)
+            this.first = frame;
+        else if (frame.width !== this.first.width || frame.height !== this.first.height)
+            throw new Error('all frames must have the same size');
+        const n = frame.width * frame.height, glyph = new Uint16Array(n), style = new Uint16Array(n);
+        const q = (v) => Math.round(v / this.step) * this.step;
+        for (let i = 0; i < n; i++) {
+            const ch = frame.chars[i];
+            let g = this.glyphs.get(ch);
+            if (g === undefined) {
+                g = this.glyphs.size;
+                this.glyphs.set(ch, g);
+            }
+            glyph[i] = g;
+            if (ch === ' ')
+                continue;
+            const { rgb, faint } = cellColor(frame, i);
+            const key = rgb ? hex([q(rgb[0]), q(rgb[1]), q(rgb[2])]) : faint ? '~' : '';
+            let s = this.styles.get(key);
+            if (s === undefined) {
+                s = this.styles.size;
+                this.styles.set(key, s);
+            }
+            style[i] = s;
+        }
+        if (this.glyphs.size > 0xffff || this.styles.size > 0xffff)
+            throw new Error('too many distinct glyphs or colors');
+        this.frames.push({ glyph, style });
+    }
+    build(fps, meta) {
+        const f = this.first;
+        if (!f)
+            throw new Error('no frames recorded');
+        const styled = this.styles.size > 1;
+        const bg = f.style.color.bg;
+        return {
+            width: f.width,
+            height: f.height,
+            aspect: f.style.aspect,
+            fps,
+            glyphs: [...this.glyphs.keys()],
+            styles: styled ? [...this.styles.keys()] : null,
+            bg: bg ? hex(bg) : null,
+            frames: this.frames.map((fr) => ({ glyph: fr.glyph, style: styled ? fr.style : null })),
+            meta,
+        };
+    }
+}
+const rgbOf = (h) => [parseInt(h.slice(1, 3), 16), parseInt(h.slice(3, 5), 16), parseInt(h.slice(5, 7), 16)];
+/** one frame as ANSI lines */
+export function recordingANSI(rec, index, depth = 'truecolor') {
+    const { width: W, height: H, glyphs } = rec, fr = rec.frames[index];
+    const codes = (rec.styles ?? ['']).map((st) => (st === '' ? '' : st === '~' ? FAINT : fg(rgbOf(st), depth)));
+    const background = bg(rec.bg ? rgbOf(rec.bg) : null, depth);
+    const ch = (i) => glyphs[fr.glyph[i]];
+    const code = fr.style ? (i) => codes[fr.style[i]] : () => '';
+    const lines = [];
+    for (let r = 0; r < H; r++)
+        lines.push(line(ch, code, r * W, W, background));
+    return lines;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createRenderer, type Frame, type Renderer, type View } from './render.ts';
+export { toText, toANSI, toHTML, cellColor, type ColorDepth } from './output.ts';
+export { parseModel, parseGLTF, parseOBJ, parseSTL, MODEL_EXTENSIONS } from './loaders/index.ts';
+export { recordLoop, RecordingBuilder, encodeStream, decodeStream, toFramesFile, fromFramesFile, stringifyFrames, parseFrames, recordingText, recordingANSI, FORMAT_VERSION, ENCODING, type Recording, type FramesFile, type RecordOptions, type CellStyle, } from './frames.ts';
+export { MeshBuilder, computeSmoothNormals, vertexCount, triangleCount, type Mesh } from './mesh.ts';
+export { CHARSETS, DEFAULTS, mergeStyles, resolveStyle, type StyleInput, type Style, type MaterialInput, type ColorInput, type EdgeMode, type Vec3, type RGB, } from './style.ts';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { createRenderer } from "./render.js";
+export { toText, toANSI, toHTML, cellColor } from "./output.js";
+export { parseModel, parseGLTF, parseOBJ, parseSTL, MODEL_EXTENSIONS } from "./loaders/index.js";
+export { recordLoop, RecordingBuilder, encodeStream, decodeStream, toFramesFile, fromFramesFile, stringifyFrames, parseFrames, recordingText, recordingANSI, FORMAT_VERSION, ENCODING, } from "./frames.js";
+export { MeshBuilder, computeSmoothNormals, vertexCount, triangleCount } from "./mesh.js";
+export { CHARSETS, DEFAULTS, mergeStyles, resolveStyle, } from "./style.js";

package/dist/loaders/gltf.d.ts

@@ -0,0 +1,7 @@
+import { type Mesh } from '../mesh.ts';
+export interface GltfOptions {
+    /** loads an external buffer (`.gltf` with a separate `.bin`) by its uri */
+    resolve?: (uri: string) => Uint8Array;
+}
+/** `.glb` (binary) or `.gltf` (JSON) bytes. Applies node transforms; all triangle primitives go into one mesh. */
+export declare function parseGLTF(bytes: Uint8Array, opts?: GltfOptions): Mesh;