headreel 1.4.0 → 1.6.0

package/dist/styles/receipt/receipt.js

@@ -0,0 +1,229 @@
+import { bestDay, currentStreak, longestStreak } from '../../core/streaks.js';
+import { canvasMeasure, fitLine } from '../../core/text.js';
+/**
+ * What the printer prints. The whole receipt is one list of text lines plus a
+ * tail (barcode, footer, tear line); the sketch rasterizes them into one
+ * offscreen strip and feeds it out of the slot. Everything here is a pure
+ * function of the data.
+ */
+export const FRAMES = 400;
+/** Paper geometry, px: a 58 mm thermal printer prints 384 dots per line. */
+export const PAPER = {
+    width: 384,
+    /** Side margins; the 32-column text grid lives between them. */
+    margin: 16,
+    text: 352,
+    size: 18,
+    line: 26,
+    /** Barcode bars, full height. */
+    bars: 48,
+};
+/** The tail: everything after the last text line, to the next header. */
+export const TAIL = {
+    gapAboveBars: 10,
+    gapBelowBars: 12,
+    footer: PAPER.line,
+    gapBelowFooter: 8,
+    tear: PAPER.line,
+    /** Paper between the tear line and the next receipt's header. */
+    leader: 18,
+};
+/** Step, pause and hold weights, in frames, normalized to `FRAMES` below. */
+const WEIGHTS = { hold: 40, step: 3, pause: 5 };
+/** Constant feed speed of the barcode tail, px per frame. */
+const FEED_SPEED = 2;
+const easeInOut = (t) => (t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2);
+/**
+ * The feed timeline: a hold, then one eased step per text line with a pause
+ * after each, then the tail at constant speed. Weights are normalized to the
+ * loop, so a short receipt feeds more slowly over the same 16 s.
+ */
+export function buildFeedPlan(textHeights, tail) {
+    const raw = [
+        { w: WEIGHTS.hold, dist: 0, kind: 'hold' },
+    ];
+    for (const h of textHeights) {
+        raw.push({ w: WEIGHTS.step, dist: h, kind: 'step' });
+        raw.push({ w: WEIGHTS.pause, dist: 0, kind: 'pause' });
+    }
+    raw.push({ w: tail / FEED_SPEED, dist: tail, kind: 'feed' });
+    const scale = FRAMES / raw.reduce((sum, g) => sum + g.w, 0);
+    const segments = [];
+    let at = 0;
+    let length = 0;
+    for (const g of raw) {
+        const end = at + g.w * scale;
+        segments.push({ start: at, end, dist: g.dist, kind: g.kind });
+        length += g.dist;
+        at = end;
+    }
+    return { length, segments };
+}
+/** Where the paper is at `t`, and whether the printer's LED is on. */
+export function feedAt(plan, t) {
+    const pos = Math.min(Math.max(t, 0), 1) * FRAMES;
+    let dist = 0;
+    for (const seg of plan.segments) {
+        const last = seg === plan.segments.at(-1);
+        if (pos < seg.end || last) {
+            const u = Math.min(1, Math.max(0, (pos - seg.start) / (seg.end - seg.start)));
+            dist += seg.kind === 'step' ? seg.dist * easeInOut(u) : seg.dist * u;
+            const led = seg.kind === 'pause' ? false : seg.kind === 'step' ? u < 0.6 : true;
+            return { offset: Math.round(dist) % plan.length, led };
+        }
+        dist += seg.dist;
+    }
+    return { offset: 0, led: true };
+}
+/**
+ * Barcode bar widths, one per calendar week: 0 for a week without
+ * contributions, otherwise 1 to 4 px by quartile of the non-zero weeks, so
+ * the busiest weeks print as the widest bars.
+ */
+export function barcodeWidths(days, from) {
+    // Calendar columns start on Sunday; the window's first week may be partial.
+    const lead = new Date(`${from}T00:00:00Z`).getUTCDay();
+    const weeks = [];
+    days.forEach((count, i) => {
+        const w = Math.floor((lead + i) / 7);
+        weeks[w] = (weeks[w] ?? 0) + count;
+    });
+    const active = weeks.filter((t) => t > 0).sort((a, b) => a - b);
+    if (active.length === 0)
+        return weeks.map(() => 0);
+    const at = (p) => active[Math.min(active.length - 1, Math.floor(p * (active.length - 1)))];
+    const [q1, q2, q3] = [at(0.25), at(0.5), at(0.75)];
+    return weeks.map((total) => total <= 0 ? 0 : total >= q3 ? 4 : total >= q2 ? 3 : total >= q1 ? 2 : 1);
+}
+const MONTHS = [
+    'JAN',
+    'FEB',
+    'MAR',
+    'APR',
+    'MAY',
+    'JUN',
+    'JUL',
+    'AUG',
+    'SEP',
+    'OCT',
+    'NOV',
+    'DEC',
+];
+/** "2026-03-12" -> "12 MAR 2026". */
+export function printDate(date) {
+    const [, m, d] = date.split('-');
+    return `${d} ${MONTHS[Number(m) - 1]} ${date.slice(0, 4)}`;
+}
+const measure = canvasMeasure('JetBrains Mono', PAPER.size);
+/** Right-aligned value with room to breathe: the till-receipt column gap. */
+const GAP = 12;
+export function buildReceipt(data, login, identity, options, palette, rng) {
+    // Thermal texture: per-line density, with a lighter band every few lines.
+    const texture = () => {
+        const d = 0.88 + rng() * 0.12;
+        return rng() < 0.15 ? d * 0.8 : d;
+    };
+    const line = (h, fields) => ({
+        h,
+        ...fields,
+        density: texture(),
+    });
+    const text = (fields) => line(PAPER.line, fields);
+    const rule = () => text({ left: '-'.repeat(32) });
+    const doubleRule = () => text({ left: '='.repeat(32) });
+    const count = (label, value) => text({ left: label, right: String(value) });
+    const lines = [];
+    // Header: the store is the user.
+    const name = fitLine(identity.name.toUpperCase(), PAPER.text, PAPER.size, PAPER.size, measure);
+    lines.push(line(PAPER.line * 2, { center: name.text, double: true }));
+    lines.push(text({ center: `github.com/${login}`, faded: true }));
+    const txn = `${Math.floor(rng() * 0x10000)
+        .toString(16)
+        .toUpperCase()
+        .padStart(4, '0')}-${String(Math.floor(rng() * 99) + 1).padStart(2, '0')}`;
+    lines.push(text({ left: `TXN ${txn}`, right: 'REG 01' }));
+    lines.push(text({ center: `${printDate(data.from)}  -  ${printDate(data.to)}`, faded: true }));
+    lines.push(rule());
+    // Items: the repositories the user committed to.
+    const empty = data.total === 0;
+    const items = data.items.slice(0, options.items);
+    if (empty) {
+        lines.push(text({ center: 'NO ITEMS' }));
+        lines.push(rule());
+    }
+    else if (items.length > 0 || data.privateCommits > 0) {
+        lines.push(text({ left: 'ITEM', right: 'QTY' }));
+        for (const item of items) {
+            const qty = String(item.commits);
+            const fitted = fitLine(item.name, PAPER.text - measure(qty, PAPER.size) - GAP, PAPER.size, PAPER.size, measure);
+            lines.push(text({ left: fitted.text, right: qty }));
+            if (item.language) {
+                lines.push(text({ left: `  @ ${item.language.name}`, faded: true }));
+            }
+        }
+        if (data.privateCommits > 0) {
+            lines.push(count('private repos', data.privateCommits));
+        }
+        lines.push(rule());
+    }
+    // Totals; a line whose count is 0 is left out. OTHER is what the per-type
+    // counts do not add up to, so the receipt always adds up.
+    const totals = [
+        count('COMMITS', data.commits),
+        count('PULL REQUESTS', data.pullRequests),
+        count('REVIEWS', data.reviews),
+        count('ISSUES', data.issues),
+        count('NEW REPOS', data.newRepos),
+        count('PRIVATE', data.restricted),
+    ].filter((l) => l.right !== '0');
+    const other = data.total -
+        (data.commits +
+            data.pullRequests +
+            data.reviews +
+            data.issues +
+            data.newRepos +
+            data.restricted);
+    if (other > 0)
+        totals.push(count('OTHER', other));
+    else if (other < 0)
+        console.warn('receipt: per-type counts exceed the calendar total; OTHER left out');
+    lines.push(...totals);
+    lines.push(doubleRule());
+    lines.push(count('TOTAL', data.total));
+    lines.push(doubleRule());
+    // Streaks and the best day; a streak of 0 is left out.
+    const longest = longestStreak(data.days);
+    if (longest > 0)
+        lines.push(text({ left: 'LONGEST STREAK', right: `${longest} DAYS` }));
+    const current = currentStreak(data.days);
+    if (current > 0)
+        lines.push(text({ left: 'CURRENT STREAK', right: `${current} DAYS` }));
+    const best = bestDay(data.days);
+    if (best) {
+        const date = new Date(Date.parse(`${data.from}T00:00:00Z`) + best.index * 86_400_000)
+            .toISOString()
+            .slice(0, 10);
+        const qty = String(best.count);
+        const label = fitLine(`BEST DAY ${printDate(date)}`, PAPER.text - measure(qty, PAPER.size) - GAP, PAPER.size, PAPER.size, measure);
+        lines.push(text({ left: label.text, right: qty }));
+    }
+    const barcode = barcodeWidths(data.days, data.from);
+    const tail = TAIL.gapAboveBars +
+        PAPER.bars +
+        TAIL.gapBelowBars +
+        TAIL.footer +
+        TAIL.gapBelowFooter +
+        TAIL.tear +
+        TAIL.leader;
+    const feed = buildFeedPlan(lines.map((l) => l.h), tail);
+    return {
+        palette,
+        total: data.total,
+        lines,
+        barcode,
+        footer: `${login.toUpperCase()}-${data.asOf.slice(0, 4)}`,
+        feed,
+        length: feed.length,
+        txn,
+    };
+}

package/dist/styles/receipt/sketch.js

@@ -0,0 +1,296 @@
+import { fitIdentity } from '../../core/text.js';
+import { feedAt, PAPER, TAIL } from './receipt.js';
+/**
+ * A thermal printer feeding the user's year as a till receipt.
+ *
+ * The whole receipt, tear line included, is rasterized once in setup into one
+ * offscreen strip (the paper). Each frame draws that strip at a whole-pixel
+ * offset, clipped at the printer's slot, tiling around at the strip's length:
+ * the roll prints the same receipt back to back, so the loop closes. Nothing
+ * on the paper is re-rasterized per frame, so held frames are byte-identical.
+ *
+ * Everything is drawn through the raw 2D context with the style set right
+ * before each draw (see Highlights Reel's note on p5's cached fill state).
+ */
+const SANS = '"Space Grotesk"';
+const MONO = '"JetBrains Mono"';
+const PROMPT = '~/receipt --last-12-months';
+const W = 1280;
+const H = 400;
+const TAU = Math.PI * 2;
+/** Width of the identity column: x 48 to 640, the printer body's left edge minus 20. */
+export const IDENTITY_COLUMN = 640 - 48;
+/** Paper and printer geometry, screen space. */
+const PAPER_X = 708;
+const SLOT_Y = 336;
+const PRINTER = { left: 660, right: 1140, bottom: 400 };
+const SLOT = { left: 700, right: 1100, bottom: 350 };
+const LED = { x: 1104, y: 369 };
+function rgba(color, alpha = 1) {
+    return `rgba(${color[0]},${color[1]},${color[2]},${alpha})`;
+}
+function setFill(ctx, color, alpha = 1) {
+    ctx.fillStyle = rgba(color, alpha);
+}
+function setFont(ctx, o) {
+    ctx.font = `${o.bold ? 700 : 400} ${o.size}px ${o.mono ? MONO : SANS}`;
+    ctx.textAlign = o.align ?? 'left';
+    ctx.textBaseline = 'alphabetic';
+    ctx.letterSpacing = `${o.tracking ?? 0}px`;
+}
+function drawText(ctx, str, x, y, o) {
+    setFont(ctx, o);
+    setFill(ctx, o.color, o.alpha ?? 1);
+    ctx.fillText(str, x, y);
+    if (o.tracking)
+        ctx.letterSpacing = '0px';
+}
+/** 0..1, periodic in `t`, so every animated value loops seamlessly. */
+function wave(t, cycles, off) {
+    return 0.5 + 0.5 * Math.sin(TAU * (t * cycles + off));
+}
+/** One text row of the paper, in strip coordinates. */
+function drawLine(ctx, line, top, p) {
+    if (!line.left && !line.right && !line.center)
+        return;
+    const color = line.faded ? p.fadedInk : p.ink;
+    ctx.font = `400 ${PAPER.size}px ${MONO}`;
+    ctx.textBaseline = 'middle';
+    ctx.letterSpacing = '0px';
+    if (line.double) {
+        // The thermal double-height mode: the same glyphs, vertically scaled.
+        ctx.save();
+        ctx.translate(0, top);
+        ctx.scale(1, 2);
+        setFill(ctx, color, line.density);
+        ctx.textAlign = 'center';
+        ctx.fillText(line.center ?? '', PAPER.width / 2, line.h / 4);
+        ctx.restore();
+        return;
+    }
+    setFill(ctx, color, line.density);
+    if (line.left) {
+        ctx.textAlign = 'left';
+        ctx.fillText(line.left, PAPER.margin, top + line.h / 2);
+    }
+    if (line.right) {
+        ctx.textAlign = 'right';
+        ctx.fillText(line.right, PAPER.width - PAPER.margin, top + line.h / 2);
+    }
+    if (line.center) {
+        ctx.textAlign = 'center';
+        ctx.fillText(line.center, PAPER.width / 2, top + line.h / 2);
+    }
+}
+/** The paper: everything the printer prints, one receipt per period. */
+function renderStrip(p, model) {
+    const P = model.palette;
+    const strip = p.createGraphics(PAPER.width, model.length);
+    const ctx = strip.drawingContext;
+    setFill(ctx, P.paper);
+    ctx.fillRect(0, 0, PAPER.width, model.length);
+    let y = 0;
+    for (const line of model.lines) {
+        drawLine(ctx, line, y, P);
+        y += line.h;
+    }
+    // Barcode: one bar per week, centered, 2 px between bars.
+    const bars = model.barcode.filter((w) => w > 0);
+    const barsTop = y + TAIL.gapAboveBars;
+    if (bars.length > 0) {
+        const total = bars.reduce((s, w) => s + w, 0) + (bars.length - 1) * 2;
+        let x = (PAPER.width - total) / 2;
+        ctx.fillStyle = rgba(P.ink, 0.95);
+        for (const w of model.barcode) {
+            if (w > 0) {
+                ctx.fillRect(Math.round(x), barsTop, w, PAPER.bars);
+                x += w + 2;
+            }
+        }
+    }
+    // Human-readable text under the barcode.
+    const footerTop = barsTop + PAPER.bars + TAIL.gapBelowBars;
+    ctx.font = `400 14px ${MONO}`;
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    ctx.letterSpacing = '2px';
+    ctx.fillStyle = rgba(P.ink, 0.9);
+    ctx.fillText(model.footer, PAPER.width / 2, footerTop + TAIL.footer / 2);
+    ctx.letterSpacing = '0px';
+    // Tear line: a perforation between receipts, with edge notches.
+    const tearY = footerTop + TAIL.footer + TAIL.gapBelowFooter + TAIL.tear / 2;
+    ctx.strokeStyle = rgba(P.fadedInk, 0.85);
+    ctx.lineWidth = 1.5;
+    ctx.setLineDash([5, 4]);
+    ctx.beginPath();
+    ctx.moveTo(8, tearY);
+    ctx.lineTo(PAPER.width - 8, tearY);
+    ctx.stroke();
+    ctx.setLineDash([]);
+    ctx.globalCompositeOperation = 'destination-out';
+    for (const cx of [0, PAPER.width]) {
+        ctx.beginPath();
+        ctx.arc(cx, tearY, 6, 0, TAU);
+        ctx.fill();
+    }
+    ctx.globalCompositeOperation = 'source-over';
+    if (P.paperBorder) {
+        ctx.strokeStyle = rgba(P.paperBorder, 0.09);
+        ctx.lineWidth = 1;
+        ctx.strokeRect(0.5, 0.5, PAPER.width - 1, model.length - 1);
+    }
+    return strip;
+}
+export function createReceiptSketch(model, identity) {
+    const P = model.palette;
+    const fitted = fitIdentity({
+        name: identity.name.toUpperCase(),
+        tagline: identity.tagline,
+        website: identity.website && `↗ ${displayUrl(identity.website)}`,
+    }, IDENTITY_COLUMN);
+    // --- static layers --------------------------------------------------------
+    /** The counter and the identity column, beneath the paper. */
+    function renderChrome(p) {
+        const chrome = p.createGraphics(W, H);
+        const ctx = chrome.drawingContext;
+        setFill(ctx, P.counter);
+        ctx.fillRect(0, 0, W, H);
+        // Soft shadow around the paper, light theme only.
+        if (P.shadow > 0) {
+            for (const [x0, x1, peak] of [
+                [PAPER_X + PAPER.width, PAPER_X + PAPER.width + 10, P.shadow],
+                [PAPER_X - 10, PAPER_X, P.shadow * 0.6],
+            ]) {
+                const grad = ctx.createLinearGradient(x0, 0, x1, 0);
+                grad.addColorStop(0, rgba(P.paperBorder, peak));
+                grad.addColorStop(1, rgba(P.paperBorder, 0));
+                ctx.fillStyle = grad;
+                ctx.fillRect(x0, 0, x1 - x0, SLOT_Y);
+            }
+        }
+        const x = 48;
+        drawText(ctx, PROMPT, x, 58, { size: 13, mono: true, color: P.accent });
+        drawText(ctx, fitted.name.text, x, 116, {
+            size: fitted.name.size,
+            bold: true,
+            color: P.identityInk,
+            tracking: 3,
+        });
+        if (fitted.tagline) {
+            drawText(ctx, fitted.tagline.text, x, 146, {
+                size: fitted.tagline.size,
+                color: P.accent,
+            });
+        }
+        drawText(ctx, model.total.toLocaleString('en-US'), x, 218, {
+            size: 34,
+            bold: true,
+            color: P.identityInk,
+        });
+        drawText(ctx, 'contributions · last 12 months', x, 240, {
+            size: 11,
+            mono: true,
+            color: P.identityMuted,
+        });
+        if (fitted.website) {
+            drawText(ctx, fitted.website.text, x, 350, {
+                size: fitted.website.size,
+                mono: true,
+                color: P.accent,
+            });
+        }
+        return chrome;
+    }
+    /** The printer, drawn over the paper's lower edge. */
+    function renderPrinter(p) {
+        const printer = p.createGraphics(W, H);
+        const ctx = printer.drawingContext;
+        setFill(ctx, P.body);
+        ctx.fillRect(PRINTER.left, SLOT_Y, PRINTER.right - PRINTER.left, PRINTER.bottom - SLOT_Y);
+        // Bevel on the body's top edge.
+        setStroke(ctx, P.bevel, 0.7);
+        ctx.lineWidth = 1.5;
+        ctx.beginPath();
+        ctx.moveTo(PRINTER.left + 8, SLOT_Y + 1);
+        ctx.lineTo(PRINTER.right - 8, SLOT_Y + 1);
+        ctx.stroke();
+        // The slot: a dark mouth with a serrated tear bar biting the paper.
+        setFill(ctx, P.slot);
+        ctx.fillRect(SLOT.left, SLOT_Y, SLOT.right - SLOT.left, SLOT.bottom - SLOT_Y);
+        setFill(ctx, P.slot);
+        ctx.beginPath();
+        for (let x = SLOT.left + 4; x < SLOT.right - 2; x += 12) {
+            ctx.moveTo(x, SLOT_Y + 1);
+            ctx.lineTo(x + 6, SLOT_Y - 5);
+            ctx.lineTo(x + 12, SLOT_Y + 1);
+            ctx.closePath();
+        }
+        ctx.fill();
+        return printer;
+    }
+    function setStroke(ctx, color, alpha = 1) {
+        ctx.strokeStyle = rgba(color, alpha);
+    }
+    let chrome;
+    let printer;
+    let strip;
+    function setup(p) {
+        chrome = renderChrome(p);
+        printer = renderPrinter(p);
+        strip = renderStrip(p, model);
+    }
+    function draw(p, _frame, t) {
+        const ctx = p.drawingContext;
+        if (chrome)
+            p.image(chrome, 0, 0);
+        // The paper, one whole receipt per period, wrapped at the strip's length.
+        const { offset, led } = feedAt(model.feed, t);
+        const L = model.length;
+        ctx.save();
+        ctx.beginPath();
+        ctx.rect(PAPER_X, 0, PAPER.width, SLOT_Y);
+        ctx.clip();
+        if (strip) {
+            p.image(strip, PAPER_X, SLOT_Y - offset);
+            p.image(strip, PAPER_X, SLOT_Y - offset - L);
+        }
+        ctx.restore();
+        if (P.paperBorder) {
+            setStroke(ctx, P.paperBorder, 0.09);
+            ctx.lineWidth = 1;
+            ctx.strokeRect(PAPER_X + 0.5, 0.5, PAPER.width - 1, SLOT_Y - 1);
+        }
+        if (printer)
+            p.image(printer, 0, 0);
+        // Status LED: blinks once per text step, lit while feeding and holding.
+        if (led) {
+            ctx.save();
+            setFill(ctx, P.accent);
+            ctx.shadowColor = rgba(P.accent, 0.8);
+            ctx.shadowBlur = 7;
+            ctx.beginPath();
+            ctx.arc(LED.x, LED.y, 4.5, 0, TAU);
+            ctx.fill();
+            ctx.restore();
+            ctx.shadowBlur = 0;
+            ctx.shadowColor = 'transparent';
+        }
+        else {
+            setFill(ctx, P.accent, 0.16);
+            ctx.beginPath();
+            ctx.arc(LED.x, LED.y, 4.5, 0, TAU);
+            ctx.fill();
+        }
+        // Prompt cursor, blinking 3 times per loop.
+        if (wave(t, 3, 0) > 0.5) {
+            setFont(ctx, { size: 13, mono: true });
+            setFill(ctx, P.accent);
+            ctx.fillRect(48 + ctx.measureText(PROMPT).width + 4, 47, 7, 13);
+        }
+    }
+    return { setup, draw };
+}
+/** "https://www.example.com/" -> "www.example.com" */
+function displayUrl(url) {
+    return url.replace(/^[a-z]+:\/\//i, '').replace(/\/+$/, '');
+}

package/dist/styles/trail-profile/index.js

@@ -0,0 +1,16 @@
+import { contributionsSchema, fetchContributions, } from '../../core/data/contributions.js';
+import { buildTrail, FRAMES } from './trail.js';
+import { options } from './options.js';
+import { paletteOf, pinnedOf } from './palette.js';
+import { createTrailSketch } from './sketch.js';
+export const trailProfile = {
+    id: 'trail-profile',
+    fps: 25,
+    frames: FRAMES,
+    pinned: (o) => pinnedOf(paletteOf(o)),
+    data: { name: 'contributions', schema: contributionsSchema, fetch: fetchContributions },
+    options,
+    createSketch({ data, identity, options, rng }) {
+        return createTrailSketch(buildTrail(data, identity, paletteOf(options)), rng);
+    },
+};

package/dist/styles/trail-profile/options.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const ACCENTS = ['sienna', 'cobalt', 'green', 'violet'];
+export const options = z
+    .object({
+    /** Color of the profile line, strata, tagline and website. */
+    accent: z.enum(ACCENTS).default('sienna'),
+})
+    .strict();

package/dist/styles/trail-profile/palette.js

@@ -0,0 +1,50 @@
+/** `over` at `alpha` over `base`, both opaque. */
+export function blend(over, base, alpha) {
+    return [
+        Math.round(over[0] * alpha + base[0] * (1 - alpha)),
+        Math.round(over[1] * alpha + base[1] * (1 - alpha)),
+        Math.round(over[2] * alpha + base[2] * (1 - alpha)),
+    ];
+}
+/** Survey-map contour brown, new to this style; the others keep shared names. */
+const ACCENT_VALUES = {
+    sienna: [138, 75, 34], // #8A4B22
+    cobalt: [47, 85, 212], // #2F55D4
+    green: [31, 107, 58], // #1F6B3A
+    violet: [106, 63, 200], // #6A3FC8
+};
+const BASE = {
+    paper: [243, 239, 227], // #F3EFE3
+    ink: [43, 38, 32], // #2B2620
+    muted: [107, 99, 88], // #6B6358
+    graticule: [47, 111, 168], // #2F6FA8
+    flag: [200, 16, 46], // #C8102E
+};
+export function paletteOf(options) {
+    const accent = ACCENT_VALUES[options.accent];
+    const paper = BASE.paper;
+    return {
+        ...BASE,
+        accent,
+        // Pre-blended solids, drawn opaque so the encoder can pin them: alpha
+        // strokes anti-alias into a ramp of near-identical colors that dithers
+        // and re-shuffles every frame the camera moves.
+        strata: blend(accent, paper, 0.6),
+        graticule: blend(BASE.graticule, paper, 0.35),
+        stipple: blend(BASE.ink, paper, 0.55),
+        grid: blend(BASE.ink, paper, 0.15),
+    };
+}
+/** Flat colors the encoder keeps exact and undithered. */
+export function pinnedOf(palette) {
+    return [
+        palette.paper,
+        palette.ink,
+        palette.accent,
+        palette.flag,
+        palette.strata,
+        palette.graticule,
+        palette.stipple,
+        palette.grid,
+    ];
+}