koi-ascii 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,934 +1,1150 @@
-/** Every glyph the ASCII pass can emit, keyed by its GLSL constant (G_<KEY>). */
-var GLYPHS = {
-	SPACE: " ",
-	DOT: ".",
-	COMMA: ",",
-	QUOTE: "'",
-	BACKTICK: "`",
-	COLON: ":",
-	MINUS: "-",
-	UNDERSCORE: "_",
-	TILDE: "~",
-	EQUALS: "=",
-	PLUS: "+",
-	STAR: "*",
-	O: "o",
-	HASH: "#",
-	PERCENT: "%",
-	AT: "@",
-	LPAREN: "(",
-	RPAREN: ")",
-	SLASH: "/",
-	BSLASH: "\\",
-	PIPE: "|",
-	BIG_O: "O"
-};
-var CHARS = Object.values(GLYPHS);
-var LINE_HEIGHT = 1.2;
-function glyphDefines() {
-	return Object.keys(GLYPHS).map((k, i) => `#define G_${k} ${i}\n`).join("");
-}
+/** The pond's own background (`#06131a`), before time-of-day grading. */
+var POND_BACKGROUND = "#06131a";
 /**
-* Rasterises the glyph set into a single-row R8 texture, one cell per glyph,
-* at the exact device-pixel cell size so the ASCII pass can copy texels 1:1.
+* The same background as the shaders take it (`#06131a` to the byte). These
+* exact values have fed the shaders since before palettes; keep them so the
+* default pond stays pixel-identical.
 */
-function buildAtlas(gl, fontPx, family) {
-	const font = `600 ${fontPx}px ${family}`;
-	const probe = document.createElement("canvas").getContext("2d");
-	if (!probe) throw new Error("2D canvas unavailable for the glyph atlas");
-	probe.font = font;
-	const cellW = Math.max(1, Math.round(probe.measureText("M").width));
-	const cellH = Math.max(1, Math.round(fontPx * LINE_HEIGHT));
-	let ascent = 0;
-	let descent = 0;
-	for (const c of CHARS) {
-		const m = probe.measureText(c);
-		ascent = Math.max(ascent, m.actualBoundingBoxAscent);
-		descent = Math.max(descent, m.actualBoundingBoxDescent);
-	}
-	const baseline = Math.round((cellH - (ascent + descent)) / 2 + ascent);
-	const canvas = document.createElement("canvas");
-	canvas.width = cellW * CHARS.length;
-	canvas.height = cellH;
-	const ctx = canvas.getContext("2d");
-	if (!ctx) throw new Error("2D canvas unavailable for the glyph atlas");
-	ctx.fillStyle = "#000";
-	ctx.fillRect(0, 0, canvas.width, canvas.height);
-	ctx.font = font;
-	ctx.fillStyle = "#fff";
-	ctx.textAlign = "center";
-	ctx.textBaseline = "alphabetic";
-	CHARS.forEach((c, i) => {
-		const m = ctx.measureText(c);
-		const inkW = m.actualBoundingBoxLeft + m.actualBoundingBoxRight;
-		const sx = inkW > cellW - .5 ? (cellW - .5) / inkW : 1;
-		const cx = (m.actualBoundingBoxRight - m.actualBoundingBoxLeft) / 2;
-		ctx.save();
-		ctx.beginPath();
-		ctx.rect(i * cellW, 0, cellW, cellH);
-		ctx.clip();
-		ctx.translate(i * cellW + cellW / 2, 0);
-		ctx.scale(sx, 1);
-		ctx.fillText(c, -cx, baseline);
-		ctx.restore();
-	});
-	const texture = gl.createTexture();
-	if (!texture) throw new Error("Could not allocate the glyph atlas texture");
-	gl.bindTexture(gl.TEXTURE_2D, texture);
-	gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
-	gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-	gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-	gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, gl.RED, gl.UNSIGNED_BYTE, canvas);
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-	return {
-		texture,
-		cellW,
-		cellH,
-		fontPx
-	};
-}
-var NIGHT = {
-	color: [
-		.36,
-		.4,
-		.58
-	],
-	ambient: [
-		.36,
-		.35,
-		.44
-	],
-	water: [
-		.58,
-		.7,
-		1
-	],
-	sky: [
-		0,
-		.01,
-		.04
-	],
-	glint: .6,
-	caustic: .25,
-	floor: .5,
-	shadowAlpha: .4,
-	glow: .55
-};
-var BLUE = {
-	color: [
-		.1,
-		.11,
-		.18
-	],
-	ambient: [
-		.36,
-		.36,
-		.48
-	],
-	water: [
-		.62,
-		.68,
-		.95
-	],
-	sky: [
-		.03,
-		.02,
-		.06
-	],
-	glint: .3,
-	caustic: .2,
-	floor: .48,
-	shadowAlpha: .1,
-	glow: .5
-};
-var GOLDEN = {
-	color: [
-		1,
-		.6,
-		.3
-	],
-	ambient: [
-		.46,
-		.36,
-		.4
-	],
-	water: [
-		.8,
-		.72,
-		.7
-	],
-	sky: [
-		.2,
-		.09,
-		.02
-	],
-	glint: 1.5,
-	caustic: .55,
-	floor: .3,
-	shadowAlpha: .75,
-	glow: .65
-};
-var MORNING = {
-	color: [
-		.78,
-		.7,
-		.58
-	],
-	ambient: [
-		.42,
-		.42,
-		.46
-	],
-	water: [
-		.98,
-		.96,
-		.96
-	],
-	sky: [
-		.03,
-		.02,
-		.01
-	],
-	glint: 1.1,
-	caustic: .85,
-	floor: .25,
-	shadowAlpha: .9,
-	glow: .45
-};
-var NOON = {
-	color: [
-		.72,
-		.71,
-		.67
-	],
-	ambient: [
-		.44,
-		.46,
-		.5
-	],
-	water: [
-		1.08,
-		1.08,
-		1.04
-	],
-	sky: [
-		0,
-		0,
-		0
-	],
-	glint: 1,
-	caustic: 1,
-	floor: .25,
-	shadowAlpha: 1,
-	glow: .35
+var POND_BG = [
+	.024,
+	.075,
+	.102
+];
+/** Pond's red markings and Ogon gold (the scene's colours, look.ts): the role defaults for accent and metallic. */
+var POND_ACCENT = [
+	.95,
+	.31,
+	.17
+];
+var POND_METALLIC = [
+	.97,
+	.72,
+	.24
+];
+var WHITE = [
+	1,
+	1,
+	1
+];
+/** Derived highlight on a light background. */
+var NEAR_BLACK = [
+	.08,
+	.09,
+	.1
+];
+/** Q13: a background brighter than this (WCAG relative luminance) is light. */
+var LIGHT_LUMINANCE = .4;
+/** Missing role slots sit this far from background toward highlight (Q12). */
+var DERIVE = {
+	water: .3,
+	ink: .45,
+	pale: .85
 };
-var KEYS = [
-	{
-		at: 0,
-		part: "night",
-		...NIGHT
-	},
-	{
-		at: .21,
-		part: "blue hour",
-		...BLUE
-	},
-	{
-		at: .265,
-		part: "golden hour",
-		...GOLDEN
-	},
-	{
-		at: .34,
-		part: "morning",
-		...MORNING
-	},
-	{
-		at: .5,
-		part: "noon",
-		...NOON
+var POND = Object.freeze({
+	mode: "filter",
+	background: null,
+	css: POND_BACKGROUND,
+	light: false,
+	tint: WHITE,
+	saturation: 1,
+	invert: false
+});
+var presets = {
+	pond: { mode: "filter" },
+	mono: {
+		mode: "ramp",
+		colors: [
+			"#0b0b0b",
+			"#5c5c5c",
+			"#f2f2f2"
+		]
 	},
-	{
-		at: .66,
-		part: "afternoon",
-		...MORNING
+	phosphor: {
+		mode: "ramp",
+		colors: [
+			"#020a04",
+			"#1b7a35",
+			"#b6ffbf"
+		]
 	},
-	{
-		at: .745,
-		part: "golden hour",
-		...GOLDEN
+	amber: {
+		mode: "ramp",
+		colors: [
+			"#0c0600",
+			"#8a4f00",
+			"#ffe2a8"
+		]
 	},
-	{
-		at: .79,
-		part: "blue hour",
-		...BLUE
+	paper: {
+		mode: "roles",
+		background: "#f3efe6",
+		water: "#b3bcbb",
+		highlight: "#1d2629",
+		fish: {
+			pale: "#4c5759",
+			ink: "#111416",
+			accent: "#c8452c",
+			metallic: "#b5832a"
+		}
 	},
-	{
-		at: 1,
-		part: "night",
-		...NIGHT
+	brand: {
+		mode: "roles",
+		background: "#14102a",
+		water: "#3b2f6e",
+		highlight: "#f1edff",
+		fish: {
+			pale: "#c8c2ff",
+			ink: "#5a4a9a",
+			accent: "#ff5c8a",
+			metallic: "#ffc2d6"
+		}
 	}
-];
-KEYS.slice(0, -1).map(({ at, part }) => ({
-	at,
-	name: part
-}));
-/** The moon hands over to the sun across [a, b] and back across [1 - b, 1 - a]. */
-var HANDOFF = [.19, .23];
-/**
-* The sun's path is tilted on screen so the noon light still comes from one
-* side: a fish swimming any way but along that diagonal shows a lit flank.
-*/
-var PATH_TILT = -.45;
-/** Sun elevation (rad) at sunrise/sunset and at noon; never 0 so it always lights something. */
-var SUN_LOW = .1;
-var SUN_HIGH = 1;
-var MOON_LOW = .25;
-var MOON_HIGH = .95;
-/** Shadow length per unit of cot(elevation), in pond units, and its cap for a low sun. */
-var SHADOW_PER_COT = .16;
-var SHADOW_MAX = .24;
-var TAU$1 = Math.PI * 2;
-/** GLSL smoothstep. */
-var smooth = (a, b, x) => {
-	const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
-	return t * t * (3 - 2 * t);
 };
-var mix$1 = (a, b, t) => a + (b - a) * t;
-var mix3 = (a, b, t) => [
-	mix$1(a[0], b[0], t),
-	mix$1(a[1], b[1], t),
-	mix$1(a[2], b[2], t)
-];
-/**
-* Scratch that azimuth() (x, y, length) and arcDir() (sun, moon) write into, so a frame
-* allocates no temporaries: single-threaded, and each is read straight after its write.
-*/
-var AZ = /* @__PURE__ */ new Float64Array(3);
-var SUN_D = /* @__PURE__ */ new Float64Array(3);
-var MOON_D = /* @__PURE__ */ new Float64Array(3);
-/**
-* Direction toward a body, into `out`, on an arc that rises at angle 0 (screen
-* left) and sets at π (screen right), with elevation lo..hi following sin(angle).
-*/
-function arcDir(angle, lo, hi, out) {
-	const el = mix$1(lo, hi, Math.max(0, Math.sin(angle)));
-	azimuth(angle);
-	const h = Math.cos(el) / AZ[2];
-	out[0] = AZ[0] * h;
-	out[1] = AZ[1] * h;
-	out[2] = Math.sin(el);
+function deepFreeze(value) {
+	if (value && typeof value === "object") {
+		for (const v of Object.values(value)) deepFreeze(v);
+		Object.freeze(value);
+	}
+	return value;
 }
-/** A body's azimuth on screen at `angle` (see arcDir), tilted, into AZ; its length is the same before and after. */
-function azimuth(angle) {
-	const ax = -Math.cos(angle);
-	const ay = -.8 * Math.sin(angle);
-	const c = Math.cos(PATH_TILT);
-	const s = Math.sin(PATH_TILT);
-	AZ[0] = ax * c - ay * s;
-	AZ[1] = ax * s + ay * c;
-	AZ[2] = Math.hypot(ax, ay) || 1;
+/** The presets behind the public `koiPalettes`, frozen all the way down. */
+var PRESETS = deepFreeze(presets);
+function warn(message) {
+	console.warn(`koi-ascii: ${message}`);
 }
-/** Half-extents of the path reflections follow, as a share of the pond's width and height. */
-var BODY_BAND = [.38, .36];
-/** Superellipse exponent of that path: high enough to hug the edges, low enough to round the corners. */
-var BODY_ROUND = 6;
-/** The moon's radius as a share of the pond's shorter side. */
-var MOON_RADIUS = .065;
-/** The moon fades in after the evening handoff and out before the morning one (D6). */
-var MOON_RISE = [1 - HANDOFF[0], 1 - HANDOFF[0] + .05];
-var MOON_SET = [HANDOFF[0] - .05, HANDOFF[0]];
-/** The sun's glitter patch: its outer edge as a share of the pond's shorter side. */
-var SUN_RADIUS = .1;
-/** The sun fades in after the morning handoff and out before the evening one (D6). */
-var SUN_RISE = [HANDOFF[1], HANDOFF[1] + .05];
-var SUN_SET = [1 - HANDOFF[1] - .05, 1 - HANDOFF[1]];
-/**
-* The sun's path runs at this share of its light's pace, so its visible day
-* (HANDOFF[1] … 1 − HANDOFF[1]) covers exactly the moon's visible night: up
-* the left side, over the top, out near the top-right corner. At the light's
-* own pace it would also run down the right side (P1: the top edge and one side).
-*/
-var SUN_PACE = 2 * HANDOFF[0] / (1 - 2 * HANDOFF[1]);
-/**
-* Where a body's reflection sits: toward its azimuth from the pond's centre,
-* out on a rounded rectangle near the edges (half-extents BODY_BAND, as a
-* share of width and height). Every point of it is at least 0.89 of the way
-* out in one axis, so with a radius under 0.12 of the shorter side the disc
-* keeps clear of the middle 40 % of the pond at any aspect (P1).
-*/
-function bodyPos(angle) {
-	azimuth(angle);
-	const x = AZ[0];
-	const y = AZ[1];
-	const k = ((Math.abs(x) / BODY_BAND[0]) ** BODY_ROUND + (Math.abs(y) / BODY_BAND[1]) ** BODY_ROUND) ** (-1 / BODY_ROUND);
-	return [.5 + x * k, .5 + y * k];
+/** WCAG 2 relative luminance of an sRGB colour. */
+function relativeLuminance([r, g, b]) {
+	const lin = (c) => c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
+	return .2126 * lin(r) + .7152 * lin(g) + .0722 * lin(b);
+}
+function isLight(color) {
+	return relativeLuminance(color) > LIGHT_LUMINANCE;
+}
+function mix$1(a, b, t) {
+	return [
+		a[0] + (b[0] - a[0]) * t,
+		a[1] + (b[1] - a[1]) * t,
+		a[2] + (b[2] - a[2]) * t
+	];
+}
+function toCss(c) {
+	return `#${c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("")}`;
 }
 /**
-* The moon's reflection at `phase`, from the phase alone (not the blended
-* light direction, which swings to the sun at the handoff). It follows the
-* moon's own azimuth: up the left side after dusk, over the top through the
-* night, and gone before either handoff starts, so it never jumps.
+* Resolves a palette. Never throws: an invalid field falls back on its own,
+* an unknown preset/mode (or anything unreadable) falls back to `pond`, each
+* with a `console.warn` (Q8). `undefined`/`null` is `pond`, silently.
 */
-function moonAt(phase) {
-	const p = (phase % 1 + 1) % 1;
-	const alpha = 1 - smooth(MOON_SET[0], MOON_SET[1], p) * (1 - smooth(MOON_RISE[0], MOON_RISE[1], p));
+function resolvePalette(input, parse) {
+	if (input === void 0 || input === null) return POND;
+	try {
+		return resolve(input, parse);
+	} catch (err) {
+		warn(`could not read the palette (${String(err)}); using 'pond'.`);
+		return POND;
+	}
+}
+function resolve(input, parse) {
+	if (typeof input === "string") {
+		if (Object.hasOwn(PRESETS, input)) return resolve(PRESETS[input], parse);
+		warn(`unknown palette '${input}'; using 'pond'.`);
+		return POND;
+	}
+	const p = typeof input === "object" ? input : {};
+	const mode = p.mode;
+	if (mode === "ramp") return resolveRamp(p, parse);
+	if (mode === "roles") return resolveRoles(p, parse);
+	if (mode === "filter") return resolveFilter(p, parse);
+	warn(`unknown palette mode '${String(mode)}' (expected 'ramp', 'roles' or 'filter'); using 'pond'.`);
+	return POND;
+}
+/** A colour field: undefined when absent (no warning), null when invalid (warned). */
+function color(value, field, parse) {
+	if (value === void 0) return void 0;
+	const parsed = typeof value === "string" ? safeParse(value, parse) : null;
+	if (!parsed) warn(`palette ${field} ${show$2(value)} is not a CSS colour (var() is not supported); ignoring it.`);
+	return parsed;
+}
+function resolveRamp(p, parse) {
+	const colors = p.colors;
+	if (!Array.isArray(colors) || colors.length < 2 || colors.length > 5) {
+		warn(`a ramp palette needs 2 to 5 colors; using 'pond'.`);
+		return POND;
+	}
+	const stops = [];
+	for (let i = 0; i < colors.length; i++) {
+		const c = typeof colors[i] === "string" ? safeParse(colors[i], parse) : null;
+		if (!c) {
+			warn(`ramp colors[${i}] ${show$2(colors[i])} is not a CSS colour; using 'pond'.`);
+			return POND;
+		}
+		stops.push(c);
+	}
+	const background = stops[0];
 	return {
-		pos: bodyPos(TAU$1 * (p - .75)),
-		radius: MOON_RADIUS,
-		alpha
+		mode: "ramp",
+		background,
+		css: toCss(background),
+		light: isLight(background),
+		stops
 	};
 }
-/**
-* The sun's glitter at `phase`, from the phase alone, on the moon's path
-* (see moonAt and SUN_PACE): rises on the left after the morning handoff,
-* over the top at noon, gone near the top-right corner before the evening
-* handoff, so it never jumps and never shares the sky with the moon.
-*/
-function sunAt(phase) {
-	const p = (phase % 1 + 1) % 1;
-	const alpha = smooth(SUN_RISE[0], SUN_RISE[1], p) * (1 - smooth(SUN_SET[0], SUN_SET[1], p));
+/** A value for a warning message; never throws. */
+function show$2(value) {
+	return typeof value === "string" ? JSON.stringify(value) : typeof value === "object" && value ? "object" : String(value);
+}
+function safeParse(css, parse) {
+	try {
+		return parse(css);
+	} catch {
+		return null;
+	}
+}
+function resolveRoles(p, parse) {
+	let background = color(p.background, "background", parse);
+	if (background === void 0) warn(`a roles palette needs a background; using ${POND_BACKGROUND}.`);
+	background ??= POND_BG;
+	const light = isLight(background);
+	const highlight = color(p.highlight, "highlight", parse) ?? (light ? NEAR_BLACK : WHITE);
+	const toward = (t) => mix$1(background, highlight, t);
+	const water = color(p.water, "water", parse) ?? toward(DERIVE.water);
+	let fish = {};
+	if (p.fish !== void 0) {
+		if (p.fish && typeof p.fish === "object") fish = p.fish;
+		else warn(`palette fish must be an object; deriving the fish colours.`);
+	}
+	const roles = {
+		background,
+		water,
+		highlight,
+		pale: color(fish.pale, "fish.pale", parse) ?? toward(DERIVE.pale),
+		ink: color(fish.ink, "fish.ink", parse) ?? toward(DERIVE.ink),
+		accent: color(fish.accent, "fish.accent", parse) ?? POND_ACCENT,
+		metallic: color(fish.metallic, "fish.metallic", parse) ?? POND_METALLIC
+	};
 	return {
-		pos: bodyPos(TAU$1 * (.25 + (p - .5) * SUN_PACE)),
-		radius: SUN_RADIUS,
-		alpha
+		mode: "roles",
+		background,
+		css: toCss(background),
+		light,
+		roles
 	};
 }
-/** Flat water and a graded background at full night with `darkNight` on. */
-var DARK_WATER = .7;
-/** Flat-water density at full night with `darkNight` on: about half the caustics show. */
-var DARK_CAUSTIC = .5;
-/** The blue hours the night fades across: out at dawn, back in at dusk. */
-var NIGHT_DAWN = [.17, .24];
-var NIGHT_DUSK = [.76, .83];
-/**
-* How much of the night shows at a phase: 1 from the end of the evening blue
-* hour to the start of the morning one, 0 by day, a smooth fade across each
-* blue hour (so golden hour is still pure day).
-*/
-function nightWeight(phase) {
-	const p = (phase % 1 + 1) % 1;
-	return 1 - smooth(NIGHT_DAWN[0], NIGHT_DAWN[1], p) * (1 - smooth(NIGHT_DUSK[0], NIGHT_DUSK[1], p));
+function resolveFilter(p, parse) {
+	const background = color(p.background, "background", parse) ?? null;
+	const tint = color(p.tint, "tint", parse) ?? WHITE;
+	let saturation = 1;
+	const s = p.saturation;
+	if (typeof s === "number" && !Number.isNaN(s)) {
+		saturation = Math.min(1, Math.max(0, s));
+		if (saturation !== s) warn(`palette saturation ${s} is outside [0, 1]; using ${saturation}.`);
+	} else if (s !== void 0) warn(`palette saturation must be a number from 0 to 1; using 1.`);
+	let invert = false;
+	if (typeof p.invert === "boolean") invert = p.invert;
+	else if (p.invert !== void 0) warn(`palette invert must be true or false; using false.`);
+	const light = background ? isLight(background) : false;
+	if (light && !invert) warn(`a light filter background needs invert: true, or the glyphs barely show.`);
+	if (!light && invert) warn(`invert: true needs a light filter background, or the glyphs barely show.`);
+	return {
+		mode: "filter",
+		background,
+		css: background ? toCss(background) : POND_BACKGROUND,
+		light,
+		tint,
+		saturation,
+		invert
+	};
 }
-/** Night weight below which no star shows: they arrive after the night and leave before it. */
-var STARS_FROM = .35;
 /**
-* How strongly the reflected stars show at a phase (the `stars` sky
-* feature): `smoothstep(0.35, 1, nightWeight)`, so 0 through the golden
-* hours and the start of each blue hour, 1 at full night.
+* Validates an intensity (Q9, R3): a number in [0, 1]. Out-of-range numbers
+* clamp, anything else (NaN, a string, a missing setter argument) keeps
+* `fallback`; both with a warning. `optional`: undefined is the omitted
+* option, which takes `fallback` silently.
 */
-function starWeight(phase) {
-	return smooth(STARS_FROM, 1, nightWeight(phase));
+function resolveIntensity(value, fallback, optional) {
+	if (value === void 0 && optional) return fallback;
+	if (typeof value !== "number" || Number.isNaN(value)) {
+		warn(`intensity must be a number from 0 to 1; keeping ${fallback}.`);
+		return fallback;
+	}
+	const clamped = Math.min(1, Math.max(0, value));
+	if (clamped !== value) warn(`intensity ${value} is outside [0, 1]; using ${clamped}.`);
+	return clamped;
 }
-/** The fireflies' dusk window: in after the golden hour, out into the night (never at dawn). */
-var FIREFLIES_IN = [.745, .8];
-var FIREFLIES_OUT = [.88, .95];
+var parserCtx;
 /**
-* How strongly the fireflies show at a phase (the `fireflies` sky feature):
-* 0 until the golden hour ends, 1 through the evening blue hour and early
-* night, 0 again from 0.95 through the night, the morning and the day.
+* The browser's own colour parser (Q7): any CSS colour a canvas accepts, in
+* sRGB, alpha dropped. `var()` and junk are rejected by `fillStyle`. Needs a
+* DOM; call it only when a palette is set, never at import.
 */
-function fireflyWeight(phase) {
-	const p = (phase % 1 + 1) % 1;
-	return smooth(FIREFLIES_IN[0], FIREFLIES_IN[1], p) * (1 - smooth(FIREFLIES_OUT[0], FIREFLIES_OUT[1], p));
-}
-/** Lighting at `phase`; without options (or `darkNight` false) exactly the 0.1 lighting. */
-function lightingAt(phase, options = {}) {
-	const p = (phase % 1 + 1) % 1;
-	let i = 0;
-	while (i < KEYS.length - 2 && p >= KEYS[i + 1].at) i++;
-	const a = KEYS[i];
-	const b = KEYS[i + 1];
-	const t = smooth(a.at, b.at, p);
-	arcDir(TAU$1 * (p - .25), SUN_LOW, SUN_HIGH, SUN_D);
-	arcDir(TAU$1 * (p - .75), MOON_LOW, MOON_HIGH, MOON_D);
-	const w = smooth(HANDOFF[0], HANDOFF[1], p) * (1 - smooth(1 - HANDOFF[1], 1 - HANDOFF[0], p));
-	const d0 = mix$1(MOON_D[0], SUN_D[0], w);
-	const d1 = mix$1(MOON_D[1], SUN_D[1], w);
-	const d2 = mix$1(MOON_D[2], SUN_D[2], w);
-	const dl = Math.hypot(d0, d1, d2);
-	const dir = [
-		d0 / dl,
-		d1 / dl,
-		d2 / dl
+var parseCssColor = (css) => {
+	if (parserCtx === void 0) {
+		const canvas = document.createElement("canvas");
+		canvas.width = canvas.height = 1;
+		parserCtx = canvas.getContext("2d", { willReadFrequently: true });
+	}
+	const ctx = parserCtx;
+	if (!ctx) return null;
+	ctx.fillStyle = "#000000";
+	ctx.fillStyle = css;
+	const a = String(ctx.fillStyle);
+	ctx.fillStyle = "#ffffff";
+	ctx.fillStyle = css;
+	if (String(ctx.fillStyle) !== a) return null;
+	const hex = /^#([0-9a-f]{6})$/i.exec(a);
+	if (hex) {
+		const n = parseInt(hex[1], 16);
+		return [
+			(n >> 16 & 255) / 255,
+			(n >> 8 & 255) / 255,
+			(n & 255) / 255
+		];
+	}
+	const rgba = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/i.exec(a);
+	if (rgba) return [
+		Number(rgba[1]) / 255,
+		Number(rgba[2]) / 255,
+		Number(rgba[3]) / 255
 	];
-	const horiz = Math.hypot(dir[0], dir[1]);
-	const len = Math.min(SHADOW_MAX, SHADOW_PER_COT * horiz / Math.max(dir[2], .001));
-	const shadow = horiz > 1e-6 ? [-dir[0] / horiz * len, -dir[1] / horiz * len] : [0, 0];
-	const floor = mix$1(a.floor, b.floor, t);
-	const water = [
-		Math.max(mix$1(a.water[0], b.water[0], t), floor),
-		Math.max(mix$1(a.water[1], b.water[1], t), floor),
-		Math.max(mix$1(a.water[2], b.water[2], t), floor)
+	ctx.fillStyle = a.replace(/\s*\/\s*[^/)]+\)$/, ")");
+	ctx.globalCompositeOperation = "copy";
+	ctx.fillRect(0, 0, 1, 1);
+	const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
+	return [
+		r / 255,
+		g / 255,
+		b / 255
 	];
-	const night = options.darkNight ? nightWeight(p) : 0;
+};
+var DEFAULT_FADE = Object.freeze({
+	strength: 1,
+	feather: 56
+});
+function avoidAmounts(strength) {
 	return {
-		dir,
-		color: mix3(a.color, b.color, t),
-		ambient: mix3(a.ambient, b.ambient, t),
-		water,
-		sky: mix3(a.sky, b.sky, t),
-		glint: mix$1(a.glint, b.glint, t),
-		caustic: mix$1(a.caustic, b.caustic, t),
-		floor,
-		shadow,
-		shadowAlpha: mix$1(a.shadowAlpha, b.shadowAlpha, t),
-		glowStrength: mix$1(a.glow, b.glow, t),
-		darkWater: night <= 0 ? 1 : mix$1(1, DARK_WATER, night),
-		darkCaustic: night <= 0 ? 1 : mix$1(1, DARK_CAUSTIC, night),
-		moon: moonAt(p),
-		sun: sunAt(p)
+		waterThin: .8 * strength,
+		fishThin: .51 * strength,
+		waterDim: .6 * strength,
+		fishDim: .85 * strength
 	};
 }
-/** Wraps any number into [0, 1). */
-function wrapPhase(p) {
-	return p - Math.floor(p);
+/** A value for a warning message; never throws. */
+function show$1(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (Array.isArray(value)) return "an array";
+	return typeof value === "object" && value ? "an object" : String(value);
 }
-/** Stays at whatever phase it was last set to. */
-var FixedSource = class {
-	kind = "fixed";
-	phase;
-	constructor(phase) {
-		this.phase = wrapPhase(phase);
-	}
-	tick() {
-		return this.phase;
-	}
-	seek(phase) {
-		this.phase = wrapPhase(phase);
+var isNumber = (v) => typeof v === "number" && Number.isFinite(v);
+/**
+* Resolves `avoidFade` (D9). Fields left out keep `current` (the defaults for
+* the option, the fade in use for setAvoidFade), so animating `strength`
+* keeps a custom feather. `strength` clamps to [0, 1]; a non-finite one, a
+* negative or non-finite feather, or a non-object warn and fall back to the
+* defaults (1 and 56).
+*/
+function resolveAvoidFade(input, current = DEFAULT_FADE) {
+	if (input === void 0 || input === null) return current;
+	if (typeof input !== "object" || Array.isArray(input)) {
+		warn(`avoidFade must be an object; got ${show$1(input)}, keeping the fade as it is.`);
+		return current;
+	}
+	const fade = input;
+	let { strength, feather } = current;
+	if (fade.strength !== void 0) {
+		if (!isNumber(fade.strength)) {
+			warn(`avoidFade.strength must be a number from 0 to 1; got ${show$1(fade.strength)}, using ${DEFAULT_FADE.strength}.`);
+			strength = DEFAULT_FADE.strength;
+		} else {
+			strength = Math.min(1, Math.max(0, fade.strength));
+			if (strength !== fade.strength) warn(`avoidFade.strength ${fade.strength} is outside [0, 1]; using ${strength}.`);
+		}
 	}
-};
-/** Runs through a whole day every `cycle` seconds. */
-var LoopSource = class {
-	kind = "loop";
-	phase;
-	cycleS;
-	constructor(cycle, phase) {
-		this.cycleS = validCycle(cycle) ?? 600;
-		this.phase = wrapPhase(phase);
+	if (fade.feather !== void 0) {
+		if (!isNumber(fade.feather) || fade.feather < 0) {
+			warn(`avoidFade.feather must be a number of CSS px, 0 or more; got ${show$1(fade.feather)}, using 56.`);
+			feather = 56;
+		} else feather = fade.feather;
 	}
-	get cycle() {
-		return this.cycleS;
+	return strength === current.strength && feather === current.feather ? current : {
+		strength,
+		feather
+	};
+}
+var NO_RADIUS = Object.freeze({
+	px: 0,
+	frac: 0
+});
+/**
+* Parses a computed `border-top-left-radius` ("8px", "50%", "8px 4px" for an
+* ellipse, whose horizontal radius it takes). One radius per zone (M13).
+*/
+function parseRadius(css) {
+	const first = (css ?? "").trim().split(/\s+/)[0] ?? "";
+	const n = parseFloat(first);
+	if (!Number.isFinite(n) || n <= 0) return NO_RADIUS;
+	return first.endsWith("%") ? {
+		px: 0,
+		frac: n / 100
+	} : {
+		px: n,
+		frac: 0
+	};
+}
+/**
+* Builds the frame's zones (A5, A8–A10): each element's box, canvas-relative
+* and grown by its pad, with a corner radius of its border radius plus the
+* pad. Zero-size boxes are skipped, and so are zones outside the visible part
+* of the canvas (its rect ∩ the viewport, `viewW` × `viewH`) grown by
+* CULL_MARGIN plus the feather. Past AVOID_MAX zones, the first in list
+* order win. Writes `rects` (x, y, w, h per zone) and `radii` (one per zone),
+* all in world px: the canvas's CSS px, whatever the device pixel ratio or
+* backing-store size. Returns the visible zones: the first
+* min(visible, AVOID_MAX) were written, the rest dropped. A plain number, so
+* a frame allocates nothing here.
+*/
+function buildZones(sources, canvas, viewW, viewH, feather, rects, radii) {
+	const reach = 50 + feather;
+	const x0 = Math.max(canvas.left, 0) - reach;
+	const y0 = Math.max(canvas.top, 0) - reach;
+	const x1 = Math.min(canvas.left + canvas.width, viewW) + reach;
+	const y1 = Math.min(canvas.top + canvas.height, viewH) + reach;
+	let count = 0;
+	for (let i = 0; i < sources.length; i++) {
+		const { rect, pad, radius } = sources[i];
+		if (!(rect.width > 0 && rect.height > 0)) continue;
+		const left = rect.left - pad;
+		const top = rect.top - pad;
+		const w = rect.width + 2 * pad;
+		const h = rect.height + 2 * pad;
+		if (left + w < x0 || left > x1 || top + h < y0 || top > y1) continue;
+		if (count >= 16) {
+			count++;
+			continue;
+		}
+		rects[count * 4] = left - canvas.left;
+		rects[count * 4 + 1] = top - canvas.top;
+		rects[count * 4 + 2] = w;
+		rects[count * 4 + 3] = h;
+		radii[count] = radius.px + radius.frac * Math.min(rect.width, rect.height) + pad;
+		count++;
+	}
+	return count;
+}
+var isElement = (v) => !!v && typeof v === "object" && typeof v.getBoundingClientRect === "function" && "isConnected" in v;
+/**
+* Validates an `avoid` list (M4): not an array warns and is empty; an entry
+* that is neither an Element nor `{ element, pad? }` (null, a DOMRect, a
+* string) warns and is skipped. A bad pad warns and falls back to 12 (D9).
+*/
+function resolveAvoidList(input) {
+	if (input === void 0 || input === null) return [];
+	if (!Array.isArray(input)) {
+		warn(`avoid must be an array of elements; got ${show$1(input)}, avoiding nothing.`);
+		return [];
+	}
+	const out = [];
+	input.forEach((item, i) => {
+		if (isElement(item)) {
+			out.push({
+				element: item,
+				pad: 12
+			});
+			return;
+		}
+		const entry = item;
+		if (!entry || typeof entry !== "object" || !isElement(entry.element)) {
+			warn(`avoid[${i}] must be an Element or { element, pad }; got ${show$1(item)}, skipping it.`);
+			return;
+		}
+		let pad = 12;
+		if (entry.pad !== void 0) {
+			if (isNumber(entry.pad) && entry.pad >= 0) pad = entry.pad;
+			else warn(`avoid[${i}].pad must be a number of CSS px, 0 or more; got ${show$1(entry.pad)}, using 12.`);
+		}
+		out.push({
+			element: entry.element,
+			pad
+		});
+	});
+	return out;
+}
+var readRadius = (el) => parseRadius(getComputedStyle(el).borderTopLeftRadius);
+/**
+* The pond's zone list. Holds its elements until set() replaces them or
+* clear() (destroy, failure) drops them. Reads `border-radius` only in
+* set() and readRadii() (mount and pond resize), and once more for an
+* element coming back from zero size (R1); never per frame otherwise.
+*/
+var AvoidZones = class {
+	rects = /* @__PURE__ */ new Float32Array(64);
+	radii = /* @__PURE__ */ new Float32Array(16);
+	entries = [];
+	/** The cap warning has been given for this list. */
+	warned = false;
+	get size() {
+		return this.entries.length;
+	}
+	/** Replaces the list; `read`: read the radii now (setAvoid), not at the next resize (mount). */
+	set(list, read = true) {
+		this.entries = resolveAvoidList(list).map(({ element, pad }) => ({
+			element,
+			pad,
+			rect: {
+				left: 0,
+				top: 0,
+				width: 0,
+				height: 0
+			},
+			radius: NO_RADIUS,
+			zero: false
+		}));
+		this.warned = false;
+		if (read) this.readRadii();
 	}
-	/** Ignores lengths outside [MIN_CYCLE_S, MAX_CYCLE_S]; keeps the phase. */
-	set cycle(s) {
-		this.cycleS = validCycle(s) ?? this.cycleS;
+	clear() {
+		this.entries = [];
 	}
-	tick(dt) {
-		this.phase = wrapPhase(this.phase + dt / this.cycleS);
-		return this.phase;
+	/** Re-reads every element's border radius (mount, pond resize). */
+	readRadii() {
+		for (const e of this.entries) {
+			e.radius = readRadius(e.element);
+			e.zero = !e.element.isConnected;
+		}
 	}
-	seek(phase) {
-		this.phase = wrapPhase(phase);
+	/**
+	* Measures every element against the canvas's rect, writes `rects` and
+	* `radii`, and returns the zone count. Warns once per list when visible
+	* zones were dropped past AVOID_MAX.
+	*/
+	measure(canvas, viewW, viewH, feather) {
+		for (let i = 0; i < this.entries.length; i++) {
+			const e = this.entries[i];
+			e.rect = e.element.getBoundingClientRect();
+			const zero = !(e.rect.width > 0 && e.rect.height > 0);
+			if (!zero && e.zero) e.radius = readRadius(e.element);
+			e.zero = zero;
+		}
+		const visible = buildZones(this.entries, canvas, viewW, viewH, feather, this.rects, this.radii);
+		if (visible > 16 && !this.warned) {
+			this.warned = true;
+			warn(`avoid: ${visible} zones are visible but the pond has 16 slots; the first 16 in list order are used.`);
+		}
+		return Math.min(visible, 16);
 	}
 };
+/** Every glyph the ASCII pass can emit, keyed by its GLSL constant (G_<KEY>). */
+var GLYPHS = {
+	SPACE: " ",
+	DOT: ".",
+	COMMA: ",",
+	QUOTE: "'",
+	BACKTICK: "`",
+	COLON: ":",
+	MINUS: "-",
+	UNDERSCORE: "_",
+	TILDE: "~",
+	EQUALS: "=",
+	PLUS: "+",
+	STAR: "*",
+	O: "o",
+	HASH: "#",
+	PERCENT: "%",
+	AT: "@",
+	LPAREN: "(",
+	RPAREN: ")",
+	SLASH: "/",
+	BSLASH: "\\",
+	PIPE: "|",
+	BIG_O: "O"
+};
+var CHARS = Object.values(GLYPHS);
+var LINE_HEIGHT = 1.2;
+function glyphDefines() {
+	return Object.keys(GLYPHS).map((k, i) => `#define G_${k} ${i}\n`).join("");
+}
 /**
-* The visitor's local time of day: 06:00 is 0.25 (sunrise), 18:00 is 0.75
-* (sunset). Fixed hours, no latitude; rendered time and seeks are ignored.
+* Rasterises the glyph set into a single-row R8 texture, one cell per glyph,
+* at the exact device-pixel cell size so the ASCII pass can copy texels 1:1.
 */
-var ClockSource = class {
-	now;
-	kind = "clock";
-	constructor(now = () => /* @__PURE__ */ new Date()) {
-		this.now = now;
-	}
-	tick() {
-		const d = this.now();
-		return wrapPhase((d.getHours() + d.getMinutes() / 60 + d.getSeconds() / 3600 + d.getMilliseconds() / 36e5) / 24);
+function buildAtlas(gl, fontPx, family) {
+	const font = `600 ${fontPx}px ${family}`;
+	const probe = document.createElement("canvas").getContext("2d");
+	if (!probe) throw new Error("2D canvas unavailable for the glyph atlas");
+	probe.font = font;
+	const cellW = Math.max(1, Math.round(probe.measureText("M").width));
+	const cellH = Math.max(1, Math.round(fontPx * LINE_HEIGHT));
+	let ascent = 0;
+	let descent = 0;
+	for (const c of CHARS) {
+		const m = probe.measureText(c);
+		ascent = Math.max(ascent, m.actualBoundingBoxAscent);
+		descent = Math.max(descent, m.actualBoundingBoxDescent);
 	}
+	const baseline = Math.round((cellH - (ascent + descent)) / 2 + ascent);
+	const canvas = document.createElement("canvas");
+	canvas.width = cellW * CHARS.length;
+	canvas.height = cellH;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) throw new Error("2D canvas unavailable for the glyph atlas");
+	ctx.fillStyle = "#000";
+	ctx.fillRect(0, 0, canvas.width, canvas.height);
+	ctx.font = font;
+	ctx.fillStyle = "#fff";
+	ctx.textAlign = "center";
+	ctx.textBaseline = "alphabetic";
+	CHARS.forEach((c, i) => {
+		const m = ctx.measureText(c);
+		const inkW = m.actualBoundingBoxLeft + m.actualBoundingBoxRight;
+		const sx = inkW > cellW - .5 ? (cellW - .5) / inkW : 1;
+		const cx = (m.actualBoundingBoxRight - m.actualBoundingBoxLeft) / 2;
+		ctx.save();
+		ctx.beginPath();
+		ctx.rect(i * cellW, 0, cellW, cellH);
+		ctx.clip();
+		ctx.translate(i * cellW + cellW / 2, 0);
+		ctx.scale(sx, 1);
+		ctx.fillText(c, -cx, baseline);
+		ctx.restore();
+	});
+	const texture = gl.createTexture();
+	if (!texture) throw new Error("Could not allocate the glyph atlas texture");
+	gl.bindTexture(gl.TEXTURE_2D, texture);
+	gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+	gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+	gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+	gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, gl.RED, gl.UNSIGNED_BYTE, canvas);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+	return {
+		texture,
+		cellW,
+		cellH,
+		fontPx
+	};
+}
+var NIGHT = {
+	color: [
+		.36,
+		.4,
+		.58
+	],
+	ambient: [
+		.36,
+		.35,
+		.44
+	],
+	water: [
+		.58,
+		.7,
+		1
+	],
+	sky: [
+		0,
+		.01,
+		.04
+	],
+	glint: .6,
+	caustic: .25,
+	floor: .5,
+	shadowAlpha: .4,
+	glow: .55
+};
+var BLUE = {
+	color: [
+		.1,
+		.11,
+		.18
+	],
+	ambient: [
+		.36,
+		.36,
+		.48
+	],
+	water: [
+		.62,
+		.68,
+		.95
+	],
+	sky: [
+		.03,
+		.02,
+		.06
+	],
+	glint: .3,
+	caustic: .2,
+	floor: .48,
+	shadowAlpha: .1,
+	glow: .5
+};
+var GOLDEN = {
+	color: [
+		1,
+		.6,
+		.3
+	],
+	ambient: [
+		.46,
+		.36,
+		.4
+	],
+	water: [
+		.8,
+		.72,
+		.7
+	],
+	sky: [
+		.2,
+		.09,
+		.02
+	],
+	glint: 1.5,
+	caustic: .55,
+	floor: .3,
+	shadowAlpha: .75,
+	glow: .65
 };
-/**
-* The pond's clock: a time source plus a manual override. While the overlay
-* slider is held the phase follows it; on release the source continues from
-* there (a loop resumes from the released phase, a slider stays put).
-*/
-var Sky = class {
-	/** Phase used for the current frame. */
-	phase;
-	held = null;
-	src;
-	constructor(source) {
-		this.src = source;
-		this.phase = source.tick(0);
-	}
-	get source() {
-		return this.src;
-	}
-	/** Swaps the source (setTime); a held phase still wins until release. */
-	setSource(source) {
-		this.src = source;
-		this.phase = this.held ?? source.tick(0);
-	}
-	get holding() {
-		return this.held !== null;
-	}
-	/** Call once per rendered frame with unscaled dt; returns the phase. */
-	update(dt) {
-		this.phase = this.held ?? this.source.tick(dt);
-		return this.phase;
-	}
-	/** Takes over from the source (slider drag); applies immediately. */
-	hold(phase) {
-		this.held = wrapPhase(phase);
-		this.phase = this.held;
-	}
-	release() {
-		if (this.held === null) return;
-		this.source.seek?.(this.held);
-		this.held = null;
-	}
+var MORNING = {
+	color: [
+		.78,
+		.7,
+		.58
+	],
+	ambient: [
+		.42,
+		.42,
+		.46
+	],
+	water: [
+		.98,
+		.96,
+		.96
+	],
+	sky: [
+		.03,
+		.02,
+		.01
+	],
+	glint: 1.1,
+	caustic: .85,
+	floor: .25,
+	shadowAlpha: .9,
+	glow: .45
 };
-function validCycle(s) {
-	return Number.isFinite(s) && s >= 1 && s <= 86400 ? s : null;
-}
-/** A phase in [0, 1] (1 wraps to 0), or null for anything else. */
-function validPhase(p) {
-	return typeof p === "number" && p >= 0 && p <= 1 ? wrapPhase(p) : null;
-}
-/**
-* Turns a `time` option into a source. Never throws: an unknown mode is a
-* loop, a cycle outside [MIN_CYCLE_S, MAX_CYCLE_S] is DEFAULT_CYCLE_S and a
-* phase outside [0, 1] is 0. A loop without a phase starts from `current`,
-* so switching to it carries on from the phase on screen.
-*/
-function timeSource(time, current) {
-	const t = time ?? {};
-	if (t.mode === "clock") return new ClockSource();
-	if (t.mode === "fixed") return new FixedSource(validPhase(t.phase) ?? 0);
-	const phase = t.phase === void 0 ? current : validPhase(t.phase) ?? 0;
-	return new LoopSource(typeof t.cycle === "number" ? t.cycle : NaN, phase);
-}
-var slots = /* @__PURE__ */ new WeakMap();
-/** Called by createKoiPond for every instance. */
-function register(handle) {
-	const slot = {
-		hooks: {},
-		core: null
-	};
-	slots.set(handle, slot);
-	return slot;
-}
-/** The pond's own background (`#06131a`), before time-of-day grading. */
-var POND_BACKGROUND = "#06131a";
-/**
-* The same background as the shaders take it (`#06131a` to the byte). These
-* exact values have fed the shaders since before palettes; keep them so the
-* default pond stays pixel-identical.
-*/
-var POND_BG = [
-	.024,
-	.075,
-	.102
-];
-/** Pond's red markings and Ogon gold (the scene's colours, look.ts): the role defaults for accent and metallic. */
-var POND_ACCENT = [
-	.95,
-	.31,
-	.17
-];
-var POND_METALLIC = [
-	.97,
-	.72,
-	.24
-];
-var WHITE = [
-	1,
-	1,
-	1
-];
-/** Derived highlight on a light background. */
-var NEAR_BLACK = [
-	.08,
-	.09,
-	.1
-];
-/** Q13: a background brighter than this (WCAG relative luminance) is light. */
-var LIGHT_LUMINANCE = .4;
-/** Missing role slots sit this far from background toward highlight (Q12). */
-var DERIVE = {
-	water: .3,
-	ink: .45,
-	pale: .85
+var NOON = {
+	color: [
+		.72,
+		.71,
+		.67
+	],
+	ambient: [
+		.44,
+		.46,
+		.5
+	],
+	water: [
+		1.08,
+		1.08,
+		1.04
+	],
+	sky: [
+		0,
+		0,
+		0
+	],
+	glint: 1,
+	caustic: 1,
+	floor: .25,
+	shadowAlpha: 1,
+	glow: .35
 };
-var POND = Object.freeze({
-	mode: "filter",
-	background: null,
-	css: POND_BACKGROUND,
-	light: false,
-	tint: WHITE,
-	saturation: 1,
-	invert: false
-});
-var presets = {
-	pond: { mode: "filter" },
-	mono: {
-		mode: "ramp",
-		colors: [
-			"#0b0b0b",
-			"#5c5c5c",
-			"#f2f2f2"
-		]
+var KEYS = [
+	{
+		at: 0,
+		part: "night",
+		...NIGHT
 	},
-	phosphor: {
-		mode: "ramp",
-		colors: [
-			"#020a04",
-			"#1b7a35",
-			"#b6ffbf"
-		]
+	{
+		at: .21,
+		part: "blue hour",
+		...BLUE
 	},
-	amber: {
-		mode: "ramp",
-		colors: [
-			"#0c0600",
-			"#8a4f00",
-			"#ffe2a8"
-		]
+	{
+		at: .265,
+		part: "golden hour",
+		...GOLDEN
 	},
-	paper: {
-		mode: "roles",
-		background: "#f3efe6",
-		water: "#b3bcbb",
-		highlight: "#1d2629",
-		fish: {
-			pale: "#4c5759",
-			ink: "#111416",
-			accent: "#c8452c",
-			metallic: "#b5832a"
-		}
+	{
+		at: .34,
+		part: "morning",
+		...MORNING
 	},
-	brand: {
-		mode: "roles",
-		background: "#14102a",
-		water: "#3b2f6e",
-		highlight: "#f1edff",
-		fish: {
-			pale: "#c8c2ff",
-			ink: "#5a4a9a",
-			accent: "#ff5c8a",
-			metallic: "#ffc2d6"
-		}
+	{
+		at: .5,
+		part: "noon",
+		...NOON
+	},
+	{
+		at: .66,
+		part: "afternoon",
+		...MORNING
+	},
+	{
+		at: .745,
+		part: "golden hour",
+		...GOLDEN
+	},
+	{
+		at: .79,
+		part: "blue hour",
+		...BLUE
+	},
+	{
+		at: 1,
+		part: "night",
+		...NIGHT
 	}
+];
+KEYS.slice(0, -1).map(({ at, part }) => ({
+	at,
+	name: part
+}));
+/** The moon hands over to the sun across [a, b] and back across [1 - b, 1 - a]. */
+var HANDOFF = [.19, .23];
+/**
+* The sun's path is tilted on screen so the noon light still comes from one
+* side: a fish swimming any way but along that diagonal shows a lit flank.
+*/
+var PATH_TILT = -.45;
+/** Sun elevation (rad) at sunrise/sunset and at noon; never 0 so it always lights something. */
+var SUN_LOW = .1;
+var SUN_HIGH = 1;
+var MOON_LOW = .25;
+var MOON_HIGH = .95;
+/** Shadow length per unit of cot(elevation), in pond units, and its cap for a low sun. */
+var SHADOW_PER_COT = .16;
+var SHADOW_MAX = .24;
+var TAU$1 = Math.PI * 2;
+/** GLSL smoothstep. */
+var smooth = (a, b, x) => {
+	const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+	return t * t * (3 - 2 * t);
 };
-function deepFreeze(value) {
-	if (value && typeof value === "object") {
-		for (const v of Object.values(value)) deepFreeze(v);
-		Object.freeze(value);
-	}
-	return value;
-}
-/** The presets behind the public `koiPalettes`, frozen all the way down. */
-var PRESETS = deepFreeze(presets);
-function warn(message) {
-	console.warn(`koi-ascii: ${message}`);
+var mix = (a, b, t) => a + (b - a) * t;
+var mix3 = (a, b, t) => [
+	mix(a[0], b[0], t),
+	mix(a[1], b[1], t),
+	mix(a[2], b[2], t)
+];
+/**
+* Scratch that azimuth() (x, y, length) and arcDir() (sun, moon) write into, so a frame
+* allocates no temporaries: single-threaded, and each is read straight after its write.
+*/
+var AZ = /* @__PURE__ */ new Float64Array(3);
+var SUN_D = /* @__PURE__ */ new Float64Array(3);
+var MOON_D = /* @__PURE__ */ new Float64Array(3);
+/**
+* Direction toward a body, into `out`, on an arc that rises at angle 0 (screen
+* left) and sets at π (screen right), with elevation lo..hi following sin(angle).
+*/
+function arcDir(angle, lo, hi, out) {
+	const el = mix(lo, hi, Math.max(0, Math.sin(angle)));
+	azimuth(angle);
+	const h = Math.cos(el) / AZ[2];
+	out[0] = AZ[0] * h;
+	out[1] = AZ[1] * h;
+	out[2] = Math.sin(el);
 }
-/** WCAG 2 relative luminance of an sRGB colour. */
-function relativeLuminance([r, g, b]) {
-	const lin = (c) => c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
-	return .2126 * lin(r) + .7152 * lin(g) + .0722 * lin(b);
+/** A body's azimuth on screen at `angle` (see arcDir), tilted, into AZ; its length is the same before and after. */
+function azimuth(angle) {
+	const ax = -Math.cos(angle);
+	const ay = -.8 * Math.sin(angle);
+	const c = Math.cos(PATH_TILT);
+	const s = Math.sin(PATH_TILT);
+	AZ[0] = ax * c - ay * s;
+	AZ[1] = ax * s + ay * c;
+	AZ[2] = Math.hypot(ax, ay) || 1;
 }
-function isLight(color) {
-	return relativeLuminance(color) > LIGHT_LUMINANCE;
+/** Half-extents of the path reflections follow, as a share of the pond's width and height. */
+var BODY_BAND = [.38, .36];
+/** Superellipse exponent of that path: high enough to hug the edges, low enough to round the corners. */
+var BODY_ROUND = 6;
+/** The moon's radius as a share of the pond's shorter side. */
+var MOON_RADIUS = .065;
+/** The moon fades in after the evening handoff and out before the morning one (D6). */
+var MOON_RISE = [1 - HANDOFF[0], 1 - HANDOFF[0] + .05];
+var MOON_SET = [HANDOFF[0] - .05, HANDOFF[0]];
+/** The sun's glitter patch: its outer edge as a share of the pond's shorter side. */
+var SUN_RADIUS = .1;
+/** The sun fades in after the morning handoff and out before the evening one (D6). */
+var SUN_RISE = [HANDOFF[1], HANDOFF[1] + .05];
+var SUN_SET = [1 - HANDOFF[1] - .05, 1 - HANDOFF[1]];
+/**
+* The sun's path runs at this share of its light's pace, so its visible day
+* (HANDOFF[1] … 1 − HANDOFF[1]) covers exactly the moon's visible night: up
+* the left side, over the top, out near the top-right corner. At the light's
+* own pace it would also run down the right side (P1: the top edge and one side).
+*/
+var SUN_PACE = 2 * HANDOFF[0] / (1 - 2 * HANDOFF[1]);
+/**
+* Where a body's reflection sits: toward its azimuth from the pond's centre,
+* out on a rounded rectangle near the edges (half-extents BODY_BAND, as a
+* share of width and height). Every point of it is at least 0.89 of the way
+* out in one axis, so with a radius under 0.12 of the shorter side the disc
+* keeps clear of the middle 40 % of the pond at any aspect (P1).
+*/
+function bodyPos(angle) {
+	azimuth(angle);
+	const x = AZ[0];
+	const y = AZ[1];
+	const k = ((Math.abs(x) / BODY_BAND[0]) ** BODY_ROUND + (Math.abs(y) / BODY_BAND[1]) ** BODY_ROUND) ** (-1 / BODY_ROUND);
+	return [.5 + x * k, .5 + y * k];
 }
-function mix(a, b, t) {
-	return [
-		a[0] + (b[0] - a[0]) * t,
-		a[1] + (b[1] - a[1]) * t,
-		a[2] + (b[2] - a[2]) * t
-	];
+/**
+* The moon's reflection at `phase`, from the phase alone (not the blended
+* light direction, which swings to the sun at the handoff). It follows the
+* moon's own azimuth: up the left side after dusk, over the top through the
+* night, and gone before either handoff starts, so it never jumps.
+*/
+function moonAt(phase) {
+	const p = (phase % 1 + 1) % 1;
+	const alpha = 1 - smooth(MOON_SET[0], MOON_SET[1], p) * (1 - smooth(MOON_RISE[0], MOON_RISE[1], p));
+	return {
+		pos: bodyPos(TAU$1 * (p - .75)),
+		radius: MOON_RADIUS,
+		alpha
+	};
 }
-function toCss(c) {
-	return `#${c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("")}`;
+/**
+* The sun's glitter at `phase`, from the phase alone, on the moon's path
+* (see moonAt and SUN_PACE): rises on the left after the morning handoff,
+* over the top at noon, gone near the top-right corner before the evening
+* handoff, so it never jumps and never shares the sky with the moon.
+*/
+function sunAt(phase) {
+	const p = (phase % 1 + 1) % 1;
+	const alpha = smooth(SUN_RISE[0], SUN_RISE[1], p) * (1 - smooth(SUN_SET[0], SUN_SET[1], p));
+	return {
+		pos: bodyPos(TAU$1 * (.25 + (p - .5) * SUN_PACE)),
+		radius: SUN_RADIUS,
+		alpha
+	};
 }
+/** Flat water and a graded background at full night with `darkNight` on. */
+var DARK_WATER = .7;
+/** Flat-water density at full night with `darkNight` on: about half the caustics show. */
+var DARK_CAUSTIC = .5;
+/** The blue hours the night fades across: out at dawn, back in at dusk. */
+var NIGHT_DAWN = [.17, .24];
+var NIGHT_DUSK = [.76, .83];
 /**
-* Resolves a palette. Never throws: an invalid field falls back on its own,
-* an unknown preset/mode (or anything unreadable) falls back to `pond`, each
-* with a `console.warn` (Q8). `undefined`/`null` is `pond`, silently.
+* How much of the night shows at a phase: 1 from the end of the evening blue
+* hour to the start of the morning one, 0 by day, a smooth fade across each
+* blue hour (so golden hour is still pure day).
 */
-function resolvePalette(input, parse) {
-	if (input === void 0 || input === null) return POND;
-	try {
-		return resolve(input, parse);
-	} catch (err) {
-		warn(`could not read the palette (${String(err)}); using 'pond'.`);
-		return POND;
-	}
+function nightWeight(phase) {
+	const p = (phase % 1 + 1) % 1;
+	return 1 - smooth(NIGHT_DAWN[0], NIGHT_DAWN[1], p) * (1 - smooth(NIGHT_DUSK[0], NIGHT_DUSK[1], p));
 }
-function resolve(input, parse) {
-	if (typeof input === "string") {
-		if (Object.hasOwn(PRESETS, input)) return resolve(PRESETS[input], parse);
-		warn(`unknown palette '${input}'; using 'pond'.`);
-		return POND;
-	}
-	const p = typeof input === "object" ? input : {};
-	const mode = p.mode;
-	if (mode === "ramp") return resolveRamp(p, parse);
-	if (mode === "roles") return resolveRoles(p, parse);
-	if (mode === "filter") return resolveFilter(p, parse);
-	warn(`unknown palette mode '${String(mode)}' (expected 'ramp', 'roles' or 'filter'); using 'pond'.`);
-	return POND;
+/** Night weight below which no star shows: they arrive after the night and leave before it. */
+var STARS_FROM = .35;
+/**
+* How strongly the reflected stars show at a phase (the `stars` sky
+* feature): `smoothstep(0.35, 1, nightWeight)`, so 0 through the golden
+* hours and the start of each blue hour, 1 at full night.
+*/
+function starWeight(phase) {
+	return smooth(STARS_FROM, 1, nightWeight(phase));
 }
-/** A colour field: undefined when absent (no warning), null when invalid (warned). */
-function color(value, field, parse) {
-	if (value === void 0) return void 0;
-	const parsed = typeof value === "string" ? safeParse(value, parse) : null;
-	if (!parsed) warn(`palette ${field} ${show$1(value)} is not a CSS colour (var() is not supported); ignoring it.`);
-	return parsed;
+/** The fireflies' dusk window: in after the golden hour, out into the night (never at dawn). */
+var FIREFLIES_IN = [.745, .8];
+var FIREFLIES_OUT = [.88, .95];
+/**
+* How strongly the fireflies show at a phase (the `fireflies` sky feature):
+* 0 until the golden hour ends, 1 through the evening blue hour and early
+* night, 0 again from 0.95 through the night, the morning and the day.
+*/
+function fireflyWeight(phase) {
+	const p = (phase % 1 + 1) % 1;
+	return smooth(FIREFLIES_IN[0], FIREFLIES_IN[1], p) * (1 - smooth(FIREFLIES_OUT[0], FIREFLIES_OUT[1], p));
 }
-function resolveRamp(p, parse) {
-	const colors = p.colors;
-	if (!Array.isArray(colors) || colors.length < 2 || colors.length > 5) {
-		warn(`a ramp palette needs 2 to 5 colors; using 'pond'.`);
-		return POND;
-	}
-	const stops = [];
-	for (let i = 0; i < colors.length; i++) {
-		const c = typeof colors[i] === "string" ? safeParse(colors[i], parse) : null;
-		if (!c) {
-			warn(`ramp colors[${i}] ${show$1(colors[i])} is not a CSS colour; using 'pond'.`);
-			return POND;
-		}
-		stops.push(c);
-	}
-	const background = stops[0];
-	return {
-		mode: "ramp",
-		background,
-		css: toCss(background),
-		light: isLight(background),
-		stops
+/** Lighting at `phase`; without options (or `darkNight` false) exactly the 0.1 lighting. */
+function lightingAt(phase, options = {}) {
+	const p = (phase % 1 + 1) % 1;
+	let i = 0;
+	while (i < KEYS.length - 2 && p >= KEYS[i + 1].at) i++;
+	const a = KEYS[i];
+	const b = KEYS[i + 1];
+	const t = smooth(a.at, b.at, p);
+	arcDir(TAU$1 * (p - .25), SUN_LOW, SUN_HIGH, SUN_D);
+	arcDir(TAU$1 * (p - .75), MOON_LOW, MOON_HIGH, MOON_D);
+	const w = smooth(HANDOFF[0], HANDOFF[1], p) * (1 - smooth(1 - HANDOFF[1], 1 - HANDOFF[0], p));
+	const d0 = mix(MOON_D[0], SUN_D[0], w);
+	const d1 = mix(MOON_D[1], SUN_D[1], w);
+	const d2 = mix(MOON_D[2], SUN_D[2], w);
+	const dl = Math.hypot(d0, d1, d2);
+	const dir = [
+		d0 / dl,
+		d1 / dl,
+		d2 / dl
+	];
+	const horiz = Math.hypot(dir[0], dir[1]);
+	const len = Math.min(SHADOW_MAX, SHADOW_PER_COT * horiz / Math.max(dir[2], .001));
+	const shadow = horiz > 1e-6 ? [-dir[0] / horiz * len, -dir[1] / horiz * len] : [0, 0];
+	const floor = mix(a.floor, b.floor, t);
+	const water = [
+		Math.max(mix(a.water[0], b.water[0], t), floor),
+		Math.max(mix(a.water[1], b.water[1], t), floor),
+		Math.max(mix(a.water[2], b.water[2], t), floor)
+	];
+	const night = options.darkNight ? nightWeight(p) : 0;
+	return {
+		dir,
+		color: mix3(a.color, b.color, t),
+		ambient: mix3(a.ambient, b.ambient, t),
+		water,
+		sky: mix3(a.sky, b.sky, t),
+		glint: mix(a.glint, b.glint, t),
+		caustic: mix(a.caustic, b.caustic, t),
+		floor,
+		shadow,
+		shadowAlpha: mix(a.shadowAlpha, b.shadowAlpha, t),
+		glowStrength: mix(a.glow, b.glow, t),
+		darkWater: night <= 0 ? 1 : mix(1, DARK_WATER, night),
+		darkCaustic: night <= 0 ? 1 : mix(1, DARK_CAUSTIC, night),
+		moon: moonAt(p),
+		sun: sunAt(p)
 	};
 }
-/** A value for a warning message; never throws. */
-function show$1(value) {
-	return typeof value === "string" ? JSON.stringify(value) : typeof value === "object" && value ? "object" : String(value);
+/** Wraps any number into [0, 1). */
+function wrapPhase(p) {
+	return p - Math.floor(p);
 }
-function safeParse(css, parse) {
-	try {
-		return parse(css);
-	} catch {
-		return null;
+/** Stays at whatever phase it was last set to. */
+var FixedSource = class {
+	kind = "fixed";
+	phase;
+	constructor(phase) {
+		this.phase = wrapPhase(phase);
 	}
-}
-function resolveRoles(p, parse) {
-	let background = color(p.background, "background", parse);
-	if (background === void 0) warn(`a roles palette needs a background; using ${POND_BACKGROUND}.`);
-	background ??= POND_BG;
-	const light = isLight(background);
-	const highlight = color(p.highlight, "highlight", parse) ?? (light ? NEAR_BLACK : WHITE);
-	const toward = (t) => mix(background, highlight, t);
-	const water = color(p.water, "water", parse) ?? toward(DERIVE.water);
-	let fish = {};
-	if (p.fish !== void 0) {
-		if (p.fish && typeof p.fish === "object") fish = p.fish;
-		else warn(`palette fish must be an object; deriving the fish colours.`);
+	tick() {
+		return this.phase;
 	}
-	const roles = {
-		background,
-		water,
-		highlight,
-		pale: color(fish.pale, "fish.pale", parse) ?? toward(DERIVE.pale),
-		ink: color(fish.ink, "fish.ink", parse) ?? toward(DERIVE.ink),
-		accent: color(fish.accent, "fish.accent", parse) ?? POND_ACCENT,
-		metallic: color(fish.metallic, "fish.metallic", parse) ?? POND_METALLIC
-	};
-	return {
-		mode: "roles",
-		background,
-		css: toCss(background),
-		light,
-		roles
-	};
-}
-function resolveFilter(p, parse) {
-	const background = color(p.background, "background", parse) ?? null;
-	const tint = color(p.tint, "tint", parse) ?? WHITE;
-	let saturation = 1;
-	const s = p.saturation;
-	if (typeof s === "number" && !Number.isNaN(s)) {
-		saturation = Math.min(1, Math.max(0, s));
-		if (saturation !== s) warn(`palette saturation ${s} is outside [0, 1]; using ${saturation}.`);
-	} else if (s !== void 0) warn(`palette saturation must be a number from 0 to 1; using 1.`);
-	let invert = false;
-	if (typeof p.invert === "boolean") invert = p.invert;
-	else if (p.invert !== void 0) warn(`palette invert must be true or false; using false.`);
-	const light = background ? isLight(background) : false;
-	if (light && !invert) warn(`a light filter background needs invert: true, or the glyphs barely show.`);
-	if (!light && invert) warn(`invert: true needs a light filter background, or the glyphs barely show.`);
-	return {
-		mode: "filter",
-		background,
-		css: background ? toCss(background) : POND_BACKGROUND,
-		light,
-		tint,
-		saturation,
-		invert
-	};
-}
+	seek(phase) {
+		this.phase = wrapPhase(phase);
+	}
+};
+/** Runs through a whole day every `cycle` seconds. */
+var LoopSource = class {
+	kind = "loop";
+	phase;
+	cycleS;
+	constructor(cycle, phase) {
+		this.cycleS = validCycle(cycle) ?? 600;
+		this.phase = wrapPhase(phase);
+	}
+	get cycle() {
+		return this.cycleS;
+	}
+	/** Ignores lengths outside [MIN_CYCLE_S, MAX_CYCLE_S]; keeps the phase. */
+	set cycle(s) {
+		this.cycleS = validCycle(s) ?? this.cycleS;
+	}
+	tick(dt) {
+		this.phase = wrapPhase(this.phase + dt / this.cycleS);
+		return this.phase;
+	}
+	seek(phase) {
+		this.phase = wrapPhase(phase);
+	}
+};
 /**
-* Validates an intensity (Q9, R3): a number in [0, 1]. Out-of-range numbers
-* clamp, anything else (NaN, a string, a missing setter argument) keeps
-* `fallback`; both with a warning. `optional`: undefined is the omitted
-* option, which takes `fallback` silently.
+* The visitor's local time of day: 06:00 is 0.25 (sunrise), 18:00 is 0.75
+* (sunset). Fixed hours, no latitude; rendered time and seeks are ignored.
 */
-function resolveIntensity(value, fallback, optional) {
-	if (value === void 0 && optional) return fallback;
-	if (typeof value !== "number" || Number.isNaN(value)) {
-		warn(`intensity must be a number from 0 to 1; keeping ${fallback}.`);
-		return fallback;
+var ClockSource = class {
+	now;
+	kind = "clock";
+	constructor(now = () => /* @__PURE__ */ new Date()) {
+		this.now = now;
 	}
-	const clamped = Math.min(1, Math.max(0, value));
-	if (clamped !== value) warn(`intensity ${value} is outside [0, 1]; using ${clamped}.`);
-	return clamped;
-}
-var parserCtx;
+	tick() {
+		const d = this.now();
+		return wrapPhase((d.getHours() + d.getMinutes() / 60 + d.getSeconds() / 3600 + d.getMilliseconds() / 36e5) / 24);
+	}
+};
 /**
-* The browser's own colour parser (Q7): any CSS colour a canvas accepts, in
-* sRGB, alpha dropped. `var()` and junk are rejected by `fillStyle`. Needs a
-* DOM; call it only when a palette is set, never at import.
+* The pond's clock: a time source plus a manual override. While the overlay
+* slider is held the phase follows it; on release the source continues from
+* there (a loop resumes from the released phase, a slider stays put).
 */
-var parseCssColor = (css) => {
-	if (parserCtx === void 0) {
-		const canvas = document.createElement("canvas");
-		canvas.width = canvas.height = 1;
-		parserCtx = canvas.getContext("2d", { willReadFrequently: true });
+var Sky = class {
+	/** Phase used for the current frame. */
+	phase;
+	held = null;
+	src;
+	constructor(source) {
+		this.src = source;
+		this.phase = source.tick(0);
 	}
-	const ctx = parserCtx;
-	if (!ctx) return null;
-	ctx.fillStyle = "#000000";
-	ctx.fillStyle = css;
-	const a = String(ctx.fillStyle);
-	ctx.fillStyle = "#ffffff";
-	ctx.fillStyle = css;
-	if (String(ctx.fillStyle) !== a) return null;
-	const hex = /^#([0-9a-f]{6})$/i.exec(a);
-	if (hex) {
-		const n = parseInt(hex[1], 16);
-		return [
-			(n >> 16 & 255) / 255,
-			(n >> 8 & 255) / 255,
-			(n & 255) / 255
-		];
+	get source() {
+		return this.src;
+	}
+	/** Swaps the source (setTime); a held phase still wins until release. */
+	setSource(source) {
+		this.src = source;
+		this.phase = this.held ?? source.tick(0);
+	}
+	get holding() {
+		return this.held !== null;
+	}
+	/** Call once per rendered frame with unscaled dt; returns the phase. */
+	update(dt) {
+		this.phase = this.held ?? this.source.tick(dt);
+		return this.phase;
+	}
+	/** Takes over from the source (slider drag); applies immediately. */
+	hold(phase) {
+		this.held = wrapPhase(phase);
+		this.phase = this.held;
+	}
+	release() {
+		if (this.held === null) return;
+		this.source.seek?.(this.held);
+		this.held = null;
 	}
-	const rgba = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/i.exec(a);
-	if (rgba) return [
-		Number(rgba[1]) / 255,
-		Number(rgba[2]) / 255,
-		Number(rgba[3]) / 255
-	];
-	ctx.fillStyle = a.replace(/\s*\/\s*[^/)]+\)$/, ")");
-	ctx.globalCompositeOperation = "copy";
-	ctx.fillRect(0, 0, 1, 1);
-	const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
-	return [
-		r / 255,
-		g / 255,
-		b / 255
-	];
 };
+function validCycle(s) {
+	return Number.isFinite(s) && s >= 1 && s <= 86400 ? s : null;
+}
+/** A phase in [0, 1] (1 wraps to 0), or null for anything else. */
+function validPhase(p) {
+	return typeof p === "number" && p >= 0 && p <= 1 ? wrapPhase(p) : null;
+}
+/**
+* Turns a `time` option into a source. Never throws: an unknown mode is a
+* loop, a cycle outside [MIN_CYCLE_S, MAX_CYCLE_S] is DEFAULT_CYCLE_S and a
+* phase outside [0, 1] is 0. A loop without a phase starts from `current`,
+* so switching to it carries on from the phase on screen.
+*/
+function timeSource(time, current) {
+	const t = time ?? {};
+	if (t.mode === "clock") return new ClockSource();
+	if (t.mode === "fixed") return new FixedSource(validPhase(t.phase) ?? 0);
+	const phase = t.phase === void 0 ? current : validPhase(t.phase) ?? 0;
+	return new LoopSource(typeof t.cycle === "number" ? t.cycle : NaN, phase);
+}
+var slots = /* @__PURE__ */ new WeakMap();
+/** Called by createKoiPond for every instance. */
+function register(handle) {
+	const slot = {
+		hooks: {},
+		core: null
+	};
+	slots.set(handle, slot);
+	return slot;
+}
 /** Small seeded PRNG (mulberry32) so a `?seed=` URL reproduces a pond. */
 var Rng = class {
 	s;
@@ -2074,22 +2290,35 @@ function overlaps(a, b) {
 	return !(a[2] < b[0] || b[2] < a[0] || a[3] < b[1] || b[3] < a[1]);
 }
 var fullscreen_default = "\nvoid main() {\nvec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\ngl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\n}\n";
-var common_default = "precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n\n#define M_WATER 0\n#define M_RIPPLE 1\n#define M_TRAIL 2\n#define M_FIN 3\n#define M_EDGE 4\n#define M_BODY 5\n#define M_EYE 6\n#define M_GLINT 7\n#define M_STAR 8\n#define M_MOON 9\n#define M_FLY 10\n#define M_SUN 11\n\n#define PI 3.14159265\n#define TAU 6.28318531\n\n\nfloat hash12(vec2 p) {\nvec3 p3 = fract(vec3(p.xyx) * 0.1031);\np3 += dot(p3, p3.yzx + 33.33);\nreturn fract((p3.x + p3.y) * p3.z);\n}\n\nvec2 hash22(vec2 p) {\nvec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\np3 += dot(p3, p3.yzx + 33.33);\nreturn fract((p3.xx + p3.yz) * p3.zy);\n}\n\n\nfloat gnoise(vec2 p) {\nvec2 i = floor(p);\nvec2 f = fract(p);\nvec2 u = f * f * (3.0 - 2.0 * f);\nfloat a = dot(hash22(i) * 2.0 - 1.0, f);\nfloat b = dot(hash22(i + vec2(1.0, 0.0)) * 2.0 - 1.0, f - vec2(1.0, 0.0));\nfloat c = dot(hash22(i + vec2(0.0, 1.0)) * 2.0 - 1.0, f - vec2(0.0, 1.0));\nfloat d = dot(hash22(i + vec2(1.0, 1.0)) * 2.0 - 1.0, f - vec2(1.0, 1.0));\nreturn mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfloat fbm(vec2 p) {\nfloat s = 0.0;\nfloat a = 0.5;\nfor (int i = 0; i < 4; i++) {\ns += a * gnoise(p);\np = mat2(1.6, 1.2, -1.2, 1.6) * p;\na *= 0.5;\n}\nreturn s;\n}\n\n#ifdef RIPPLE_PACKED\n\n\nvec2 enc16(float v) {\nfloat x = floor(clamp(v * 0.5 + 0.5, 0.0, 1.0) * 65535.0 + 0.5);\nfloat hi = floor(x / 256.0);\nreturn vec2(hi, x - hi * 256.0) / 255.0;\n}\n\nfloat dec16(vec2 e) {\nvec2 b = floor(e * 255.0 + 0.5);\nreturn (b.x * 256.0 + b.y) / 65535.0 * 2.0 - 1.0;\n}\n#endif\n";
+var common_default = "precision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n\n#define M_WATER 0\n#define M_RIPPLE 1\n#define M_TRAIL 2\n#define M_FIN 3\n#define M_EDGE 4\n#define M_BODY 5\n#define M_EYE 6\n#define M_GLINT 7\n#define M_STAR 8\n#define M_MOON 9\n#define M_FLY 10\n#define M_SUN 11\n\n\n\nbool avoidWater(int mat) { return mat <= M_TRAIL || mat == M_GLINT; }\n\n#define PI 3.14159265\n#define TAU 6.28318531\n\n\nfloat hash12(vec2 p) {\nvec3 p3 = fract(vec3(p.xyx) * 0.1031);\np3 += dot(p3, p3.yzx + 33.33);\nreturn fract((p3.x + p3.y) * p3.z);\n}\n\nvec2 hash22(vec2 p) {\nvec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));\np3 += dot(p3, p3.yzx + 33.33);\nreturn fract((p3.xx + p3.yz) * p3.zy);\n}\n\n\nfloat gnoise(vec2 p) {\nvec2 i = floor(p);\nvec2 f = fract(p);\nvec2 u = f * f * (3.0 - 2.0 * f);\nfloat a = dot(hash22(i) * 2.0 - 1.0, f);\nfloat b = dot(hash22(i + vec2(1.0, 0.0)) * 2.0 - 1.0, f - vec2(1.0, 0.0));\nfloat c = dot(hash22(i + vec2(0.0, 1.0)) * 2.0 - 1.0, f - vec2(0.0, 1.0));\nfloat d = dot(hash22(i + vec2(1.0, 1.0)) * 2.0 - 1.0, f - vec2(1.0, 1.0));\nreturn mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfloat fbm(vec2 p) {\nfloat s = 0.0;\nfloat a = 0.5;\nfor (int i = 0; i < 4; i++) {\ns += a * gnoise(p);\np = mat2(1.6, 1.2, -1.2, 1.6) * p;\na *= 0.5;\n}\nreturn s;\n}\n\n#ifdef RIPPLE_PACKED\n\n\nvec2 enc16(float v) {\nfloat x = floor(clamp(v * 0.5 + 0.5, 0.0, 1.0) * 65535.0 + 0.5);\nfloat hi = floor(x / 256.0);\nreturn vec2(hi, x - hi * 256.0) / 255.0;\n}\n\nfloat dec16(vec2 e) {\nvec2 b = floor(e * 255.0 + 0.5);\nreturn (b.x * 256.0 + b.y) / 65535.0 * 2.0 - 1.0;\n}\n#endif\n";
 var ripple_default = "\n\nuniform sampler2D uState;\nuniform ivec2 uSize;\nuniform float uDamping;\nuniform vec4 uDrops[MAX_DROPS];\nuniform int uDropCount;\n\nin vec2 vPx;\nout vec4 fragColor;\n\nvec2 state(ivec2 c) {\nc = clamp(c, ivec2(0), uSize - 1);\nvec4 s = texelFetch(uState, c, 0);\n#ifdef RIPPLE_PACKED\nreturn vec2(dec16(s.rg), dec16(s.ba));\n#else\nreturn s.rg;\n#endif\n}\n\nvoid main() {\n\n\nivec2 c = ivec2(vPx);\nvec2 s = state(c);\nfloat lap = state(c + ivec2(1, 0)).x + state(c - ivec2(1, 0)).x\n+ state(c + ivec2(0, 1)).x + state(c - ivec2(0, 1)).x - 4.0 * s.x;\nfloat h = 2.0 * s.x - s.y + 0.3 * lap;\n\n\nvec2 fc = vec2(c) + 0.5;\nfloat edge = min(min(fc.x, fc.y), min(float(uSize.x) - fc.x, float(uSize.y) - fc.y));\nh *= uDamping * mix(0.86, 1.0, smoothstep(0.0, 8.0, edge));\n\nfor (int i = 0; i < MAX_DROPS; i++) {\nif (i >= uDropCount) break;\nvec4 d = uDrops[i];\nfloat x = length(fc - d.xy) / d.z;\nif (x < 1.0) {\nfloat k = 1.0 - x * x;\nh += d.w * k * k;\n}\n}\nh = clamp(h, -1.0, 1.0);\n\n#ifdef RIPPLE_PACKED\nfragColor = vec4(enc16(h), enc16(s.x));\n#else\nfragColor = vec4(h, s.x, 0.0, 1.0);\n#endif\n}\n";
+var uniforms_default = "\n\n\nuniform float uRipplePx;\nuniform int uFishCount;\nuniform vec2 uCell;\nuniform float uTime;\n\n\n\nuniform vec3 uLightDir;\nuniform vec3 uLightCol;\nuniform vec3 uWaterTint;\nuniform float uCaustic;\nuniform float uCalm;\n\n\n\nuniform vec3 uWaterDim;\nuniform vec3 uWaterLit;\nuniform vec3 uOgonGold;\nuniform vec3 uGlintCol;\nuniform float uRoles;\n\n\nconst float RIPPLE_GAIN = 28.0;\n\n\nconst float REFRACT = 220.0;\n";
+var light_default = "\n\n\n\n\n\n\nuniform vec3 uAmbient;\nuniform float uFloor;\n\n\nconst float CALM_FLICKER = 0.3;\n\nfloat flicker() { return mix(1.0, CALM_FLICKER, uCalm); }\n\n\n\n\n\nvec3 diffuseDir() {\nreturn normalize(vec3(uLightDir.xy, max(uLightDir.z, 0.5)));\n}\n\n\n\nvec3 lightOn(vec3 n) {\nreturn max(uAmbient + uLightCol * max(dot(n, diffuseDir()), 0.0), vec3(uFloor));\n}\n\n\nvec3 lightHue() {\nreturn uLightCol / max(max(uLightCol.r, max(uLightCol.g, uLightCol.b)), 1e-3);\n}\n\n\n\nvec3 mirrorHue() {\nreturn mix(lightHue(), vec3(1.0), 0.4);\n}\n";
+var cell_default = "\n\n\n\n\n\nstruct Cell {\nvec3 col;\nfloat dens;\nint mat;\nvec2 dir;\nfloat aux;\nfloat style;\n};\n\n\nvec2 lineDir(vec2 d) {\nvec2 c = d / uCell;\nfloat l = length(c);\nreturn l > 1e-6 ? c / l : vec2(1.0, 0.0);\n}\n\nvec2 cellNormal(vec2 n) {\nvec2 c = n * uCell;\nfloat l = length(c);\nreturn l > 1e-6 ? c / l : vec2(1.0, 0.0);\n}\n\n\nfloat coverage(float d, vec2 n) {\nfloat span = abs(n.x) * uCell.x + abs(n.y) * uCell.y;\nreturn clamp(0.5 - d / span, 0.0, 1.0);\n}\n\nfloat sq(float x) { return x * x; }\n\nbool inBox(vec2 p, vec4 box, float pad) {\nreturn all(greaterThanEqual(p, box.xy - pad)) && all(lessThanEqual(p, box.zw + pad));\n}\n";
+var ripples_default = "\n\n\n\n\n\nuniform sampler2D uRipple;\nuniform ivec2 uRippleSize;\n\nfloat rippleTexel(ivec2 c) {\nc = clamp(c, ivec2(0), uRippleSize - 1);\n#ifdef RIPPLE_PACKED\nreturn dec16(texelFetch(uRipple, c, 0).rg);\n#else\nreturn texelFetch(uRipple, c, 0).r;\n#endif\n}\n\nfloat rippleAt(vec2 p) {\nvec2 t = p / uRipplePx - 0.5;\nvec2 i = floor(t);\nvec2 f = t - i;\nivec2 c = ivec2(i);\nreturn mix(mix(rippleTexel(c), rippleTexel(c + ivec2(1, 0)), f.x),\nmix(rippleTexel(c + ivec2(0, 1)), rippleTexel(c + ivec2(1, 1)), f.x), f.y);\n}\n";
+var water_default = "\n\n\n\n\n\n\n\nuniform vec3 uSky;\nuniform float uGlint;\nuniform float uDarkWater;\nuniform float uDarkCaustic;\nuniform float uMoteThin;\nuniform vec3 uRippleCol;\n\n\n\n\n\nconst float GLINT_TILT = 2.0;\n\n\nfloat caustic(vec2 x, float t) {\nvec2 i = floor(x);\nvec2 f = fract(x);\nfloat f1 = 8.0;\nfloat f2 = 8.0;\nfor (int y = -1; y <= 1; y++) {\nfor (int k = -1; k <= 1; k++) {\nvec2 b = vec2(float(k), float(y));\nvec2 o = 0.5 + 0.42 * sin(t + TAU * hash22(i + b));\nfloat d = length(b + o - f);\nif (d < f1) {\nf2 = f1;\nf1 = d;\n} else if (d < f2) {\nf2 = d;\n}\n}\n}\nreturn 1.0 - smoothstep(0.0, 0.22, f2 - f1);\n}\n\nCell water(vec2 p, float h, vec2 g) {\nCell c;\n\nvec2 mp = floor((p + vec2(7.0, -4.0) * uTime) / uCell);\n\nfloat mote = step(mix(0.96, 0.99, uMoteThin), hash12(mp)) * (0.4 + 0.6 * hash12(mp + 17.0));\n\n\n\nfloat shimmer = 0.8 + 0.6 * fbm(p * 0.0016 + vec2(uTime * 0.012, -uTime * 0.008));\nfloat lit = smoothstep(0.45, 0.95, caustic(p * 0.011 + g * 3.0, uTime * 0.45) * shimmer);\nc.mat = M_WATER;\n\nc.dens = max(mote * 0.5, lit * mix(0.6, 1.0, uCaustic));\n\nc.col = mix(uWaterDim, uWaterLit, 0.6 * lit * min(uCaustic, 1.0)) * uWaterTint + uSky;\n\n\nif (uDarkWater < 1.0) c.col *= uDarkWater;\nif (uDarkCaustic < 1.0) c.dens *= uDarkCaustic;\nc.aux = hash12(mp + 3.1);\nc.dir = vec2(1.0, 0.0);\nc.style = 0.0;\n\nfloat rip = smoothstep(0.15, 0.6, length(g) * RIPPLE_GAIN);\nif (rip > 0.25) {\nc.mat = M_RIPPLE;\nc.dens = rip;\nc.col = mix(uWaterLit, uRippleCol, rip) * uWaterTint + uSky;\nc.dir = lineDir(vec2(-g.y, g.x));\nc.aux = h > 0.0 ? 1.0 : 0.0;\n}\n\n\n\n\nvec3 H = normalize(uLightDir + vec3(0.0, 0.0, 1.0));\nvec2 az = normalize(uLightDir.xy + vec2(1e-5, 0.0));\nvec2 across = vec2(-az.y, az.x);\nfloat low = 1.0 - uLightDir.z;\nvec2 e = -g * RIPPLE_GAIN * GLINT_TILT - H.xy / H.z;\nfloat ea = dot(e, az);\nfloat ec = dot(e, across);\n\n\nfloat gl = exp(-sq(ea / (0.3 + 0.4 * low)) - sq(ec / (0.3 + 0.8 * low)));\ngl *= smoothstep(0.06, 0.25, length(g) * RIPPLE_GAIN);\n\n\nvec2 r = vec2(dot(p, az), dot(p, across)) / (max(uCell.x, uCell.y) * vec2(1.0 + 5.0 * low, 1.0));\nfloat tw = hash12(floor(r) + floor(uTime * 6.0 * flicker()) * 0.613);\ngl *= uGlint * (0.45 + 1.1 * tw);\nif (gl > 0.45) {\nc.mat = M_GLINT;\nc.dens = min(gl, 1.0);\n\n\nvec3 gc = uRoles > 0.5 ? uGlintCol : mirrorHue();\nc.col = gc * mix(0.8, 1.0, smoothstep(0.45, 1.0, gl));\nc.dir = lineDir(az);\nc.aux = low;\n}\nreturn c;\n}\n";
+var sky_default = "\n\n\n\n\n\n\nuniform float uStars;\nuniform vec2 uView;\n\n\n\nuniform vec4 uMoon;\n\n\n\nuniform vec4 uSun;\nuniform vec3 uStarCool;\nuniform vec3 uStarWarm;\nuniform vec3 uMoonCol;\nuniform vec3 uSunCol;\n\n\n\nconst float MOON_GAIN = 0.85;\n\n\n\n\nconst float SUN_THIN = 0.5;\nconst vec2 SUN_GAIN = vec2(0.6, 0.9);\n\n\n\nconst float SUN_MIN = 0.45;\nconst float SUN_CORE = 0.115;\n\n\n\n\nvoid stars(vec2 p, vec2 g, inout Cell c) {\nif (uStars < 0.02 || c.mat != M_WATER) return;\nvec2 cell = floor((p + g * REFRACT * 2.0) / uCell);\n\nif (hash12(cell * 0.917 + 41.0) < 0.984) return;\nfloat mag = hash12(cell + 7.7);\nfloat ph = hash12(cell + 2.3) * TAU;\n\n\nfloat tw = 0.75 + 0.25 * sin(uTime * (0.8 + 1.6 * mag) + ph);\ntw += 0.5 * pow(max(sin(uTime * 0.37 + ph * 3.0), 0.0), 40.0);\ntw = mix(tw, 0.8, uCalm);\nfloat v = mag * tw * uStars;\nif (v < 0.15) return;\nc.mat = M_STAR;\nc.dens = v;\nc.aux = hash12(cell + 9.1);\nc.style = 0.0;\n\n\nfloat k = 0.35 + 0.6 * min(v, 1.0);\nvec3 col = mix(uStarCool, uStarWarm, c.aux);\nc.col = uRoles > 0.5 ? mix(uWaterDim, col, k) : col * k;\n}\n\n\n\n\n\nvoid moon(vec2 p, vec2 g, inout Cell c) {\nfloat a = uMoon.w;\nif (a < 0.02) return;\nfloat R = uMoon.z * min(uView.x, uView.y);\n\nvec2 wob = vec2(sin(p.y * 0.21 + uTime * 1.3 * flicker()) * 1.2, 0.0);\nvec2 dq = p + g * REFRACT * 3.0 + wob - uMoon.xy * uView;\nfloat dist = length(dq);\nif (dist > R * 1.4) return;\nvec2 n = dist > 1e-3 ? dq / dist : vec2(1.0, 0.0);\nfloat cv = coverage(dist - R, n);\nif (cv < 0.25) return;\nfloat r = dist / R;\nfloat maria = smoothstep(-0.05, 0.2, fbm(dq / R * 1.7 + 5.0));\nfloat lum = (0.95 - 0.45 * maria) * (1.0 - 0.25 * r * r);\nc.mat = M_MOON;\nc.aux = 0.0;\n\n\nfloat k = (0.35 + 0.5 * lum) * MOON_GAIN * a;\nc.col = uRoles > 0.5 ? mix(uWaterDim, uMoonCol, k) : uMoonCol * k;\nif (length(g) * RIPPLE_GAIN > 0.35) {\nc.style = 2.0;\nc.dens = a;\nc.dir = lineDir(vec2(-g.y, g.x));\nc.col = mix(c.col, uRoles > 0.5 ? uGlintCol : vec3(1.0), 0.3 * a);\n} else if (cv < 0.8) {\nc.style = 1.0;\nc.dens = cv;\nc.dir = cellNormal(n);\n} else {\nc.style = 0.0;\nc.dens = 0.72 * lum * a;\n}\n}\n\n\n\n\n\n\nvoid sun(vec2 p, vec2 g, inout Cell c) {\nfloat a = uSun.w;\nif (a < 0.02 || c.mat == M_GLINT) return;\nfloat R = uSun.z * min(uView.x, uView.y);\nvec2 dq = p + g * REFRACT * 3.0 - uSun.xy * uView;\nfloat r = length(dq) / R;\nif (r > 1.0) return;\nvec2 cell = floor(p / uCell);\n\n\nfloat flash = floor(uTime * 5.0 * flicker());\n\nif (hash12(cell * 1.31 + flash * 0.29 + 3.0) > (1.0 - SUN_THIN) * a) return;\nfloat tw = hash12(cell + flash * 0.613);\ntw = mix(tw, hash12(cell + 0.37), uCalm * 0.7);\nfloat v = (1.0 - smoothstep(SUN_CORE, 1.0, r)) * (0.35 + 0.9 * tw);\nif (v < SUN_MIN) return;\nc.mat = M_SUN;\nc.dens = min(v, 1.0);\nc.aux = 0.0;\nc.style = 0.0;\n\n\nfloat k = mix(SUN_GAIN.x, SUN_GAIN.y, smoothstep(SUN_MIN, 1.0, v));\nc.col = uRoles > 0.5 ? mix(uWaterDim, uSunCol, k) : uSunCol * mirrorHue() * k;\n}\n";
+var fish_default = "\n\n\n\n\n\nuniform sampler2D uFish;\n\nstruct Hit {\nfloat d;\nfloat u;\nfloat v;\nvec2 n;\n};\n\nvec4 F(int f, int i) { return texelFetch(uFish, ivec2(i, f), 0); }\n\n\n\nHit polyline(int f, int i0, int count, vec2 p) {\nHit h;\nh.d = 1e9;\nh.u = 0.0;\nh.v = 0.0;\nh.n = vec2(1.0, 0.0);\n\n\n\nfloat bu = 0.0, br = 0.0;\nvec2 bdq = vec2(0.0), bab = vec2(0.0), bap = vec2(0.0);\nvec4 A = F(f, i0);\nfor (int k = 0; k < count; k++) {\nvec4 B = F(f, i0 + k + 1);\nvec2 ab = B.xy - A.xy;\nvec2 ap = p - A.xy;\nfloat t = clamp(dot(ap, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\nvec2 dq = ap - ab * t;\nfloat dist = length(dq);\nfloat r = mix(A.z, B.z, t);\nfloat d = dist - r;\nbool w = d < h.d;\nh.d = w ? d : h.d;\nbu = w ? (float(k) + t) / float(count) : bu;\nbr = w ? r : br;\nbdq = w ? dq : bdq;\nbab = w ? ab : bab;\nbap = w ? ap : bap;\nA = B;\n}\n\n\nif (h.d < 1e9) {\nfloat dist = length(bdq);\nh.u = bu;\nfloat side = bab.x * bap.y - bab.y * bap.x < 0.0 ? -1.0 : 1.0;\nh.v = side * dist / max(br, 1e-3);\nh.n = dist > 1e-4 ? bdq / dist : normalize(vec2(-bab.y, bab.x) + 1e-6);\n}\nreturn h;\n}\n\n\nfloat finDist(vec2 p, vec2 a, vec2 b, float r0, float r1, out float t) {\nvec2 ab = b - a;\nvec2 ap = p - a;\nt = clamp(dot(ap, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\nfloat r = mix(r0, r1, smoothstep(0.0, 0.5, t)) * (1.0 - 0.45 * smoothstep(0.55, 1.0, t));\nreturn length(ap - ab * t) - r;\n}\n\n\n\nfloat tailSD(int f, vec2 q, vec4 fin) {\nHit th = polyline(f, J_BODY - 1, J_TAIL, q);\nvec2 tip = F(f, J_TOTAL - 1).xy;\nvec2 tdir = normalize(tip - F(f, J_TOTAL - 2).xy + 1e-6);\nreturn max(max(th.d, (th.u - 1.0 + fin.w * (1.0 - min(abs(th.v), 1.0))) * fin.z), dot(q - tip, tdir));\n}\n";
+var markings_default = "\n\n\n\n\n\n\n\nuniform vec3 uKohakuWhite;\nuniform vec3 uHiRed;\nuniform vec3 uSumi;\nuniform vec3 uShowaWhite;\nuniform vec3 uOgonShade;\nuniform vec3 uOgonGlint;\nuniform vec3 uKohakuFin;\nuniform vec3 uKohakuTail;\nuniform vec3 uOgonFin;\nuniform vec3 uOgonTail;\n\n\n\nvec3 kohaku(float u, float v, float seed) {\nfloat n = fbm(vec2(u * 3.0, v * 0.8) + seed)\n+ 0.08\n+ 0.35 * exp(-sq((u - 0.14) / 0.08))\n- 0.45 * v * v\n- 0.7 * smoothstep(0.75, 0.92, u)\n- 0.8 * (1.0 - smoothstep(0.02, 0.07, u));\nreturn mix(uKohakuWhite, uHiRed, smoothstep(-0.02, 0.04, n));\n}\n\n\nvec3 showa(float u, float v, float seed, out float sumiAmt) {\nfloat s = fbm(vec2(u * 3.5 + v * 0.9, v * 1.4) + seed * 1.7) + 0.04;\nfloat r = fbm(vec2(u * 2.6, v * 0.9) + seed * 2.3 + 31.0)\n+ 0.06 - 0.3 * v * v + 0.2 * exp(-sq((u - 0.12) / 0.1));\nfloat sumi = smoothstep(0.0, 0.04, s);\nfloat hi = smoothstep(0.0, 0.04, r);\nsumiAmt = sumi * (1.0 - 0.5 * hi);\nreturn mix(mix(uShowaWhite, uHiRed, hi), uSumi, sumiAmt);\n}\n\n\n\nvec3 ogon(float u, float v, float seed, out float glint) {\nvec2 sc = vec2(u * 26.0, v * 4.0 + 4.0);\nvec2 id = floor(vec2(sc.x + 0.5 * mod(floor(sc.y), 2.0), sc.y));\nfloat ph = hash12(id + seed);\nfloat twinkle = pow(0.5 + 0.5 * sin(uTime * 2.3 * flicker() + ph * TAU + u * 7.0), 14.0) * step(0.55, ph);\nfloat band = exp(-sq((v - 0.35 * sin(uTime * 0.6 + u * 4.0 + seed)) * 2.2));\nglint = max(twinkle, band * 0.6);\nvec3 base = mix(uOgonShade, uOgonGold, 1.0 - abs(v));\nreturn mix(base, uOgonGlint, glint);\n}\n\nvec3 pectoralColor(int variety, float t) {\nif (variety == V_KOHAKU) return uKohakuFin;\nif (variety == V_SHOWA) return mix(uSumi, uShowaWhite, smoothstep(0.15, 0.45, t));\nreturn uOgonFin;\n}\n\nvec3 tailColor(int variety, float u, float v, float seed) {\nif (variety == V_KOHAKU) return uKohakuTail;\nif (variety == V_SHOWA) {\nfloat streak = smoothstep(0.1, 0.2, gnoise(vec2(v * 3.0, u * 1.5) + seed));\nreturn mix(uShowaWhite, uSumi, streak * (1.0 - u * 0.6));\n}\nreturn mix(uOgonGold, uOgonTail, u);\n}\n";
+var trails_default = "\n\n\n\n\n\nuniform vec3 uSilk;\nuniform vec3 uBubble;\nuniform vec3 uGoldDust;\n\n\nvoid trailSeg(vec2 p, vec4 A, vec4 B, float w0, bool live, int variety,\ninout float best, inout vec2 bestDir, inout int bestVariety) {\nvec2 ab = B.xy - A.xy;\nvec2 ap = p - A.xy;\nfloat t = clamp(dot(ap, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\nfloat dist = length(ap - ab * t);\nfloat age = mix(A.z, B.z, t);\nfloat w = w0 * (0.5 + 1.4 * age) + 0.3 * min(uCell.x, uCell.y);\nfloat I = pow(1.0 - age, 1.3) * (1.0 - smoothstep(w * 0.35, w, dist));\nif (live && I > best) {\nbest = I;\nbestDir = ab;\nbestVariety = variety;\n}\n}\n\n\n\n#if TRAIL_CHUNK % 4 != 0\n#error trails.glsl unrolls by 4\n#endif\n#if TRAIL_CHUNKS * TRAIL_CHUNK > TRAIL_N + TRAIL_CHUNKS - 1\n#error trails.glsl fetches past the fish row\n#endif\n\nvoid trails(vec2 p, inout Cell c) {\nfloat best = 0.0;\nvec2 bestDir = vec2(1.0, 0.0);\nint bestVariety = 0;\n\n\n\n\nfloat cellPad = 0.3 * min(uCell.x, uCell.y);\nfor (int f = 0; f < MAX_FISH; f++) {\nif (f >= uFishCount) break;\nif (!inBox(p, F(f, T_TBOX), cellPad)) continue;\nvec4 P1 = F(f, T_P1);\nint n = int(P1.x + 0.5);\nfloat w0 = P1.y;\nint variety = int(F(f, T_P0).x + 0.5);\n\n\n\n\nfor (int ch = 0; 1 + ch * TRAIL_CHUNK < n; ch++) {\nint k0 = 1 + ch * TRAIL_CHUNK;\nif (!inBox(p, F(f, T_CBOX + ch), cellPad)) continue;\nvec4 A = F(f, T_TRAIL + k0 - 1);\nfor (int j = 0; j < TRAIL_CHUNK; j += 4) {\nint k = k0 + j;\nif (k >= n) break;\n\n\n\nvec4 B0 = F(f, T_TRAIL + k), B1 = F(f, T_TRAIL + k + 1);\nvec4 B2 = F(f, T_TRAIL + k + 2), B3 = F(f, T_TRAIL + k + 3);\ntrailSeg(p, A, B0, w0, true, variety, best, bestDir, bestVariety);\ntrailSeg(p, B0, B1, w0, k + 1 < n, variety, best, bestDir, bestVariety);\ntrailSeg(p, B1, B2, w0, k + 2 < n, variety, best, bestDir, bestVariety);\ntrailSeg(p, B2, B3, w0, k + 3 < n, variety, best, bestDir, bestVariety);\nA = B3;\n}\n}\n}\nif (best < 0.05) return;\n\nvec2 cell = floor(p / uCell);\nvec3 col;\nif (bestVariety == V_KOHAKU) {\n\nbest *= 0.7 + 0.6 * gnoise(p * 0.035 - uTime * 0.5);\ncol = uSilk;\n} else if (bestVariety == V_SHOWA) {\n\nfloat hb = hash12(cell * 1.37 + 5.0);\nbest *= step(0.62, hb) * (0.7 + 0.6 * hb);\ncol = uBubble;\n} else {\n\nfloat tw = hash12(cell + floor(uTime * 7.0 * flicker()) * 0.731);\nbest *= step(0.5, tw) * 1.2;\ncol = uGoldDust;\n}\nif (best < 0.12) return;\nc.mat = M_TRAIL;\nc.dens = min(best, 1.0);\n\nc.col = (bestVariety == V_KOHAKU ? col * (0.6 + 0.4 * smoothstep(0.1, 0.6, best)) : mix(uWaterLit, col, smoothstep(0.1, 0.6, best))) * uWaterTint;\nc.dir = lineDir(bestDir);\nc.aux = 0.0;\nc.style = float(bestVariety);\n}\n";
+var compose_default = "\n\n\n\n\n\n\n\n\nuniform vec2 uShadow;\nuniform float uShadowAlpha;\nuniform vec3 uEyeCol;\n\n\nuniform vec3 uSumiRim;\nuniform vec3 uAddTint;\n\n\nconst float SPEC_POW = 18.0;\n\nfloat shadow(int f, vec2 p) {\nfloat lift = 1.25 - F(f, T_P0).w;\nvec2 q = p - uShadow * lift;\nfloat blur = max(uCell.x, uCell.y) * (0.5 + 1.5 * lift);\nif (!inBox(q, F(f, T_BBOX), blur)) return 0.0;\nfloat d = min(polyline(f, 0, J_BODY - 1, q).d,\npolyline(f, J_BODY - 1, J_TAIL, q).d + max(uCell.x, uCell.y) * 0.5);\nreturn (1.0 - smoothstep(-blur, blur, d)) * (0.95 - 0.35 * lift) * uShadowAlpha;\n}\n\n\nvec2 refrAt(vec2 x) {\nfloat e = uRipplePx;\nreturn vec2(rippleAt(x + vec2(e, 0.0)) - rippleAt(x - vec2(e, 0.0)),\nrippleAt(x + vec2(0.0, e)) - rippleAt(x - vec2(0.0, e))) / (2.0 * e) * REFRACT;\n}\n\nvoid drawFish(int f, vec2 p, vec2 refr, inout Cell c) {\nvec4 P0 = F(f, T_P0);\nint variety = int(P0.x + 0.5);\nfloat seed = P0.y;\nfloat depth = P0.w;\n\nvec2 q = p + refr * (0.5 + depth);\nif (!inBox(q, F(f, T_BBOX), max(uCell.x, uCell.y) * 1.5)) return;\nfloat fog = 0.55 * depth;\nvec3 fogCol = uWaterDim * uWaterTint;\nfloat fade = 1.0 - 0.3 * depth;\nfloat style = float(variety);\nvec4 fin = F(f, T_FIN);\n\nvec3 flatLight = lightOn(vec3(0.0, 0.0, 1.0));\n\n\n\nfloat reach = max(uCell.x, uCell.y);\nvec2 ex = vec2(uCell.x * 0.5, 0.0);\nvec2 ey = vec2(0.0, uCell.y * 0.5);\n\n\nfor (int s = 0; s < 2; s++) {\nvec4 pf = F(f, T_PEC_L + s);\nfloat t, t2;\nfloat d = finDist(q, pf.xy, pf.zw, fin.x, fin.y, t);\nif (d > reach) continue;\nvec2 gr = vec2(finDist(q + ex, pf.xy, pf.zw, fin.x, fin.y, t2) - finDist(q - ex, pf.xy, pf.zw, fin.x, fin.y, t2),\nfinDist(q + ey, pf.xy, pf.zw, fin.x, fin.y, t2) - finDist(q - ey, pf.xy, pf.zw, fin.x, fin.y, t2)) / uCell;\nvec2 n = normalize(gr + 1e-6);\nfloat cv = coverage(d, n);\nif (cv > 0.25) {\nc.col = mix(pectoralColor(variety, t) * flatLight, fogCol, fog);\nc.aux = 0.0;\nc.style = style;\nif (cv < 0.8) {\nc.mat = M_EDGE;\nc.dens = cv;\nc.dir = cellNormal(n);\n} else {\nc.mat = M_FIN;\nc.col *= 0.75;\nc.dens = 0.6 * fade;\nc.dir = lineDir(q - pf.xy);\n}\n}\n}\n\n\n\nfloat td = tailSD(f, q, fin);\nif (td < reach) {\nvec2 gr = vec2(tailSD(f, q + ex, fin) - tailSD(f, q - ex, fin),\ntailSD(f, q + ey, fin) - tailSD(f, q - ey, fin)) / uCell;\nvec2 n = normalize(gr + 1e-6);\nfloat tcv = coverage(td, n);\nif (tcv > 0.25) {\nHit th = polyline(f, J_BODY - 1, J_TAIL, q);\nc.col = mix(tailColor(variety, th.u, th.v, seed) * flatLight, fogCol, fog);\nc.aux = 0.0;\nc.style = style;\nif (tcv < 0.8) {\nc.mat = M_EDGE;\nc.dens = tcv;\nc.dir = cellNormal(n);\n} else {\nc.mat = M_FIN;\nc.col *= 0.75;\nc.dens = (0.65 - 0.2 * th.u) * fade;\nc.dir = lineDir(q - F(f, J_BODY - 1).xy);\n}\n}\n}\n\n\nHit bh = polyline(f, 0, J_BODY - 1, q);\nfloat bcv = coverage(bh.d, bh.n);\nif (bcv > 0.18) {\nfloat glint = 0.0;\nfloat sumiAmt = 0.0;\nvec3 bc = variety == V_KOHAKU ? kohaku(bh.u, bh.v, seed)\n: variety == V_SHOWA ? showa(bh.u, bh.v, seed, sumiAmt)\n: ogon(bh.u, bh.v, seed, glint);\n\n\nfloat a = min(abs(bh.v), 1.0) * 0.92;\nvec3 N = vec3(bh.n * a, sqrt(1.0 - a * a));\nfloat ndl = dot(N, diffuseDir());\nvec3 lit = lightOn(N);\n\n\n\nvec3 H = normalize(uLightDir + vec3(0.0, 0.0, 1.0));\nfloat spec = pow(max(dot(N, H), 0.0), SPEC_POW);\nvec3 hue = lightHue() * length(uLightCol) * 0.82 * uAddTint;\nvec3 hi = variety == V_OGON ? hue * uOgonGold * 0.9 : hue * (variety == V_SHOWA ? 0.32 + 0.25 * sumiAmt : 0.3);\n\nvec2 az = normalize(uLightDir.xy + vec2(1e-5, 0.0));\nfloat rim = a * a * a * max(-dot(bh.n, az), 0.0) * (0.35 + 0.65 * (1.0 - uLightDir.z));\n\n\nfloat cst = smoothstep(0.5, 0.95, caustic(q * 0.014 + refr * 0.012 + seed, uTime * 0.45));\nvec3 caust = uLightCol * uAddTint * cst * uCaustic * 0.4 * max(ndl, 0.0) * (1.0 - depth);\nc.col = mix(bc * lit + hi * spec + uLightCol * uAddTint * rim * 0.6 + caust, fogCol, fog);\n\nfloat shade = mix(0.58, 1.05, smoothstep(-0.2, 0.9, ndl)) + 0.25 * spec;\nc.style = style;\nif (bcv > 0.8) {\n\n\nfloat Yl = dot(bc * bc, vec3(0.2126, 0.7152, 0.0722));\nfloat Ls = 1.16 * pow(Yl, 1.0 / 3.0) - 0.16;\nc.mat = M_BODY;\nc.dens = mix(0.6, 1.0, Ls) * shade * fade;\nc.aux = glint;\n} else {\nc.mat = M_EDGE;\nc.dens = bcv;\nc.dir = cellNormal(bh.n);\nc.aux = 0.0;\nc.col = mix(c.col, mix(uSumiRim * lit, fogCol, fog), 0.65 * sumiAmt);\n}\n}\n\n\nvec4 E = F(f, T_EYE);\n\n\n\n\nvec2 eyeReach = 0.5 * uCell + REFRACT / uRipplePx * abs(0.5 + depth) + 1.0;\nfor (int s = 0; s < 2; s++) {\nvec2 e = s == 0 ? E.xy : E.zw;\nbool hit = length(q - e) < P0.z;\nif (!hit && all(lessThanEqual(abs(p - e), eyeReach))) {\n\n\nvec2 de = abs(p + refrAt(e) * (0.5 + depth) - e);\nhit = de.x < uCell.x * 0.5 && de.y < uCell.y * 0.5;\n}\nif (hit) {\nc.mat = M_EYE;\nc.col = mix(uEyeCol * max(flatLight, vec3(0.75)), fogCol, fog * 0.5);\nc.dens = 1.0;\nc.aux = 0.0;\nc.style = style;\n}\n}\n}\n";
+var glyphs_default = "\n\n\n\n\nconst int BODY_N = 6;\nconst int BODY_RAMP[BODY_N] = int[BODY_N](G_EQUALS, G_PLUS, G_STAR, G_HASH, G_PERCENT, G_AT);\n\nfloat bayer4(ivec2 c) {\nconst int B[16] = int[16](0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5);\nreturn (float(B[(c.x & 3) + (c.y & 3) * 4]) + 0.5) / 16.0;\n}\n\n\nint lineGlyph(vec2 d, int horizontal, int vertical) {\nfloat a = atan(d.y, d.x);\nif (a < 0.0) a += PI;\nint s = int(floor(a / (PI * 0.25) + 0.5)) % 4;\nif (s == 0) return horizontal;\nif (s == 1) return G_BSLASH;\nif (s == 2) return vertical;\nreturn G_SLASH;\n}\n\n\n\nint edgeGlyph(vec2 n, float cov) {\nint o = int(floor((atan(n.y, n.x) + TAU) / (PI * 0.25) + 0.5)) % 8;\nif (o == 0) return G_RPAREN;\nif (o == 4) return G_LPAREN;\nif (o == 1 || o == 5) return G_SLASH;\nif (o == 3 || o == 7) return G_BSLASH;\nif (o == 2) return cov > 0.5 ? G_UNDERSCORE : G_MINUS;\nreturn cov > 0.5 ? G_MINUS : G_UNDERSCORE;\n}\n\nint pickGlyph(Cell c, ivec2 cell) {\nfloat dens = clamp(c.dens, 0.0, 1.0);\nfloat aux = clamp(c.aux, 0.0, 1.0);\nint style = int(c.style + 0.5);\nif (c.mat == M_WATER) {\nif (dens < 0.12) return G_SPACE;\nif (dens < 0.6) return aux < 0.4 ? G_DOT : aux < 0.65 ? G_COMMA : aux < 0.85 ? G_BACKTICK : G_QUOTE;\nreturn G_COLON;\n}\nif (c.mat == M_RIPPLE) {\nif (dens < 0.45) return G_DOT;\nreturn lineGlyph(c.dir, aux > 0.5 ? G_TILDE : G_MINUS, G_PIPE);\n}\nif (c.mat == M_TRAIL) {\nif (style == V_SHOWA) return dens > 0.55 ? G_O : G_DOT;\nif (style == V_OGON) return dens > 0.65 ? G_STAR : dens > 0.35 ? G_QUOTE : G_DOT;\nif (dens < 0.3) return G_DOT;\nif (dens < 0.55) return G_MINUS;\nreturn lineGlyph(c.dir, G_TILDE, G_COLON);\n}\nif (c.mat == M_FIN) {\nif (dens < 0.3) return G_DOT;\nif (dens < 0.45) return G_QUOTE;\nreturn lineGlyph(c.dir, style == V_OGON ? G_TILDE : G_MINUS, G_PIPE);\n}\nif (c.mat == M_EDGE) return edgeGlyph(c.dir, dens);\nif (c.mat == M_BODY) {\nif (aux > 0.75) return G_STAR;\nfloat x = smoothstep(0.3, 0.95, dens) * float(BODY_N - 1) + (bayer4(cell) - 0.5) * 0.5;\nreturn BODY_RAMP[clamp(int(floor(x + 0.5)), 0, BODY_N - 1)];\n}\nif (c.mat == M_EYE) return G_O;\nif (c.mat == M_STAR) {\n\nif (dens > 0.95) return G_STAR;\nif (dens > 0.65) return G_PLUS;\nif (dens > 0.4) return aux < 0.5 ? G_QUOTE : G_BACKTICK;\nreturn G_DOT;\n}\nif (c.mat == M_MOON) {\nif (style == 2) return lineGlyph(c.dir, G_EQUALS, G_PIPE);\nif (style == 1) return edgeGlyph(c.dir, dens);\nreturn dens < 0.33 ? G_DOT : dens < 0.56 ? G_COLON : dens < 0.67 ? G_O : G_BIG_O;\n}\nif (c.mat == M_SUN) return dens > 0.8 ? G_STAR : dens > 0.6 ? G_PLUS : G_DOT;\nif (c.mat == M_GLINT) {\n\nif (aux > 0.55) return dens > 0.6 ? lineGlyph(c.dir, dens > 0.85 ? G_EQUALS : G_MINUS, G_PIPE) : G_DOT;\nreturn dens > 0.75 ? G_STAR : G_PLUS;\n}\nreturn G_SPACE;\n}\n";
+var avoid_default = "\n\n\n\n\n\n\n\n\n\n#define AVOID_MAX 16\n\nuniform int uAvoidN;\nuniform vec4 uAvoid[AVOID_MAX];\nuniform vec4 uAvoidR[AVOID_MAX / 4];\nuniform vec4 uAvoidFade;\n\n\nfloat avoidDist(vec2 p) {\nfloat d = 1e9;\n\nfor (int i = 0; i < uAvoidN; i++) {\nvec2 hs = uAvoid[i].zw * 0.5;\nfloat r = min(uAvoidR[i >> 2][i & 3], min(hs.x, hs.y));\nvec2 q = abs(p - uAvoid[i].xy - hs) - hs + r;\nd = min(d, length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r);\n}\nreturn d;\n}\n\n\n\nfloat avoidMask(float d) {\nreturn 1.0 - smoothstep(0.0, max(uAvoidFade.z, 0.5), d);\n}\n\n\n\nfloat avoidThin(float m, int mat) {\nreturn 1.0 - (avoidWater(mat) ? uAvoidFade.x : uAvoidFade.y) * m;\n}\n";
 /** Each chunk's file name and source, in compile order. */
 var sceneChunks = [
-	["uniforms.glsl", "\n\n\nuniform float uRipplePx;\nuniform int uFishCount;\nuniform vec2 uCell;\nuniform float uTime;\n\n\n\nuniform vec3 uLightDir;\nuniform vec3 uLightCol;\nuniform vec3 uWaterTint;\nuniform float uCaustic;\nuniform float uCalm;\n\n\n\nuniform vec3 uWaterDim;\nuniform vec3 uWaterLit;\nuniform vec3 uOgonGold;\nuniform vec3 uGlintCol;\nuniform float uRoles;\n\n\nconst float RIPPLE_GAIN = 28.0;\n\n\nconst float REFRACT = 220.0;\n"],
-	["light.glsl", "\n\n\n\n\n\n\nuniform vec3 uAmbient;\nuniform float uFloor;\n\n\nconst float CALM_FLICKER = 0.3;\n\nfloat flicker() { return mix(1.0, CALM_FLICKER, uCalm); }\n\n\n\n\n\nvec3 diffuseDir() {\nreturn normalize(vec3(uLightDir.xy, max(uLightDir.z, 0.5)));\n}\n\n\n\nvec3 lightOn(vec3 n) {\nreturn max(uAmbient + uLightCol * max(dot(n, diffuseDir()), 0.0), vec3(uFloor));\n}\n\n\nvec3 lightHue() {\nreturn uLightCol / max(max(uLightCol.r, max(uLightCol.g, uLightCol.b)), 1e-3);\n}\n\n\n\nvec3 mirrorHue() {\nreturn mix(lightHue(), vec3(1.0), 0.4);\n}\n"],
-	["cell.glsl", "\n\n\n\n\n\nstruct Cell {\nvec3 col;\nfloat dens;\nint mat;\nvec2 dir;\nfloat aux;\nfloat style;\n};\n\n\nvec2 lineDir(vec2 d) {\nvec2 c = d / uCell;\nfloat l = length(c);\nreturn l > 1e-6 ? c / l : vec2(1.0, 0.0);\n}\n\nvec2 cellNormal(vec2 n) {\nvec2 c = n * uCell;\nfloat l = length(c);\nreturn l > 1e-6 ? c / l : vec2(1.0, 0.0);\n}\n\n\nfloat coverage(float d, vec2 n) {\nfloat span = abs(n.x) * uCell.x + abs(n.y) * uCell.y;\nreturn clamp(0.5 - d / span, 0.0, 1.0);\n}\n\nfloat sq(float x) { return x * x; }\n\nbool inBox(vec2 p, vec4 box, float pad) {\nreturn all(greaterThanEqual(p, box.xy - pad)) && all(lessThanEqual(p, box.zw + pad));\n}\n"],
-	["ripples.glsl", "\n\n\n\n\n\nuniform sampler2D uRipple;\nuniform ivec2 uRippleSize;\n\nfloat rippleTexel(ivec2 c) {\nc = clamp(c, ivec2(0), uRippleSize - 1);\n#ifdef RIPPLE_PACKED\nreturn dec16(texelFetch(uRipple, c, 0).rg);\n#else\nreturn texelFetch(uRipple, c, 0).r;\n#endif\n}\n\nfloat rippleAt(vec2 p) {\nvec2 t = p / uRipplePx - 0.5;\nvec2 i = floor(t);\nvec2 f = t - i;\nivec2 c = ivec2(i);\nreturn mix(mix(rippleTexel(c), rippleTexel(c + ivec2(1, 0)), f.x),\nmix(rippleTexel(c + ivec2(0, 1)), rippleTexel(c + ivec2(1, 1)), f.x), f.y);\n}\n"],
-	["water.glsl", "\n\n\n\n\n\n\n\nuniform vec3 uSky;\nuniform float uGlint;\nuniform float uDarkWater;\nuniform float uDarkCaustic;\nuniform float uMoteThin;\nuniform vec3 uRippleCol;\n\n\n\n\n\nconst float GLINT_TILT = 2.0;\n\n\nfloat caustic(vec2 x, float t) {\nvec2 i = floor(x);\nvec2 f = fract(x);\nfloat f1 = 8.0;\nfloat f2 = 8.0;\nfor (int y = -1; y <= 1; y++) {\nfor (int k = -1; k <= 1; k++) {\nvec2 b = vec2(float(k), float(y));\nvec2 o = 0.5 + 0.42 * sin(t + TAU * hash22(i + b));\nfloat d = length(b + o - f);\nif (d < f1) {\nf2 = f1;\nf1 = d;\n} else if (d < f2) {\nf2 = d;\n}\n}\n}\nreturn 1.0 - smoothstep(0.0, 0.22, f2 - f1);\n}\n\nCell water(vec2 p, float h, vec2 g) {\nCell c;\n\nvec2 mp = floor((p + vec2(7.0, -4.0) * uTime) / uCell);\n\nfloat mote = step(mix(0.96, 0.99, uMoteThin), hash12(mp)) * (0.4 + 0.6 * hash12(mp + 17.0));\n\n\n\nfloat shimmer = 0.8 + 0.6 * fbm(p * 0.0016 + vec2(uTime * 0.012, -uTime * 0.008));\nfloat lit = smoothstep(0.45, 0.95, caustic(p * 0.011 + g * 3.0, uTime * 0.45) * shimmer);\nc.mat = M_WATER;\n\nc.dens = max(mote * 0.5, lit * mix(0.6, 1.0, uCaustic));\n\nc.col = mix(uWaterDim, uWaterLit, 0.6 * lit * min(uCaustic, 1.0)) * uWaterTint + uSky;\n\n\nif (uDarkWater < 1.0) c.col *= uDarkWater;\nif (uDarkCaustic < 1.0) c.dens *= uDarkCaustic;\nc.aux = hash12(mp + 3.1);\nc.dir = vec2(1.0, 0.0);\nc.style = 0.0;\n\nfloat rip = smoothstep(0.15, 0.6, length(g) * RIPPLE_GAIN);\nif (rip > 0.25) {\nc.mat = M_RIPPLE;\nc.dens = rip;\nc.col = mix(uWaterLit, uRippleCol, rip) * uWaterTint + uSky;\nc.dir = lineDir(vec2(-g.y, g.x));\nc.aux = h > 0.0 ? 1.0 : 0.0;\n}\n\n\n\n\nvec3 H = normalize(uLightDir + vec3(0.0, 0.0, 1.0));\nvec2 az = normalize(uLightDir.xy + vec2(1e-5, 0.0));\nvec2 across = vec2(-az.y, az.x);\nfloat low = 1.0 - uLightDir.z;\nvec2 e = -g * RIPPLE_GAIN * GLINT_TILT - H.xy / H.z;\nfloat ea = dot(e, az);\nfloat ec = dot(e, across);\n\n\nfloat gl = exp(-sq(ea / (0.3 + 0.4 * low)) - sq(ec / (0.3 + 0.8 * low)));\ngl *= smoothstep(0.06, 0.25, length(g) * RIPPLE_GAIN);\n\n\nvec2 r = vec2(dot(p, az), dot(p, across)) / (max(uCell.x, uCell.y) * vec2(1.0 + 5.0 * low, 1.0));\nfloat tw = hash12(floor(r) + floor(uTime * 6.0 * flicker()) * 0.613);\ngl *= uGlint * (0.45 + 1.1 * tw);\nif (gl > 0.45) {\nc.mat = M_GLINT;\nc.dens = min(gl, 1.0);\n\n\nvec3 gc = uRoles > 0.5 ? uGlintCol : mirrorHue();\nc.col = gc * mix(0.8, 1.0, smoothstep(0.45, 1.0, gl));\nc.dir = lineDir(az);\nc.aux = low;\n}\nreturn c;\n}\n"],
-	["sky.glsl", "\n\n\n\n\n\n\nuniform float uStars;\nuniform vec2 uView;\n\n\n\nuniform vec4 uMoon;\n\n\n\nuniform vec4 uSun;\nuniform vec3 uStarCool;\nuniform vec3 uStarWarm;\nuniform vec3 uMoonCol;\nuniform vec3 uSunCol;\n\n\n\nconst float MOON_GAIN = 0.85;\n\n\n\n\nconst float SUN_THIN = 0.5;\nconst vec2 SUN_GAIN = vec2(0.6, 0.9);\n\n\n\nconst float SUN_MIN = 0.45;\nconst float SUN_CORE = 0.115;\n\n\n\n\nvoid stars(vec2 p, vec2 g, inout Cell c) {\nif (uStars < 0.02 || c.mat != M_WATER) return;\nvec2 cell = floor((p + g * REFRACT * 2.0) / uCell);\n\nif (hash12(cell * 0.917 + 41.0) < 0.984) return;\nfloat mag = hash12(cell + 7.7);\nfloat ph = hash12(cell + 2.3) * TAU;\n\n\nfloat tw = 0.75 + 0.25 * sin(uTime * (0.8 + 1.6 * mag) + ph);\ntw += 0.5 * pow(max(sin(uTime * 0.37 + ph * 3.0), 0.0), 40.0);\ntw = mix(tw, 0.8, uCalm);\nfloat v = mag * tw * uStars;\nif (v < 0.15) return;\nc.mat = M_STAR;\nc.dens = v;\nc.aux = hash12(cell + 9.1);\nc.style = 0.0;\n\n\nfloat k = 0.35 + 0.6 * min(v, 1.0);\nvec3 col = mix(uStarCool, uStarWarm, c.aux);\nc.col = uRoles > 0.5 ? mix(uWaterDim, col, k) : col * k;\n}\n\n\n\n\n\nvoid moon(vec2 p, vec2 g, inout Cell c) {\nfloat a = uMoon.w;\nif (a < 0.02) return;\nfloat R = uMoon.z * min(uView.x, uView.y);\n\nvec2 wob = vec2(sin(p.y * 0.21 + uTime * 1.3 * flicker()) * 1.2, 0.0);\nvec2 dq = p + g * REFRACT * 3.0 + wob - uMoon.xy * uView;\nfloat dist = length(dq);\nif (dist > R * 1.4) return;\nvec2 n = dist > 1e-3 ? dq / dist : vec2(1.0, 0.0);\nfloat cv = coverage(dist - R, n);\nif (cv < 0.25) return;\nfloat r = dist / R;\nfloat maria = smoothstep(-0.05, 0.2, fbm(dq / R * 1.7 + 5.0));\nfloat lum = (0.95 - 0.45 * maria) * (1.0 - 0.25 * r * r);\nc.mat = M_MOON;\nc.aux = 0.0;\n\n\nfloat k = (0.35 + 0.5 * lum) * MOON_GAIN * a;\nc.col = uRoles > 0.5 ? mix(uWaterDim, uMoonCol, k) : uMoonCol * k;\nif (length(g) * RIPPLE_GAIN > 0.35) {\nc.style = 2.0;\nc.dens = a;\nc.dir = lineDir(vec2(-g.y, g.x));\nc.col = mix(c.col, uRoles > 0.5 ? uGlintCol : vec3(1.0), 0.3 * a);\n} else if (cv < 0.8) {\nc.style = 1.0;\nc.dens = cv;\nc.dir = cellNormal(n);\n} else {\nc.style = 0.0;\nc.dens = 0.72 * lum * a;\n}\n}\n\n\n\n\n\n\nvoid sun(vec2 p, vec2 g, inout Cell c) {\nfloat a = uSun.w;\nif (a < 0.02 || c.mat == M_GLINT) return;\nfloat R = uSun.z * min(uView.x, uView.y);\nvec2 dq = p + g * REFRACT * 3.0 - uSun.xy * uView;\nfloat r = length(dq) / R;\nif (r > 1.0) return;\nvec2 cell = floor(p / uCell);\n\n\nfloat flash = floor(uTime * 5.0 * flicker());\n\nif (hash12(cell * 1.31 + flash * 0.29 + 3.0) > (1.0 - SUN_THIN) * a) return;\nfloat tw = hash12(cell + flash * 0.613);\ntw = mix(tw, hash12(cell + 0.37), uCalm * 0.7);\nfloat v = (1.0 - smoothstep(SUN_CORE, 1.0, r)) * (0.35 + 0.9 * tw);\nif (v < SUN_MIN) return;\nc.mat = M_SUN;\nc.dens = min(v, 1.0);\nc.aux = 0.0;\nc.style = 0.0;\n\n\nfloat k = mix(SUN_GAIN.x, SUN_GAIN.y, smoothstep(SUN_MIN, 1.0, v));\nc.col = uRoles > 0.5 ? mix(uWaterDim, uSunCol, k) : uSunCol * mirrorHue() * k;\n}\n"],
-	["fish.glsl", "\n\n\n\n\n\nuniform sampler2D uFish;\n\nstruct Hit {\nfloat d;\nfloat u;\nfloat v;\nvec2 n;\n};\n\nvec4 F(int f, int i) { return texelFetch(uFish, ivec2(i, f), 0); }\n\n\n\nHit polyline(int f, int i0, int count, vec2 p) {\nHit h;\nh.d = 1e9;\nh.u = 0.0;\nh.v = 0.0;\nh.n = vec2(1.0, 0.0);\n\n\n\nfloat bu = 0.0, br = 0.0;\nvec2 bdq = vec2(0.0), bab = vec2(0.0), bap = vec2(0.0);\nvec4 A = F(f, i0);\nfor (int k = 0; k < count; k++) {\nvec4 B = F(f, i0 + k + 1);\nvec2 ab = B.xy - A.xy;\nvec2 ap = p - A.xy;\nfloat t = clamp(dot(ap, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\nvec2 dq = ap - ab * t;\nfloat dist = length(dq);\nfloat r = mix(A.z, B.z, t);\nfloat d = dist - r;\nbool w = d < h.d;\nh.d = w ? d : h.d;\nbu = w ? (float(k) + t) / float(count) : bu;\nbr = w ? r : br;\nbdq = w ? dq : bdq;\nbab = w ? ab : bab;\nbap = w ? ap : bap;\nA = B;\n}\n\n\nif (h.d < 1e9) {\nfloat dist = length(bdq);\nh.u = bu;\nfloat side = bab.x * bap.y - bab.y * bap.x < 0.0 ? -1.0 : 1.0;\nh.v = side * dist / max(br, 1e-3);\nh.n = dist > 1e-4 ? bdq / dist : normalize(vec2(-bab.y, bab.x) + 1e-6);\n}\nreturn h;\n}\n\n\nfloat finDist(vec2 p, vec2 a, vec2 b, float r0, float r1, out float t) {\nvec2 ab = b - a;\nvec2 ap = p - a;\nt = clamp(dot(ap, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\nfloat r = mix(r0, r1, smoothstep(0.0, 0.5, t)) * (1.0 - 0.45 * smoothstep(0.55, 1.0, t));\nreturn length(ap - ab * t) - r;\n}\n\n\n\nfloat tailSD(int f, vec2 q, vec4 fin) {\nHit th = polyline(f, J_BODY - 1, J_TAIL, q);\nvec2 tip = F(f, J_TOTAL - 1).xy;\nvec2 tdir = normalize(tip - F(f, J_TOTAL - 2).xy + 1e-6);\nreturn max(max(th.d, (th.u - 1.0 + fin.w * (1.0 - min(abs(th.v), 1.0))) * fin.z), dot(q - tip, tdir));\n}\n"],
-	["markings.glsl", "\n\n\n\n\n\n\n\nuniform vec3 uKohakuWhite;\nuniform vec3 uHiRed;\nuniform vec3 uSumi;\nuniform vec3 uShowaWhite;\nuniform vec3 uOgonShade;\nuniform vec3 uOgonGlint;\nuniform vec3 uKohakuFin;\nuniform vec3 uKohakuTail;\nuniform vec3 uOgonFin;\nuniform vec3 uOgonTail;\n\n\n\nvec3 kohaku(float u, float v, float seed) {\nfloat n = fbm(vec2(u * 3.0, v * 0.8) + seed)\n+ 0.08\n+ 0.35 * exp(-sq((u - 0.14) / 0.08))\n- 0.45 * v * v\n- 0.7 * smoothstep(0.75, 0.92, u)\n- 0.8 * (1.0 - smoothstep(0.02, 0.07, u));\nreturn mix(uKohakuWhite, uHiRed, smoothstep(-0.02, 0.04, n));\n}\n\n\nvec3 showa(float u, float v, float seed, out float sumiAmt) {\nfloat s = fbm(vec2(u * 3.5 + v * 0.9, v * 1.4) + seed * 1.7) + 0.04;\nfloat r = fbm(vec2(u * 2.6, v * 0.9) + seed * 2.3 + 31.0)\n+ 0.06 - 0.3 * v * v + 0.2 * exp(-sq((u - 0.12) / 0.1));\nfloat sumi = smoothstep(0.0, 0.04, s);\nfloat hi = smoothstep(0.0, 0.04, r);\nsumiAmt = sumi * (1.0 - 0.5 * hi);\nreturn mix(mix(uShowaWhite, uHiRed, hi), uSumi, sumiAmt);\n}\n\n\n\nvec3 ogon(float u, float v, float seed, out float glint) {\nvec2 sc = vec2(u * 26.0, v * 4.0 + 4.0);\nvec2 id = floor(vec2(sc.x + 0.5 * mod(floor(sc.y), 2.0), sc.y));\nfloat ph = hash12(id + seed);\nfloat twinkle = pow(0.5 + 0.5 * sin(uTime * 2.3 * flicker() + ph * TAU + u * 7.0), 14.0) * step(0.55, ph);\nfloat band = exp(-sq((v - 0.35 * sin(uTime * 0.6 + u * 4.0 + seed)) * 2.2));\nglint = max(twinkle, band * 0.6);\nvec3 base = mix(uOgonShade, uOgonGold, 1.0 - abs(v));\nreturn mix(base, uOgonGlint, glint);\n}\n\nvec3 pectoralColor(int variety, float t) {\nif (variety == V_KOHAKU) return uKohakuFin;\nif (variety == V_SHOWA) return mix(uSumi, uShowaWhite, smoothstep(0.15, 0.45, t));\nreturn uOgonFin;\n}\n\nvec3 tailColor(int variety, float u, float v, float seed) {\nif (variety == V_KOHAKU) return uKohakuTail;\nif (variety == V_SHOWA) {\nfloat streak = smoothstep(0.1, 0.2, gnoise(vec2(v * 3.0, u * 1.5) + seed));\nreturn mix(uShowaWhite, uSumi, streak * (1.0 - u * 0.6));\n}\nreturn mix(uOgonGold, uOgonTail, u);\n}\n"],
-	["trails.glsl", "\n\n\n\n\n\nuniform vec3 uSilk;\nuniform vec3 uBubble;\nuniform vec3 uGoldDust;\n\n\nvoid trailSeg(vec2 p, vec4 A, vec4 B, float w0, bool live, int variety,\ninout float best, inout vec2 bestDir, inout int bestVariety) {\nvec2 ab = B.xy - A.xy;\nvec2 ap = p - A.xy;\nfloat t = clamp(dot(ap, ab) / max(dot(ab, ab), 1e-6), 0.0, 1.0);\nfloat dist = length(ap - ab * t);\nfloat age = mix(A.z, B.z, t);\nfloat w = w0 * (0.5 + 1.4 * age) + 0.3 * min(uCell.x, uCell.y);\nfloat I = pow(1.0 - age, 1.3) * (1.0 - smoothstep(w * 0.35, w, dist));\nif (live && I > best) {\nbest = I;\nbestDir = ab;\nbestVariety = variety;\n}\n}\n\n\n\n#if TRAIL_CHUNK % 4 != 0\n#error trails.glsl unrolls by 4\n#endif\n#if TRAIL_CHUNKS * TRAIL_CHUNK > TRAIL_N + TRAIL_CHUNKS - 1\n#error trails.glsl fetches past the fish row\n#endif\n\nvoid trails(vec2 p, inout Cell c) {\nfloat best = 0.0;\nvec2 bestDir = vec2(1.0, 0.0);\nint bestVariety = 0;\n\n\n\n\nfloat cellPad = 0.3 * min(uCell.x, uCell.y);\nfor (int f = 0; f < MAX_FISH; f++) {\nif (f >= uFishCount) break;\nif (!inBox(p, F(f, T_TBOX), cellPad)) continue;\nvec4 P1 = F(f, T_P1);\nint n = int(P1.x + 0.5);\nfloat w0 = P1.y;\nint variety = int(F(f, T_P0).x + 0.5);\n\n\n\n\nfor (int ch = 0; 1 + ch * TRAIL_CHUNK < n; ch++) {\nint k0 = 1 + ch * TRAIL_CHUNK;\nif (!inBox(p, F(f, T_CBOX + ch), cellPad)) continue;\nvec4 A = F(f, T_TRAIL + k0 - 1);\nfor (int j = 0; j < TRAIL_CHUNK; j += 4) {\nint k = k0 + j;\nif (k >= n) break;\n\n\n\nvec4 B0 = F(f, T_TRAIL + k), B1 = F(f, T_TRAIL + k + 1);\nvec4 B2 = F(f, T_TRAIL + k + 2), B3 = F(f, T_TRAIL + k + 3);\ntrailSeg(p, A, B0, w0, true, variety, best, bestDir, bestVariety);\ntrailSeg(p, B0, B1, w0, k + 1 < n, variety, best, bestDir, bestVariety);\ntrailSeg(p, B1, B2, w0, k + 2 < n, variety, best, bestDir, bestVariety);\ntrailSeg(p, B2, B3, w0, k + 3 < n, variety, best, bestDir, bestVariety);\nA = B3;\n}\n}\n}\nif (best < 0.05) return;\n\nvec2 cell = floor(p / uCell);\nvec3 col;\nif (bestVariety == V_KOHAKU) {\n\nbest *= 0.7 + 0.6 * gnoise(p * 0.035 - uTime * 0.5);\ncol = uSilk;\n} else if (bestVariety == V_SHOWA) {\n\nfloat hb = hash12(cell * 1.37 + 5.0);\nbest *= step(0.62, hb) * (0.7 + 0.6 * hb);\ncol = uBubble;\n} else {\n\nfloat tw = hash12(cell + floor(uTime * 7.0 * flicker()) * 0.731);\nbest *= step(0.5, tw) * 1.2;\ncol = uGoldDust;\n}\nif (best < 0.12) return;\nc.mat = M_TRAIL;\nc.dens = min(best, 1.0);\n\nc.col = (bestVariety == V_KOHAKU ? col * (0.6 + 0.4 * smoothstep(0.1, 0.6, best)) : mix(uWaterLit, col, smoothstep(0.1, 0.6, best))) * uWaterTint;\nc.dir = lineDir(bestDir);\nc.aux = 0.0;\nc.style = float(bestVariety);\n}\n"],
-	["compose.glsl", "\n\n\n\n\n\n\n\n\nuniform vec2 uShadow;\nuniform float uShadowAlpha;\nuniform vec3 uEyeCol;\n\n\nuniform vec3 uSumiRim;\nuniform vec3 uAddTint;\n\n\nconst float SPEC_POW = 18.0;\n\nfloat shadow(int f, vec2 p) {\nfloat lift = 1.25 - F(f, T_P0).w;\nvec2 q = p - uShadow * lift;\nfloat blur = max(uCell.x, uCell.y) * (0.5 + 1.5 * lift);\nif (!inBox(q, F(f, T_BBOX), blur)) return 0.0;\nfloat d = min(polyline(f, 0, J_BODY - 1, q).d,\npolyline(f, J_BODY - 1, J_TAIL, q).d + max(uCell.x, uCell.y) * 0.5);\nreturn (1.0 - smoothstep(-blur, blur, d)) * (0.95 - 0.35 * lift) * uShadowAlpha;\n}\n\n\nvec2 refrAt(vec2 x) {\nfloat e = uRipplePx;\nreturn vec2(rippleAt(x + vec2(e, 0.0)) - rippleAt(x - vec2(e, 0.0)),\nrippleAt(x + vec2(0.0, e)) - rippleAt(x - vec2(0.0, e))) / (2.0 * e) * REFRACT;\n}\n\nvoid drawFish(int f, vec2 p, vec2 refr, inout Cell c) {\nvec4 P0 = F(f, T_P0);\nint variety = int(P0.x + 0.5);\nfloat seed = P0.y;\nfloat depth = P0.w;\n\nvec2 q = p + refr * (0.5 + depth);\nif (!inBox(q, F(f, T_BBOX), max(uCell.x, uCell.y) * 1.5)) return;\nfloat fog = 0.55 * depth;\nvec3 fogCol = uWaterDim * uWaterTint;\nfloat fade = 1.0 - 0.3 * depth;\nfloat style = float(variety);\nvec4 fin = F(f, T_FIN);\n\nvec3 flatLight = lightOn(vec3(0.0, 0.0, 1.0));\n\n\n\nfloat reach = max(uCell.x, uCell.y);\nvec2 ex = vec2(uCell.x * 0.5, 0.0);\nvec2 ey = vec2(0.0, uCell.y * 0.5);\n\n\nfor (int s = 0; s < 2; s++) {\nvec4 pf = F(f, T_PEC_L + s);\nfloat t, t2;\nfloat d = finDist(q, pf.xy, pf.zw, fin.x, fin.y, t);\nif (d > reach) continue;\nvec2 gr = vec2(finDist(q + ex, pf.xy, pf.zw, fin.x, fin.y, t2) - finDist(q - ex, pf.xy, pf.zw, fin.x, fin.y, t2),\nfinDist(q + ey, pf.xy, pf.zw, fin.x, fin.y, t2) - finDist(q - ey, pf.xy, pf.zw, fin.x, fin.y, t2)) / uCell;\nvec2 n = normalize(gr + 1e-6);\nfloat cv = coverage(d, n);\nif (cv > 0.25) {\nc.col = mix(pectoralColor(variety, t) * flatLight, fogCol, fog);\nc.aux = 0.0;\nc.style = style;\nif (cv < 0.8) {\nc.mat = M_EDGE;\nc.dens = cv;\nc.dir = cellNormal(n);\n} else {\nc.mat = M_FIN;\nc.col *= 0.75;\nc.dens = 0.6 * fade;\nc.dir = lineDir(q - pf.xy);\n}\n}\n}\n\n\n\nfloat td = tailSD(f, q, fin);\nif (td < reach) {\nvec2 gr = vec2(tailSD(f, q + ex, fin) - tailSD(f, q - ex, fin),\ntailSD(f, q + ey, fin) - tailSD(f, q - ey, fin)) / uCell;\nvec2 n = normalize(gr + 1e-6);\nfloat tcv = coverage(td, n);\nif (tcv > 0.25) {\nHit th = polyline(f, J_BODY - 1, J_TAIL, q);\nc.col = mix(tailColor(variety, th.u, th.v, seed) * flatLight, fogCol, fog);\nc.aux = 0.0;\nc.style = style;\nif (tcv < 0.8) {\nc.mat = M_EDGE;\nc.dens = tcv;\nc.dir = cellNormal(n);\n} else {\nc.mat = M_FIN;\nc.col *= 0.75;\nc.dens = (0.65 - 0.2 * th.u) * fade;\nc.dir = lineDir(q - F(f, J_BODY - 1).xy);\n}\n}\n}\n\n\nHit bh = polyline(f, 0, J_BODY - 1, q);\nfloat bcv = coverage(bh.d, bh.n);\nif (bcv > 0.18) {\nfloat glint = 0.0;\nfloat sumiAmt = 0.0;\nvec3 bc = variety == V_KOHAKU ? kohaku(bh.u, bh.v, seed)\n: variety == V_SHOWA ? showa(bh.u, bh.v, seed, sumiAmt)\n: ogon(bh.u, bh.v, seed, glint);\n\n\nfloat a = min(abs(bh.v), 1.0) * 0.92;\nvec3 N = vec3(bh.n * a, sqrt(1.0 - a * a));\nfloat ndl = dot(N, diffuseDir());\nvec3 lit = lightOn(N);\n\n\n\nvec3 H = normalize(uLightDir + vec3(0.0, 0.0, 1.0));\nfloat spec = pow(max(dot(N, H), 0.0), SPEC_POW);\nvec3 hue = lightHue() * length(uLightCol) * 0.82 * uAddTint;\nvec3 hi = variety == V_OGON ? hue * uOgonGold * 0.9 : hue * (variety == V_SHOWA ? 0.32 + 0.25 * sumiAmt : 0.3);\n\nvec2 az = normalize(uLightDir.xy + vec2(1e-5, 0.0));\nfloat rim = a * a * a * max(-dot(bh.n, az), 0.0) * (0.35 + 0.65 * (1.0 - uLightDir.z));\n\n\nfloat cst = smoothstep(0.5, 0.95, caustic(q * 0.014 + refr * 0.012 + seed, uTime * 0.45));\nvec3 caust = uLightCol * uAddTint * cst * uCaustic * 0.4 * max(ndl, 0.0) * (1.0 - depth);\nc.col = mix(bc * lit + hi * spec + uLightCol * uAddTint * rim * 0.6 + caust, fogCol, fog);\n\nfloat shade = mix(0.58, 1.05, smoothstep(-0.2, 0.9, ndl)) + 0.25 * spec;\nc.style = style;\nif (bcv > 0.8) {\n\n\nfloat Yl = dot(bc * bc, vec3(0.2126, 0.7152, 0.0722));\nfloat Ls = 1.16 * pow(Yl, 1.0 / 3.0) - 0.16;\nc.mat = M_BODY;\nc.dens = mix(0.6, 1.0, Ls) * shade * fade;\nc.aux = glint;\n} else {\nc.mat = M_EDGE;\nc.dens = bcv;\nc.dir = cellNormal(bh.n);\nc.aux = 0.0;\nc.col = mix(c.col, mix(uSumiRim * lit, fogCol, fog), 0.65 * sumiAmt);\n}\n}\n\n\nvec4 E = F(f, T_EYE);\n\n\n\n\nvec2 eyeReach = 0.5 * uCell + REFRACT / uRipplePx * abs(0.5 + depth) + 1.0;\nfor (int s = 0; s < 2; s++) {\nvec2 e = s == 0 ? E.xy : E.zw;\nbool hit = length(q - e) < P0.z;\nif (!hit && all(lessThanEqual(abs(p - e), eyeReach))) {\n\n\nvec2 de = abs(p + refrAt(e) * (0.5 + depth) - e);\nhit = de.x < uCell.x * 0.5 && de.y < uCell.y * 0.5;\n}\nif (hit) {\nc.mat = M_EYE;\nc.col = mix(uEyeCol * max(flatLight, vec3(0.75)), fogCol, fog * 0.5);\nc.dens = 1.0;\nc.aux = 0.0;\nc.style = style;\n}\n}\n}\n"],
-	["glyphs.glsl", "\n\n\n\n\nconst int BODY_N = 6;\nconst int BODY_RAMP[BODY_N] = int[BODY_N](G_EQUALS, G_PLUS, G_STAR, G_HASH, G_PERCENT, G_AT);\n\nfloat bayer4(ivec2 c) {\nconst int B[16] = int[16](0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5);\nreturn (float(B[(c.x & 3) + (c.y & 3) * 4]) + 0.5) / 16.0;\n}\n\n\nint lineGlyph(vec2 d, int horizontal, int vertical) {\nfloat a = atan(d.y, d.x);\nif (a < 0.0) a += PI;\nint s = int(floor(a / (PI * 0.25) + 0.5)) % 4;\nif (s == 0) return horizontal;\nif (s == 1) return G_BSLASH;\nif (s == 2) return vertical;\nreturn G_SLASH;\n}\n\n\n\nint edgeGlyph(vec2 n, float cov) {\nint o = int(floor((atan(n.y, n.x) + TAU) / (PI * 0.25) + 0.5)) % 8;\nif (o == 0) return G_RPAREN;\nif (o == 4) return G_LPAREN;\nif (o == 1 || o == 5) return G_SLASH;\nif (o == 3 || o == 7) return G_BSLASH;\nif (o == 2) return cov > 0.5 ? G_UNDERSCORE : G_MINUS;\nreturn cov > 0.5 ? G_MINUS : G_UNDERSCORE;\n}\n\nint pickGlyph(Cell c, ivec2 cell) {\nfloat dens = clamp(c.dens, 0.0, 1.0);\nfloat aux = clamp(c.aux, 0.0, 1.0);\nint style = int(c.style + 0.5);\nif (c.mat == M_WATER) {\nif (dens < 0.12) return G_SPACE;\nif (dens < 0.6) return aux < 0.4 ? G_DOT : aux < 0.65 ? G_COMMA : aux < 0.85 ? G_BACKTICK : G_QUOTE;\nreturn G_COLON;\n}\nif (c.mat == M_RIPPLE) {\nif (dens < 0.45) return G_DOT;\nreturn lineGlyph(c.dir, aux > 0.5 ? G_TILDE : G_MINUS, G_PIPE);\n}\nif (c.mat == M_TRAIL) {\nif (style == V_SHOWA) return dens > 0.55 ? G_O : G_DOT;\nif (style == V_OGON) return dens > 0.65 ? G_STAR : dens > 0.35 ? G_QUOTE : G_DOT;\nif (dens < 0.3) return G_DOT;\nif (dens < 0.55) return G_MINUS;\nreturn lineGlyph(c.dir, G_TILDE, G_COLON);\n}\nif (c.mat == M_FIN) {\nif (dens < 0.3) return G_DOT;\nif (dens < 0.45) return G_QUOTE;\nreturn lineGlyph(c.dir, style == V_OGON ? G_TILDE : G_MINUS, G_PIPE);\n}\nif (c.mat == M_EDGE) return edgeGlyph(c.dir, dens);\nif (c.mat == M_BODY) {\nif (aux > 0.75) return G_STAR;\nfloat x = smoothstep(0.3, 0.95, dens) * float(BODY_N - 1) + (bayer4(cell) - 0.5) * 0.5;\nreturn BODY_RAMP[clamp(int(floor(x + 0.5)), 0, BODY_N - 1)];\n}\nif (c.mat == M_EYE) return G_O;\nif (c.mat == M_STAR) {\n\nif (dens > 0.95) return G_STAR;\nif (dens > 0.65) return G_PLUS;\nif (dens > 0.4) return aux < 0.5 ? G_QUOTE : G_BACKTICK;\nreturn G_DOT;\n}\nif (c.mat == M_MOON) {\nif (style == 2) return lineGlyph(c.dir, G_EQUALS, G_PIPE);\nif (style == 1) return edgeGlyph(c.dir, dens);\nreturn dens < 0.33 ? G_DOT : dens < 0.56 ? G_COLON : dens < 0.67 ? G_O : G_BIG_O;\n}\nif (c.mat == M_SUN) return dens > 0.8 ? G_STAR : dens > 0.6 ? G_PLUS : G_DOT;\nif (c.mat == M_GLINT) {\n\nif (aux > 0.55) return dens > 0.6 ? lineGlyph(c.dir, dens > 0.85 ? G_EQUALS : G_MINUS, G_PIPE) : G_DOT;\nreturn dens > 0.75 ? G_STAR : G_PLUS;\n}\nreturn G_SPACE;\n}\n"],
-	["main.frag", "\n\n\n\n\n\n\n\n\n\n\n\n\nuniform int uOrder[MAX_FISH];\nuniform vec2 uOriginCss;\nuniform int uLayer;\nuniform int uFishDraw;\n\nlayout(location = 0) out vec4 oColor;\nlayout(location = 1) out vec4 oInfo;\n\nvoid main() {\nvec2 p = (floor(gl_FragCoord.xy) + 0.5) * uCell + uOriginCss;\n\nfloat e = uRipplePx;\nfloat h = rippleAt(p);\nvec2 g = vec2(rippleAt(p + vec2(e, 0.0)) - rippleAt(p - vec2(e, 0.0)),\nrippleAt(p + vec2(0.0, e)) - rippleAt(p - vec2(0.0, e))) / (2.0 * e);\n\nCell c;\nif (uLayer == 0) {\nc = water(p, h, g);\nstars(p, g, c);\nmoon(p, g, c);\nsun(p, g, c);\n\nfloat sh = 0.0;\n\n\n\nfor (int f = 0; f < uFishCount; f++) {\nsh = max(sh, shadow(f, p));\n}\nc.dens *= clamp(1.0 - 1.4 * sh, 0.0, 1.0);\nc.col *= 1.0 - 0.5 * sh;\n\ntrails(p, c);\n} else {\n\n\nc = Cell(vec3(0.0), 0.0, -1, vec2(1.0, 0.0), 0.0, 0.0);\n}\n\nvec2 refr = g * REFRACT;\nfor (int k = 0; k < MAX_FISH; k++) {\nif (k >= uFishDraw) break;\ndrawFish(uOrder[k], p, refr, c);\n}\n\nif (uLayer == 1 && c.mat < 0) discard;\n\nint glyph = pickGlyph(c, ivec2(gl_FragCoord.xy));\noColor = vec4(c.col, clamp(c.dens, 0.0, 1.0));\noInfo = vec4(float(glyph) / 255.0, float(c.mat) / 255.0, 0.0, 0.0);\n}\n"]
+	["uniforms.glsl", uniforms_default],
+	["light.glsl", light_default],
+	["cell.glsl", cell_default],
+	["ripples.glsl", ripples_default],
+	["water.glsl", water_default],
+	["sky.glsl", sky_default],
+	["fish.glsl", fish_default],
+	["markings.glsl", markings_default],
+	["trails.glsl", trails_default],
+	["compose.glsl", compose_default],
+	["glyphs.glsl", glyphs_default],
+	["avoid.glsl", avoid_default],
+	["main.frag", "\n\n\n\n\n\n\n\n\n\n\n\n\n\nuniform int uOrder[MAX_FISH];\nuniform vec2 uOriginCss;\nuniform int uLayer;\nuniform int uFishDraw;\n\nlayout(location = 0) out vec4 oColor;\nlayout(location = 1) out vec4 oInfo;\n\nvoid main() {\nvec2 p = (floor(gl_FragCoord.xy) + 0.5) * uCell + uOriginCss;\n\nfloat e = uRipplePx;\nfloat h = rippleAt(p);\nvec2 g = vec2(rippleAt(p + vec2(e, 0.0)) - rippleAt(p - vec2(e, 0.0)),\nrippleAt(p + vec2(0.0, e)) - rippleAt(p - vec2(0.0, e))) / (2.0 * e);\n\nCell c;\nif (uLayer == 0) {\nc = water(p, h, g);\nstars(p, g, c);\nmoon(p, g, c);\nsun(p, g, c);\n\nfloat sh = 0.0;\n\n\n\nfor (int f = 0; f < uFishCount; f++) {\nsh = max(sh, shadow(f, p));\n}\nc.dens *= clamp(1.0 - 1.4 * sh, 0.0, 1.0);\nc.col *= 1.0 - 0.5 * sh;\n\ntrails(p, c);\n} else {\n\n\nc = Cell(vec3(0.0), 0.0, -1, vec2(1.0, 0.0), 0.0, 0.0);\n}\n\nvec2 refr = g * REFRACT;\nfor (int k = 0; k < MAX_FISH; k++) {\nif (k >= uFishDraw) break;\ndrawFish(uOrder[k], p, refr, c);\n}\n\nif (uLayer == 1 && c.mat < 0) discard;\n\n\n\n\nfloat m = 0.0;\nbool outline = false;\nif (uAvoidN > 0) {\nfloat d = avoidDist(p);\nm = avoidMask(d);\nif (m > 0.0) c.dens *= avoidThin(m, c.mat);\n\noutline = uAvoidFade.w > 0.5 && abs(d) < 0.5 * max(uCell.x, uCell.y);\n}\n\nint glyph = pickGlyph(c, ivec2(gl_FragCoord.xy));\nif (outline) {\nc.col = uHiRed;\nglyph = G_DOT;\nm = 0.0;\n}\noColor = vec4(c.col, clamp(c.dens, 0.0, 1.0));\noInfo = vec4(float(glyph) / 255.0, float(c.mat) / 255.0, m, 0.0);\n}\n"]
 ];
 var sceneSrc = sceneChunks.map(([, src]) => src).join("\n");
 /** The line each chunk starts on in sceneSrc, 1-based, so compile errors can name `sky.glsl:42`. */
@@ -2102,13 +2331,13 @@ var sceneLines = sceneChunks.map(([name, src]) => {
 	line += src.split("\n").length;
 	return start;
 });
-var ascii_default = "\n\n\nuniform sampler2D uScene0;\nuniform sampler2D uScene1;\nuniform sampler2D uAtlas;\nuniform ivec2 uCellPx;\nuniform ivec2 uOrigin;\nuniform ivec2 uGrid;\nuniform int uCanvasH;\nuniform vec3 uBg;\nuniform vec3 uRawBg;\nuniform int uRaw;\n\nuniform int uLook;\nuniform vec3 uOutBg;\nuniform vec3 uStops[5];\nuniform vec3 uStopDeltas[4];\nuniform int uStopCount;\nuniform vec3 uTint;\nuniform float uSaturation;\nuniform int uInvert;\nuniform float uIntensity;\n#ifdef GLOW\nuniform sampler2D uGlow;\nuniform vec2 uGlowScale;\nuniform int uGlowOn;\n#endif\n\nin vec2 vPx;\nout vec4 fragColor;\n\n\n\n\nfloat lum(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }\n\n\nvec3 ramp(vec3 pix) {\nfloat t = clamp((lum(pix) - lum(uBg)) / (0.9 - lum(uBg)), 0.0, 1.0);\nfloat x = t * float(uStopCount - 1);\n\n\nfloat fi = min(floor(x), float(uStopCount - 2));\n\n\n\n\nvec3 a = uStops[0], d = uStopDeltas[0];\nif (uStopCount > 2) {\nif (fi >= 1.0) { a = uStops[1]; d = uStopDeltas[1]; }\nif (uStopCount > 3) {\nif (fi >= 2.0) { a = uStops[2]; d = uStopDeltas[2]; }\nif (uStopCount > 4 && fi >= 3.0) { a = uStops[3]; d = uStopDeltas[3]; }\n}\n}\n\n\nreturn a + (x - fi) * d;\n}\n\n\n\nvec3 filtered(vec3 pix) {\nvec3 d = pix - uBg;\nfloat y = lum(d);\nvec3 chroma = (d - vec3(y)) * uSaturation;\n\n\n\n\nfloat tl = lum(uTint);\nif (uInvert == 1) return uOutBg - y * 1.25 * tl * (vec3(1.0 + tl) - uTint) + chroma * 0.9;\nreturn uOutBg + (vec3(y) + chroma) * uTint;\n}\n\nvoid main() {\n\n\nivec2 q = ivec2(int(vPx.x), uCanvasH - 1 - int(vPx.y)) - uOrigin;\n\n\nvec2 cf = floor((vec2(q) + 0.5) / vec2(uCellPx));\nivec2 cell = ivec2(cf);\n\n\nif (any(greaterThanEqual(uvec2(cell), uvec2(uGrid)))) {\nfragColor = vec4(uRaw == 1 ? uRawBg : uOutBg, 1.0);\nreturn;\n}\n\n\nivec2 local = ivec2(vec2(q) - cf * vec2(uCellPx));\nvec4 s0 = texelFetch(uScene0, cell, 0);\nif (uRaw == 1) {\nfragColor = vec4(mix(uRawBg, s0.rgb, s0.a), 1.0);\nreturn;\n}\nint glyph = int(texelFetch(uScene1, cell, 0).r * 255.0 + 0.5);\nfloat ink = texelFetch(uAtlas, ivec2(int(float(glyph) * float(uCellPx.x)) + local.x, local.y), 0).r;\nvec3 bg = uBg;\n#ifdef GLOW\n\n\n\n\n\nif (uGlowOn == 1) bg += textureLod(uGlow, (vec2(q) + 0.5) * uGlowScale, 0.0).rgb;\n#endif\nvec3 c = mix(bg, s0.rgb, ink);\n\n\nif (uLook != 0 || uIntensity < 1.0) {\nif (uLook == 1) c = ramp(c);\nelse if (uLook == 2) c = clamp(filtered(c), 0.0, 1.0);\nif (uIntensity < 1.0) c = mix(uOutBg, c, uIntensity);\n}\nfragColor = vec4(c, 1.0);\n}\n";
+var ascii_default = "\n\n\nuniform sampler2D uScene0;\nuniform sampler2D uScene1;\nuniform sampler2D uAtlas;\nuniform ivec2 uCellPx;\nuniform ivec2 uOrigin;\nuniform ivec2 uGrid;\nuniform int uCanvasH;\nuniform vec3 uBg;\nuniform vec3 uRawBg;\nuniform int uRaw;\n\nuniform int uLook;\nuniform vec3 uOutBg;\nuniform vec3 uStops[5];\nuniform vec3 uStopDeltas[4];\nuniform int uStopCount;\nuniform vec3 uTint;\nuniform float uSaturation;\nuniform int uInvert;\nuniform float uIntensity;\nuniform vec2 uAvoidDim;\n#ifdef GLOW\nuniform sampler2D uGlow;\nuniform vec2 uGlowScale;\nuniform int uGlowOn;\n#endif\n\nin vec2 vPx;\nout vec4 fragColor;\n\n\n\n\nfloat lum(vec3 c) { return dot(c, vec3(0.299, 0.587, 0.114)); }\n\n\nvec3 ramp(vec3 pix) {\nfloat t = clamp((lum(pix) - lum(uBg)) / (0.9 - lum(uBg)), 0.0, 1.0);\nfloat x = t * float(uStopCount - 1);\n\n\nfloat fi = min(floor(x), float(uStopCount - 2));\n\n\n\n\nvec3 a = uStops[0], d = uStopDeltas[0];\nif (uStopCount > 2) {\nif (fi >= 1.0) { a = uStops[1]; d = uStopDeltas[1]; }\nif (uStopCount > 3) {\nif (fi >= 2.0) { a = uStops[2]; d = uStopDeltas[2]; }\nif (uStopCount > 4 && fi >= 3.0) { a = uStops[3]; d = uStopDeltas[3]; }\n}\n}\n\n\nreturn a + (x - fi) * d;\n}\n\n\n\nvec3 filtered(vec3 pix) {\nvec3 d = pix - uBg;\nfloat y = lum(d);\nvec3 chroma = (d - vec3(y)) * uSaturation;\n\n\n\n\nfloat tl = lum(uTint);\nif (uInvert == 1) return uOutBg - y * 1.25 * tl * (vec3(1.0 + tl) - uTint) + chroma * 0.9;\nreturn uOutBg + (vec3(y) + chroma) * uTint;\n}\n\nvoid main() {\n\n\nivec2 q = ivec2(int(vPx.x), uCanvasH - 1 - int(vPx.y)) - uOrigin;\n\n\nvec2 cf = floor((vec2(q) + 0.5) / vec2(uCellPx));\nivec2 cell = ivec2(cf);\n\n\nif (any(greaterThanEqual(uvec2(cell), uvec2(uGrid)))) {\nfragColor = vec4(uRaw == 1 ? uRawBg : uOutBg, 1.0);\nreturn;\n}\n\n\nivec2 local = ivec2(vec2(q) - cf * vec2(uCellPx));\nvec4 s0 = texelFetch(uScene0, cell, 0);\nif (uRaw == 1) {\nfragColor = vec4(mix(uRawBg, s0.rgb, s0.a), 1.0);\nreturn;\n}\nvec4 s1 = texelFetch(uScene1, cell, 0);\nint glyph = int(s1.r * 255.0 + 0.5);\nfloat ink = texelFetch(uAtlas, ivec2(int(float(glyph) * float(uCellPx.x)) + local.x, local.y), 0).r;\nvec3 bg = uBg;\n#ifdef GLOW\n\n\n\n\n\nif (uGlowOn == 1) bg += textureLod(uGlow, (vec2(q) + 0.5) * uGlowScale, 0.0).rgb;\n#endif\nvec3 c = mix(bg, s0.rgb, ink);\n\n\nif (uLook != 0 || uIntensity < 1.0) {\nif (uLook == 1) c = ramp(c);\nelse if (uLook == 2) c = clamp(filtered(c), 0.0, 1.0);\nif (uIntensity < 1.0) c = mix(uOutBg, c, uIntensity);\n}\n\n\n\n\nif (uAvoidDim != vec2(0.0) && s1.b > 0.0) {\nint mat = int(s1.g * 255.0 + 0.5);\nc = mix(uOutBg, c, 1.0 - (avoidWater(mat) ? uAvoidDim.x : uAvoidDim.y) * s1.b);\n}\nfragColor = vec4(c, 1.0);\n}\n";
 var pixel_default = "\n\n\n\n\nuniform vec2 uDev;\nout vec2 vPx;\n\nvoid main() {\nvec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\ngl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\nvPx = p * uDev;\n}\n";
 var glow_default = "\n\n\n\n\n\nuniform ivec2 uGrid;\nuniform float uAspect;\nuniform float uGain;\n\nout vec4 oGlow;\n\n\n\n#ifdef EMIT_TEX\n\n\n\nuniform sampler2D uEmit;\n#endif\n\nvoid main() {\nivec2 cell = ivec2(gl_FragCoord.xy);\nvec3 sum = vec3(0.0);\nfloat wsum = 0.0;\nfor (int y = -RY; y <= RY; y++) {\nfor (int x = -RX; x <= RX; x++) {\n\nvec2 d = vec2(float(x) * uAspect, float(y));\nfloat k = exp(-dot(d, d) * 0.6);\nwsum += k;\n#ifdef EMIT_TEX\nvec4 e = texelFetch(uEmit, cell + ivec2(x + RX, y + RY), 0);\nsum += e.rgb * e.a * k;\n#else\nivec2 n = cell + ivec2(x, y);\n\n\nivec2 nc = clamp(n, ivec2(0), uGrid - 1);\nvec4 e = emission(nc);\nif (all(equal(n, nc))) sum += e.rgb * e.a * k;\n#endif\n}\n}\n\n\nvec3 halo = sum * (uGain / wsum);\noGlow = vec4(halo / (1.0 + 2.5 * max(halo.r, max(halo.g, halo.b))), 1.0);\n}\n";
 var emission_default$1 = "\n\n\n\nuniform sampler2D uScene0;\nuniform sampler2D uScene1;\n\n\n\n\n\n\nvec4 emission(ivec2 cell) {\nvec4 s0 = texelFetch(uScene0, cell, 0);\nint mat = int(texelFetch(uScene1, cell, 0).g * 255.0 + 0.5);\nfloat w = mat == M_FLY ? 1.3\n: mat == M_GLINT ? 1.0\n: mat == M_SUN ? 1.2\n: mat == M_EYE ? 0.7\n: mat == M_MOON ? 0.5\n: mat == M_STAR ? 0.35\n: mat == M_RIPPLE ? 0.45\n: mat == M_BODY || mat == M_EDGE || mat == M_FIN ? 0.4\n: 0.0;\nfloat lum = dot(s0.rgb, vec3(0.299, 0.587, 0.114));\nreturn vec4(s0.rgb, w * s0.a * smoothstep(0.3, 0.85, lum));\n}\n";
 var emission_default = "\n\n\n\n\n\nout vec4 oEmit;\n\nvoid main() {\noEmit = emission(ivec2(gl_FragCoord.xy) - ivec2(RX, RY));\n}\n";
 var fly_default$1 = "\n\n\n\nlayout(location = 0) in vec4 aFly;\n\nuniform vec2 uCell;\nuniform vec2 uOriginCss;\nuniform ivec2 uGrid;\nuniform float uFlies;\n\nout float vBright;\n\n\nconst float FLY_MIN = 0.22;\n\nvoid main() {\nfloat v = aFly.z * uFlies;\nvBright = v;\ngl_PointSize = 1.0;\n\nvec2 cell = floor((aFly.xy - uOriginCss) / uCell);\nvec2 ndc = (cell + 0.5) / vec2(uGrid) * 2.0 - 1.0;\n\ngl_Position = v < FLY_MIN ? vec4(2.0, 2.0, 0.0, 1.0) : vec4(ndc, 0.0, 1.0);\n}\n";
-var fly_default = "\n\n\n\n\nuniform vec3 uFlyCol;\nuniform vec3 uWaterDim;\nuniform float uRoles;\n\nin float vBright;\n\nlayout(location = 0) out vec4 oColor;\nlayout(location = 1) out vec4 oInfo;\n\nvoid main() {\nfloat v = min(vBright, 1.0);\nint glyph = v > 0.7 ? G_STAR : v > 0.45 ? G_PLUS : G_DOT;\nfloat k = min(0.45 + 0.6 * v, 1.0);\nvec3 col = uRoles > 0.5 ? mix(uWaterDim, uFlyCol, k) : uFlyCol * k;\noColor = vec4(col, v);\noInfo = vec4(float(glyph) / 255.0, float(M_FLY) / 255.0, 0.0, 0.0);\n}\n";
+var fly_default = "\n\n\n\n\n\n\n\nuniform vec3 uFlyCol;\nuniform vec3 uWaterDim;\nuniform float uRoles;\nuniform vec2 uCell;\nuniform vec2 uOriginCss;\n\nin float vBright;\n\nlayout(location = 0) out vec4 oColor;\nlayout(location = 1) out vec4 oInfo;\n\nvoid main() {\nfloat v = min(vBright, 1.0);\n\nfloat m = uAvoidN > 0 ? avoidMask(avoidDist((floor(gl_FragCoord.xy) + 0.5) * uCell + uOriginCss)) : 0.0;\n\nfloat vt = m > 0.0 ? v * avoidThin(m, M_FLY) : v;\nint glyph = vt > 0.7 ? G_STAR : vt > 0.45 ? G_PLUS : G_DOT;\nfloat k = min(0.45 + 0.6 * v, 1.0);\nvec3 col = uRoles > 0.5 ? mix(uWaterDim, uFlyCol, k) : uFlyCol * k;\noColor = vec4(col, vt);\noInfo = vec4(float(glyph) / 255.0, float(M_FLY) / 255.0, m, 0.0);\n}\n";
 /** `file:line` for line n of a compiled shader, or just n before the first file. */
 function sourceLine(files, n) {
 	let file;
@@ -2377,34 +2606,34 @@ function scale(a, k) {
 * deep water and ripples come from water, highlight and background only (Q11).
 */
 function rolesScene(r) {
-	const ripple = mix(r.water, r.highlight, .6);
+	const ripple = mix$1(r.water, r.highlight, .6);
 	return {
-		uWaterDim: mix(r.background, r.water, .37),
+		uWaterDim: mix$1(r.background, r.water, .37),
 		uWaterLit: r.water,
 		uRippleCol: ripple,
 		uKohakuWhite: r.pale,
 		uHiRed: r.accent,
 		uSumi: r.ink,
-		uShowaWhite: mix(r.pale, r.background, .05),
+		uShowaWhite: mix$1(r.pale, r.background, .05),
 		uOgonGold: r.metallic,
 		uOgonShade: scale(r.metallic, .8),
-		uOgonGlint: mix(r.metallic, r.highlight, .6),
+		uOgonGlint: mix$1(r.metallic, r.highlight, .6),
 		uEyeCol: r.highlight,
-		uSumiRim: mix(r.ink, r.pale, .7),
-		uKohakuFin: mix(r.pale, r.water, .15),
-		uKohakuTail: mix(r.pale, r.water, .12),
-		uOgonFin: mix(r.metallic, r.highlight, .25),
-		uOgonTail: mix(r.metallic, r.highlight, .45),
+		uSumiRim: mix$1(r.ink, r.pale, .7),
+		uKohakuFin: mix$1(r.pale, r.water, .15),
+		uKohakuTail: mix$1(r.pale, r.water, .12),
+		uOgonFin: mix$1(r.metallic, r.highlight, .25),
+		uOgonTail: mix$1(r.metallic, r.highlight, .45),
 		uSilk: r.pale,
-		uBubble: mix(r.water, r.highlight, .6),
-		uGoldDust: mix(r.metallic, r.highlight, .15),
+		uBubble: mix$1(r.water, r.highlight, .6),
+		uGoldDust: mix$1(r.metallic, r.highlight, .15),
 		uGlintCol: r.highlight,
 		uAddTint: r.highlight,
 		uStarCool: r.highlight,
-		uStarWarm: mix(r.highlight, r.water, .25),
-		uMoonCol: mix(r.highlight, r.pale, .25),
+		uStarWarm: mix$1(r.highlight, r.water, .25),
+		uMoonCol: mix$1(r.highlight, r.pale, .25),
 		uSunCol: r.highlight,
-		uFlyCol: mix(r.metallic, r.highlight, .32)
+		uFlyCol: mix$1(r.metallic, r.highlight, .32)
 	};
 }
 var luma = (c) => .2126 * c[0] + .7152 * c[1] + .0722 * c[2];
@@ -2578,6 +2807,8 @@ function starsAt(phase, sky, light) {
 function firefliesAt(phase, sky) {
 	return sky.fireflies ? fireflyWeight(phase) : 0;
 }
+/** Stands in for mount()'s zone arrays until the first setAvoid. */
+var NO_ZONES = /* @__PURE__ */ new Float32Array(0);
 /** World px per ripple simulation texel. */
 var RIPPLE_PX = 5;
 var RIPPLE_HZ = 60;
@@ -2622,6 +2853,8 @@ var Renderer = class {
 	intensity = 1;
 	/** Night-sky features, already resolved; mount() owns them like the palette. */
 	sky = DEFAULT_SKY;
+	/** Debug switch: outlines the readability zones (in the palette's hi red) and draws them even at strength 0. */
+	showAvoid = false;
 	gl;
 	fontFamily;
 	vao;
@@ -2642,6 +2875,18 @@ var Renderer = class {
 	dropBuf = /* @__PURE__ */ new Float32Array(128);
 	stopBuf = /* @__PURE__ */ new Float32Array(15);
 	stopDeltaBuf = /* @__PURE__ */ new Float32Array(12);
+	/**
+	* Readability zones for the next frames, as mount() last measured them: x,
+	* y, w, h and a radius each, world px. mount()'s arrays (setAvoid); never
+	* read while avoidCount is 0.
+	*/
+	avoidRects = NO_ZONES;
+	avoidRadii = NO_ZONES;
+	avoidCount = 0;
+	/** The readability fade, already resolved; mount() owns it like the palette. */
+	avoidFade = DEFAULT_FADE;
+	/** What avoidFade's strength does to each material (worked out once per setAvoidFade, not per frame). */
+	avoidAmounts = avoidAmounts(DEFAULT_FADE.strength);
 	/** Scene colours for the active palette (roles replace the pond's). */
 	sceneColors = POND_SCENE;
 	uploadedColors = null;
@@ -2726,7 +2971,7 @@ var Renderer = class {
 		const glow = emission ? `#define EMIT_TEX\n${glow_default}` : `${emission_default$1}\n${glow_default}`;
 		this.glowProg = software ? null : new Program(gl, vertex, fragment(glow), "glow");
 		this.asciiProg = new Program(gl, pixelVertex, fragment((software ? "" : "#define GLOW\n") + ascii_default), "ascii");
-		this.flyProg = new Program(gl, `#version 300 es\n${common_default}\n${fly_default$1}`, fragment(fly_default), "fly");
+		this.flyProg = new Program(gl, `#version 300 es\n${common_default}\n${fly_default$1}`, fragment(`${avoid_default}\n${fly_default}`), "fly");
 		const vao = gl.createVertexArray();
 		const flyVao = gl.createVertexArray();
 		const flyBuf = gl.createBuffer();
@@ -2768,6 +3013,28 @@ var Renderer = class {
 	setSky(sky) {
 		this.sky = sky;
 	}
+	/**
+	* Sets the readability zones the next render() fades under: `count` zones,
+	* `rects` x, y, w, h and `radii` one per zone, in world px. The arrays are
+	* kept, not copied (mount() refills them before each draw).
+	*/
+	setAvoid(rects, radii, count) {
+		this.avoidRects = rects;
+		this.avoidRadii = radii;
+		this.avoidCount = count;
+	}
+	/**
+	* Whether render() draws zones at all: not in the raw view (A14), nor at
+	* strength 0 unless outlined. mount() skips measuring when it doesn't.
+	*/
+	get drawsAvoid() {
+		return !this.raw && (this.avoidFade.strength > 0 || this.showAvoid);
+	}
+	/** Sets the readability fade; the next render() draws with it. */
+	setAvoidFade(fade) {
+		this.avoidFade = fade;
+		this.avoidAmounts = avoidAmounts(fade.strength);
+	}
 	/** Sizes everything for a drawing buffer of devW × devH device pixels. */
 	resize(devW, devH, dpr) {
 		const gl = this.gl;
@@ -2850,6 +3117,8 @@ var Renderer = class {
 		const sceneLight = this.sceneLight;
 		const stars = this.stars;
 		const flies = this.flies;
+		const amounts = this.avoidAmounts;
+		const zones = this.drawsAvoid ? this.avoidCount : 0;
 		const gl = this.gl;
 		const atlas = this.atlas;
 		const scene = this.scene;
@@ -2887,7 +3156,8 @@ var Renderer = class {
 			for (const [name, c] of Object.entries(colors)) sp.vec3(name, c[0], c[1], c[2]);
 			this.uploadedColors = colors;
 		}
-		sp.float("uRoles", roles ? 1 : 0).texture("uFish", 0, this.fishTex).texture("uRipple", 1, ripple[0].textures[0]).ivec2("uRippleSize", this.simW, this.simH).float("uRipplePx", RIPPLE_PX).int("uFishCount", count).ints("uOrder", pond.order).vec2("uCell", atlas.cellW / this.dpr, atlas.cellH / this.dpr).vec2("uOriginCss", this.originX / this.dpr, this.originY / this.dpr).float("uTime", pond.time % 65536).vec3("uLightDir", light.dir[0], light.dir[1], light.dir[2]).vec3("uLightCol", sceneLight.color[0], sceneLight.color[1], sceneLight.color[2]).vec3("uAmbient", sceneLight.ambient[0], sceneLight.ambient[1], sceneLight.ambient[2]).vec3("uWaterTint", sceneLight.water[0], sceneLight.water[1], sceneLight.water[2]).vec3("uSky", sceneLight.sky[0], sceneLight.sky[1], sceneLight.sky[2]).float("uGlint", light.glint).float("uCaustic", light.caustic).float("uFloor", light.floor).float("uDarkWater", light.darkWater).float("uDarkCaustic", light.darkCaustic).vec2("uShadow", unit * light.shadow[0], unit * light.shadow[1]).float("uShadowAlpha", light.shadowAlpha).float("uCalm", pond.calm ? 1 : 0).float("uStars", stars.stars).float("uMoteThin", stars.moteThin).vec2("uView", this.devW / this.dpr, this.devH / this.dpr).vec4("uMoon", light.moon.pos[0], light.moon.pos[1], light.moon.radius, this.sky.moon ? light.moon.alpha : 0).vec4("uSun", light.sun.pos[0], light.sun.pos[1], light.sun.radius, this.sky.sun ? light.sun.alpha : 0);
+		sp.float("uRoles", roles ? 1 : 0).texture("uFish", 0, this.fishTex).texture("uRipple", 1, ripple[0].textures[0]).ivec2("uRippleSize", this.simW, this.simH).float("uRipplePx", RIPPLE_PX).int("uFishCount", count).ints("uOrder", pond.order).vec2("uCell", atlas.cellW / this.dpr, atlas.cellH / this.dpr).vec2("uOriginCss", this.originX / this.dpr, this.originY / this.dpr).float("uTime", pond.time % 65536).vec3("uLightDir", light.dir[0], light.dir[1], light.dir[2]).vec3("uLightCol", sceneLight.color[0], sceneLight.color[1], sceneLight.color[2]).vec3("uAmbient", sceneLight.ambient[0], sceneLight.ambient[1], sceneLight.ambient[2]).vec3("uWaterTint", sceneLight.water[0], sceneLight.water[1], sceneLight.water[2]).vec3("uSky", sceneLight.sky[0], sceneLight.sky[1], sceneLight.sky[2]).float("uGlint", light.glint).float("uCaustic", light.caustic).float("uFloor", light.floor).float("uDarkWater", light.darkWater).float("uDarkCaustic", light.darkCaustic).vec2("uShadow", unit * light.shadow[0], unit * light.shadow[1]).float("uShadowAlpha", light.shadowAlpha).float("uCalm", pond.calm ? 1 : 0).float("uStars", stars.stars).float("uMoteThin", stars.moteThin).vec2("uView", this.devW / this.dpr, this.devH / this.dpr).vec4("uMoon", light.moon.pos[0], light.moon.pos[1], light.moon.radius, this.sky.moon ? light.moon.alpha : 0).vec4("uSun", light.sun.pos[0], light.sun.pos[1], light.sun.radius, this.sky.sun ? light.sun.alpha : 0).int("uAvoidN", zones);
+		if (zones > 0) this.avoidUniforms(sp, amounts);
 		sp.int("uLayer", 0).int("uFishDraw", 0);
 		gl.drawArrays(gl.TRIANGLES, 0, 3);
 		if (count > 0) {
@@ -2904,7 +3174,8 @@ var Renderer = class {
 				for (const [name, c] of Object.entries(colors)) fp.vec3(name, c[0], c[1], c[2]);
 				this.flyColors = colors;
 			}
-			fp.float("uRoles", roles ? 1 : 0).vec2("uCell", atlas.cellW / this.dpr, atlas.cellH / this.dpr).vec2("uOriginCss", this.originX / this.dpr, this.originY / this.dpr).ivec2("uGrid", this.cols, this.rows).float("uFlies", flies);
+			fp.float("uRoles", roles ? 1 : 0).vec2("uCell", atlas.cellW / this.dpr, atlas.cellH / this.dpr).vec2("uOriginCss", this.originX / this.dpr, this.originY / this.dpr).ivec2("uGrid", this.cols, this.rows).float("uFlies", flies).int("uAvoidN", zones);
+			if (zones > 0) this.avoidUniforms(fp, amounts);
 			gl.drawArrays(gl.POINTS, 0, 14);
 			gl.bindVertexArray(this.vao);
 		}
@@ -2939,10 +3210,14 @@ var Renderer = class {
 		const look = this.look;
 		const filter = palette.mode === "filter" ? palette : null;
 		const tint = filter?.tint ?? WHITE;
-		const ascii = this.asciiProg.use().texture("uScene0", 0, scene.textures[0]).texture("uScene1", 1, scene.textures[1]).texture("uAtlas", 2, atlas.texture).vec2("uDev", this.devW, this.devH).ivec2("uCellPx", atlas.cellW, atlas.cellH).ivec2("uOrigin", this.originX, this.originY).ivec2("uGrid", this.cols, this.rows).int("uCanvasH", this.devH).vec3("uBg", look.bg[0], look.bg[1], look.bg[2]).vec3("uRawBg", POND_BG[0], POND_BG[1], POND_BG[2]).int("uRaw", this.raw ? 1 : 0).int("uLook", look.look).vec3("uOutBg", look.outBg[0], look.outBg[1], look.outBg[2]).vec3s("uStops", this.stopBuf).vec3s("uStopDeltas", this.stopDeltaBuf).int("uStopCount", palette.mode === "ramp" ? palette.stops.length : 2).vec3("uTint", tint[0], tint[1], tint[2]).float("uSaturation", filter?.saturation ?? 1).int("uInvert", filter?.invert ? 1 : 0).float("uIntensity", this.raw ? 1 : this.intensity);
+		const ascii = this.asciiProg.use().texture("uScene0", 0, scene.textures[0]).texture("uScene1", 1, scene.textures[1]).texture("uAtlas", 2, atlas.texture).vec2("uDev", this.devW, this.devH).ivec2("uCellPx", atlas.cellW, atlas.cellH).ivec2("uOrigin", this.originX, this.originY).ivec2("uGrid", this.cols, this.rows).int("uCanvasH", this.devH).vec3("uBg", look.bg[0], look.bg[1], look.bg[2]).vec3("uRawBg", POND_BG[0], POND_BG[1], POND_BG[2]).int("uRaw", this.raw ? 1 : 0).int("uLook", look.look).vec3("uOutBg", look.outBg[0], look.outBg[1], look.outBg[2]).vec3s("uStops", this.stopBuf).vec3s("uStopDeltas", this.stopDeltaBuf).int("uStopCount", palette.mode === "ramp" ? palette.stops.length : 2).vec3("uTint", tint[0], tint[1], tint[2]).float("uSaturation", filter?.saturation ?? 1).int("uInvert", filter?.invert ? 1 : 0).float("uIntensity", this.raw ? 1 : this.intensity).vec2("uAvoidDim", zones > 0 ? amounts.waterDim : 0, zones > 0 ? amounts.fishDim : 0);
 		if (this.glowTarget) ascii.texture("uGlow", 3, this.glowTarget.textures[0]).vec2("uGlowScale", 1 / (this.cols * atlas.cellW), 1 / (this.rows * atlas.cellH)).int("uGlowOn", haloDrawn ? 1 : 0);
 		gl.drawArrays(gl.TRIANGLES, 0, 3);
 	}
+	/** The zones and their thinning, for the scene and firefly programs (scene/avoid.glsl). */
+	avoidUniforms(prog, amounts) {
+		prog.vec4s("uAvoid", this.avoidRects).vec4s("uAvoidR", this.avoidRadii).vec4("uAvoidFade", amounts.waterThin, amounts.fishThin, this.avoidFade.feather, this.showAvoid ? 1 : 0);
+	}
 	/** Moves up to MAX_DROPS pending impulses into the uniform buffer, in sim texels. */
 	takeDrops(pond) {
 		const drops = pond.drops;
@@ -2980,15 +3255,19 @@ function mount(container, options) {
 	const interactive = options.interactive === "canvas" || options.interactive === "none" ? options.interactive : "window";
 	const seed = typeof options.seed === "number" && Number.isFinite(options.seed) ? options.seed >>> 0 : Math.random() * 2 ** 32 >>> 0;
 	const sky = new Sky(timeSource(options.time, 0));
+	const { background, onError } = options;
 	let palette = resolvePalette(options.palette, parseCssColor);
 	let intensity = resolveIntensity(options.intensity, 1, true);
 	let skyFeatures = resolveSky(options.sky);
+	const zones = new AvoidZones();
+	zones.set(options.avoid, false);
+	let avoidFade = resolveAvoidFade(options.avoidFade);
 	let canvas = document.createElement("canvas");
 	canvas.setAttribute("aria-hidden", "true");
 	canvas.style.display = "block";
 	canvas.style.width = "100%";
 	canvas.style.height = "100%";
-	canvas.style.backgroundColor = options.background || palette.css;
+	canvas.style.backgroundColor = background || palette.css;
 	if (interactive === "canvas") canvas.style.touchAction = "none";
 	container.append(canvas);
 	const listeners = new AbortController();
@@ -3020,6 +3299,7 @@ function mount(container, options) {
 		cancelAnimationFrame(raf);
 		raf = 0;
 		renderer = null;
+		zones.clear();
 		if (gl && !gl.isContextLost()) gl.getExtension("WEBGL_lose_context")?.loseContext();
 	};
 	const fail = (code, message, cause) => {
@@ -3032,12 +3312,12 @@ function mount(container, options) {
 			canvas = blank;
 		}
 		const error = koiPondError(code, message, cause);
-		if (!options.onError) {
+		if (!onError) {
 			console.error(error);
 			return;
 		}
 		try {
-			options.onError(error);
+			onError(error);
 		} catch (err) {
 			console.error(err);
 		}
@@ -3049,7 +3329,7 @@ function mount(container, options) {
 		setPalette(next) {
 			if (destroyed) return;
 			palette = resolvePalette(next, parseCssColor);
-			if (!options.background) canvas.style.backgroundColor = palette.css;
+			if (!background) canvas.style.backgroundColor = palette.css;
 			renderer?.setLook(palette, intensity);
 		},
 		setIntensity(next) {
@@ -3062,6 +3342,15 @@ function mount(container, options) {
 			skyFeatures = resolveSky(next);
 			renderer?.setSky(skyFeatures);
 		},
+		setAvoid(list) {
+			if (destroyed || failed) return;
+			zones.set(list);
+		},
+		setAvoidFade(next) {
+			if (destroyed || failed) return;
+			avoidFade = resolveAvoidFade(next, avoidFade);
+			renderer?.setAvoidFade(avoidFade);
+		},
 		pause() {
 			paused = true;
 			schedule();
@@ -3144,6 +3433,7 @@ function mount(container, options) {
 				renderer = new Renderer(ctx, fontFamily, software);
 				renderer.setLook(palette, intensity);
 				renderer.setSky(skyFeatures);
+				renderer.setAvoidFade(avoidFade);
 				sizeDirty = true;
 				return true;
 			} catch (err) {
@@ -3256,6 +3546,7 @@ function mount(container, options) {
 			}
 			pond.resize(size.w / size.dpr, size.h / size.dpr);
 			r.resize(bw, bh, size.dpr * bw / size.w);
+			zones.readRadii();
 		};
 		/** Applies a pending resize; false while there is nothing to draw into. */
 		const prepare = () => {
@@ -3268,8 +3559,26 @@ function mount(container, options) {
 				sizeDirty = false;
 				applySize(renderer);
 			}
+			measureZones(renderer);
 			return renderer;
 		};
+		/**
+		* Measures the readability zones for the draw about to happen. On every
+		* drawn frame and manual draw (D8), never while the loop is stopped: the
+		* page's elements move without telling anyone (scroll, transforms,
+		* animations), so a fresh read is the only way to be right. No reads
+		* without zones, or when the renderer won't draw them (strength 0 without
+		* the debug outline, the raw view); the next frame that draws them
+		* measures afresh.
+		*/
+		const measureZones = (r) => {
+			let count = 0;
+			if (zones.size > 0 && r.drawsAvoid) {
+				const c = canvas.getBoundingClientRect();
+				count = zones.measure(c, window.innerWidth, window.innerHeight, avoidFade.feather);
+			}
+			r.setAvoid(zones.rects, zones.radii, count);
+		};
 		/** Simulates `dt` seconds and draws; shared by the frame loop and step(). */
 		const advance = (r, dt) => {
 			pond.calm = reduceMotion.matches;