@mkbabb/glass-ui 4.2.0 → 5.0.0

package/dist/components/custom/dock/constants.d.ts

@@ -1,98 +0,0 @@
-import type { Component } from "vue";
-/**
- * BC.W-DOCK-STACK-RAIL — one `<DockStack>` member descriptor: a stack member that fans
- * OUT of the macOS hover-expand stack (id + label + glyph + optional select handler).
- * A `<script setup>` SFC cannot re-export a named type through the `export { default }`
- * barrel, so the descriptor lives here (the colocated types home) and the SFC imports
- * it; the barrel re-exports it for consumers typing their `items` array. This is the
- * stack's MEMBER, not a facet chip — the divider-carousel `DockRailItem` is RETIRED
- * (clean break, no alias).
- */
-export interface DockStackItem {
-    /** Stable identifier — the `v-for` key + the selected-member id. */
-    id: string;
-    /** The member's accessible label (the `aria-label` + tooltip). */
-    label: string;
-    /** The member glyph (a `@lucide/vue` icon or any component). */
-    icon?: Component;
-    /** Optional per-member select handler (fired alongside the model write). */
-    onSelect?: () => void;
-    /**
-     * BE.W-DOCK-RAIL-REALIZE — the per-FACET accent hue (the `mode="facets"` context
-     * carousel only — IGNORED by the macOS `mode="stack"` glyph fan). A complete
-     * `<color>` (a consumer DATA/context hue) written to the chip's `--glass-accent`
-     * (the BB.W-GLASS-ACCENT per-instance chromatic-rim axis, `rim.css`/`material.css`),
-     * so each context facet carries its OWN rim+glint hue — the AZ context-carousel
-     * identity. Unset ⇒ the neutral warm-cream rim (the `--glass-accent: transparent`
-     * no-op floor). NOT a plate-background fill (the accent rides the THIN rim/glint;
-     * presets-in-consumers — no consumer hue enters a library token).
-     */
-    accent?: string;
-}
-/**
- * BA.W-DOCK-SECTIONS — the three named zone kinds the declarative `<DockSection>`
- * descriptor renders (the R8-9 "rail core + sections + nav" three-zone gestalt):
- *   - `"rail-core"` — the leading home/brand region (the ℱ wordmark / category trigger).
- *   - `"section"`   — a named, divider-demarcated group of controls; a section
- *                     carrying `layers` composes the existing `DockLayerGroup`/`DockLayer`
- *                     registry (NOT a parallel layer machine).
- *   - `"nav"`       — the trailing nav arrows / utility group.
- */
-export type DockSectionKind = "rail-core" | "section" | "nav";
-/**
- * BA.W-DOCK-SECTIONS — one declarative section descriptor. A consumer passes
- * `sections: readonly DockSectionDescriptor[]` to `<DockSection>` and the dock body
- * renders the tripartite silhouette (rail-core | divided named sections | nav)
- * demarcated by `<DockSeparator>` — the IG-A3 / R8-9 "abstract this into a re-usable
- * component for layering" library gap. A `<script setup>` SFC cannot re-export a named
- * type through its default barrel, so the descriptor lives here (the colocated types
- * home, beside `DockRailItem`) and `DockSection.vue` imports it; the barrel re-exports
- * it for consumers typing their `sections` array.
- */
-export interface DockSectionDescriptor {
-    /** Which of the three zone kinds this descriptor renders. */
-    kind: DockSectionKind;
-    /** Stable identifier — the `v-for` key + the layer-context id for a `section`. */
-    id: string;
-    /** Optional accessible label for the grouped zone. */
-    label?: string;
-    /**
-     * For a `section` kind: the stack members this section carries. When present
-     * (length > 1) the members ride the dock's `#rail` stack (the macOS hover-expand
-     * stack, OUTSIDE the dock box — never re-inflating it). The descriptor names them;
-     * `<DockStack :items>` fans them out.
-     */
-    layers?: readonly DockStackItem[];
-}
-/**
- * The ONE dock-morph spring authority — the iOS-26 interruptible-physics tuning the
- * dock's single `SpringProgress` orchestrator (`dockMorphContext.ts`) AND the
- * `useLayerTransition` engine both read. Co-located here so the `response`/`damping`
- * pair is defined ONCE rather than duplicated at the top of each composable (the two
- * prior copies were a DRY hazard — a re-tune had to touch both).
- */
-export declare const DOCK_SPRING: {
-    readonly response: number;
-    readonly dampingFraction: number;
-};
-/**
- * The CSS properties whose `transitionend` the dock-morph window watches to know a
- * resize-morph has settled (`useDockMorphWindow.ts`). A `transitionend` on any other
- * property is ignored.
- */
-export declare const RESIZE_MORPH_PROPS: Set<string>;
-/** `Symbol()` label for the `DockContext` injection key (`dockContext.ts`). */
-export declare const DOCK_CONTEXT_LABEL = "glass-ui:dock-context";
-/** `Symbol()` label for the `DockLayerGroupContext` injection key (`dockLayerContext.ts`). */
-export declare const DOCK_LAYER_GROUP_LABEL = "glass-ui:dock-layer-group";
-/** `Symbol()` label for the `DockMorphContext` injection key (`dockMorphContext.ts`). */
-export declare const DOCK_MORPH_LABEL = "glass-ui:dock-morph-context";
-/** AZ.W-DOCK-FLICKER — the hover-hysteresis tuning pair (useDockState).
- *  HOVER_INTENT_MS: the intent-dwell before a collapsed→hover expand commits
- *  (a sweeping-edge enter is canceled by the chasing leave inside this window).
- *  EDGE_BAND_PX: the morphing-edge-sweep recheck band — a mid-morph leave with
- *  the pointer still inside (within this band of the moving edge) is the box
- *  edge sweeping past the cursor, not a real exit. */
-export declare const HOVER_INTENT_MS = 60;
-export declare const EDGE_BAND_PX = 24;
-export declare const MORPH_SETTLE_MS = 840;

package/dist/components/custom/dock/index.d.ts

@@ -1,24 +0,0 @@
-export { default as GlassDock } from "./GlassDock.vue";
-export { default as DockLayerGroup } from "./DockLayerGroup.vue";
-export { default as DockLayer } from "./DockLayer.vue";
-export { default as DockIconButton } from "./DockIconButton.vue";
-export { default as DockBackgroundToggle } from "./DockBackgroundToggle.vue";
-export { default as DockTabButton } from "./DockTabButton.vue";
-export { default as DockSelectTrigger } from "./DockSelectTrigger.vue";
-export { default as DockDropdownTrigger } from "./DockDropdownTrigger.vue";
-export { default as DockPopoverTrigger } from "./DockPopoverTrigger.vue";
-export { default as DockSeparator } from "./DockSeparator.vue";
-export { default as DockStack } from "./DockStack.vue";
-export type { DockStackItem } from "./constants";
-export { default as DockSection } from "./DockSection.vue";
-export type { DockSectionDescriptor, DockSectionKind } from "./constants";
-export type { UseDockStateOptions, UseDockStateReturn, DockState } from "./composables";
-export { useLayerTransition } from "./composables";
-export type { UseLayerTransitionOptions, UseLayerTransitionReturn, } from "./composables";
-export { DOCK_CONTEXT_KEY, useDockContext, useOptionalDockContext, provideDockContext, type DockContext, type DockOrientation, type DockLayout, } from "./composables/dockContext";
-export { useDockOrientationMorph, type DockMorphOrientation, type UseDockOrientationMorphOptions, type UseDockOrientationMorphReturn, } from "./composables/useDockOrientationMorph";
-export { useDockCtaReceive, type UseDockCtaReceiveOptions, type UseDockCtaReceiveReturn, type DockCtaReceivePreset, } from "../../../composables/motion/useDockCtaReceive";
-export { useDockSearch } from "./composables";
-export type { UseDockSearchOptions, UseDockSearchReturn } from "./composables";
-export { GooFilter } from "../goo-filter";
-export { useDockFission, DOCK_SPLIT_SIGNATURES, type DockSplitContext, type DockSplitVector, type DockSplitSquishPeak, type DockSplitSignature, type DockFissionPieceRegistration, type DockFissionPieceHandle, type UseDockFissionOptions, type UseDockFissionReturn, } from "./composables/useDockFission";

package/dist/components/custom/dot-flow-field/DotFlowField.vue.d.ts

@@ -1,42 +0,0 @@
-import type { FlowFieldConfig } from "./constants";
-/**
- * DotFlowField — a calm anchored dot-matrix a slow LARGE wave sweeps through
- * (BC.W-VIZ-DOTFLOW retopology — NOT the BB free-advecting particle cloud).
- *
- * Each dot is anchored to a deterministic lattice cell and eases toward its sub-cell
- * displacement target with a restoring spring (no advection, no re-seed); a broad
- * bright iso-band sweeps the lattice, lighting the dots it passes — the low-frequency
- * Gerstner/Tessendorf sum-of-sines height (`composables/flowField.ts`). WebGPU-FIRST:
- * the compute pass pulls the lattice to its target, the render pass draws instanced
- * billboard quads lit by the sweeping band; a pure WebGL2 FRAGMENT fallback evaluates
- * the SAME field where WebGPU is absent (no Canvas2D — the §E "no canvas" mandate). It
- * composes `useDotFlowField` → the `createGpuSubstrate` picker over the ONE canvas
- * lifecycle leaf (offscreen-pause, live-PRM freeze, the shared pointer field) — it never
- * bootstraps its own context.
- *
- * The DEFAULT palette is the warm-cream library identity; the mono-dim-on-near-black
- * reference + the globe mask are DEMO presets (presets-in-consumers — never a library
- * token). The teal-on-navy is GONE entirely (clean break).
- */
-type __VLS_Props = {
-    /** The full author schema (the studio's `useConfiguratorState` model). */
-    config?: FlowFieldConfig;
-    /**
-     * The declarative WCAG-2.2.2 pause seam. `v-model:paused` parks the render loop
-     * (the substrate's `manual` suspend) when `true`. Wire `<DockBackgroundToggle>`'s
-     * `@update:paused` to this `v-model`.
-     */
-    paused?: boolean;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    pause: () => void;
-    resume: () => void;
-    wake: () => void;
-    renderAt: (timeSec: number) => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:paused": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:paused"?: ((value: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/components/custom/dot-flow-field/composables/flowField.d.ts

@@ -1,104 +0,0 @@
-/** A 2-vector. */
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-/**
- * One Gerstner / Tessendorf wave component. `amplitude` A_i, `wavelength` λ_i (so
- * k_i = 2π/λ_i), `direction` in DEGREES (the unit travel direction), `phase` φ_i.
- * `ω_i = √(g·k_i)` is derived from the dispersion relation, not stored.
- */
-export interface WaveComponent {
-    amplitude: number;
-    wavelength: number;
-    /** Travel direction in degrees (0 = +x). */
-    direction: number;
-    phase: number;
-}
-/** Deep-water gravity constant (normalized; scales the dispersion ω). */
-export declare const FLOW_GRAVITY = 9.81;
-/**
- * The Gerstner-sum velocity v(p,t) = ∇⊥h = (∂h/∂y, −∂h/∂x), ANALYTIC. The single
- * math source the WGSL kernel transcribes. `windSpeed` scales the dispersion ω;
- * `windDirection` (deg) is folded into each component's direction by the caller (the
- * components carry their own absolute direction). Returns the un-normalized flow vector.
- */
-export declare function gerstnerVelocity(p: Vec2, timeSec: number, waves: readonly WaveComponent[], windSpeed: number): Vec2;
-/** The 2D curl of the scalar fbm potential (the JS twin of `curlFBM`). */
-export declare function curlFBM(p: Vec2): Vec2;
-/**
- * The COMPOSITE flow velocity v(p,t): the Gerstner sum-of-sines analytic ∇⊥h PLUS the
- * `curlStrength`-weighted fbm curl-noise braiding term. The SINGLE math source the WGSL
- * compute kernel transcribes; `proof:viz-dotflow` clause F3 round-trips the two paths.
- *
- * RETOPOLOGY (BC.W-VIZ-DOTFLOW). The curl domain-scale dropped 1.7→0.55 (coarse braiding,
- * not fine chatter) per the §3.2 regime inversion. The velocity is no longer an advection
- * integrand (the lattice does not advect) — it is the DISPLACEMENT field's perp-gradient
- * source. `sampleDisplacement` is the per-frame sub-cell offset; `sampleVelocity` stays as
- * the round-trip anchor + the analytic ∇⊥h the displacement reads.
- */
-export declare function sampleVelocity(p: Vec2, timeSec: number, waves: readonly WaveComponent[], windSpeed: number, curlStrength: number): Vec2;
-/** The cursor-vortex lever set (the √φ-laddered radius + the spin/drag/burst gains). */
-export interface VortexParams {
-    cursor: Vec2;
-    /** Pointer velocity (domain units / sec). */
-    pointerVel: Vec2;
-    /** Flick-burst impulse 0..1. */
-    burst: number;
-    /** Pointer active? (inert when false — the vortex is off). */
-    active: boolean;
-    radius: number;
-    spin: number;
-    dragGain: number;
-    burstShove: number;
-}
-/**
- * The velocity the cursor injects at `p` — the perturbation `cs_flow` adds to the curl
- * current. A true tangential vortex (∇⊥ of the radial), plus a drag-along (the streamlines
- * follow the gesture) and a radial flick shove (the shockwave), all gaussian-falling off the
- * vortex radius. Returns the un-normalized perturbation in domain/sec.
- */
-export declare function pointerVortex(p: Vec2, v: VortexParams): Vec2;
-/** The shipped domain half-extent (the lattice is laid out over [-half, half]²). */
-export declare const FLOW_DOMAIN_HALF = 0.85;
-/**
- * The deterministic lattice origin for a particle index — the WGSL `instance_index →
- * origin` mapping matches this EXACTLY (the F3 round-trip anchor). `cols` columns, square
- * pitch in DOMAIN units; the grid is centered on the origin so the field reads symmetric.
- * Index `i` walks row-major (`col = i % cols`, `row = floor(i / cols)`).
- */
-export declare function gridOrigin(index: number, cols: number, pitch: number): Vec2;
-/**
- * The scalar Gerstner HEIGHT at an origin — the brightness driver (the moving bright
- * stripe the lattice paints). `h(o,t) = Σ_i A_i·sin(k_i·(D_i·o) − ω_i·t + φ_i)`, the SAME
- * sum the velocity derives from (no second wave table). The brightness field reads at the
- * ANCHOR (`o`), not the live position, so the sweep is stable + low-frequency.
- */
-export declare function sampleHeight(o: Vec2, timeSec: number, waves: readonly WaveComponent[], windSpeed: number): number;
-/**
- * The sub-cell DISPLACEMENT for an origin — the divergence-free ∇⊥h (the Gerstner perp-
- * gradient) PLUS a faint coarse curl break. The dot eases toward `o + disp·displaceAmp`
- * (the restoring spring lives in the kernel); this is the target offset, NOT an advection
- * step. Capped LOW by `displaceAmp` so the dot never leaves its cell by > ~0.5 pitch.
- */
-export declare function sampleDisplacement(o: Vec2, timeSec: number, waves: readonly WaveComponent[], windSpeed: number, curlStrength: number): Vec2;
-/**
- * The sweeping bright-stripe band: a `smoothstep` band centered `center` width `width`
- * over the normalized height — the moving iso-band that lights the dots it passes. The
- * band is symmetric about the center (a soft ridge crossing the lattice as `h` sweeps).
- */
-export declare function waveBand(h: number, center: number, width: number): number;
-/**
- * Build the wave ladder about a dominant wind direction. BC.W-VIZ-DOTFLOW REGIME
- * INVERSION (research/viz/dot-flow-field.md §3.2): the LOW-frequency coherent regime — a
- * LARGE base wavelength (≈½–1 period across the view → ONE dominant sweeping wave), 2-3
- * octaves (no fine chatter), a steep amplitude persistence (×0.38 → the base wave
- * dominates, detail a whisper), the λ falloff floored so the finest λ ≥ ~⅓ view. The
- * directions spread MODESTLY about `windDirection` (the sweep reads as ONE coherent form,
- * not a braided delta).
- *
- * `lambda0Mul` is λ₀ as a MULTIPLE of the domain extent (default 2.5 — the §1 target);
- * `octaves` is 2-3 (the coherent band). Amplitudes follow the Phillips falloff × the
- * per-octave persistence so the field stays energy-realistic.
- */
-export declare function buildWaveLadder(windDirection: number, octaves?: number, lambda0Mul?: number): WaveComponent[];

package/dist/components/custom/dot-flow-field/composables/flowGLProgram.d.ts

@@ -1,8 +0,0 @@
-export declare function compileGL(gl: WebGL2RenderingContext, type: number, src: string): WebGLShader;
-export declare function linkGL(gl: WebGL2RenderingContext, vsSrc: string, fsSrc: string): WebGLProgram;
-/** Probe whether an internal format is color-renderable as a float FBO target (R-A). */
-export declare function probeRenderable(gl: WebGL2RenderingContext, internal: number, type: number): boolean;
-/** Pack a Float32Array to half-float (RGBA16F upload) — the RGBA32F-absent fallback (R-A). */
-export declare function float32ToHalf(src: Float32Array): Uint16Array;
-/** IEEE-754 float32 → float16 bits (the standard round-to-nearest packing). */
-export declare function f32ToF16(val: number): number;

package/dist/components/custom/dot-flow-field/composables/flowSetupGL.d.ts

@@ -1,9 +0,0 @@
-import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
-import { type FlowSetupDeps } from "./useFlowParticles";
-/**
- * Build the `setupGL(gl)` callback the picker invokes on the WebGL2 path (the LIVE path).
- * `field` is the kept fullscreen-fragment dot-lattice; `flow` routes to the state-texture
- * GPGPU + two-FBO trail + point-sprite motes + present composite (flowSetupGLFlow) — the SAME
- * advected-population gestalt as the WGPU compute path (the ONE math source via the GLSL chunk).
- */
-export declare function createFlowGLSetup(deps: FlowSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/dot-flow-field/composables/flowSetupGLFlow.d.ts

@@ -1,12 +0,0 @@
-import type { WebGLCanvasFrame } from "../../../../composables/glass/webgl/useWebGLCanvas";
-import { type FlowSetupDeps } from "./useFlowParticles";
-/**
- * The `flow` WebGL2 channel — the AURORA CURRENT, made real + measurable + equal-gestalt:
- *   1. STATE-TEXTURE GPGPU advect pass (one texel per mote; pos/speed/life ping-pong),
- *   2. TRAIL decay-blit (prev → cur at the derived α) on a two-FBO RGBA16F ping-pong,
- *   3. MOTE point-sprite draw (additive into the trail; speed→hue/brightness),
- *   4. PRESENT composite (trail over the warm floor + corner-bloom → the swapchain).
- * The float state/trail RTs fall RGBA32F→RGBA16F where the render extension is absent (R-A);
- * the trail is pinned NEAREST (no half-float-linear extension dependency).
- */
-export declare function createFlowGLFlow(deps: FlowSetupDeps): (gl: WebGL2RenderingContext) => WebGLCanvasFrame;

package/dist/components/custom/dot-flow-field/composables/flowSetupWGPU.d.ts

@@ -1,7 +0,0 @@
-import type { WebGPUCanvasFrame } from "../../../../composables/glass/webgpu/useWebGPUCanvas";
-import { type FlowSetupDeps } from "./useFlowParticles";
-/**
- * Build the dot-flow-field `setupWGPU(device, context, format)` callback. Closes over the
- * config/palette getters + the renderer's demand gate + the pointer `onFrame`/`getPointer`.
- */
-export declare function createFlowWGPUSetup(deps: FlowSetupDeps): (device: GPUDevice, context: GPUCanvasContext, format: GPUTextureFormat) => WebGPUCanvasFrame;

package/dist/components/custom/dot-flow-field/composables/uniformBridgeWGPU.d.ts

@@ -1,65 +0,0 @@
-import type { OklchStop } from "../../../../composables/color";
-import { type FlowFieldConfig } from "../constants";
-/** The domain half-extent (the lattice spans [-half, half]²; mirrors flowField.ts). */
-export declare const FLOW_DOMAIN_HALF = 0.85;
-export interface FlowGridGeometry {
-    cols: number;
-    count: number;
-    /** The lattice pitch in DOMAIN units (the px pitch mapped to the domain). */
-    pitchDomain: number;
-}
-/** Compile-time lattice cap (mirrors the WGSL storage-buffer array bound). */
-export declare const FLOW_MAX_LATTICE = 16384;
-export declare function flowGridGeometry(gridPitchPx: number, canvasCssMin: number): FlowGridGeometry;
-export declare const FLOW_COMPUTE_UNIFORM_BYTES: number;
-/** The live pointer/vortex state the renderer feeds the compute kernel each frame. */
-export interface FlowPointerState {
-    /** Cursor in domain space ([-half,half]²). */
-    cursorX: number;
-    cursorY: number;
-    /** Pointer velocity in domain units / sec. */
-    velX: number;
-    velY: number;
-    /** Flick-burst impulse (0..1). */
-    burst: number;
-    /** Pointer active (1) / inert (0). */
-    active: number;
-}
-/** A rest (pointer-inert) state — the vortex is off. */
-export declare const FLOW_POINTER_REST: FlowPointerState;
-export interface FlowUniformScratch {
-    buffer: ArrayBuffer;
-    f32: Float32Array;
-    i32: Int32Array;
-}
-export declare function createFlowComputeScratch(): FlowUniformScratch;
-/** Pack the compute uniforms in place. `count` is the live mote/lattice count (flow mode
- *  uses particleCount; field mode uses the lattice geometry count). */
-export declare function packFlowComputeUniforms(scratch: FlowUniformScratch, config: FlowFieldConfig, timeSec: number, dt: number, geometry: FlowGridGeometry, count: number, pointer?: FlowPointerState): FlowUniformScratch;
-export declare const FLOW_RENDER_UNIFORM_BYTES: number;
-/** The speed normalizer (the modal mote speed maps to the ramp MIDDLE — H2: so the full
- *  ember→gold→white spread paints, not a unimodal-amber blowout). */
-export declare const FLOW_SPEED_NORM = 0.022;
-export declare function createFlowRenderScratch(): FlowUniformScratch;
-/** The base resting brightness (the calm-lattice floor before the band lights a dot). */
-export declare const FLOW_BASE_BRIGHT = 0.22;
-/** The drift-driven size pulse (a subtle breathing; never a re-seed). */
-export declare const FLOW_SIZE_PULSE = 0.4;
-/** Pack the render uniforms in place. */
-export declare function packFlowRenderUniforms(scratch: FlowUniformScratch, config: FlowFieldConfig, timeSec: number, aspect: number, canvasCssMin: number, geometry: FlowGridGeometry, palette: OklchStop[]): FlowUniformScratch;
-/** The byte size of one lattice dot in the storage buffer (vec4<f32>). */
-export declare const FLOW_PARTICLE_BYTES = 16;
-/**
- * Seed the lattice storage buffer: each dot starts AT its anchor origin (the restoring
- * spring needs no initial offset). `(pos.x, pos.y, height=0, |disp|=0)` per index — the
- * compute kernel re-derives the origin from `gridOrigin(index, cols, pitch)` each frame,
- * so the seed only needs the starting position (the lattice settles on the first frames).
- */
-export declare function seedLatticeBuffer(geometry: FlowGridGeometry): Float32Array;
-/**
- * BD.W-DOTFLOW-AURORA-CURRENT — seed the FLOW mote buffer: each mote scattered across the
- * domain, life STAGGERED across [0, lifetimeSec) so deaths/respawns don't synchronize (the
- * field never blinks). `(pos.x, pos.y, speed=0, life)` per index. A deterministic hash so
- * the capture path reproduces.
- */
-export declare function seedFlowBuffer(count: number, lifetimeSec: number): Float32Array;

package/dist/components/custom/dot-flow-field/composables/useDotFlowField.d.ts

@@ -1,35 +0,0 @@
-import { type Ref } from "vue";
-import { type GpuBackend } from "../../../../composables/glass/webgpu/useGpuSubstrate";
-import type { OklchStop } from "../../../../composables/color";
-import type { FlowFieldConfig } from "../constants";
-export interface UseDotFlowFieldOptions {
-    config: FlowFieldConfig;
-    /** Resolve the dot-color palette as OKLCh (the demo themes it; default warm-identity). */
-    getPalette: () => OklchStop[];
-    /** `"capture"` → renderAt-only (the deterministic π capture path). Default `"live"`. */
-    mode?: "live" | "capture";
-}
-/** The uniform handle a consumer wires its lifecycle against (backend-agnostic). */
-export interface DotFlowFieldHandle {
-    /** The resolved backend (`"webgpu"` where supported, else the WebGL2 fragment fallback). */
-    readonly backend: GpuBackend;
-    /** Park the loop (the WCAG-2.2.2 pause seam — `DockBackgroundToggle` wires this). */
-    pause: () => void;
-    /** Re-arm the loop. */
-    resume: () => void;
-    /** Re-arm a parked loop on demand (a pointer/setter that re-introduced motion). */
-    wake: () => void;
-    /** Draw one frame out-of-loop (capture / thumbnail). */
-    renderAt: (timeSec: number) => void;
-    /** The live `prefers-reduced-motion: reduce` state. */
-    readonly reducedMotion: boolean;
-    /** Tear down the renderer + release GPU/GL resources. */
-    dispose: () => void;
-}
-/**
- * Mount the dot-flow-field renderer on `canvasRef`. The WebGPU primary runs the
- * compute+render two-pass over the anchored lattice; the WebGL2 fallback evaluates the SAME
- * `flowField.ts` field as a fullscreen fragment pass (the ONE math source). Returns the
- * uniform lifecycle handle.
- */
-export declare function useDotFlowField(canvasRef: Ref<HTMLCanvasElement | null>, options: UseDotFlowFieldOptions): DotFlowFieldHandle;

package/dist/components/custom/dot-flow-field/composables/useFlowParticles.d.ts

@@ -1,32 +0,0 @@
-import type { OklchStop } from "../../../../composables/color";
-import type { FlowFieldConfig } from "../constants";
-import { type FlowPointerState } from "./uniformBridgeWGPU";
-export { flowGridGeometry } from "./uniformBridgeWGPU";
-/** The deep warm-near-black floor + the warm rose corner-bloom (linear-sRGB), the §3 ground.
- *  Resolved off a warm-fire-adjacent OKLCh ground (NOT teal). The demo preset overrides via
- *  `config.background`; this is the fallback ground for the flow present-composite. */
-export declare const FLOW_FLOOR_OKLCH: OklchStop;
-export declare const FLOW_BLOOM_OKLCH: OklchStop;
-export interface FlowSetupDeps {
-    canvas: HTMLCanvasElement;
-    config: FlowFieldConfig;
-    /** The resolved (ColorResolver) palette stops as OKLCh — re-read each frame so a live palette edit reaches the buffer. */
-    getPalette: () => OklchStop[];
-    /** Demand-gate (the renderer's quiescence layer — substrate-agnostic). */
-    shouldContinue: () => boolean;
-    /**
-     * The per-frame pointer hook — useDotFlowField advances the shared
-     * `usePointerVelocityField` here (the no-own-rAF discipline). ZERO own rAF.
-     */
-    onFrame?: (timeSec: number) => void;
-    /** The live pointer/vortex state the renderer feeds the flow kernel (rest = inert). */
-    getPointer?: () => FlowPointerState;
-}
-/** A px-min reader (the lattice density rides the min CSS dimension). */
-export declare function cssMin(canvas: HTMLCanvasElement): number;
-/** The flow mote count, clamped to the storage/state cap. */
-export declare function flowCount(config: FlowFieldConfig): number;
-/** The square state-texture side that holds `count` motes (one texel each). */
-export declare function stateCols(count: number): number;
-export { createFlowWGPUSetup } from "./flowSetupWGPU";
-export { createFlowGLSetup } from "./flowSetupGL";

package/dist/components/custom/dot-flow-field/constants.d.ts

@@ -1,120 +0,0 @@
-import type { WaveComponent } from "./composables/flowField";
-import type { OklchStop } from "../../../composables/color";
-/** Compile-time lattice cap — mirrors the WGSL storage-buffer array bound. */
-export declare const MAX_PARTICLES = 16384;
-/** Compile-time wave-component cap — mirrors the WGSL `MAX_WAVE_COMPONENTS` #define. */
-export declare const MAX_WAVE_COMPONENTS = 8;
-/** Compile-time palette cap — mirrors the WGSL `MAX_FLOW_STOPS` #define. */
-export declare const MAX_FLOW_STOPS = 4;
-export declare const PHI = 1.618033988749895;
-export declare const SQRT_PHI: number;
-/**
- * The per-frame trail decay α DERIVED from a half-life in seconds (DRY — `trailDecay` is
- * NOT a free knob; the streak persistence is a proportion of `trailHalfLife`). At a 60fps
- * reference cadence, α = 2^(−dtRef / halfLife) so the trail fades to ½ over `halfLife`.
- */
-export declare function flowTrailDecay(halfLifeSec: number, dtRef?: number): number;
-/**
- * The full author schema — the studio's `useConfiguratorState` model. Every field is a
- * tunable the demo configurator drives; the SFC resolves it into the uniform table.
- *
- * RETOPOLOGY: the lattice density is derived from `gridPitch` (a clean break from the free
- * `particleCount` — README MIGRATION row `particleCount → gridPitch`). The brightness/scale
- * shape rides `contrast`/`waveBandCenter`/`waveBandWidth`; the sub-cell drift rides
- * `displaceAmp`/`springK`; `coherence` maps the octave count + persistence.
- */
-export interface FlowFieldConfig {
-    /**
-     * BD.W-DOTFLOW-AURORA-CURRENT — the topology discriminator (the dock `dim`-idiom
-     * discipline: ONE schema, two orthogonal lever sets, no fork). `"flow"` (default) is
-     * the AURORA CURRENT — a dense population ADVECTED along the curl current, trailing
-     * fading ribbons of warm-fire light, the cursor a live vortex. `"field"` is the calm
-     * anchored halftone (the rebuild's content-deferential backdrop — the kept register).
-     */
-    mode: "flow" | "field";
-    /** Mote population (flow mode) — re-introduced, mode-scoped (field keeps gridPitch). */
-    particleCount: number;
-    /** Trail streak half-life in seconds (the √φ τ₀ anchor); `trailDecay` derives from it. */
-    trailHalfLife: number;
-    /** Half-res trail buffer scale (R-D — quarters the float fillrate at 0.5). */
-    trailScale: number;
-    /** Inertia 0..1: the velocity lerp rate (LOW = weighty arcs, eases into the field). */
-    turnRate: number;
-    /** Advection speed gain (|V| → displacement-per-frame). */
-    speedScale: number;
-    /** Brightness-from-speed gain (the velocity-map glow). */
-    speedGlow: number;
-    /** Mote lifetime in seconds before respawn (the √φ τ₀·φ rung). */
-    lifetimeSec: number;
-    /** Density-vignette strength (shared with field; thins spawns behind the content rect). */
-    edgeBias: number;
-    /** The clear content region (the v4 content-deferential vignette; shared with field). */
-    contentMask: {
-        cx: number;
-        cy: number;
-        rx: number;
-        ry: number;
-    } | null;
-    /** Cursor-vortex fall-off radius (the √φ r₀ anchor). */
-    vortexRadius: number;
-    /** Cursor-vortex tangential spin gain (the swirl). */
-    vortexSpin: number;
-    /** Cursor-drag advection gain (the streamlines follow the gesture). */
-    dragGain: number;
-    /** Flick-burst radial shove gain (the shockwave). */
-    burstShove: number;
-    /** WebGPU cartoon-cast shadow offset (drops on WebGL2/PRM/PRT). */
-    shadowOffset: number;
-    /** WebGPU velocity-anisotropic squash-stretch amount (drops on WebGL2/PRM/PRT). */
-    stretchAmp: number;
-    /** The Gerstner sum-of-sines table (1..MAX_WAVE_COMPONENTS) — the LARGE-wave ladder. */
-    waveComponents: WaveComponent[];
-    /** The dispersion-driven sweep speed (scales ω). LOW = slow sweep (default 0.3). */
-    windSpeed: number;
-    /** The fbm curl-noise braiding-break weight (0..0.4 — keep low; default 0.12). */
-    curlStrength: number;
-    /** The lattice spacing in CSS-px (drives N = view/pitch²). ~26px ≈ the reference. */
-    gridPitch: number;
-    /** The dot billboard base radius in px @ 1×. */
-    dotSize: number;
-    /** How far a dot drifts from its anchor, in pitch fractions (capped < 0.5 pitch). */
-    displaceAmp: number;
-    /** The restoring-spring rate (the pull-to-anchor stiffness; higher = stiffer). */
-    springK: number;
-    /** The sweeping-band center over the normalized height (the iso-band the wave rides). */
-    waveBandCenter: number;
-    /** The sweeping bright-stripe thickness (`waveBand` width over the normalized height). */
-    waveBandWidth: number;
-    /** The brightness modulation depth (subtle ↔ bold; 0..1). */
-    contrast: number;
-    /** The Coherence axis (0..1; high = few coarse octaves coherent, low = many fine). */
-    coherence: number;
-    /** The soft-disc globe mask (the reference's two-sphere composition); off by default. */
-    globeMask: boolean;
-    /** The dot-color ramp (the demo themes it mono-white); resolved via the ColorResolver. */
-    palette: OklchStop[];
-    /** The ground color (the demo sets near-black; default transparent). */
-    background: OklchStop | "transparent";
-    /** Pointer-warp the lattice (a local displacement ripple about the cursor). */
-    interactive: boolean;
-    /** ONE static frame then park under `prefers-reduced-motion: reduce`. */
-    respectReducedMotion: boolean;
-}
-/**
- * The warm-cream identity palette (the library default — NOT teal). A two-stop warm-amber
- * ramp over the warm-cream foreground family, resolved via the ColorResolver. A consumer
- * (the demo) themes it mono-white-on-near-black through a PRESET, never a token edit.
- */
-export declare const WARM_IDENTITY_PALETTE: OklchStop[];
-/**
- * The default LARGE-wave ladder about a 35° diagonal wind — 3 coherent octaves, λ₀ at
- * 2.5× the domain extent (ONE dominant sweeping wave). The §1 regime inversion.
- */
-export declare const DEFAULT_WAVE_COMPONENTS: WaveComponent[];
-/**
- * The shipped warm-identity default config — the SUBTLE + LARGE regime (the §1/§2
- * topology+regime targets): a calm warm-cream lattice (~26px pitch) a slow LARGE wave
- * sweeps through, the dots only breathing a hair off their anchors. globeMask OFF (the
- * neutral register — the reference's soft-disc is a DEMO preset).
- */
-export declare const DEFAULT_FLOW_CONFIG: FlowFieldConfig;

package/dist/components/custom/dot-flow-field/index.d.ts

@@ -1,5 +0,0 @@
-export { default as DotFlowField } from "./DotFlowField.vue";
-export { useDotFlowField, type DotFlowFieldHandle, type UseDotFlowFieldOptions, } from "./composables/useDotFlowField";
-export { type FlowFieldConfig, DEFAULT_FLOW_CONFIG, DEFAULT_WAVE_COMPONENTS, WARM_IDENTITY_PALETTE, MAX_PARTICLES, MAX_WAVE_COMPONENTS, MAX_FLOW_STOPS, } from "./constants";
-export { type WaveComponent, type Vec2, sampleVelocity, gerstnerVelocity, curlFBM, pointerVortex, type VortexParams, buildWaveLadder, gridOrigin, sampleHeight, sampleDisplacement, waveBand, FLOW_GRAVITY, FLOW_DOMAIN_HALF, } from "./composables/flowField";
-export type { OklchStop } from "../../../composables/color";

package/dist/components/custom/dot-flow-field/shaders/flow-field.compute.wgsl.d.ts

@@ -1 +0,0 @@
-export declare const FLOW_FIELD_COMPUTE_WGSL = "\nconst MAX_WAVE_COMPONENTS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst FLOW_GRAVITY: f32 = 9.81;\nconst CURL_EPS: f32 = 0.012;\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nstruct Particle {\n  // field: (pos.x, pos.y, height, |disp|) \u2014 the anchored-lattice live state\n  // flow:  (pos.x, pos.y, speed, life)    \u2014 the advected-mote live state\n  data: vec4<f32>,\n};\n\n// \u2500\u2500 Uniforms (the typed-struct source-of-truth \u2014 see uniformBridgeWGPU.ts) \u2500\u2500\nstruct FlowUniforms {\n  // p0: (uTime, uDt, uWindSpeed, uCurlStrength)\n  p0: vec4<f32>,\n  // p1: (uGridPitch, uDisplaceAmp, uSpringK, uGridCols)  \u2014 the lattice geometry (field)\n  p1: vec4<f32>,\n  // ints: (uWaveCount, uParticleCount, uGridColsI, uMode)  \u2014 uMode: 0=field, 1=flow\n  ints: vec4<i32>,\n  // f0: (uTurnRate, uSpeedScale, uLifetimeSec, uDomainHalf)  \u2014 the flow advection levers\n  f0: vec4<f32>,\n  // f1: (uVortexRadius, uVortexSpin, uDragGain, uBurstShove)  \u2014 the cursor vortex\n  f1: vec4<f32>,\n  // ptr: (cursor.x, cursor.y, vel.x, vel.y)  \u2014 the pointer in domain space + its velocity\n  ptr: vec4<f32>,\n  // ptr2: (burst, pointerActive, edgeBias, _pad)\n  ptr2: vec4<f32>,\n  // each wave row: (amplitude, wavelength, directionDeg, phase)\n  waves: array<vec4<f32>, 8>,\n};\n\n@group(0) @binding(0) var<uniform> u: FlowUniforms;\n@group(0) @binding(1) var<storage, read_write> particles: array<Particle>;\n\n// \u2500\u2500 The deterministic lattice origin (transcribes flowField.ts gridOrigin) \u2500\u2500\nfn gridOrigin(index: u32, cols: i32, pitch: f32) -> vec2<f32> {\n  let c = max(cols, 1);\n  let col = i32(index) % c;\n  let row = i32(index) / c;\n  let half = f32(c - 1) * pitch * 0.5;\n  return vec2<f32>(f32(col) * pitch - half, f32(row) * pitch - half);\n}\n\n// \u2500\u2500 The Gerstner-sum analytic \u2207\u22A5h velocity (transcribes flowField.ts gerstnerVelocity) \u2500\u2500\nfn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  var dhdx = 0.0;\n  var dhdy = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let amplitude = w.x;\n    let wavelength = max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let phase = w.w;\n    let k = TAU / wavelength;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + phase;\n    let akc = amplitude * k * cos(theta);\n    dhdx = dhdx + akc * d.x;\n    dhdy = dhdy + akc * d.y;\n  }\n  // v = \u2207\u22A5h = (\u2202h/\u2202y, \u2212\u2202h/\u2202x).\n  return vec2<f32>(dhdy, -dhdx);\n}\n\n// \u2500\u2500 The scalar Gerstner HEIGHT (transcribes flowField.ts sampleHeight \u2014 the brightness\n//    driver, normalized to \u2248[-1,1] by the total amplitude so the band thresholds are\n//    wave-table-independent). \u2500\u2500\nfn sampleHeight(o: vec2<f32>, t: f32) -> f32 {\n  var h = 0.0;\n  var ampSum = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let k = TAU / max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * o.x + d.y * o.y) - omega * t + w.w;\n    h = h + w.x * sin(theta);\n    ampSum = ampSum + abs(w.x);\n  }\n  return h / max(ampSum, 1e-4);\n}\n\n// \u2500\u2500 Shared curl-noise basis (the WGSL twin of flow.glsl.ts curlFBM) \u2500\u2500\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\nfn valueNoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let a = hash21(i + vec2<f32>(0.0, 0.0));\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);\n}\n\nfn potentialFBM(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(p * freq);\n    p = FBM_ROT * p;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\nfn curlFBM(p: vec2<f32>) -> vec2<f32> {\n  let dx = potentialFBM(p + vec2<f32>(CURL_EPS, 0.0)) - potentialFBM(p - vec2<f32>(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2<f32>(0.0, CURL_EPS)) - potentialFBM(p - vec2<f32>(0.0, CURL_EPS));\n  let g = vec2<f32>(dx, dy) / (2.0 * CURL_EPS);\n  return vec2<f32>(g.y, -g.x);\n}\n\n// The composite flow velocity (transcribes flowField.ts sampleVelocity EXACTLY \u2014 the\n// coarse \u00D70.55 curl domain-scale, the \u00A73.2 inversion).\nfn sampleVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let curlStrength = u.p0.w;\n  var v = gerstnerVelocity(p, t);\n  if (curlStrength > 0.0) {\n    let c = curlFBM(vec2<f32>(p.x * 0.55 + t * 0.15, p.y * 0.55));\n    v = v + c * curlStrength;\n  }\n  return v;\n}\n\n// The sub-cell DISPLACEMENT (transcribes flowField.ts sampleDisplacement \u2014 \u2207\u22A5h + the\n// coarse curl break, soft-clamped through tanh so the magnitude rides into [0,1)).\nfn sampleDisplacement(o: vec2<f32>, t: f32) -> vec2<f32> {\n  let v = sampleVelocity(o, t);\n  let mag = length(v);\n  if (mag < 1e-5) { return vec2<f32>(0.0, 0.0); }\n  let bounded = tanh(mag);\n  return v * (bounded / mag);\n}\n\n// \u2500\u2500 The cursor VORTEX injected into the velocity field (transcribes flowField.ts\n//    pointerVortex). r = p \u2212 cursor; a gaussian fall-off; a TRUE tangential \u2207\u22A5 swirl +\n//    a drag-along term + a radial burst shove. Inert when the pointer is inactive. \u2500\u2500\nfn pointerVortex(p: vec2<f32>) -> vec2<f32> {\n  if (u.ptr2.y < 0.5) { return vec2<f32>(0.0, 0.0); } // pointer inactive \u2192 no vortex\n  let cursor = u.ptr.xy;\n  let vel = u.ptr.zw;\n  let burst = u.ptr2.x;\n  let radius = max(u.f1.x, 1e-3);\n  let r = p - cursor;\n  let d = length(r);\n  let fall = exp(-(d * d) / (radius * radius));\n  let swirl = normalize(vec2<f32>(-r.y, r.x) + vec2<f32>(1e-6, 0.0)); // tangential \u2207\u22A5\n  let radial = r / max(d, 1e-4);\n  let v = swirl * u.f1.y          // the spin\n        + vel * u.f1.z            // the drag (streamlines follow the gesture)\n        + radial * burst * u.f1.w; // the flick shockwave\n  return v * fall;\n}\n\n// \u2500\u2500 density-weighted respawn: a hash-stratified seed inside the domain, biased toward the\n//    edges by edgeBias (a faint vignette \u2014 the field never thins to a hole). \u2500\u2500\nfn respawn(idx: u32, t: f32) -> vec2<f32> {\n  let half = u.f0.w;\n  let s = f32(idx) * 0.013 + t * 0.37;\n  let rx = hash21(vec2<f32>(s, 1.7)) * 2.0 - 1.0;\n  let ry = hash21(vec2<f32>(3.1, s)) * 2.0 - 1.0;\n  // edgeBias>0 pushes the seed toward the perimeter (a power-curve on |coord|).\n  let bias = clamp(u.ptr2.z, 0.0, 1.0);\n  let bx = sign(rx) * pow(abs(rx), mix(1.0, 0.5, bias));\n  let by = sign(ry) * pow(abs(ry), mix(1.0, 0.5, bias));\n  return vec2<f32>(bx, by) * half;\n}\n\n// \u2500\u2500 cs_field \u2014 the ANCHORED-LATTICE evaluator (BYTE-MOVED from cs_main; the field-mode\n//    fence-scoped unit; F1 greps the no-advection/no-reseed witness WITHIN this brace-span).\nfn cs_field(idx: u32, t: f32, dt: f32) {\n  let pitch = u.p1.x;\n  let displaceAmp = u.p1.y;\n  let springK = u.p1.z;\n  let cols = u.ints.z;\n\n  // The PERMANENT anchor \u2014 no wrap, no re-seed (the coherence fix).\n  let o = gridOrigin(idx, cols, pitch);\n  let disp = sampleDisplacement(o, t);\n  let anchorTarget = o + disp * (displaceAmp * pitch);\n\n  var pr = particles[idx];\n  var pos = pr.data.xy;\n  // Framerate-independent critically-damped pull-to-anchor:\n  //   p \u2190 mix(p, anchorTarget, 1 - exp(-springK\u00B7dt))  (the GPGPU influence-pull pattern).\n  let k = 1.0 - exp(-springK * dt);\n  pos = mix(pos, anchorTarget, k);\n\n  let h = sampleHeight(o, t);\n  particles[idx] = Particle(vec4<f32>(pos, h, length(disp)));\n}\n\n// \u2500\u2500 cs_flow \u2014 the AURORA CURRENT (the RE-INVENT register). Momentum-integrated advection\n//    along the curl current + the live cursor vortex, with lifetime decay + density-weighted\n//    respawn. F1b greps the pos+=v*dt + respawn( + pointerVortex( witness in THIS function.\nfn cs_flow(idx: u32, t: f32, dt: f32) {\n  let half = u.f0.w;\n  let turnRate = u.f0.x;\n  let speedScale = u.f0.y;\n  let lifetimeSec = max(u.f0.z, 1e-3);\n\n  var pr = particles[idx];\n  var pos = pr.data.xy;\n  var life = pr.data.w;\n\n  // First-frame / dead / out-of-domain seed (the density-weighted respawn).\n  let outOfDomain = max(abs(pos.x), abs(pos.y)) > half * 1.05;\n  if (life <= 0.0 || outOfDomain) {\n    pos = respawn(idx, t);\n    // stratify the initial life across [0,lifetime] so deaths don't synchronize.\n    life = lifetimeSec * hash21(vec2<f32>(f32(idx) * 0.027, t * 0.11));\n  }\n\n  // The target velocity: the divergence-free curl current + the cursor vortex.\n  let vField = sampleVelocity(pos, t) + pointerVortex(pos);\n  // Momentum/inertia: the low turnRate scales how hard the mote commits to the field\n  // each step \u2014 a weighty ease into the current's turns (arcs, not snaps), the\n  // overlapping-action/follow-through on a particle (R4-motion).\n  let v = vField * turnRate * speedScale;\n  // Forward-Euler advection step (the integrator \u2014 F1b's witness pos = pos + v*dt).\n  pos = pos + v * dt * 60.0;\n\n  life = life - dt;\n  let speed = length(v);\n  particles[idx] = Particle(vec4<f32>(pos, speed, life));\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  let count = u32(u.ints.y);\n  if (idx >= count) { return; } // bounds-guard the dispatch tail\n\n  let t = u.p0.x;\n  let dt = u.p0.y;\n  let mode = u.ints.w;\n\n  if (mode == 1) {\n    cs_flow(idx, t, dt);\n  } else {\n    cs_field(idx, t, dt);\n  }\n}\n";