@roobscoob/vibes 0.0.0-stage → 0.2.0

package/dist/parse.js

@@ -0,0 +1,208 @@
+// Colors from text, read as generously as can be: anything CSS takes (hex
+// codes with or without #, names, rgb(), hsl(), hwb(), oklch(), oklab(),
+// lab(), lch(), color()), color temperatures ("2700K", "candlelight"), the
+// lights' own ("lemtone(265 0.3 40)", or "265° C0.30 · 40 lm" as a color
+// prints itself), and any of those with lumens or a fidelity alongside
+// ("#f80 · 120 lm", "2700K @ 400lm").
+//
+// This only reads the text: what it says comes back as a Spec, and color.ts
+// makes the color.
+import { cssNamed, LIGHT_NAMES } from "./names.js";
+const NUMBER = /^([-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(%|deg|rad|grad|turn)?$/;
+function token(text) {
+    if (text === "none")
+        return { value: 0, unit: "" };
+    const m = NUMBER.exec(text);
+    return m ? { value: Number(m[1]), unit: (m[2] ?? "") } : null;
+}
+/** An angle in degrees. */
+function angle(t) {
+    if (t.unit === "rad")
+        return (t.value * 180) / Math.PI;
+    if (t.unit === "grad")
+        return t.value * 0.9;
+    if (t.unit === "turn")
+        return t.value * 360;
+    return t.value;
+}
+/** A number, with 100% as `hundred`. */
+const scaled = (t, hundred) => (t.unit === "%" ? (t.value / 100) * hundred : t.value);
+/** A fraction 0–1, from a percentage, or a number: 0–1 as it is, past 1 read as a percentage (hsl(240, 100, 50)). */
+const fraction = (t) => (t.unit === "%" || Math.abs(t.value) > 1 ? t.value / 100 : t.value);
+/** Lightness 0–1, from a percentage, or a number: 0–1 as it is, past 1 read as a percentage (oklch(70 0.2 265)). */
+const lightness = fraction;
+/** What `text` says a color is, or null if it can't be read. */
+export function parseColor(text) {
+    const s = text.trim().toLowerCase();
+    if (!s)
+        return null;
+    const whole = one(s);
+    if (whole)
+        return whole;
+    // A color, its lumens and its fidelity, in any order: "#f80 · 120 lm", "2700k @ 400lm", "2700k 400lm".
+    const found = {};
+    for (const part of s.split(/\s*[·@]\s*/)) {
+        if (!part || read(part, found))
+            continue;
+        if (part.includes("("))
+            return null;
+        // Word by word, a number with the unit after it first ("50 lumens", "fidelity 0.5").
+        const words = part.split(/\s+/);
+        for (let i = 0; i < words.length; i++) {
+            if (i + 1 < words.length && read(`${words[i]} ${words[i + 1]}`, found))
+                i++;
+            else if (!read(words[i], found))
+                return null;
+        }
+    }
+    if (!found.spec)
+        return null;
+    if (found.lm !== undefined)
+        found.spec.lm = found.lm;
+    if (found.fidelity !== undefined)
+        found.spec.fidelity = found.fidelity;
+    return found.spec;
+}
+/** One part of a longer text, into `found`: lumens ("400 lm"), a fidelity ("F0.50"), or the color. */
+function read(part, found) {
+    let m;
+    if ((m = /^([-+]?(?:\d+\.?\d*|\.\d+))\s*(?:lm|lumens?)$/.exec(part))) {
+        found.lm = Number(m[1]);
+        return true;
+    }
+    // "f0.5" needs its point, so it isn't taken for a hex code like "f80".
+    if ((m = /^(?:f(\d*\.\d+)|fidelity\s*[:=]?\s*(\d*\.?\d+))$/.exec(part))) {
+        found.fidelity = Number(m[1] ?? m[2]);
+        return true;
+    }
+    const c = one(part);
+    if (!c || found.spec)
+        return false;
+    found.spec = c;
+    return true;
+}
+/** One color, alone. */
+function one(s) {
+    if (s === "off" || s === "none" || s === "dark" || s === "transparent")
+        return { space: "off" };
+    const name = cssNamed(s.replace(/[\s_-]/g, ""));
+    if (name)
+        return hex(name);
+    const kelvin = LIGHT_NAMES[s.replace(/[\s_-]/g, "")];
+    if (kelvin)
+        return { space: "kelvin", kelvin };
+    let m;
+    if ((m = /^(\d+(?:\.\d+)?)\s*(?:k|kelvin)$/.exec(s)))
+        return { space: "kelvin", kelvin: Number(m[1]) };
+    // As a color prints itself: "265° c0.300".
+    if ((m = /^([-+]?\d+(?:\.\d+)?)\s*(?:°|deg)\s*c\s*(\d*\.?\d+)$/.exec(s)))
+        return { space: "lemtone", hue: Number(m[1]), chroma: Number(m[2]) };
+    if (/^#?(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(s))
+        return hex(s.replace("#", ""));
+    if ((m = /^([a-z][a-z0-9-]*)\((.*)\)$/.exec(s)))
+        return fn(m[1], m[2]);
+    return null;
+}
+/** Hex digits (3, 4, 6 or 8 of them, the last as alpha) as sRGB. */
+function hex(digits) {
+    const full = digits.length <= 4 ? [...digits].map((d) => d + d).join("") : digits;
+    const at = (i) => parseInt(full.slice(i, i + 2), 16) / 255;
+    const spec = { space: "srgb", rgb: [at(0), at(2), at(4)] };
+    if (full.length === 8)
+        spec.alpha = at(6);
+    return spec;
+}
+/** A function: rgb(…), oklch(…), color(display-p3 …), lemtone(…), … */
+function fn(name, inside) {
+    const [main = "", alphaText] = inside.split("/");
+    const words = main.trim().split(/[\s,]+/).filter(Boolean);
+    let space;
+    if (name === "color")
+        space = words.shift();
+    const t = words.map(token);
+    if (t.some((x) => x === null))
+        return null;
+    const v = t;
+    // Old-style rgba(1, 2, 3, 0.5): a fourth number is alpha.
+    let alpha;
+    if (alphaText !== undefined) {
+        const a = token(alphaText.trim());
+        if (!a)
+            return null;
+        alpha = scaled(a, 1);
+    }
+    else if (v.length === 4 && name !== "lemtone")
+        alpha = scaled(v.pop(), 1);
+    const spec = make(name, space, v);
+    if (spec && alpha !== undefined)
+        spec.alpha = alpha;
+    return spec;
+}
+function make(name, space, v) {
+    const need = (n) => v.length >= n;
+    switch (name) {
+        case "rgb":
+        case "rgba":
+            if (!need(3))
+                return null;
+            return { space: "srgb", rgb: [scaled(v[0], 255) / 255, scaled(v[1], 255) / 255, scaled(v[2], 255) / 255] };
+        case "hsl":
+        case "hsla":
+            if (!need(3))
+                return null;
+            return { space: "hsl", h: angle(v[0]), s: fraction(v[1]), l: fraction(v[2]) };
+        case "hwb":
+            if (!need(3))
+                return null;
+            return { space: "hwb", h: angle(v[0]), w: fraction(v[1]), b: fraction(v[2]) };
+        case "oklab":
+            if (!need(3))
+                return null;
+            return { space: "oklab", lab: [lightness(v[0]), scaled(v[1], 0.4), scaled(v[2], 0.4)] };
+        case "oklch":
+            if (!need(3))
+                return null;
+            return { space: "oklch", l: lightness(v[0]), c: scaled(v[1], 0.4), h: angle(v[2]) };
+        case "lab":
+            if (!need(3))
+                return null;
+            return { space: "lab", lab: [scaled(v[0], 100), scaled(v[1], 125), scaled(v[2], 125)] };
+        case "lch":
+            if (!need(3))
+                return null;
+            return { space: "lch", l: scaled(v[0], 100), c: scaled(v[1], 150), h: angle(v[2]) };
+        case "color": {
+            if (!need(3))
+                return null;
+            const c = [scaled(v[0], 1), scaled(v[1], 1), scaled(v[2], 1)];
+            if (space === "srgb" || space === "srgb-linear" || space === "display-p3")
+                return { space, rgb: c };
+            if (space === "xyz" || space === "xyz-d65")
+                return { space: "xyz", xyz: c };
+            if (space === "xyz-d50")
+                return { space: "xyz-d50", xyz: c };
+            return null;
+        }
+        case "lemtone": {
+            if (!need(2))
+                return null;
+            const spec = { space: "lemtone", hue: angle(v[0]), chroma: v[1].value };
+            if (v[2])
+                spec.lm = v[2].value;
+            if (v[3])
+                spec.fidelity = v[3].value;
+            return spec;
+        }
+        case "white":
+        case "kelvin": {
+            if (!need(1))
+                return null;
+            const spec = { space: "kelvin", kelvin: v[0].value };
+            if (v[1])
+                spec.lm = v[1].value;
+            return spec;
+        }
+        default:
+            return null;
+    }
+}

package/dist/shape.d.ts

@@ -0,0 +1,44 @@
+/** The fractional part: 2.25 → 0.25, -0.25 → 0.75. */
+export declare const fract: (x: number) => number;
+export declare const clamp: (x: number, lo?: number, hi?: number) => number;
+/** From a (at t = 0) to b (at t = 1). */
+export declare const lerp: (a: number, b: number, t: number) => number;
+/** x from the range [inLo, inHi] to [outLo, outHi], not clamped. */
+export declare const remap: (x: number, inLo: number, inHi: number, outLo?: number, outHi?: number) => number;
+/** 0 below e0, 1 above e1, and a smooth S between. */
+export declare function smoothstep(e0: number, e1: number, x: number): number;
+/** A smooth wave, one cycle per unit: 0 at whole numbers, 1 halfway between. */
+export declare const wave: (x: number) => number;
+/** Rises from 0 to 1 over each cycle, then drops back at once. */
+export declare const saw: (x: number) => number;
+/** Rises from 0 to 1 over the first half of each cycle and falls back over the second. */
+export declare const tri: (x: number) => number;
+/** 1 for the first `duty` of each cycle, 0 for the rest: a hard on and off. */
+export declare const square: (x: number, duty?: number) => 0 | 1;
+/** Easings, 0 to 1 onto 0 to 1 (cubic). */
+export declare const ease: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+/** A number from 0 to 1 that looks random but is always the same for the same inputs. */
+export declare function hash(...ns: number[]): number;
+/**
+ * Smooth noise from 0 to 1, in up to three dimensions: nearby inputs give
+ * nearby values, and features are about 1 unit apart. noiseAt(x / 4, y / 4,
+ * t / 5) makes blobs about 4 m across that change over about 5 s.
+ */
+export declare function noiseAt(x: number, y?: number, z?: number): number;
+/**
+ * How much of something is left after dt seconds, if half goes every
+ * `halfLife` seconds: value *= decay(dt, 2) halves it every 2 s, whatever the
+ * tick rate.
+ */
+export declare const decay: (dt: number, halfLife: number) => number;
+/**
+ * True with the chance of something that happens `perSecond` times a second
+ * on average, over the last dt seconds: the same in the room (100 ticks a
+ * second) as in the preview (about 30).
+ */
+export declare const chance: (perSecond: number, dt: number) => boolean;
+//# sourceMappingURL=shape.d.ts.map

package/dist/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../src/shape.ts"],"names":[],"mappings":"AAMA,sDAAsD;AACtD,eAAO,MAAM,KAAK,MAAO,MAAM,WAAsB,CAAC;AAEtD,eAAO,MAAM,KAAK,MAAO,MAAM,qCAAoD,CAAC;AAEpF,yCAAyC;AACzC,eAAO,MAAM,IAAI,MAAO,MAAM,KAAK,MAAM,KAAK,MAAM,WAAoB,CAAC;AAEzE,oEAAoE;AACpE,eAAO,MAAM,KAAK,MAAO,MAAM,QAAQ,MAAM,QAAQ,MAAM,2CACE,CAAC;AAE9D,sDAAsD;AACtD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED,gFAAgF;AAChF,eAAO,MAAM,IAAI,MAAO,MAAM,WAAkC,CAAC;AAEjE,kEAAkE;AAClE,eAAO,MAAM,GAAG,MAAO,MAAM,WAAa,CAAC;AAE3C,0FAA0F;AAC1F,eAAO,MAAM,GAAG,MAAO,MAAM,WAAmC,CAAC;AAEjE,+EAA+E;AAC/E,eAAO,MAAM,MAAM,MAAO,MAAM,yBAA0C,CAAC;AAE3E,2CAA2C;AAC3C,eAAO,MAAM,IAAI;IACf,EAAE,MAAM,MAAM;IACd,GAAG,MAAM,MAAM;IACf,KAAK,MAAM,MAAM;CAIlB,CAAC;AAMF,yFAAyF;AACzF,wBAAgB,IAAI,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,GAAG,MAAM,CAQ5C;AAiBD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,GAAG,MAAM,CAavD;AAED;;;;GAIG;AACH,eAAO,MAAM,KAAK,OAAQ,MAAM,YAAY,MAAM,WAAgD,CAAC;AAEnG;;;;GAIG;AACH,eAAO,MAAM,MAAM,cAAe,MAAM,MAAM,MAAM,YAAkD,CAAC"}

package/dist/shape.js

@@ -0,0 +1,89 @@
+// Numbers to numbers: waves, easing, ranges, hashing, noise, and time steps.
+// Waves count in cycles: wave(t / 8) goes round once every 8 seconds. They
+// all run 0 to 1, starting at 0, so they make good brightnesses and mixes.
+const TAU = 2 * Math.PI;
+/** The fractional part: 2.25 → 0.25, -0.25 → 0.75. */
+export const fract = (x) => x - Math.floor(x);
+export const clamp = (x, lo = 0, hi = 1) => (x < lo ? lo : x > hi ? hi : x);
+/** From a (at t = 0) to b (at t = 1). */
+export const lerp = (a, b, t) => a + (b - a) * t;
+/** x from the range [inLo, inHi] to [outLo, outHi], not clamped. */
+export const remap = (x, inLo, inHi, outLo = 0, outHi = 1) => outLo + ((x - inLo) / (inHi - inLo || 1)) * (outHi - outLo);
+/** 0 below e0, 1 above e1, and a smooth S between. */
+export function smoothstep(e0, e1, x) {
+    const t = clamp((x - e0) / (e1 - e0 || 1));
+    return t * t * (3 - 2 * t);
+}
+/** A smooth wave, one cycle per unit: 0 at whole numbers, 1 halfway between. */
+export const wave = (x) => 0.5 - 0.5 * Math.cos(TAU * x);
+/** Rises from 0 to 1 over each cycle, then drops back at once. */
+export const saw = (x) => fract(x);
+/** Rises from 0 to 1 over the first half of each cycle and falls back over the second. */
+export const tri = (x) => 1 - Math.abs(2 * fract(x) - 1);
+/** 1 for the first `duty` of each cycle, 0 for the rest: a hard on and off. */
+export const square = (x, duty = 0.5) => (fract(x) < duty ? 1 : 0);
+/** Easings, 0 to 1 onto 0 to 1 (cubic). */
+export const ease = {
+    in: (x) => clamp(x) ** 3,
+    out: (x) => 1 - (1 - clamp(x)) ** 3,
+    inOut: (x) => {
+        const t = clamp(x);
+        return t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+    },
+};
+// Each number's exact bits, so any number (not only whole ones) hashes.
+const bits = new Float64Array(1);
+const words = new Uint32Array(bits.buffer);
+/** A number from 0 to 1 that looks random but is always the same for the same inputs. */
+export function hash(...ns) {
+    let h = 0x9e3779b9;
+    for (const n of ns) {
+        bits[0] = n === 0 ? 0 : n; // -0 and 0 hash the same
+        h = mixBits(h ^ words[0]);
+        h = mixBits(h ^ words[1]);
+    }
+    return (h >>> 0) / 4294967296;
+}
+function mixBits(h) {
+    h = Math.imul(h ^ (h >>> 16), 0x85ebca6b);
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
+    return h ^ (h >>> 16);
+}
+// Whole-number lattice hashing for noise: faster than hash() and as good there.
+function lattice(x, y, z) {
+    let h = Math.imul(x, 0x27d4eb2d) ^ Math.imul(y, 0x165667b1) ^ Math.imul(z, 0x9e3779b1);
+    h = mixBits(h);
+    return (h >>> 0) / 4294967296;
+}
+const fade = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+/**
+ * Smooth noise from 0 to 1, in up to three dimensions: nearby inputs give
+ * nearby values, and features are about 1 unit apart. noiseAt(x / 4, y / 4,
+ * t / 5) makes blobs about 4 m across that change over about 5 s.
+ */
+export function noiseAt(x, y = 0, z = 0) {
+    const xi = Math.floor(x);
+    const yi = Math.floor(y);
+    const zi = Math.floor(z);
+    const u = fade(x - xi);
+    const v = fade(y - yi);
+    const w = fade(z - zi);
+    const c = (dx, dy, dz) => lattice(xi + dx, yi + dy, zi + dz);
+    const x00 = lerp(c(0, 0, 0), c(1, 0, 0), u);
+    const x10 = lerp(c(0, 1, 0), c(1, 1, 0), u);
+    const x01 = lerp(c(0, 0, 1), c(1, 0, 1), u);
+    const x11 = lerp(c(0, 1, 1), c(1, 1, 1), u);
+    return lerp(lerp(x00, x10, v), lerp(x01, x11, v), w);
+}
+/**
+ * How much of something is left after dt seconds, if half goes every
+ * `halfLife` seconds: value *= decay(dt, 2) halves it every 2 s, whatever the
+ * tick rate.
+ */
+export const decay = (dt, halfLife) => (halfLife > 0 ? 0.5 ** (dt / halfLife) : 0);
+/**
+ * True with the chance of something that happens `perSecond` times a second
+ * on average, over the last dt seconds: the same in the room (100 ticks a
+ * second) as in the preview (about 30).
+ */
+export const chance = (perSecond, dt) => Math.random() < 1 - Math.exp(-perSecond * dt);

package/dist/signal.d.ts

@@ -0,0 +1,26 @@
+import { type Field } from "./field.ts";
+export interface Every {
+    /** How many marks so far: 0, 1, 2, … */
+    count: Field<number>;
+    /** 0 to 1 from one mark to the next. */
+    ramp: Field<number>;
+    /** Seconds since the last mark. */
+    since: Field<number>;
+    /** 0, up to 1 in `attack` seconds after each mark (default 0.01), and back to 0 over `release` (default 0.3). */
+    env(options?: {
+        attack?: number;
+        release?: number;
+    }): Field<number>;
+    /** The next of these at each mark, round and round. */
+    seq<T>(list: readonly T[]): Field<T>;
+}
+export interface Clock {
+    readonly bpm: number;
+    /** Beats so far (not whole: 2.5 is halfway through the third). */
+    beats: Field<number>;
+    /** Marks every n beats: every(1) is each beat, every(4) each bar of four. */
+    every(n: number): Every;
+}
+/** A clock at `bpm` beats a minute, starting with the sketch. */
+export declare function clock(bpm: number): Clock;
+//# sourceMappingURL=signal.d.ts.map

package/dist/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../src/signal.ts"],"names":[],"mappings":"AAQA,OAAO,EAAS,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAG/C,MAAM,WAAW,KAAK;IACpB,wCAAwC;IACxC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,wCAAwC;IACxC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB,mCAAmC;IACnC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,iHAAiH;IACjH,GAAG,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACpE,uDAAuD;IACvD,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,6EAA6E;IAC7E,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACzB;AAED,iEAAiE;AACjE,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CA+BxC"}

package/dist/signal.js

@@ -0,0 +1,44 @@
+// Signals: fields that only read the time, for wiring into any number a field
+// or source takes. A clock counts beats; every(n) marks each n-th one, and
+// from those come envelopes (a flash on each), sequences (a new value each)
+// and ramps (0 to 1 across each).
+//
+//   const beat = clock(96);
+//   osc(4).rotate(beat.every(4).seq([0, 45, 90, 135])).color(palettes.dusk).boost(beat.every(1).env(), 0.8)
+import { field } from "./field.js";
+import { fract } from "./shape.js";
+/** A clock at `bpm` beats a minute, starting with the sketch. */
+export function clock(bpm) {
+    const beats = field(({ t }) => (t * bpm) / 60);
+    return {
+        bpm,
+        beats,
+        every(n) {
+            const at = (t) => (t * bpm) / 60 / n;
+            const seconds = (60 / bpm) * n;
+            const since = field(({ t }) => fract(at(t)) * seconds);
+            return {
+                count: field(({ t }) => Math.floor(at(t))),
+                ramp: field(({ t }) => fract(at(t))),
+                since,
+                env({ attack = 0.01, release = 0.3 } = {}) {
+                    return field((here) => {
+                        const s = since(here);
+                        if (s < attack)
+                            return s / attack;
+                        const k = Math.max(0, 1 - (s - attack) / release);
+                        return k * k;
+                    });
+                },
+                seq(list) {
+                    if (list.length === 0)
+                        throw new Error("seq(): give it at least one value");
+                    return field(({ t }) => {
+                        const i = Math.floor(at(t)) % list.length;
+                        return list[i < 0 ? i + list.length : i];
+                    });
+                },
+            };
+        },
+    };
+}

package/dist/sketch.d.ts

@@ -0,0 +1,29 @@
+import { type ColorInput } from "./color.ts";
+import type { Update } from "./arclamp.ts";
+import { Here } from "./here.ts";
+/** What a color light should make, here and now; null, undefined or false leaves it as it is below. */
+export type LookResult = ColorInput | null | undefined | false | void;
+/** The color lights' look: a function of here giving a color, one color for every light, or a palette, laid across the room. */
+export type Look = ((here: Here) => LookResult) | ColorInput;
+/** Whether an old bulb should be on: true or false, a number (on at 0.5 or more), "on" or "off"; null or undefined leaves it as it is. */
+export type SwitchResult = boolean | number | string | null | undefined | void;
+/** The old bulbs' look: a function of here (a field too) saying whether each is on, or one answer for them all. */
+export type SwitchLook = ((here: Here) => SwitchResult) | boolean | number | string;
+/** A look for each kind of light (light.kind); either may be left out, and its lights are left as they are. */
+export interface Looks {
+    /** For the color bulbs and panels. */
+    color?: Look;
+    /** For the old bulbs, which only switch. */
+    switch?: SwitchLook;
+}
+export interface SketchOptions {
+    /** The old bulbs' look, beside a color look given on its own. */
+    switch?: SwitchLook;
+}
+/** Your color look (a function of here, or a field) as arclamp's update(); old bulbs are left alone, unless given `switch`. */
+export declare function sketch(look: (here: Here) => LookResult, options?: SketchOptions): Update;
+/** A look for each kind of light: { color, switch }. */
+export declare function sketch(looks: Looks): Update;
+/** One color for every color light, or a palette laid across the room, as arclamp's update(). */
+export declare function sketch(look: ColorInput, options?: SketchOptions): Update;
+//# sourceMappingURL=sketch.d.ts.map

package/dist/sketch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sketch.d.ts","sourceRoot":"","sources":["../src/sketch.ts"],"names":[],"mappings":"AAuBA,OAAO,EAA2B,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,KAAK,EAAa,MAAM,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAW,IAAI,EAAiC,MAAM,WAAW,CAAC;AAKzE,uGAAuG;AACvG,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,GAAG,IAAI,CAAC;AAEtE,gIAAgI;AAChI,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,UAAU,CAAC,GAAG,UAAU,CAAC;AAE7D,0IAA0I;AAC1I,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;AAE/E,mHAAmH;AACnH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,KAAK,YAAY,CAAC,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAEpF,+GAA+G;AAC/G,MAAM,WAAW,KAAK;IACpB,sCAAsC;IACtC,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,4CAA4C;IAC5C,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,iEAAiE;IACjE,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAKD,+HAA+H;AAC/H,wBAAgB,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;AAC1F,wDAAwD;AACxD,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;AAC7C,iGAAiG;AACjG,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC"}

package/dist/sketch.js

@@ -0,0 +1,141 @@
+// sketch(): your looks as arclamp's update().
+//
+// Color lights and old bulbs are controlled apart, each by a look of its own,
+// named for the kind of light it's for (light.kind):
+//
+//   sketch({ color: osc(3).color(palettes.dusk), switch: osc(1, 0.25).thresh() })
+//
+// The color look is asked about the color bulbs and panels only: a function
+// of here (your own, or a field) giving a color, one color for every light,
+// or a palette laid across the room. Anything that says a color will do (a
+// Color, "#f80", "2700K", { r, g, b }, …). sketch(look) is
+// sketch({ color: look }).
+//
+// The switch look is asked about the old bulbs only, which just switch: true or
+// false, a number (on at 0.5 or more, as arclamp's own `on` channel), "on" or
+// "off", or a function of here (a field too) giving one. Without one, the old
+// bulbs are left as they are; a color never switches them.
+//
+// Null or undefined from either leaves the light as it is below (so does
+// false from a color look). Something that can't be read leaves it as it is
+// too, with a warning (once for each kind of mistake), so one slip doesn't
+// stop the sketch.
+import { Color, color, isPalette } from "./color.js";
+import { colorOf, Here, roomOf, sameLayout } from "./here.js";
+// A tick after a long gap (the sketch paused, or held up) counts as at most this long.
+const MAX_DT = 0.25;
+export function sketch(given, options = {}) {
+    if (options && typeof options === "object" && "on" in options)
+        throw new Error(ON_KEY);
+    const looks = isLooks(given) ? { switch: options.switch, ...given } : { color: given, switch: options.switch };
+    const askColor = looks.color === undefined ? null : lookOf(looks.color);
+    const askSwitch = looks.switch === undefined ? null : switchLookOf(looks.switch);
+    let room = null;
+    let last = null;
+    const warned = new Set();
+    const warn = (kind, text) => {
+        if (warned.has(kind))
+            return;
+        warned.add(kind);
+        console.warn(`${text} (warning once)`);
+    };
+    return (prev, nowMs, initialMs) => {
+        const list = Array.isArray(prev?.lights) ? prev.lights : [];
+        if (!room || !sameLayout(prev, room))
+            room = roomOf(prev, room);
+        const t = (nowMs - initialMs) / 1000;
+        const dt = last === null ? 0 : Math.min(MAX_DT, Math.max(0, (nowMs - last) / 1000));
+        last = nowMs;
+        const lights = [];
+        for (let i = 0; i < list.length; i++) {
+            const light = room.lights[i];
+            light.below = colorOf(list[i], light.kind);
+            light.belowOn = light.below.lm > 0;
+            const ask = light.kind === "switch" ? askSwitch : askColor;
+            if (!ask)
+                continue;
+            const v = ask(new Here(light.x, light.y, t, dt, nowMs, light, room));
+            if (light.kind === "switch") {
+                const on = readOn(v);
+                if (on === "unreadable") {
+                    warn("on", `light ${light.id} is an old bulb, which only switches: its look gives true or false, a number (on at 0.5 or more), or "on" or "off", not ${describe(v)}; give old bulbs a look of their own, sketch({ color, switch })`);
+                }
+                else if (on !== null)
+                    lights.push({ id: light.id, channels: { on: on ? 1 : 0 } });
+                continue;
+            }
+            if (v === null || v === undefined || v === false)
+                continue;
+            let c;
+            try {
+                c = v instanceof Color ? v : color(v);
+            }
+            catch (err) {
+                if (typeof v === "number") {
+                    warn("number", `light ${light.id} was given ${v}, and a number is read as a color temperature in kelvin; for a pattern from 0 to 1, color it first, like osc(3).color(palettes.dusk)`);
+                }
+                else {
+                    warn("unreadable", `light ${light.id} was given something that isn't a color, so it's left as it is: ${err.message}`);
+                }
+                continue;
+            }
+            const channels = c.channels;
+            if (!Number.isFinite(channels.a) || !Number.isFinite(channels.b) || !Number.isFinite(channels.brightness) || !Number.isFinite(channels.fidelity)) {
+                warn("nan", `light ${light.id} was given a color that isn't all numbers, ${JSON.stringify(c)}, so it's left as it is`);
+                continue;
+            }
+            lights.push({ id: light.id, channels });
+        }
+        return { lights };
+    };
+}
+const ON_KEY = 'old bulbs\' look is `switch`, for the kind of light it\'s for: sketch({ color, switch }), or sketch(look, { switch })';
+/** Whether a sketch was given a look for each kind of light ({ color, switch }) rather than one look. */
+function isLooks(v) {
+    if (!v || typeof v !== "object" || v instanceof Color || Array.isArray(v))
+        return false;
+    const keys = Object.keys(v);
+    // { on } would read as an old bulb's channels, a color: say what's meant instead.
+    if (keys.includes("on"))
+        throw new Error(ON_KEY);
+    return keys.length > 0 && keys.every((k) => k === "color" || k === "switch");
+}
+/** The color look as a function of here. One color is the same everywhere (and said wrong, an error now, not each tick). */
+function lookOf(look) {
+    if (isPalette(look))
+        return (here) => look(here.u);
+    if (typeof look === "function")
+        return look;
+    const c = color(look);
+    return () => c;
+}
+/** The switch look as a function of here. One answer is the same everywhere (and said wrong, an error now). */
+function switchLookOf(look) {
+    if (typeof look === "function")
+        return look;
+    const on = readOn(look);
+    if (on === "unreadable")
+        throw new Error(`${describe(look)} isn't on or off: give true or false, a number (on at 0.5 or more), or "on" or "off"`);
+    return () => on;
+}
+/** On (true), off (false), leave it (null), or can't tell. */
+function readOn(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === "boolean")
+        return v;
+    if (typeof v === "number")
+        return Number.isFinite(v) ? v >= 0.5 : "unreadable";
+    if (typeof v === "string") {
+        const s = v.trim().toLowerCase();
+        if (s === "on" || s === "true" || s === "yes")
+            return true;
+        if (s === "off" || s === "false" || s === "no")
+            return false;
+        return s !== "" && Number.isFinite(Number(s)) ? Number(s) >= 0.5 : "unreadable";
+    }
+    if (typeof v === "object" && !(v instanceof Color) && "on" in v)
+        return readOn(v.on);
+    return "unreadable";
+}
+const describe = (v) => (v instanceof Color ? `a color (${v})` : typeof v === "string" ? `"${v}"` : JSON.stringify(v) ?? String(v));

package/dist/spaces.d.ts

@@ -0,0 +1,24 @@
+import { type Vec3 } from "./lemtone.ts";
+/** The light a screen's white stands for, in lumens. */
+export declare const SCREEN_WHITE_LM = 1000;
+export declare const linearSrgbToXyz: (rgb: Vec3) => Vec3;
+export declare const xyzToLinearSrgb: (X: Vec3) => Vec3;
+/** sRGB's gamma, undone (extended past 0 and 1 the same way both sides, as CSS does). */
+export declare function decode(v: number): number;
+/** sRGB's gamma. */
+export declare function encode(v: number): number;
+export declare const linearP3ToXyz: (rgb: Vec3) => Vec3;
+export declare const xyzD50ToXyz: (X: Vec3) => Vec3;
+/** CIE Lab (L 0–100) as XYZ (D65). */
+export declare function labToXyz(L: number, a: number, b: number): Vec3;
+/** HSL (hue in degrees, saturation and lightness 0–1) as gamma-encoded sRGB (CSS Color 4). */
+export declare function hslToSrgb(h: number, s: number, l: number): Vec3;
+/** HWB (hue in degrees, whiteness and blackness 0–1) as gamma-encoded sRGB (CSS Color 4). */
+export declare function hwbToSrgb(h: number, w: number, b: number): Vec3;
+/** Gamma-encoded sRGB as HSL (CSS Color 4): hue in degrees (0 for grays), saturation and lightness 0–1. */
+export declare function srgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+//# sourceMappingURL=spaces.d.ts.map

package/dist/spaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaces.d.ts","sourceRoot":"","sources":["../src/spaces.ts"],"names":[],"mappings":"AASA,OAAO,EAA4B,KAAK,IAAI,EAAE,MAAM,cAAc,CAAC;AAEnE,wDAAwD;AACxD,eAAO,MAAM,eAAe,OAAO,CAAC;AAcpC,eAAO,MAAM,eAAe,QAAS,IAAI,KAAG,IAAqC,CAAC;AAClF,eAAO,MAAM,eAAe,MAAO,IAAI,KAAG,IAAmC,CAAC;AAE9E,yFAAyF;AACzF,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC;AAED,oBAAoB;AACpB,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC;AAQD,eAAO,MAAM,aAAa,QAAS,IAAI,KAAG,IAAyB,CAAC;AASpE,eAAO,MAAM,WAAW,MAAO,IAAI,KAAG,IAAwB,CAAC;AAE/D,sCAAsC;AACtC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAU9D;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAO/D;AAED,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAM/D;AAED,2GAA2G;AAC3G,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAU9F"}