@fnndsc/orrery 0.1.0

package/dist/draw/stars.js

@@ -0,0 +1,132 @@
+/**
+ * @file Stars: every node a point of light, sized true to the sphere it stands for. Error-free stars glow additively; a star with any errored share is drawn solid over the glow, so failure always shows through.
+ *
+ * @module
+ */
+import * as THREE from 'three';
+import { DIM_OPACITY } from './constants.js';
+/** A star's smallest size on screen, in CSS pixels: no node ever vanishes. */
+export const STAR_FLOOR_PX = 2;
+/** A star never swells past this many CSS pixels: near the camera a feed is spheres, not a glow. */
+export const STAR_CAP_PX = 28;
+/** A star's sprite spans this many times its sphere's diameter: core plus glow. */
+export const STAR_GLOW = 1.8;
+export const STAR_VERTEX = `
+attribute float radius;
+attribute float alpha;
+attribute vec3 tint;
+attribute float flash;
+uniform float scale;
+uniform float floorPx;
+uniform float capPx;
+varying vec3 vTint;
+varying float vAlpha;
+varying float vFlash;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  gl_Position = projectionMatrix * mv;
+  float px = ${STAR_GLOW.toFixed(1)} * 2.0 * radius * scale / max(0.0001, -mv.z);
+  // An arrival flashes: the star swells past its cap for a moment.
+  gl_PointSize = min(max(px, floorPx), capPx) * (1.0 + 1.6 * flash);
+  vTint = tint;
+  vAlpha = alpha;
+  vFlash = flash;
+}`;
+/** The glow: a bright core falling off to nothing at the sprite's edge. */
+export const STAR_FRAGMENT_GLOW = `
+varying vec3 vTint;
+varying float vAlpha;
+varying float vFlash;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
+  if (d > 1.0) discard;
+  float core = smoothstep(0.6, 0.0, d);
+  float halo = pow(1.0 - d, 2.2) * 0.55;
+  float a = clamp(core + halo, 0.0, 1.0) * vAlpha;
+  vec3 c = mix(vTint, vec3(1.0), vFlash * 0.6);
+  gl_FragColor = vec4(c * a, a);
+}`;
+/**
+ * The ring: a star of another kind — a thin bright circle round a small
+ * core, so a plugin reads apart from the feeds around it.
+ */
+export const STAR_FRAGMENT_RING = `
+varying vec3 vTint;
+varying float vAlpha;
+varying float vFlash;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
+  if (d > 1.0) discard;
+  float ring = smoothstep(0.62, 0.72, d) * smoothstep(0.92, 0.82, d);
+  float core = smoothstep(0.28, 0.0, d);
+  float a = clamp(ring + core, 0.0, 1.0) * vAlpha;
+  gl_FragColor = vec4(mix(vTint, vec3(1.0), 0.35 + vFlash * 0.4), a);
+}`;
+/** The ember: an errored star drawn solid over the glow, so red stays red. */
+export const STAR_FRAGMENT_EMBER = `
+varying vec3 vTint;
+varying float vAlpha;
+varying float vFlash;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
+  if (d > 1.0) discard;
+  float a = smoothstep(1.0, 0.35, d) * vAlpha;
+  gl_FragColor = vec4(mix(vTint, vec3(1.0), vFlash * 0.6), a);
+}`;
+/**
+ * Builds one layer of stars — the glow or the embers — as one draw call.
+ * Each entry learns its slot in the layer.
+ *
+ * @param entries - The layer's stars.
+ * @param ember - Whether this is the ember layer (drawn solid, over the glow).
+ * @param layerIndex - The layer's index, recorded on each entry.
+ * @param pixelRatio - The display's pixel ratio, for the size floor and cap.
+ * @returns The layer, not yet added to anything.
+ */
+export function starLayer_make(entries, ember, layerIndex, pixelRatio, ring = false) {
+    const positions = new Float32Array(entries.length * 3);
+    const tints = new Float32Array(entries.length * 3);
+    const radii = new Float32Array(entries.length);
+    const alphas = new Float32Array(entries.length);
+    entries.forEach((entry, i) => {
+        entry.layer = layerIndex;
+        entry.slot = i;
+        positions.set([entry.position.x, entry.position.y, entry.position.z], i * 3);
+        tints.set([entry.color.r, entry.color.g, entry.color.b], i * 3);
+        radii[i] = entry.radius;
+        alphas[i] = entry.dim ? DIM_OPACITY * 1.5 : 1;
+    });
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute('tint', new THREE.BufferAttribute(tints, 3));
+    geometry.setAttribute('radius', new THREE.BufferAttribute(radii, 1));
+    const alpha = new THREE.BufferAttribute(alphas, 1);
+    geometry.setAttribute('alpha', alpha);
+    const flash = new THREE.BufferAttribute(new Float32Array(entries.length), 1);
+    geometry.setAttribute('flash', flash);
+    const material = new THREE.ShaderMaterial({
+        uniforms: { scale: { value: 1 }, floorPx: { value: STAR_FLOOR_PX * pixelRatio }, capPx: { value: STAR_CAP_PX * pixelRatio } },
+        vertexShader: STAR_VERTEX,
+        fragmentShader: ring ? STAR_FRAGMENT_RING : ember ? STAR_FRAGMENT_EMBER : STAR_FRAGMENT_GLOW,
+        transparent: true,
+        depthWrite: false,
+        blending: ember || ring ? THREE.NormalBlending : THREE.AdditiveBlending,
+    });
+    const points = new THREE.Points(geometry, material);
+    // Embers over the glow: drawn after it, whatever the sort says.
+    points.renderOrder = ring ? 3 : ember ? 2 : 1;
+    points.frustumCulled = false;
+    return { points, material, alpha, base: Float32Array.from(alphas), flash };
+}
+/**
+ * The stars' pixel scale for a canvas and a camera: pixels per unit of size
+ * at unit depth.
+ *
+ * @param heightPx - The canvas's height in device pixels.
+ * @param fovDeg - The camera's vertical field of view, in degrees.
+ * @returns The scale the star shader multiplies by.
+ */
+export function starScale_of(heightPx, fovDeg) {
+    return heightPx / (2 * Math.tan((fovDeg * Math.PI) / 360));
+}
+//# sourceMappingURL=stars.js.map

package/dist/draw/stars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stars.js","sourceRoot":"","sources":["../../src/draw/stars.ts"],"names":[],"mappings":"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"}

package/dist/draw/timing.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file The drawing's clock: how a wave steps down a graph, how long a pulse takes, how long a replay rests.
+ *
+ * @module
+ */
+/** Wave delay between one dependency tier firing and the next. */
+export declare const WAVE_STEP_MS: number;
+/** A pulse's trip along one tube; a live edge repeats it. */
+export declare const PULSE_TRIP_MS: number;
+/** The rest between two replays of a finished feed's run. */
+export declare const REPLAY_REST_MS: number;

package/dist/draw/timing.js

@@ -0,0 +1,12 @@
+/**
+ * @file The drawing's clock: how a wave steps down a graph, how long a pulse takes, how long a replay rests.
+ *
+ * @module
+ */
+/** Wave delay between one dependency tier firing and the next. */
+export const WAVE_STEP_MS = 450;
+/** A pulse's trip along one tube; a live edge repeats it. */
+export const PULSE_TRIP_MS = 1200;
+/** The rest between two replays of a finished feed's run. */
+export const REPLAY_REST_MS = 1800;
+//# sourceMappingURL=timing.js.map

package/dist/draw/timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.js","sourceRoot":"","sources":["../../src/draw/timing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,kEAAkE;AAClE,MAAM,CAAC,MAAM,YAAY,GAAW,GAAG,CAAC;AAExC,6DAA6D;AAC7D,MAAM,CAAC,MAAM,aAAa,GAAW,IAAI,CAAC;AAE1C,6DAA6D;AAC7D,MAAM,CAAC,MAAM,cAAc,GAAW,IAAI,CAAC"}

package/dist/draw/tubeField.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @file The tubes of every solid molecule, and the lamps its stages wear.
+ *
+ * A tube joins two solid spheres and carries a pulse from parent to child:
+ * into a live stage it streams, and the stage blinks with each pulse that
+ * lands; into a finished one it replays the run stage by stage in the order
+ * the stages ran, each stage dark until its pulse lands, flaring then and
+ * staying lit, the lot dimming before the next replay. A tube into a failed
+ * stage is red. A tube follows its spheres when one is pulled, and re-reads
+ * the states it carries when a stage starts or finishes.
+ *
+ * @module
+ */
+import * as THREE from 'three';
+import type { NodeState } from '../types/encoding.js';
+import type { Palette } from './palette.js';
+import { type TubeSpec } from './tubes.js';
+/**
+ * One node as the tubes read it.
+ *
+ * @property position - Where it stands.
+ * @property radius - Its sphere's radius.
+ * @property parents - The nodes it hangs from.
+ * @property joins - The nodes it joins from another branch.
+ * @property state - What it is doing.
+ */
+export interface TubeNode {
+    position: THREE.Vector3;
+    radius: number;
+    parents: ReadonlyArray<string>;
+    joins: ReadonlyArray<string>;
+    state: NodeState;
+}
+/**
+ * What holds a set of tubes: the field sets `tubes` to the mesh it draws
+ * for it, and draws them at the owner's `mix` (a molecule fading in).
+ */
+export interface TubeOwner {
+    tubes: THREE.InstancedMesh | null;
+    mix: number;
+}
+/** What the field needs to know of the scene it draws in. */
+export interface TubeFieldHost {
+    /** Where the tubes are drawn. */
+    parent: THREE.Object3D;
+    /** A node as the tubes read it, now. */
+    node(id: string): TubeNode | undefined;
+    /** A stage's sphere, for its lamp; undefined when it is not drawn solid. */
+    sphere(id: string): THREE.Mesh | undefined;
+    /** The colours, now. */
+    palette(): Palette;
+}
+/**
+ * A tube's pulse, by the state of the stage it runs into: it streams into a
+ * stage at work (1), replays into one that has run (2), rests otherwise (0).
+ *
+ * @param state - The stage's state.
+ * @returns The tube shader's mode.
+ */
+export declare function tubeMode_of(state: NodeState): number;
+/**
+ * The tubes of every solid molecule in a scene, and their lamps.
+ */
+export declare class TubeField {
+    private readonly host;
+    private sets;
+    private materials;
+    private glows;
+    private stale;
+    private census;
+    /**
+     * @param host - The scene the field draws in.
+     */
+    constructor(host: TubeFieldHost);
+    /** How many tube materials are live (one per set and one for a census). */
+    materialCount(): number;
+    /** How many job-to-job tubes the census drew; 0 when it drew lines. */
+    censusCount(): number;
+    /** Whether any set of tubes runs through a node. */
+    holds(id: string): boolean;
+    /** A stage under a set of tubes started or finished: its tubes are re-read next frame. */
+    stale_mark(): void;
+    /**
+     * Joins a molecule's solid spheres with tubes.
+     *
+     * @param owner - What holds the set; its `tubes` becomes the mesh.
+     * @param entries - The molecule's nodes, children of its tubes.
+     * @param members - The nodes whose spheres are solid: a tube runs only between two.
+     */
+    build(owner: TubeOwner, entries: ReadonlyArray<string>, members: ReadonlySet<string>): void;
+    /**
+     * Draws a census's job-to-job tubes: one mesh for all of them.
+     *
+     * @param specs - The tubes.
+     * @param deepest - The deepest stage the wave reaches, for the replay's cycle.
+     */
+    census_build(specs: ReadonlyArray<TubeSpec>, deepest: number): void;
+    /**
+     * Moves the tubes' clock on, re-reads states that changed, and lights the lamps.
+     *
+     * @param now - This frame's time.
+     */
+    frame(now: number): void;
+    /**
+     * Brings every tube to the spheres it joins, where they stand now: a
+     * pulled node drags its tubes with it.
+     */
+    follow(): void;
+    /**
+     * Lets one set of tubes go: its molecule is stars again.
+     *
+     * @param mesh - The set's mesh.
+     */
+    release(mesh: THREE.InstancedMesh): void;
+    /** Forgets everything: the scene is being redrawn (its parent already cleared). */
+    clear(): void;
+    /** Re-reads every set of tubes from the states as they are now. */
+    private restatus;
+    /**
+     * Lights a replayed molecule's stages on its tubes' clock: every stage
+     * starts the cycle dimmed, flares as its pulse lands and stays lit, and
+     * the lot dims again as the rest runs out — then the run replays.
+     */
+    private lamps_animate;
+    /**
+     * Paints one stage's lamp: its colour from dark to lit, and — while a
+     * pulse has just landed — a flash toward white and a glow that blooms
+     * out and settles.
+     */
+    private lamp_paint;
+}

package/dist/draw/tubeField.js

@@ -0,0 +1,352 @@
+/**
+ * @file The tubes of every solid molecule, and the lamps its stages wear.
+ *
+ * A tube joins two solid spheres and carries a pulse from parent to child:
+ * into a live stage it streams, and the stage blinks with each pulse that
+ * lands; into a finished one it replays the run stage by stage in the order
+ * the stages ran, each stage dark until its pulse lands, flaring then and
+ * staying lit, the lot dimming before the next replay. A tube into a failed
+ * stage is red. A tube follows its spheres when one is pulled, and re-reads
+ * the states it carries when a stage starts or finishes.
+ *
+ * @module
+ */
+import * as THREE from 'three';
+import { LAMP_BLOOM_MS, LAMP_BLOOM_REACH, LAMP_DIM, LAMP_FADE_MS, LAMP_WHITE } from './lamps.js';
+import { nebulaTexture_get } from './nebula.js';
+import { PULSE_TRIP_MS, REPLAY_REST_MS, WAVE_STEP_MS } from './timing.js';
+import { TUBE_FRAGMENT, TUBE_VERTEX, tubeGeometry_get, tubeMesh_make } from './tubes.js';
+/**
+ * A tube's pulse, by the state of the stage it runs into: it streams into a
+ * stage at work (1), replays into one that has run (2), rests otherwise (0).
+ *
+ * @param state - The stage's state.
+ * @returns The tube shader's mode.
+ */
+export function tubeMode_of(state) {
+    if (state === 'live')
+        return 1;
+    if (state === 'done' || state === 'failed')
+        return 2;
+    return 0;
+}
+/**
+ * The tubes of every solid molecule in a scene, and their lamps.
+ */
+export class TubeField {
+    host;
+    sets = [];
+    materials = [];
+    glows = new Map();
+    stale = false;
+    census = 0;
+    /**
+     * @param host - The scene the field draws in.
+     */
+    constructor(host) {
+        this.host = host;
+    }
+    /** How many tube materials are live (one per set and one for a census). */
+    materialCount() {
+        return this.materials.length;
+    }
+    /** How many job-to-job tubes the census drew; 0 when it drew lines. */
+    censusCount() {
+        return this.census;
+    }
+    /** Whether any set of tubes runs through a node. */
+    holds(id) {
+        return this.sets.some((set) => set.members.has(id));
+    }
+    /** A stage under a set of tubes started or finished: its tubes are re-read next frame. */
+    stale_mark() {
+        this.stale = true;
+    }
+    /**
+     * Joins a molecule's solid spheres with tubes.
+     *
+     * @param owner - What holds the set; its `tubes` becomes the mesh.
+     * @param entries - The molecule's nodes, children of its tubes.
+     * @param members - The nodes whose spheres are solid: a tube runs only between two.
+     */
+    build(owner, entries, members) {
+        const opacity = owner.mix;
+        const palette = this.host.palette();
+        const edges = [];
+        for (const id of entries) {
+            const child = this.host.node(id);
+            if (child === undefined)
+                continue;
+            for (const parentId of child.parents) {
+                const parent = this.host.node(parentId);
+                if (parent !== undefined && members.has(parentId))
+                    edges.push({ fromId: parentId, from: parent, toId: id, to: child, join: false });
+            }
+            for (const parentId of child.joins) {
+                const parent = this.host.node(parentId);
+                if (parent !== undefined && members.has(parentId))
+                    edges.push({ fromId: parentId, from: parent, toId: id, to: child, join: true });
+            }
+        }
+        if (edges.length === 0)
+            return;
+        // A stage's depth in its molecule: the wave reaches it that many steps in.
+        const depth = new Map();
+        const depth_of = (id, seen = new Set()) => {
+            const known = depth.get(id);
+            if (known !== undefined)
+                return known;
+            if (seen.has(id))
+                return 0;
+            seen.add(id);
+            const node = this.host.node(id);
+            const parents = node === undefined ? [] : [...node.parents, ...node.joins].filter((p) => members.has(p));
+            const d = parents.length === 0 ? 0 : 1 + Math.max(...parents.map((p) => depth_of(p, seen)));
+            depth.set(id, d);
+            return d;
+        };
+        const now = performance.now();
+        const colors = new Float32Array(edges.length * 3);
+        const modes = new Float32Array(edges.length);
+        const starts = new Float32Array(edges.length);
+        const bright = palette.edge.clone().lerp(new THREE.Color('#ffffff'), 0.45);
+        const mesh = new THREE.InstancedMesh(tubeGeometry_get(), new THREE.ShaderMaterial({
+            uniforms: { time: { value: now }, opacity: { value: opacity }, born: { value: now }, cycle: { value: 1 } },
+            vertexShader: TUBE_VERTEX,
+            fragmentShader: TUBE_FRAGMENT,
+            transparent: true,
+        }), edges.length);
+        const up = new THREE.Vector3(0, 1, 0);
+        const carrier = new THREE.Object3D();
+        let deepest = 0;
+        const set = [];
+        // A replayed stage lights when its pulse arrives: the root at once,
+        // every other stage as the first tube into it lands.
+        const lamps = new Map();
+        // A running stage blinks with the stream: lit each time a pulse lands,
+        // dark again before the next, until it is done.
+        const blinks = new Set();
+        edges.forEach(({ fromId, from, toId, to, join }, i) => {
+            const along = to.position.clone().sub(from.position);
+            const length = along.length();
+            // Thick enough to read as a tube, not a hairline, at the molecule's framing.
+            const width = Math.max(0.06, Math.min(from.radius, to.radius) * 0.34);
+            carrier.position.copy(from.position).addScaledVector(along, 0.5);
+            carrier.quaternion.setFromUnitVectors(up, length > 0 ? along.clone().divideScalar(length) : up);
+            carrier.scale.set(width, length, width);
+            carrier.updateMatrix();
+            mesh.setMatrixAt(i, carrier.matrix);
+            set.push({ from: fromId, to: toId, width });
+            const color = to.state === 'failed' ? palette.error : join ? palette.join : bright;
+            colors.set([color.r, color.g, color.b], i * 3);
+            modes[i] = tubeMode_of(to.state);
+            const d = depth_of(fromId);
+            deepest = Math.max(deepest, d);
+            starts[i] = d * WAVE_STEP_MS;
+            if (modes[i] === 1)
+                blinks.add(toId);
+            if (modes[i] === 2) {
+                const landed = starts[i] + PULSE_TRIP_MS / 2;
+                lamps.set(toId, Math.min(lamps.get(toId) ?? Infinity, landed));
+                if (d === 0)
+                    lamps.set(fromId, 0);
+            }
+        });
+        mesh.instanceMatrix.needsUpdate = true;
+        // Instanced attributes ride a clone of the shared tube, so each
+        // molecule's tubes carry their own colours and pulses.
+        const geometry = tubeGeometry_get().clone();
+        geometry.setAttribute('aColor', new THREE.InstancedBufferAttribute(colors, 3));
+        geometry.setAttribute('aMode', new THREE.InstancedBufferAttribute(modes, 1));
+        geometry.setAttribute('aStart', new THREE.InstancedBufferAttribute(starts, 1));
+        mesh.geometry = geometry;
+        mesh.frustumCulled = false;
+        this.host.parent.add(mesh);
+        owner.tubes = mesh;
+        if (mesh.material instanceof THREE.ShaderMaterial) {
+            this.materials.push(mesh.material);
+            const cycle = mesh.material.uniforms['cycle'];
+            if (cycle !== undefined)
+                cycle.value = (deepest + 1) * WAVE_STEP_MS + PULSE_TRIP_MS / 2 + REPLAY_REST_MS;
+        }
+        this.sets.push({ mesh, edges: set, lamps, blinks, owner, entries, members });
+    }
+    /**
+     * Draws a census's job-to-job tubes: one mesh for all of them.
+     *
+     * @param specs - The tubes.
+     * @param deepest - The deepest stage the wave reaches, for the replay's cycle.
+     */
+    census_build(specs, deepest) {
+        if (specs.length === 0)
+            return;
+        const mesh = tubeMesh_make(specs, (deepest + 1) * WAVE_STEP_MS + PULSE_TRIP_MS / 2 + REPLAY_REST_MS);
+        this.host.parent.add(mesh);
+        if (mesh.material instanceof THREE.ShaderMaterial)
+            this.materials.push(mesh.material);
+        this.census = specs.length;
+    }
+    /**
+     * Moves the tubes' clock on, re-reads states that changed, and lights the lamps.
+     *
+     * @param now - This frame's time.
+     */
+    frame(now) {
+        if (this.materials.length === 0)
+            return;
+        for (const material of this.materials) {
+            const time = material.uniforms['time'];
+            if (time !== undefined)
+                time.value = now;
+        }
+        if (this.stale)
+            this.restatus();
+        this.lamps_animate(now);
+    }
+    /**
+     * Brings every tube to the spheres it joins, where they stand now: a
+     * pulled node drags its tubes with it.
+     */
+    follow() {
+        const up = new THREE.Vector3(0, 1, 0);
+        const carrier = new THREE.Object3D();
+        for (const { mesh, edges } of this.sets) {
+            edges.forEach(({ from, to, width }, i) => {
+                const a = this.host.sphere(from);
+                const b = this.host.sphere(to);
+                if (a === undefined || b === undefined)
+                    return;
+                const along = b.position.clone().sub(a.position);
+                const length = along.length();
+                carrier.position.copy(a.position).addScaledVector(along, 0.5);
+                carrier.quaternion.setFromUnitVectors(up, length > 0 ? along.clone().divideScalar(length) : up);
+                carrier.scale.set(width, length, width);
+                carrier.updateMatrix();
+                mesh.setMatrixAt(i, carrier.matrix);
+            });
+            mesh.instanceMatrix.needsUpdate = true;
+        }
+    }
+    /**
+     * Lets one set of tubes go: its molecule is stars again.
+     *
+     * @param mesh - The set's mesh.
+     */
+    release(mesh) {
+        this.host.parent.remove(mesh);
+        this.sets = this.sets.filter((set) => set.mesh !== mesh);
+        mesh.geometry.dispose();
+        if (mesh.material instanceof THREE.ShaderMaterial) {
+            const material = mesh.material;
+            this.materials = this.materials.filter((m) => m !== material);
+            material.dispose();
+        }
+    }
+    /** Forgets everything: the scene is being redrawn (its parent already cleared). */
+    clear() {
+        this.materials = [];
+        this.census = 0;
+        this.sets = [];
+        for (const glow of this.glows.values())
+            glow.material.dispose();
+        this.glows = new Map();
+    }
+    /** Re-reads every set of tubes from the states as they are now. */
+    restatus() {
+        this.stale = false;
+        const stale = this.sets;
+        this.sets = [];
+        for (const set of stale) {
+            this.host.parent.remove(set.mesh);
+            set.mesh.geometry.dispose();
+            if (set.mesh.material instanceof THREE.ShaderMaterial) {
+                const material = set.mesh.material;
+                this.materials = this.materials.filter((m) => m !== material);
+                material.dispose();
+            }
+            set.owner.tubes = null;
+            this.build(set.owner, set.entries, set.members);
+        }
+        this.follow();
+    }
+    /**
+     * Lights a replayed molecule's stages on its tubes' clock: every stage
+     * starts the cycle dimmed, flares as its pulse lands and stays lit, and
+     * the lot dims again as the rest runs out — then the run replays.
+     */
+    lamps_animate(now) {
+        const shown = new Set();
+        for (const { mesh: tubes, lamps, blinks } of this.sets) {
+            if ((lamps.size === 0 && blinks.size === 0) || !(tubes.material instanceof THREE.ShaderMaterial))
+                continue;
+            const born = Number(tubes.material.uniforms['born']?.value ?? now);
+            const cycle = Number(tubes.material.uniforms['cycle']?.value ?? 1);
+            const local = (((now - born) % cycle) + cycle) % cycle;
+            // Out of the cycle's last stretch every lamp fades back down.
+            const fade = Math.min(1, Math.max(0, (cycle - local) / LAMP_FADE_MS));
+            for (const [id, landed] of lamps) {
+                const since = local - landed;
+                this.lamp_paint(id, since < 0 ? 0 : fade, since >= 0 && since < LAMP_BLOOM_MS ? since / LAMP_BLOOM_MS : -1, shown);
+            }
+            // The stream's pulse lands every trip; a running stage flares then
+            // and dies back toward dark.
+            const trip = ((now % PULSE_TRIP_MS) + PULSE_TRIP_MS) % PULSE_TRIP_MS;
+            for (const id of blinks) {
+                if (lamps.has(id))
+                    continue;
+                const decay = Math.max(0, 1 - trip / (PULSE_TRIP_MS * 0.8));
+                this.lamp_paint(id, decay * decay, trip < LAMP_BLOOM_MS ? trip / LAMP_BLOOM_MS : -1, shown);
+            }
+        }
+        for (const [id, glow] of this.glows) {
+            if (shown.has(id))
+                continue;
+            glow.visible = false;
+            if (this.host.sphere(id) === undefined) {
+                this.host.parent.remove(glow);
+                glow.material.dispose();
+                this.glows.delete(id);
+            }
+        }
+    }
+    /**
+     * Paints one stage's lamp: its colour from dark to lit, and — while a
+     * pulse has just landed — a flash toward white and a glow that blooms
+     * out and settles.
+     */
+    lamp_paint(id, lit, bloom, shown) {
+        const sphere = this.host.sphere(id);
+        if (sphere === undefined || !(sphere.material instanceof THREE.MeshStandardMaterial))
+            return;
+        let base = sphere.userData['lampBase'];
+        if (!(base instanceof THREE.Color)) {
+            base = sphere.material.color.clone();
+            sphere.userData['lampBase'] = base;
+        }
+        const flash = bloom < 0 ? 0 : (1 - bloom) ** 2;
+        sphere.material.color
+            .copy(base)
+            .multiplyScalar(LAMP_DIM + (1 - LAMP_DIM) * Math.max(lit, flash))
+            .lerp(LAMP_WHITE, Math.min(1, 0.22 * lit + 0.7 * flash));
+        if (bloom < 0)
+            return;
+        let glow = this.glows.get(id);
+        if (glow === undefined) {
+            glow = new THREE.Sprite(new THREE.SpriteMaterial({
+                map: nebulaTexture_get(), color: base.clone().lerp(LAMP_WHITE, 0.35),
+                transparent: true, blending: THREE.AdditiveBlending, depthWrite: false,
+            }));
+            this.glows.set(id, glow);
+            this.host.parent.add(glow);
+        }
+        const radius = sphere.geometry.parameters?.radius ?? 0.55;
+        // Out fast, then settle: the glow swells to its reach and fades.
+        const swell = 1 - (1 - bloom) ** 3;
+        glow.position.copy(sphere.position);
+        glow.scale.setScalar(radius * (2 + LAMP_BLOOM_REACH * swell) * sphere.scale.x);
+        glow.material.opacity = 0.9 * (1 - bloom) ** 1.5;
+        glow.visible = true;
+        shown.add(id);
+    }
+}
+//# sourceMappingURL=tubeField.js.map