@fundamental-engine/core 0.4.0

package/dist/core/accretion.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Accretion — the pure, DOM-free core of the sink submodel (§6.9, agent-consumption-model).
+ *
+ * A `sink` captures matter into an accretion core, HOLDS it (the particle stays in the pool with
+ * `cap = b`, drifting to the core in the integrator), and on saturation RELEASES exactly what it
+ * held. This module owns the conserved release math and the capture/release event edge so both
+ * `field.ts` (the impure shell that dispatches events + writes the DOM) and the conformance tests
+ * exercise the *same* code. No DOM, no globals.
+ */
+import type { Body, Particle } from './types.ts';
+/**
+ * Release exactly the particles a body captured: eject each just **past** the absorption radius
+ * along a random bearing, give it a radial outward velocity, clear its capture + heat to 1, and
+ * reset the body's load to 0. Held matter is **conserved** — released particles stay in the
+ * caller's pool (never deleted), so `count` is preserved. Returns the released particles (in pool
+ * order). `rng` is injectable for deterministic tests; defaults to `Math.random`.
+ *
+ * Ejecting past `absorbR` (rather than at the core) is what makes a supernova a real cycle. Matter
+ * dropped at the core sits *inside* the capture radius and is re-grabbed on the very next frame,
+ * degenerating the explosion into a per-frame strobe whose blast progressively evacuates the
+ * catchment until the sink falls dormant. Leaving the accretion zone lets a `sink+attract` well
+ * reel the ejecta back for a genuine fill → explode → fall-back → refill cycle (a lone `sink`
+ * simply lets it disperse).
+ */
+export declare function releaseCaptured(particles: readonly Particle[], b: Body, rng?: () => number): Particle[];
+/** Sink fill fraction ∈ [0,1] — the value written to `--load` / `--mass`. 0 when not a sink. */
+export declare function sinkLoad(b: Body): number;
+/** The discrete capture/release event a sink crosses this frame, if any. */
+export type CaptureEvent = 'captured' | 'released' | null;
+/**
+ * Capture/release event edge for a sink body. `prevArmed` is whether `captured` has fired since the
+ * last release; `accreting` is `b.accreted > 0` after this frame's force pass. Rising edge →
+ * `captured`; falling edge (which only happens via release/supernova, since load drops to 0 there)
+ * → `released`. Pure: the caller persists `armed` and performs the dispatch.
+ */
+export declare function captureEdge(prevArmed: boolean, accreting: boolean): {
+    fire: CaptureEvent;
+    armed: boolean;
+};
+/**
+ * Attention-gated discharge (#365, the Contour Charge behavior): a sink gated on engagement
+ * (`data-when="active"`) releases what it holds on the FALLING edge of engagement — the vessel
+ * charges while attended and discharges when attention leaves. The condition pass already gates
+ * capture (a closed gate pulls nothing new in); this is the matching release side. Pure trigger:
+ * the caller supplies the release ritual (the engine passes `env.supernova`, so discharge is the
+ * same conserved release — same radial burst, same `field:released` event — as saturation).
+ * Returns the bodies that discharged this pass.
+ */
+export declare function dischargeDisengaged(bodies: readonly Body[], release: (b: Body) => void): Body[];
+//# sourceMappingURL=accretion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accretion.d.ts","sourceRoot":"","sources":["../../src/core/accretion.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,CAAC,EAAE,IAAI,EACP,GAAG,GAAE,MAAM,MAAoB,GAC9B,QAAQ,EAAE,CA4BZ;AAED,gGAAgG;AAChG,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAIxC;AAED,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;AAE1D;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAI1G;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,IAAI,GAAG,IAAI,EAAE,CAW/F"}

package/dist/core/accretion.js

@@ -0,0 +1,98 @@
+/**
+ * Accretion — the pure, DOM-free core of the sink submodel (§6.9, agent-consumption-model).
+ *
+ * A `sink` captures matter into an accretion core, HOLDS it (the particle stays in the pool with
+ * `cap = b`, drifting to the core in the integrator), and on saturation RELEASES exactly what it
+ * held. This module owns the conserved release math and the capture/release event edge so both
+ * `field.ts` (the impure shell that dispatches events + writes the DOM) and the conformance tests
+ * exercise the *same* code. No DOM, no globals.
+ */
+/**
+ * Release exactly the particles a body captured: eject each just **past** the absorption radius
+ * along a random bearing, give it a radial outward velocity, clear its capture + heat to 1, and
+ * reset the body's load to 0. Held matter is **conserved** — released particles stay in the
+ * caller's pool (never deleted), so `count` is preserved. Returns the released particles (in pool
+ * order). `rng` is injectable for deterministic tests; defaults to `Math.random`.
+ *
+ * Ejecting past `absorbR` (rather than at the core) is what makes a supernova a real cycle. Matter
+ * dropped at the core sits *inside* the capture radius and is re-grabbed on the very next frame,
+ * degenerating the explosion into a per-frame strobe whose blast progressively evacuates the
+ * catchment until the sink falls dormant. Leaving the accretion zone lets a `sink+attract` well
+ * reel the ejecta back for a genuine fill → explode → fall-back → refill cycle (a lone `sink`
+ * simply lets it disperse).
+ */
+export function releaseCaptured(particles, b, rng = Math.random) {
+    const released = [];
+    const rim = b.absorbR + 6; // clear the capture horizon so it isn't re-captured next frame
+    for (const q of particles) {
+        if (q.cap !== b)
+            continue;
+        const ang = rng() * Math.PI * 2;
+        const spd = 4 + rng() * 3;
+        q.cap = null;
+        q.x = b.cx + Math.cos(ang) * rim;
+        q.y = b.cy + Math.sin(ang) * rim;
+        q.vx = Math.cos(ang) * spd;
+        q.vy = Math.sin(ang) * spd;
+        // the core sits on the page plane: release resets the z lane too (z-axis.md).
+        if (q.z)
+            q.z = 0;
+        if (q.vz)
+            q.vz = 0;
+        q.heat = 1;
+        // A supernova is a CONSERVATION event: the ejected matter rejoins the PERSISTENT
+        // field. Mortal (class-[S] source-spawned) matter that a sink captured and held is
+        // released immortal — so a source→sink→supernova loop visibly conserves (the matter
+        // the source made becomes lasting field matter, bounded by the engine's pool ceiling)
+        // instead of the released particles aging out and vanishing moments after release. A
+        // no-op for the conserved base pool (age already undefined), so the canonical sink —
+        // captured base particles return exactly as before — is unchanged.
+        q.age = undefined;
+        released.push(q);
+    }
+    b.accreted = 0;
+    return released;
+}
+/** Sink fill fraction ∈ [0,1] — the value written to `--load` / `--mass`. 0 when not a sink. */
+export function sinkLoad(b) {
+    if (b.capacity <= 0)
+        return 0;
+    const f = b.accreted / b.capacity;
+    return f < 0 ? 0 : f > 1 ? 1 : f;
+}
+/**
+ * Capture/release event edge for a sink body. `prevArmed` is whether `captured` has fired since the
+ * last release; `accreting` is `b.accreted > 0` after this frame's force pass. Rising edge →
+ * `captured`; falling edge (which only happens via release/supernova, since load drops to 0 there)
+ * → `released`. Pure: the caller persists `armed` and performs the dispatch.
+ */
+export function captureEdge(prevArmed, accreting) {
+    if (accreting && !prevArmed)
+        return { fire: 'captured', armed: true };
+    if (!accreting && prevArmed)
+        return { fire: 'released', armed: false };
+    return { fire: null, armed: prevArmed };
+}
+/**
+ * Attention-gated discharge (#365, the Contour Charge behavior): a sink gated on engagement
+ * (`data-when="active"`) releases what it holds on the FALLING edge of engagement — the vessel
+ * charges while attended and discharges when attention leaves. The condition pass already gates
+ * capture (a closed gate pulls nothing new in); this is the matching release side. Pure trigger:
+ * the caller supplies the release ritual (the engine passes `env.supernova`, so discharge is the
+ * same conserved release — same radial burst, same `field:released` event — as saturation).
+ * Returns the bodies that discharged this pass.
+ */
+export function dischargeDisengaged(bodies, release) {
+    const discharged = [];
+    for (const b of bodies) {
+        if (b.when !== 'active' || !b.tokens.includes('sink'))
+            continue;
+        if (b.wasOn && !b.on && b.accreted > 0) {
+            release(b);
+            discharged.push(b);
+        }
+        b.wasOn = b.on;
+    }
+    return discharged;
+}
+//# sourceMappingURL=accretion.js.map

package/dist/core/accretion.js.map

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

package/dist/core/agents.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Element agents (§22.4) — a force can move a DOM element by a transform offset,
+ * with an anchor spring pulling it back to its layout slot. Pure integration
+ * here; the per-frame force probe and the transform writes live in the field loop.
+ */
+import type { Vec2 } from './types.ts';
+export interface ElementOffset {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+}
+/** Integrate an element's offset under a net force (element mass + damping, §22.4). */
+export declare function integrateOffset(o: ElementOffset, fx: number, fy: number, mEl: number, friction?: number, maxOffset?: number): void;
+/** The anchor-spring force pulling an offset back toward home (o = 0, §22.4). */
+export declare function anchorForce(o: ElementOffset, k?: number): Vec2;
+/** Element inertial mass from its rendered area (heavier = harder to move). */
+export declare function elementMass(area: number): number;
+/**
+ * Self-laying-out repulsion (Concept 3): every other element pushes this one away,
+ * `Σ C·(c − cⱼ)/|c − cⱼ|²` — so a cluster spreads out. Softened near coincidence so
+ * fully-overlapping elements don't blow up. `others` are the other element centres.
+ */
+export declare function repelForce(self: Vec2, others: readonly Vec2[], C?: number, soft?: number): Vec2;
+/**
+ * Density-pressure force (Concept 3): push an element *down* the local density gradient
+ * (toward emptier field), `−∇ρ`, estimated by a 4-tap finite difference of a density
+ * sampler at `±delta`. So elements drift off crowded matter toward open space.
+ */
+export declare function densityPush(sample: (x: number, y: number) => number, x: number, y: number, delta?: number, scale?: number): Vec2;
+//# sourceMappingURL=agents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/core/agents.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,uFAAuF;AACvF,wBAAgB,eAAe,CAC7B,CAAC,EAAE,aAAa,EAChB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,QAAQ,SAAM,EACd,SAAS,SAAK,GACb,IAAI,CAWN;AAED,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,SAAO,GAAG,IAAI,CAE5D;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,IAAI,EAAE,EAAE,CAAC,SAAO,EAAE,IAAI,SAAK,GAAG,IAAI,CAYzF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EACxC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,SAAK,EACV,KAAK,SAAI,GACR,IAAI,CAIN"}

package/dist/core/agents.js

@@ -0,0 +1,51 @@
+/** Integrate an element's offset under a net force (element mass + damping, §22.4). */
+export function integrateOffset(o, fx, fy, mEl, friction = 0.9, maxOffset = 80) {
+    const m = mEl > 0 ? mEl : 1;
+    o.vx = (o.vx + fx / m) * friction;
+    o.vy = (o.vy + fy / m) * friction;
+    o.x += o.vx;
+    o.y += o.vy;
+    const d = Math.hypot(o.x, o.y);
+    if (d > maxOffset) {
+        o.x = (o.x / d) * maxOffset;
+        o.y = (o.y / d) * maxOffset;
+    }
+}
+/** The anchor-spring force pulling an offset back toward home (o = 0, §22.4). */
+export function anchorForce(o, k = 0.02) {
+    return { x: -o.x * k, y: -o.y * k };
+}
+/** Element inertial mass from its rendered area (heavier = harder to move). */
+export function elementMass(area) {
+    const m = area / 30000;
+    return m < 0.6 ? 0.6 : m > 6 ? 6 : m;
+}
+/**
+ * Self-laying-out repulsion (Concept 3): every other element pushes this one away,
+ * `Σ C·(c − cⱼ)/|c − cⱼ|²` — so a cluster spreads out. Softened near coincidence so
+ * fully-overlapping elements don't blow up. `others` are the other element centres.
+ */
+export function repelForce(self, others, C = 1600, soft = 26) {
+    let fx = 0;
+    let fy = 0;
+    const s2 = soft * soft;
+    for (const o of others) {
+        const dx = self.x - o.x;
+        const dy = self.y - o.y;
+        const d2 = dx * dx + dy * dy + s2; // softened |c − cⱼ|²
+        fx += (C * dx) / d2; // magnitude ≈ C/|d| along the separation unit vector
+        fy += (C * dy) / d2;
+    }
+    return { x: fx, y: fy };
+}
+/**
+ * Density-pressure force (Concept 3): push an element *down* the local density gradient
+ * (toward emptier field), `−∇ρ`, estimated by a 4-tap finite difference of a density
+ * sampler at `±delta`. So elements drift off crowded matter toward open space.
+ */
+export function densityPush(sample, x, y, delta = 16, scale = 1) {
+    const gx = (sample(x + delta, y) - sample(x - delta, y)) / (2 * delta);
+    const gy = (sample(x, y + delta) - sample(x, y - delta)) / (2 * delta);
+    return { x: -gx * scale, y: -gy * scale }; // negative gradient → toward lower density
+}
+//# sourceMappingURL=agents.js.map

package/dist/core/agents.js.map

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

package/dist/core/attention.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Conserved attention (§2.4 + possibilities Concept 2) — one finite *strength
+ * budget* for the whole page. Engaging a body raises its demand and, because the
+ * total is conserved, pulls allocation off every other body: the field physically
+ * cannot emphasise two things at once. Navigation becomes moving force between
+ * sections, not fading opacity.
+ *
+ * This is pure: it returns a per-body effective-strength multiplier the integrator
+ * folds into each body's force. The model is feed-forward on *demand* (configured
+ * strength × engagement), which gives it two properties worth keeping:
+ *
+ *   1. Rest-neutral — when nothing is engaged every multiplier is exactly 1, so a
+ *      field that opts in is unchanged until something is actually engaged.
+ *   2. Total-strength-conserving — Σ Sᵢ·mulᵢ = Σ Sᵢ (within the clamp). The budget
+ *      is literally invariant frame to frame; a boost to one body is exactly the
+ *      starvation of the others.
+ *
+ *   demandᵢ = 1 + β·onᵢ            (β = engagement multiplier)
+ *   mulᵢ    = demandᵢ · (Σ Sⱼ / Σ Sⱼ·demandⱼ)
+ *
+ * The closed form drops out: the normaliser `k = ΣS / ΣM` is 1 when nothing is
+ * engaged, < 1 once anything is, so idle bodies dim (·k) while engaged bodies gain
+ * ((1+β)·k). A density-closed-loop variant (steer toward actual fill, §8) is a
+ * possible refinement; this feed-forward form is chosen first for stability.
+ */
+export interface AttnInput {
+    /** the body's configured force magnitude S. */
+    strength: number;
+    /** engaged (hover / focus / tap). */
+    on: boolean;
+}
+export interface AttnOpts {
+    /** engagement multiplier β — how much harder an engaged body competes (default 2). */
+    beta?: number;
+    /** clamp floor for the multiplier (default 0.25). */
+    lo?: number;
+    /** clamp ceiling for the multiplier (default 3). */
+    hi?: number;
+}
+export interface AttnAllocItem {
+    /** the item's competitive demand — any non-negative magnitude (a lens-weighted urgency, say). */
+    urgency: number;
+    /** pinned items sit outside the competition: each takes exactly `cap` off the top. */
+    pinned?: boolean;
+}
+export interface AttnAllocOpts {
+    /** per-item weight ceiling (default 1). */
+    cap?: number;
+}
+/**
+ * Conserved allocation (§2.4 — one finite budget): distribute `budget` across items
+ * proportional to `urgency`, capping each weight at `cap` (default 1) and re-flowing
+ * capped excess over the rest (water-filling). `pinned` items take exactly `cap` off
+ * the top; the remaining budget water-fills over the unpinned by urgency.
+ *
+ * Invariant: Σ(returned) === budget (±ε) whenever budget ≤ items.length × cap and the
+ * unpinned items carry any positive urgency. Zero/negative/non-finite urgencies get 0 —
+ * the budget only flows where there is demand, so an all-zero unpinned set allocates
+ * nothing (extracted as-is from the Inbox example, where this never starves anyone:
+ * urgencies are blends of normalized signals). Past the ceiling (budget > N × cap)
+ * every weight saturates at `cap`. Pure; deterministic; never NaN; never negative;
+ * each weight ≤ cap. Each water-filling pass either finishes or caps at least one
+ * item, so N passes always converge.
+ */
+export declare function allocateAttention(items: ReadonlyArray<AttnAllocItem>, budget: number, opts?: AttnAllocOpts): number[];
+/**
+ * The per-body effective-strength multipliers for one frame, index-aligned with
+ * `bodies`. All 1 when nothing is engaged or the input is degenerate (empty /
+ * non-positive total), so it is always safe to apply.
+ */
+export declare function attentionMuls(bodies: readonly AttnInput[], opts?: AttnOpts): number[];
+//# sourceMappingURL=attention.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attention.d.ts","sourceRoot":"","sources":["../../src/core/attention.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,EAAE,EAAE,OAAO,CAAC;CACb;AAED,MAAM,WAAW,QAAQ;IACvB,sFAAsF;IACtF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,iGAAiG;IACjG,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,EACnC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,aAAkB,GACvB,MAAM,EAAE,CA2CV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,EAAE,IAAI,GAAE,QAAa,GAAG,MAAM,EAAE,CA0BzF"}

package/dist/core/attention.js

@@ -0,0 +1,122 @@
+/**
+ * Conserved attention (§2.4 + possibilities Concept 2) — one finite *strength
+ * budget* for the whole page. Engaging a body raises its demand and, because the
+ * total is conserved, pulls allocation off every other body: the field physically
+ * cannot emphasise two things at once. Navigation becomes moving force between
+ * sections, not fading opacity.
+ *
+ * This is pure: it returns a per-body effective-strength multiplier the integrator
+ * folds into each body's force. The model is feed-forward on *demand* (configured
+ * strength × engagement), which gives it two properties worth keeping:
+ *
+ *   1. Rest-neutral — when nothing is engaged every multiplier is exactly 1, so a
+ *      field that opts in is unchanged until something is actually engaged.
+ *   2. Total-strength-conserving — Σ Sᵢ·mulᵢ = Σ Sᵢ (within the clamp). The budget
+ *      is literally invariant frame to frame; a boost to one body is exactly the
+ *      starvation of the others.
+ *
+ *   demandᵢ = 1 + β·onᵢ            (β = engagement multiplier)
+ *   mulᵢ    = demandᵢ · (Σ Sⱼ / Σ Sⱼ·demandⱼ)
+ *
+ * The closed form drops out: the normaliser `k = ΣS / ΣM` is 1 when nothing is
+ * engaged, < 1 once anything is, so idle bodies dim (·k) while engaged bodies gain
+ * ((1+β)·k). A density-closed-loop variant (steer toward actual fill, §8) is a
+ * possible refinement; this feed-forward form is chosen first for stability.
+ */
+/**
+ * Conserved allocation (§2.4 — one finite budget): distribute `budget` across items
+ * proportional to `urgency`, capping each weight at `cap` (default 1) and re-flowing
+ * capped excess over the rest (water-filling). `pinned` items take exactly `cap` off
+ * the top; the remaining budget water-fills over the unpinned by urgency.
+ *
+ * Invariant: Σ(returned) === budget (±ε) whenever budget ≤ items.length × cap and the
+ * unpinned items carry any positive urgency. Zero/negative/non-finite urgencies get 0 —
+ * the budget only flows where there is demand, so an all-zero unpinned set allocates
+ * nothing (extracted as-is from the Inbox example, where this never starves anyone:
+ * urgencies are blends of normalized signals). Past the ceiling (budget > N × cap)
+ * every weight saturates at `cap`. Pure; deterministic; never NaN; never negative;
+ * each weight ≤ cap. Each water-filling pass either finishes or caps at least one
+ * item, so N passes always converge.
+ */
+export function allocateAttention(items, budget, opts = {}) {
+    const cap = opts.cap ?? 1;
+    const n = items.length;
+    const w = new Array(n).fill(0);
+    if (n === 0 || !(cap > 0))
+        return w;
+    // pins first — each holds exactly `cap`, off the top of the budget.
+    const u = new Array(n).fill(0);
+    let free = [];
+    let pinnedCount = 0;
+    for (let i = 0; i < n; i++) {
+        const it = items[i];
+        if (it.pinned) {
+            w[i] = cap;
+            pinnedCount++;
+        }
+        else {
+            u[i] = Number.isFinite(it.urgency) && it.urgency > 0 ? it.urgency : 0;
+            free.push(i);
+        }
+    }
+    // water-fill the rest: scale urgencies so the round sums to the remaining budget,
+    // saturate anything that would exceed `cap`, re-flow the freed budget over the rest.
+    let rem = Math.max(0, budget - pinnedCount * cap);
+    for (let pass = 0; pass < n && free.length && rem > 0; pass++) {
+        const sum = free.reduce((s, i) => s + u[i], 0) || 1;
+        const k = rem / sum;
+        const still = [];
+        let capped = 0;
+        for (const i of free) {
+            if (u[i] * k >= cap) {
+                w[i] = cap;
+                capped++;
+            }
+            else
+                still.push(i);
+        }
+        if (!capped) {
+            for (const i of still)
+                w[i] = u[i] * k;
+            break;
+        }
+        rem -= capped * cap; // provably ≥ 0: each capped share was ≥ cap of a round summing to rem
+        free = still;
+    }
+    return w;
+}
+/**
+ * The per-body effective-strength multipliers for one frame, index-aligned with
+ * `bodies`. All 1 when nothing is engaged or the input is degenerate (empty /
+ * non-positive total), so it is always safe to apply.
+ */
+export function attentionMuls(bodies, opts = {}) {
+    const beta = opts.beta ?? 2;
+    const lo = opts.lo ?? 0.25;
+    const hi = opts.hi ?? 3;
+    const n = bodies.length;
+    const out = new Array(n).fill(1);
+    if (n === 0)
+        return out;
+    let sumS = 0;
+    let sumM = 0;
+    for (const b of bodies) {
+        const s = b.strength > 0 ? b.strength : 0;
+        sumS += s;
+        sumM += s * (1 + (b.on ? beta : 0));
+    }
+    if (sumS <= 0 || sumM <= 0)
+        return out; // nothing to allocate → leave neutral
+    const k = sumS / sumM; // demand normaliser; exactly 1 when nothing is engaged
+    for (let i = 0; i < n; i++) {
+        const demand = 1 + (bodies[i].on ? beta : 0);
+        let mul = demand * k;
+        if (mul < lo)
+            mul = lo;
+        else if (mul > hi)
+            mul = hi;
+        out[i] = mul;
+    }
+    return out;
+}
+//# sourceMappingURL=attention.js.map

package/dist/core/attention.js.map

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

package/dist/core/causality.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cross-boundary causality (possibilities Concept 4) — density doesn't stop at a
+ * body's edge. When a body saturates (its eased density `d` climbs past a
+ * threshold, e.g. because it's engaged and gathering matter), the excess **spills
+ * to its neighbours**, weighted by proximity, as a conserved transfer. Hover one
+ * card and the ones beside it light up; the wiring between elements appears because
+ * matter actually flows between them, not because it was hand-drawn (§10 threads,
+ * made emergent).
+ *
+ * Pure: given each body's density and centre, returns the per-body **lit delta** —
+ * how much density it receives from (or donates to) its neighbours this frame. The
+ * caller adds it to `d` to get the body's `lit` signal, writes that to the element,
+ * and fires a DOM event on threshold crossing.
+ *
+ *   excessᵢ = max(0, dᵢ − θ)
+ *   wᵢⱼ     = max(0, 1 − dist(i,j)/falloff)        proximity weight, bounded (no 1/d blow-up)
+ *   Φᵢⱼ     = κ · excessᵢ · wᵢⱼ / Σₖ wᵢₖ            i donates, j receives
+ *   Δⱼ      = Σᵢ Φᵢⱼ − Σⱼ Φⱼₖ                       received − donated
+ *
+ * Conserved by construction: ΣΔ = 0 (every donation is exactly a reception).
+ */
+export interface SpillBody {
+    /** eased density d ∈ [0,1] (§8). */
+    d: number;
+    cx: number;
+    cy: number;
+}
+export interface SpillOpts {
+    /** density above which a body spills its excess (default 0.55). */
+    threshold?: number;
+    /** fraction of the excess that flows out (default 0.6). */
+    kappa?: number;
+    /** proximity reach in px — past this, no transfer (default 320). */
+    falloff?: number;
+}
+/** Per-body lit delta (received − donated), index-aligned with `bodies`. Sums to 0. */
+export declare function spillover(bodies: readonly SpillBody[], opts?: SpillOpts): number[];
+//# sourceMappingURL=causality.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"causality.d.ts","sourceRoot":"","sources":["../../src/core/causality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,SAAS;IACxB,oCAAoC;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,SAAS;IACxB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,uFAAuF;AACvF,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,EAAE,IAAI,GAAE,SAAc,GAAG,MAAM,EAAE,CAuCtF"}

package/dist/core/causality.js

@@ -0,0 +1,64 @@
+/**
+ * Cross-boundary causality (possibilities Concept 4) — density doesn't stop at a
+ * body's edge. When a body saturates (its eased density `d` climbs past a
+ * threshold, e.g. because it's engaged and gathering matter), the excess **spills
+ * to its neighbours**, weighted by proximity, as a conserved transfer. Hover one
+ * card and the ones beside it light up; the wiring between elements appears because
+ * matter actually flows between them, not because it was hand-drawn (§10 threads,
+ * made emergent).
+ *
+ * Pure: given each body's density and centre, returns the per-body **lit delta** —
+ * how much density it receives from (or donates to) its neighbours this frame. The
+ * caller adds it to `d` to get the body's `lit` signal, writes that to the element,
+ * and fires a DOM event on threshold crossing.
+ *
+ *   excessᵢ = max(0, dᵢ − θ)
+ *   wᵢⱼ     = max(0, 1 − dist(i,j)/falloff)        proximity weight, bounded (no 1/d blow-up)
+ *   Φᵢⱼ     = κ · excessᵢ · wᵢⱼ / Σₖ wᵢₖ            i donates, j receives
+ *   Δⱼ      = Σᵢ Φᵢⱼ − Σⱼ Φⱼₖ                       received − donated
+ *
+ * Conserved by construction: ΣΔ = 0 (every donation is exactly a reception).
+ */
+/** Per-body lit delta (received − donated), index-aligned with `bodies`. Sums to 0. */
+export function spillover(bodies, opts = {}) {
+    const threshold = opts.threshold ?? 0.55;
+    const kappa = opts.kappa ?? 0.6;
+    const falloff = opts.falloff ?? 320;
+    const n = bodies.length;
+    const delta = new Array(n).fill(0);
+    if (n < 2)
+        return delta;
+    const w = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+        const bi = bodies[i];
+        const excess = bi.d - threshold;
+        if (excess <= 0)
+            continue;
+        // proximity weights to every other body within reach
+        let total = 0;
+        for (let j = 0; j < n; j++) {
+            if (j === i) {
+                w[j] = 0;
+                continue;
+            }
+            const bj = bodies[j];
+            const dist = Math.hypot(bi.cx - bj.cx, bi.cy - bj.cy);
+            const ww = dist < falloff ? 1 - dist / falloff : 0;
+            w[j] = ww;
+            total += ww;
+        }
+        if (total <= 0)
+            continue;
+        const out = kappa * excess; // total density this body spills
+        for (let j = 0; j < n; j++) {
+            const wj = w[j];
+            if (wj <= 0)
+                continue;
+            const phi = (out * wj) / total;
+            delta[j] += phi; // neighbour receives
+            delta[i] -= phi; // this body donates (conserved)
+        }
+    }
+    return delta;
+}
+//# sourceMappingURL=causality.js.map

package/dist/core/causality.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"causality.js","sourceRoot":"","sources":["../../src/core/causality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkBH,uFAAuF;AACvF,MAAM,UAAU,SAAS,CAAC,MAA4B,EAAE,OAAkB,EAAE;IAC1E,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;IACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,GAAG,CAAC;IAChC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;IACpC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACxB,MAAM,KAAK,GAAG,IAAI,KAAK,CAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAExB,MAAM,CAAC,GAAG,IAAI,KAAK,CAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;QACtB,MAAM,MAAM,GAAG,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;QAChC,IAAI,MAAM,IAAI,CAAC;YAAE,SAAS;QAE1B,qDAAqD;QACrD,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACZ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBACT,SAAS;YACX,CAAC;YACD,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAE,CAAC;YACtB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;YACtD,MAAM,EAAE,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACV,KAAK,IAAI,EAAE,CAAC;QACd,CAAC;QACD,IAAI,KAAK,IAAI,CAAC;YAAE,SAAS;QAEzB,MAAM,GAAG,GAAG,KAAK,GAAG,MAAM,CAAC,CAAC,iCAAiC;QAC7D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC;YACjB,IAAI,EAAE,IAAI,CAAC;gBAAE,SAAS;YACtB,MAAM,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC;YAC/B,KAAK,CAAC,CAAC,CAAE,IAAI,GAAG,CAAC,CAAC,qBAAqB;YACvC,KAAK,CAAC,CAAC,CAAE,IAAI,GAAG,CAAC,CAAC,gCAAgC;QACpD,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/core/conditions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Built-in `data-when` gate predicates (§5). Selective gates read each particle;
+ * `active` reads the body; `scrolling` reads the shared frame state (`env.scrollV`),
+ * so it acts only while the page is actually scrolling.
+ */
+import type { Body, ConditionRegistry, Env, Particle } from './types.ts';
+export declare const conditions: ConditionRegistry;
+/** Does body `b`'s gate pass for particle `p`? Empty gate (`''`) always passes. */
+export declare function passes(reg: ConditionRegistry, b: Body, p: Particle, env?: Env): boolean;
+//# sourceMappingURL=conditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/core/conditions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAa,iBAAiB,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEpF,eAAO,MAAM,UAAU,EAAE,iBAQxB,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,GAAG,EAAE,iBAAiB,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAIvF"}

package/dist/core/conditions.js

@@ -0,0 +1,22 @@
+/**
+ * Built-in `data-when` gate predicates (§5). Selective gates read each particle;
+ * `active` reads the body; `scrolling` reads the shared frame state (`env.scrollV`),
+ * so it acts only while the page is actually scrolling.
+ */
+export const conditions = {
+    active: (b) => b.on,
+    // speed gates read the full 3D speed (z-axis.md) — vz is 0 in a flat field.
+    fast: (_b, p) => p.vx * p.vx + p.vy * p.vy + (p.vz ?? 0) * (p.vz ?? 0) > 0.9,
+    slow: (_b, p) => p.vx * p.vx + p.vy * p.vy + (p.vz ?? 0) * (p.vz ?? 0) < 0.22,
+    hot: (_b, p) => p.heat > 0.3,
+    cool: (_b, p) => p.heat < 0.08,
+    scrolling: (_b, _p, env) => (env?.scrollV ?? 0) > 0.25,
+};
+/** Does body `b`'s gate pass for particle `p`? Empty gate (`''`) always passes. */
+export function passes(reg, b, p, env) {
+    if (!b.when)
+        return true;
+    const fn = reg[b.when];
+    return fn ? fn(b, p, env) : true;
+}
+//# sourceMappingURL=conditions.js.map

package/dist/core/conditions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.js","sourceRoot":"","sources":["../../src/core/conditions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,CAAC,MAAM,UAAU,GAAsB;IAC3C,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE;IACnB,4EAA4E;IAC5E,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,GAAG;IAC5E,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI;IAC7E,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG;IAC5B,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI;IAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,OAAO,IAAI,CAAC,CAAC,GAAG,IAAI;CACvD,CAAC;AAEF,mFAAmF;AACnF,MAAM,UAAU,MAAM,CAAC,GAAsB,EAAE,CAAO,EAAE,CAAW,EAAE,GAAS;IAC5E,IAAI,CAAC,CAAC,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,EAAE,GAA0B,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC9C,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACnC,CAAC"}