@fundamental-engine/core 0.4.0

package/dist/core/types.d.ts

@@ -0,0 +1,610 @@
+/**
+ * Core contracts for the reciprocal field.
+ *
+ * These types encode the spec in `docs/engine-reference/forces-system.md`:
+ *   - the data model (§3): Particle, Body, Env
+ *   - the force-registry contract (§4) generalized to agents (§22)
+ *   - mass & momentum (§21), conditions (§5), formations (§7)
+ *
+ * This is the contract the engine implements: `createField`, the force registry,
+ * the integrator, and the conformance harness all build on these shapes.
+ */
+import type { FlowOptions } from './flow.ts';
+import type { FieldHost } from './host.ts';
+import type { ClassifiedTokens } from '../config/forces.config.ts';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/** A force id. Open string so the registry can be extended (§20), but the
+ *  canonical set is enumerated in `config/forces.config.ts`. */
+export type Token = string;
+/** The three kinds of thing a force can act on (§22). A particle is the
+ *  lightest agent; an element is a heavy body with a DOM consumer; an event
+ *  sink is write-only. */
+export type AgentKind = 'particle' | 'element' | 'event';
+/**
+ * A free particle — the lightest agent (§3.2, §21).
+ *
+ * `m` is inertial mass. Today it is nominal (always 1 — the engine integrates
+ * `v += F`, §2.2). Under first-class mass (§21, Option B) it becomes `∝ size`
+ * and the integrator divides by it. Mutate `vx/vy/heat/x/y` from a force.
+ */
+export interface Particle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    /**
+     * OPTIONAL Z LANE (docs/engine-reference/z-axis.md): position/velocity along the
+     * depth axis. Undefined ⇒ 0 ⇒ the flat field — every formula reduces to the 2D
+     * engine exactly. Only a field created with `depth > 0` ever moves these; authors
+     * never have to supply them. Bodies (DOM elements) always live on the z = 0 plane.
+     */
+    z?: number;
+    vz?: number;
+    /** inertial mass — 1 = nominal (§21). */
+    m: number;
+    /** ∈ [0,1]; drives color (toward accent), size, and glow (§2.2). */
+    heat: number;
+    /** render-radius basis. */
+    size: number;
+    /** the sink/blackhole body holding this particle, or null (§6.9). */
+    cap: Body | null;
+    /** stable per-particle scatter target fractions, for the `spread` formation (§7). */
+    gx?: number;
+    gy?: number;
+    /** scatter fraction along z — only meaningful in a `depth > 0` field. */
+    gz?: number;
+    /** frames-to-live for *mortal* (spawned) matter — decremented each tick, despawned at
+     *  ≤ 0 (the [S] source sink). Undefined ⇒ immortal (the conserved base field). */
+    age?: number;
+    /** signed charge q, for `charge` / `magnetism` (§20.10). */
+    charge?: number;
+    /** species tag, for `hunt` (§20.3). */
+    species?: number;
+    /** carried pigment, conserved color transport (§20.8). */
+    color?: string;
+    /** an opaque data record bound to this particle by `FieldHandle.seed` (e.g. a "project atom"). */
+    atom?: AtomPayload;
+}
+/**
+ * A data record bindable to a particle (`FieldHandle.seed`). Opaque to the engine except `weight`
+ * (0..1), which scales the particle's mass + size — so richer records read as heavier, more central
+ * matter. Picked back out with `FieldHandle.atomAt(x, y)`.
+ */
+export interface AtomPayload {
+    readonly weight?: number;
+    readonly [key: string]: unknown;
+}
+/**
+ * A registered DOM element acting as a force source (§3.1). Parsed from
+ * `data-*` attributes; the runtime fields are refreshed each scan/frame.
+ */
+export interface Body {
+    el: HTMLElement;
+    /** space-joined force ids from `data-body` (they compose, §4). */
+    tokens: Token[];
+    /** `tokens` split into `{ modifiers, forces, sources }` per the modifier contract
+     *  (workover v0.3). The scanner fills it at parse time; the integrator memoizes it
+     *  lazily for bodies built elsewhere (conformance, tests). Modifiers carry the
+     *  formalized order `spotlight → screen → resonate`. */
+    classified?: ClassifiedTokens;
+    /** force magnitude S. */
+    strength: number;
+    /** influence radius d_max, px. */
+    range: number;
+    /** capture radius for `sink`. */
+    absorbR: number;
+    /** load at which a sink supernovas (was `maxMass`, renamed §21.2). */
+    capacity: number;
+    /** swirl/charge sign or spin (±). */
+    spin: number;
+    /** heading in radians, with its unit vector, for stream/jet/etc. */
+    angle: number;
+    ux: number;
+    uy: number;
+    /** conditional gate id (§5); '' = always. */
+    when: string;
+    /** opt into two-way density write-back (§8). */
+    feedback: boolean;
+    /** the body's tint from `data-color`, for `pigment` color transport (§20.8). */
+    tint?: string;
+    /** shaped source (`data-shaped`): forces reference the nearest point on the element's
+     *  box, not its centre, so matter gathers in a shell around the shape (field-systems
+     *  Stage C). Undefined ⇒ point source (the default). */
+    shaped?: boolean;
+    fmin: number;
+    fmax: number;
+    opsz: string;
+    /** `data-pair` — selector for the body this one is wormhole-paired to (`warp`, §22.3 relocate). */
+    pair?: string;
+    /** `data-twist` — rotation (radians) applied to matter relocated through a `warp` throat. */
+    twist?: number;
+    /** `data-scale` — scale applied to the relocated local offset through a `warp` throat (default 1). */
+    warpScale?: number;
+    /** `data-life` — frames each particle this body's [S] source emits lives (the mortal `age`).
+     *  Undefined ⇒ the source's own default lifespan. Part of the source budget contract. */
+    life?: number;
+    /** `data-cap` — the most live particles this body's [S] source may sustain; the emission
+     *  rate is clamped to `cap / life` per frame. Undefined ⇒ rate-limited by lifespan only. */
+    cap?: number;
+    /** the [S] budget contract is satisfied — the author declared at least one of
+     *  `data-life` / `data-cap` / `data-budget` / `data-sink` (workover §"Source and sink rules").
+     *  False on a source body ⇒ the scanner's dev guard warns and applies the safe defaults. */
+    budgeted?: boolean;
+    /** `data-screen-min` — the floor of the `screen` modifier's attenuation factor (default 0:
+     *  full cancellation at the core is allowed). Only read on bodies carrying `screen`. */
+    screenMin?: number;
+    /** the resolved paired body for `warp` (set each scan from `pair`); undefined if unpaired. */
+    pairBody?: Body;
+    /** the paired throat's live centre, refreshed each frame from `pairBody` (the relocate target). */
+    warpX?: number;
+    warpY?: number;
+    /** whether a relocate target is currently resolved (the `warp` force no-ops without one). */
+    warpHas?: boolean;
+    /** source mass M for `gravity`/`charge` (§20.10/§21). */
+    M: number;
+    cx: number;
+    cy: number;
+    hw: number;
+    hh: number;
+    /** engaged (hover/focus/tap → data-active="1"). */
+    on: boolean;
+    /** on-screen and exerting force (§2.1). */
+    vis: boolean;
+    /** captured load (was `mass`, renamed §21.2). */
+    accreted: number;
+    /** per-frame density tally and its eased value d ∈ [0,1] (§8). */
+    count: number;
+    d: number;
+    /** conserved-attention effective-strength multiplier (§2.4); 1 = neutral. */
+    attn?: number;
+    /** fractional-emission accumulator for a budgeted [S] source (`spawn`) — carries the
+     *  sub-1/frame remainder when the rate is clamped to `cap / life`. Runtime state. */
+    emitAcc?: number;
+    /** prior engagement state, for the attention-gated discharge edge (#365). Runtime state. */
+    wasOn?: boolean;
+    /** per-frame local thermodynamic accumulators (workover §"Metrics") — sums over the same
+     *  `range/2` sample window as `count`, reset each step, only on `data-feedback` bodies:
+     *  n samples, Σvx, Σvy, Σ|v|, Σ|v|², Σheat. Allocated lazily on first sample. */
+    thermo?: {
+        n: number;
+        sx: number;
+        sy: number;
+        ss: number;
+        ss2: number;
+        sh: number;
+    };
+    /** the eased measured metrics (workover §"Metrics"): entropy / coherence / temperature
+     *  ∈ [0,1], exported as `--entropy` / `--coherence` / `--temperature`. Lazily allocated. */
+    metrics?: {
+        entropy: number;
+        coherence: number;
+        temperature: number;
+    };
+    /** target points for `morph` (§20.3 [D]) — a sampled mark / logo / chart / shape the
+     *  matter assembles into. NEVER words or letterforms (§11); words glow/grow via `--d`. */
+    targets?: readonly {
+        x: number;
+        y: number;
+    }[];
+    /** custom rectangle provider for a shadow-DOM body whose physical box is not the host
+     *  box (closed roots, internal cores). The measurer prefers this over the host's own
+     *  `getBoundingClientRect` (shadow-dom.md §10/§16). */
+    rect?: () => DOMRect;
+    /** element that receives the field's CSS-variable write-back, when it differs from the
+     *  body's element (shadow-dom.md §11). Defaults to `el`. */
+    writeTarget?: HTMLElement;
+}
+/** A formation preset — a global bias on every free particle (§7). */
+export interface Formation {
+    driftX: number;
+    wander: number;
+    orbit: number;
+    spread: number;
+    conv: number;
+}
+/** A persistent scalar grid backing field-buffer forces (§20.1 class [C]). */
+export interface ScalarGrid {
+    sample(x: number, y: number): number;
+    deposit(x: number, y: number, amount: number): void;
+    gradient(x: number, y: number): Vec2;
+}
+/**
+ * The shared per-frame environment handed to every force (§3.3), extended with
+ * the services later classes need (§20.1) and the sim unit-system constants
+ * (§20.10). Engines may leave the heavier services as no-ops until built.
+ */
+export interface Env {
+    /** vector from particle to body: (b.cx − p.x, b.cy − p.y). */
+    dx: number;
+    dy: number;
+    /**
+     * z component of the particle→body vector (z-axis.md). OPTIONAL — undefined reads
+     * as 0. Bodies live on the z = 0 plane, so this is `0 − (p.z ?? 0)` — always 0 in a
+     * flat field, where every force's z term vanishes and the 2D behavior is exact.
+     */
+    dz?: number;
+    /** |(dx, dy, dz)|, clamped ≥ 1 (= the 2D distance in a flat field). */
+    dist: number;
+    /** the active, eased formation (§7). */
+    form: Formation;
+    W: number;
+    H: number;
+    /** depth of the simulation volume (z-axis.md). OPTIONAL; 0/undefined = the flat field. */
+    D?: number;
+    /** elapsed time in seconds (for time-varying terms: curl drift, resonance). */
+    t: number;
+    /** frame counter (for the periodic brownian jitter + scatter animation, §7). */
+    frameN: number;
+    /** integration step: 1 a frame, 0 under reduced motion (§2.2/§18). */
+    dt: number;
+    /** velocity cap / "speed of light" of the unit system (§20.10). */
+    c: number;
+    /** gravitational constant of the unit system (§20.10). */
+    G: number;
+    /** recent page-scroll speed (eased, px/frame); drives the `scrolling` gate (§5).
+     *  Undefined / 0 off the page, so the gate is inert under the conformance harness. */
+    scrollV?: number;
+    /** the engine's random source (#371) — forces and the integrator draw jitter from here so a
+     *  seeded rng makes a run reproducible (record/replay). Optional for fixture back-compat;
+     *  call sites fall back to Math.random. */
+    rng?: () => number;
+    /** throw a micro-reaction at a point — sparks/heat (§23). */
+    spark(x: number, y: number, power: number, color?: string): void;
+    /** release everything a body has captured (§6.9). */
+    supernova(b: Body): void;
+    /** create a particle — source forces only (§20, class [S]). */
+    spawn(p: Partial<Particle>): void;
+    /** neighbours within r — particle↔particle forces (§20.1 class [B]). */
+    neighbors(p: Particle, r: number): Particle[];
+    /** a named scalar grid — field-buffer forces (§20.1 class [C]). */
+    grid(name: string): ScalarGrid;
+    /** the net *structure* field at a world point — the superposition of every body's
+     *  `field()` hook (the dipoles and monopoles, field-systems Stage B). The vector matter
+     *  follows under `fieldflow`. Set by the integrator each step from the live bodies; absent
+     *  in bare/probe envs, where a field-following force simply no-ops. */
+    fieldAt?(x: number, y: number): Vec2;
+}
+/**
+ * A force module (§4). The engine owns the loop and everything conserved; a
+ * force owns only the math that nudges one agent given the shared `env`.
+ *
+ * `apply` is the common path (a free particle). A force opts into other agent
+ * tiers (§22) by listing them in `targets` and the engine routes accordingly;
+ * most forces need no per-tier code because the *agent's* consumer interprets
+ * the influence. Default `targets` is `['particle']` — today's behaviour.
+ */
+export interface Force {
+    token: Token;
+    label: string;
+    targets?: AgentKind[];
+    apply(b: Body, p: Particle, env: Env): void;
+    /**
+     * This force *replaces* velocity (a reflection, rotation, or relaunch) rather than
+     * *adding* an acceleration, so first-class mass (§21.3) must not scale its effect: a
+     * bounce reflects and a lens bends regardless of inertia. Additive forces leave this
+     * unset and have their Δv scaled by `1/m`. Set on `wall`, `jet`, `lens`, `gate`.
+     */
+    kinematic?: boolean;
+    /**
+     * Optional *modifier* hook (§20.3 `resonate`/`spotlight`). Run before the body's
+     * other tokens apply, for this particle: a returned `strength` multiplies the
+     * sibling forces' strength for this frame; `gate: true` skips them entirely. A
+     * pure modifier (e.g. `spotlight`) can leave `apply` a no-op.
+     */
+    modify?(b: Body, p: Particle, env: Env): {
+        strength?: number;
+        gate?: boolean;
+    };
+    /**
+     * Optional *source* hook (§20.1 class [S], e.g. `spawn`). Run once per body per frame
+     * — not per particle — after the per-particle force pass, so a body can *create*
+     * matter via `env.spawn`. A pure source leaves `apply` a no-op. Sources break
+     * conservation by design and must self-budget (a lifespan `age` plus the engine's
+     * pool ceiling keep the count bounded).
+     */
+    source?(b: Body, env: Env): void;
+    /**
+     * Optional *visual field* hook (field-systems plan, Stage B). The in-plane field vector
+     * the body projects at a world point, with no particle and no velocity. Renders field
+     * lines and makes velocity- or charge-dependent forces (whose `apply` is a no-op on a
+     * still probe) visible in the field-flow view. For `magnetism` this is the dipole
+     * structure of B — particles still curve perpendicular, they do not follow it; for
+     * `charge` it is the electric field the force pushes along. Pure: same input, same output.
+     */
+    field?(b: Body, x: number, y: number): Vec2;
+    /**
+     * Optional *scalar field* hook (system-contracts §2 — a field may be vector, scalar, or compound).
+     * Returns a scalar value at a world point (e.g. a potential `Φ`, a density, a temperature) for
+     * contour / potential / heatmap rendering, with no particle. Pure: same input, same output. A
+     * force may own a vector `field()`, a `scalarField()`, both, or neither.
+     */
+    scalarField?(b: Body, x: number, y: number): number;
+    meta?: {
+        desc?: string;
+    };
+}
+/** A connector between two elements for `field.threads` (§10). */
+export interface ThreadLink {
+    a: Element;
+    b: Element;
+    color?: string;
+}
+/** A `data-when` gate predicate (§5). Selective gates read each particle; the engine
+ *  also passes the shared `env`, so a gate can read frame state (e.g. `scrolling`). */
+export type Condition = (b: Body, p: Particle, env?: Env) => boolean;
+/** The force registry — `token → module` (§4). */
+export type ForceRegistry = Record<Token, Force>;
+/** The condition registry — `id → predicate` (§5). */
+export type ConditionRegistry = Record<string, Condition>;
+/** Options for `createField` (§2.5 config). */
+/**
+ * Field Surfaces — *where* a field visualization composites relative to page content:
+ *   · the UNDERLAY (behind content) is the default `<field-root>` canvas, driven by `render`/setRender;
+ *   · the OVERLAY (in front of content) is an optional second surface driven by `overlay`/setOverlay.
+ * Setting both (immersive) lets content sit *inside* the field. Overlay modes are READINGS — line/text
+ * diagnostics that reveal what the field is doing without occluding text; `'off'` clears the overlay
+ * surface. The vocabulary (each: what it draws · which quantity it reads):
+ *   · `streamlines` — arrows along the net push a still probe would feel · vector flow (felt)
+ *   · `force-vectors` — the same arrows scaled by raw magnitude · vector flow (absolute)
+ *   · `field-lines` — arrows along the structure-only field (dipoles/monopoles) · field geometry
+ *   · `grid` — a reference lattice displaced by the local field · deformation
+ *   · `temperature` — iso-contour lines of accumulated particle heat · thermal scalar
+ *   · `energy` — iso-contour lines of kinetic energy (½m|v|²) · energy scalar
+ *   · `path` — streamline curves integrated from seeded probes · vector flow, traced over distance
+ *   · `data` — numeric density readouts at each measuring body · per-body measurement
+ * Readings are ADDITIVE: `setOverlay` accepts one mode or a stack (array), drawn in order on the one
+ * front surface — so matter (underlay) + heatmap + several readings compose into one legible picture.
+ */
+export type OverlayMode = 'off' | 'streamlines' | 'force-vectors' | 'field-lines' | 'grid' | 'temperature' | 'energy' | 'path' | 'data';
+/** One reading, or an additive stack of readings, for `setOverlay` / `FieldOptions.overlay`. */
+export type OverlayInput = OverlayMode | readonly OverlayMode[];
+export interface FieldOptions {
+    /** travelling accent color (§9). */
+    accent?: string;
+    /** particle-count multiplier (§2.5). */
+    density?: number;
+    /**
+     * OPT-IN Z VOLUME (docs/engine-reference/z-axis.md): depth of the simulation volume
+     * in px. 0 — the default — is the flat field, byte-identical to the 2D engine. > 0
+     * lets matter seed, wander, and wrap through a shallow z volume behind the surface;
+     * bodies stay on the z = 0 plane and their forces pull matter back toward it. The
+     * render projects z as a size/alpha recession. Purely additive: no API requires z.
+     */
+    depth?: number;
+    /** draw the background Currents (§24); default true. Set false for the bare
+     *  free-particle field with no carrier waves. */
+    waves?: boolean;
+    /** substrate background: `'opaque'` (default) paints the near-black substrate each frame;
+     *  `'transparent'` clears to transparent instead, so the underlay can sit OVER light content
+     *  (a 3D scene, an image, a light page) without blanking it out. The bright matter survives;
+     *  no `mix-blend-mode` workaround needed. Trails light-paint and fade to transparent rather
+     *  than to black. Purely additive — the default is unchanged. */
+    background?: 'opaque' | 'transparent';
+    /** render mode (§20.6): 'dots' (default), 'trails' (light-painting), 'links'
+     *  (constellation), 'metaballs' (a liquid iso-surface, not dots), 'streamlines'
+     *  (draw the force field itself — diagnostic, REPLACES the dots), 'flow' (the dots
+     *  AND the streamlines drawn together in the one underlay canvas — particles
+     *  drifting along the visible flow, with no separate front surface and no
+     *  `mix-blend`, so it stays a single cheap layer), 'none' (the signals-only engine,
+     *  §13.7 / #297: the full simulation + feedback pipeline runs, but no canvas
+     *  context is acquired, no backing store is sized, and nothing is ever drawn —
+     *  the field exists purely as signals: `--d`, `--load`, `--lit`, capture
+     *  events, `scrollV()`). */
+    render?: 'dots' | 'trails' | 'links' | 'metaballs' | 'voronoi' | 'streamlines' | 'flow' | 'none';
+    /** first-class mass (§21.3): when true, particle mass ∝ size and body forces
+     *  accelerate by `a = F/m` (heavier matter moves less). Default false (unit mass). */
+    mass?: boolean;
+    /** color template for the travelling accent (§9): a built-in name
+     *  (`'ours'` · `'heatmap'` · `'infrared'` · `'spectrum'`) or custom hex stops. */
+    palette?: string | readonly string[];
+    /** conserved attention (§2.4): one finite strength budget — engaging a body
+     *  pulls force off every other. Default false; rest-neutral until engaged. */
+    attention?: boolean;
+    /** cross-boundary causality (Concept 4): a saturated body spills density to its
+     *  neighbours (writing `--lit` + firing `field:lit`/`field:dim`). Default false. */
+    causality?: boolean;
+    /** density heatmap (field-systems H1): a scalar buffer of where matter pools, drawn as a
+     *  glow underlay and sampled to bodies as `--field-heatmap-density`. Default false. */
+    heatmap?: boolean;
+    /**
+     * Field Surfaces (overlay placement): a caller-provided canvas for the OVERLAY surface, drawn in
+     * front of page content. Core sizes its backing store (matching the main canvas dpr) and draws the
+     * `overlay` mode onto it each frame; the caller owns the element and its CSS placement (fixed,
+     * full-viewport, `pointer-events:none`, above content / below nav). Keeps core DOM-free — the host
+     * provides the canvas, core only draws. Default unset → no overlay surface.
+     */
+    overlayCanvas?: HTMLCanvasElement;
+    /** initial overlay visualization mode (Field Surfaces); default `'off'`. */
+    overlay?: OverlayInput;
+    /** the drawing backend for the overlay surface (#373) — defaults to the Canvas 2D
+     *  implementation over `overlayCanvas`. The structural seam a WebGL/WebGPU surface
+     *  implements; see render-backend.ts. */
+    overlayBackend?: import('./render-backend.ts').RenderBackend;
+    /** the random source for ALL engine randomness — particle seeding, spawn scatter, jitter,
+     *  release angles (#371). Defaults to Math.random; supply a seeded generator and a run
+     *  becomes reproducible (the record/replay seam). */
+    rng?: () => number;
+    /** the wall-clock source for input-idle tracking (#371) — defaults to performance.now.
+     *  One of the three clocks (wall / frame / simulation); see temporal.ts for the others. */
+    now?: () => number;
+    /**
+     * Feedback seam (Phase D3): when set, the engine routes its per-body feedback channels to this
+     * sink each frame *instead of* writing CSS variables / dispatching events directly — so the
+     * platform's FeedbackRegistry can own the write phase. The simulation (the eased density value) is
+     * unchanged; only the write target moves. Default unset → the engine installs an internal default
+     * sink (#228) whose direct writes are identical to the historical behavior (same variables, same
+     * three-decimal formatting, same `field:lit`/`field:dim` hysteresis) — the sink contract is the
+     * one write path either way. Font-variation weight is a typographic render effect and stays in
+     * the engine.
+     */
+    feedbackSink?: FeedbackSink;
+    /**
+     * The environment seam (frontier): the {@link FieldHost} the engine drives the DOM through. REQUIRED
+     * by `createField` (core imports zero DOM). In the browser, use `browserHost()` from
+     * `@fundamental-engine/platform`, or the `@fundamental-engine/{vanilla,elements,react}` entry points that wire it for
+     * you; inject a custom host for a headless renderer / different document / tests.
+     */
+    host?: FieldHost;
+}
+/** Per-element feedback values the engine produces each frame (Phase D3 seam). */
+export interface FeedbackChannels {
+    /** the body's eased gathered density `d` ∈ [0,1] → `--d` / `--field-density`. */
+    density?: number;
+    /** the ambient heatmap density at the body → `--field-heatmap-density`. */
+    heatmapDensity?: number;
+    /** sink accretion fill ∈ [0,1] → `--load` / `--mass`. */
+    load?: number;
+    /** cross-boundary lit signal ∈ [0,1] → `--lit` + thresholded `field:lit` / `field:dim`. */
+    lit?: number;
+    /** measured local disorder ∈ [0,1] (workover §"Metrics") → `--entropy`. Engine-measured
+     *  thermodynamics — distinct from the platform's inferred `--field-entropy` pipeline lane. */
+    entropy?: number;
+    /** measured local order ∈ [0,1] (= 1 − entropy) → `--coherence`. Engine-measured;
+     *  distinct from the platform's `--field-coherence` lane AND from the `--coherence`
+     *  palette *color* token `cssTokens()` sets on `:root`. */
+    coherence?: number;
+    /** measured local agitation ∈ [0,1] (heat + kinetic) → `--temperature`. */
+    temperature?: number;
+}
+/** Receives a body's feedback channels in place of direct DOM writes (Phase D3). */
+export type FeedbackSink = (el: HTMLElement, channels: FeedbackChannels) => void;
+/** The handle returned by `createField` — the public field API (§13). */
+export interface FieldHandle {
+    /** (re)scan the document for `[data-body]` bodies after a layout change. */
+    scan(): void;
+    /** alias of `scan`. */
+    rescan(): void;
+    /** recolor the travelling accent (§9). */
+    setAccent(hex: string): void;
+    /** swap the accent's color template live: a built-in name or custom hex stops (§9). */
+    setPalette(palette: string | readonly string[]): void;
+    /** switch the global formation (§7). */
+    setFormation(name: string): void;
+    /** toggle conserved attention (§2.4) live — one finite strength budget. */
+    setAttention(on: boolean): void;
+    /** toggle cross-boundary causality (Concept 4) live — density spills to neighbours. */
+    setCausality(on: boolean): void;
+    /** toggle the density heatmap layer (field-systems H1) live. */
+    setHeatmap(on: boolean): void;
+    /**
+     * Switch the underlay render mode (§20.6) live — the surface behind content. `'none'` is the
+     * signals-only mode (§13.7 / #297): drawing stops from the next frame while the simulation and
+     * its signals stay live. Switching TO `'none'` at runtime keeps an already-acquired context and
+     * backing store (the no-allocation guarantee belongs to fields CREATED with `render: 'none'`);
+     * switching FROM `'none'` acquires the context lazily and sizes the backing store at that moment.
+     */
+    setRender(mode: 'dots' | 'trails' | 'links' | 'metaballs' | 'voronoi' | 'streamlines' | 'flow' | 'none'): void;
+    /**
+     * Render field READINGS on the OVERLAY surface — in front of page content (Field Surfaces). Pairs
+     * with `setRender` (the underlay); set both for an immersive look. No-op unless the field was created
+     * with an `overlayCanvas`. Accepts one reading or an additive stack (drawn in order); `'off'` (or an
+     * empty stack) clears the overlay surface.
+     */
+    setOverlay(mode: OverlayInput): void;
+    /** wire glowing connector lines between a set, or clear with null (§10). */
+    threads(list: ThreadLink[] | null): void;
+    /** a discrete one-shot: shove + heat matter near (x, y), optionally tinting it (§11). */
+    burst(x: number, y: number, hex?: string): void;
+    /**
+     * Place or move a dynamic flow focus at `(x, y)` — a movable target the field bends toward: it
+     * pulls free matter in, curves the streamlines, and eases the wave spine to it. Call repeatedly to
+     * retarget it (follow the pointer, track an element, animate a path); clear with `clearFlow()`.
+     */
+    flowTo(x: number, y: number, opts?: FlowOptions): void;
+    /** Remove the flow focus — the field relaxes back to its bodies-only shape. */
+    clearFlow(): void;
+    /**
+     * Bind a data record to each base particle, round-robin (so every dot carries a piece of meaning).
+     * Each record's `weight` (0..1) scales that particle's mass + size — richer records read as heavier,
+     * more central matter. Re-applied across resize/density rebuilds. Pick them back with `atomAt`.
+     */
+    seed(atoms: readonly AtomPayload[]): void;
+    /** The seeded record on the nearest particle to (x, y) within ~24px, or null. For hover-to-inspect. */
+    atomAt(x: number, y: number): AtomPayload | null;
+    /**
+     * Focus the nearest seeded particle to (x, y) within ~24px: hold it still and light it up, and
+     * return its record (or null + clear focus if none). The dwell affordance before a click — call
+     * on hover-dwell, then `clearFocus()` when the pointer moves on.
+     */
+    focusAt(x: number, y: number): AtomPayload | null;
+    /** Release the focused particle (it resumes drifting). */
+    clearFocus(): void;
+    /**
+     * Live particle count — the current size of the particle pool. Equivalent to `store.size`
+     * inside the engine. Use for external budget monitors and debug overlays that need the count
+     * without walking the particle array (which `inspectBudget` does internally).
+     */
+    particleCount(): number;
+    /**
+     * Snapshot of kinetic, thermal, and total energy for the current frame. Thin forward to
+     * `energyReport(store.particles)` from `@fundamental-engine/core/diagnostics/energy` — the function
+     * already exists; this accessor exposes it through the public handle so external tools
+     * (DataConsole, Inspector) don't need a reference to the internal particle array.
+     */
+    energy(): {
+        kinetic: number;
+        thermal: number;
+        total: number;
+        count: number;
+    };
+    /**
+     * Sample the live field at a point: the net force a still test particle would feel there — the
+     * superposition of every visible body's influence (attract/gravity wells, charge/magnetism
+     * dipole structure, flow bias, …). Returns the force vector as `{ x, y }` in field-pixel space.
+     * Pure and read-only (no pool mutation), safe to call any time and at any spatial resolution —
+     * the engine does not pre-bake a grid. The seam external visualizers consume to build their own
+     * field geometry: vector grids, streamline tubes, mesh displacement. `@fundamental-engine/three`'s
+     * `vectorField` / `streamlineTubes` are the first consumers. Thin wrapper over the existing
+     * `forceAt(bodies, forces, env, x, y)`.
+     */
+    sample(x: number, y: number): Vec2;
+    /**
+     * Copy live particle state into a caller-owned buffer and return the number of particles
+     * written. Stride 5, packed `[x, y, z, heat, size, …]` in CSS-pixel field coordinates — the
+     * layout maps straight onto a renderer's vertex buffer (e.g. a `THREE.BufferAttribute`), so an
+     * alternative surface can draw the swarm without a 2D context and without the engine exposing
+     * its internal particle objects. `z` is the optional depth lane (z-axis.md): always `0` in a flat
+     * field, populated only when the field was created with `depth > 0`. Zero-allocation and
+     * read-only: it never mutates the pool.
+     *
+     * Writes `min(particleCount(), floor(out.length / 5))` particles — pass `new Float32Array(cap *
+     * 5)` sized to your cap (over-sizing is safe; the return value is the count actually written).
+     * Pull-based: call once per frame after the engine has stepped, then upload the slice
+     * `[0, n*5)`. The companion of `particleCount()` for renderers that need positions, not just the
+     * tally; `@fundamental-engine/three`'s particle bridge is the first consumer.
+     */
+    readParticles(out: Float32Array): number;
+    /**
+     * The engine's eased page-scroll velocity for the current frame — the same EMA value the
+     * `scrolling` condition gate uses: `(prev × 0.7) + (|scrollDelta| × 0.3)` per frame.
+     * Units are pixels per frame at the native rAF cadence (~1 at 60 fps per pixel/s of scroll).
+     * Near 0 = user is reading/stopped; 2+ = slow deliberate scroll; 10+ = fast scan/jump.
+     * CAVEAT: px/frame is refresh-rate dependent — the same physical scroll reads roughly half
+     * this value on a 120 Hz display. A px/ms normalization may replace this unit before 1.0
+     * (the surface is experimental); thresholds tuned on 60 Hz should treat the value as coarse.
+     * Written to `--field-scroll-v` on `:root` by the platform write phase when a platform
+     * runtime is active. Pull-based: read on demand, do not poll in tight loops.
+     */
+    scrollV(): number;
+    /**
+     * Element-level visibility hint. `setVisible(false)` while the canvas is hidden or offscreen
+     * (`display:none`, scrolled out) skips ALL draw work — usually the dominant frame cost — while
+     * the simulation and its signals stay live: `scrollV()`, feedback vars (`--d`, `--load`),
+     * capture events keep flowing. Distinct from the tab-level pause (the engine already stops
+     * fully on the host's visibilitychange). `<field-root>` wires this automatically from an
+     * IntersectionObserver on the host element; call it yourself for custom embeddings.
+     */
+    setVisible(on: boolean): void;
+    /**
+     * Switch the substrate background live (the construction `background` option, at runtime).
+     * `'transparent'` clears to transparent so the underlay composites over light content;
+     * `'opaque'` restores the near-black substrate. Additive — no existing caller is affected.
+     */
+    setBackground(mode: 'opaque' | 'transparent'): void;
+    /** stop the loop and release listeners. */
+    destroy(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

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

package/dist/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":""}