@fundamental-engine/core 0.4.0

package/dist/core/weights.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Weight primitives — the page-weight → body-strength contract made one definition.
+ *
+ * Every page in the example family computes the same two numbers by hand:
+ *
+ *   1. **A weight** — a positive magnitude (citations, market cap, message count) log-normalized
+ *      against the set's max into `0..1`: `ln(x+1) / ln(max+1)`. The log is the family's standard
+ *      "consensus" shape — heavy-tailed data (one work with 6,046 citations next to one with 12)
+ *      compresses into a legible range while zero stays exactly zero and the max reads exactly one.
+ *   2. **A strength** — that weight mapped onto the engine's attract-body range for the
+ *      `data-strength` attribute: `0.4 + w · 1.6`, i.e. `w ∈ 0..1 → strength ∈ 0.4..2.0`. The floor
+ *      keeps even the lightest body *present* in the field (strength 0 would make it inert); the
+ *      ceiling is the range the example family's attract bodies were tuned in.
+ *
+ * That pair IS the contract between page weights and engine body strengths, and it was hand-rolled
+ * at ~38 call sites — drift-prone magic numbers. These primitives are the extraction (the same
+ * ratchet as `temporal.ts`, the sibling module): pure, deterministic maps — zero DOM, zero state.
+ * Degenerate inputs (NaN, ±Infinity, negative magnitudes, `max ≤ 0`) never produce NaN — each
+ * function documents its safe value.
+ *
+ * Equivalences for callers replacing the hand-rolls (the wave-2 spec):
+ *
+ *   - `logNormalize(x, max)` `===` `Math.log(x + 1) / Math.log(max + 1)` for finite `x ≥ 0` and
+ *     finite `max > 0` with `x ≤ max` — bit-for-bit, no epsilon (same expression, then clamped).
+ *     The evidence page's `Math.max(...counts, 1)` guard on the max is subsumed by the `max ≤ 0 → 0`
+ *     rule for integer counts: all-zero counts produce all-zero weights either way.
+ *   - `el.dataset.strength = (0.4 + w * 1.6).toFixed(2)` becomes
+ *     `el.dataset.strength = weightToStrength(w).toFixed(2)` — the function returns the number;
+ *     the two-decimal formatting stays at the attribute write.
+ */
+/**
+ * The `data-strength` floor: `weightToStrength(0)` — the lightest body's strength. A zero-weight
+ * body still participates in the field; it is light, not absent.
+ */
+export declare const WEIGHT_STRENGTH_BASE = 0.4;
+/**
+ * The `data-strength` span: `weightToStrength(1) − weightToStrength(0)`. Base + span = `2.0`,
+ * the heaviest attract strength the example family uses.
+ */
+export declare const WEIGHT_STRENGTH_SPAN = 1.6;
+/**
+ * Log-normalize a positive magnitude against the set's max:
+ *
+ *     weight = clamp01( ln(value + 1) / ln(max + 1) )
+ *
+ * The family's standard "consensus" shape — heavy tails compress (a 500× citation gap reads as a
+ * legible weight gap, not a 500× one), zero stays exactly `0`, and `value === max` reads exactly
+ * `1`. Monotonically non-decreasing in `value` for a fixed `max > 0`.
+ *
+ * For finite `value ≥ 0` and finite `max > 0` with `value ≤ max` this is bit-for-bit
+ * `Math.log(value + 1) / Math.log(max + 1)` — the exact expression the example pages hand-roll.
+ *
+ * Degenerate inputs: `max ≤ 0` (or non-finite) returns `0` for every value — no max, no scale;
+ * a negative, NaN, or `-Infinity` value reads as `0`; a value above the max (`+Infinity`
+ * included) clamps to `1` — live updates can briefly outrun a stale max; re-normalize via
+ * {@link logNormalizeAll}.
+ */
+export declare function logNormalize(value: number, max: number): number;
+/**
+ * {@link logNormalize} over a whole set in one pass: weights are index-aligned with `values`,
+ * each normalized against the set's own max (negative/NaN entries read as `0`, exactly as in
+ * `logNormalize`). The max is returned too — live pages keep it and re-normalize incoming
+ * single values against it between full passes.
+ *
+ * An empty set, or one with no positive finite value, returns `{ weights: [0, …], max: 0 }`
+ * (all-zero counts produce all-zero weights — the same result as the pages'
+ * `Math.max(...counts, 1)` guard). Otherwise the largest entry's weight is exactly `1`.
+ */
+export declare function logNormalizeAll(values: readonly number[]): {
+    weights: number[];
+    max: number;
+};
+/**
+ * The page-weight → engine-strength contract:
+ *
+ *     strength = WEIGHT_STRENGTH_BASE + w · WEIGHT_STRENGTH_SPAN    (= 0.4 + w · 1.6)
+ *
+ * so `w ∈ 0..1 → strength ∈ 0.4..2.0` — the attract-body range every example uses for
+ * `data-strength`. The constants are exported so the mapping has ONE definition; the endpoints
+ * are exact: `weightToStrength(0) === 0.4`, `weightToStrength(1) === 2.0`. Monotonically
+ * increasing in `w`.
+ *
+ * Returns the number; callers `.toFixed(2)` at the attribute write
+ * (`el.dataset.strength = weightToStrength(w).toFixed(2)`).
+ *
+ * Degenerate inputs: `w` outside `0..1` clamps to the endpoints (±Infinity included); NaN reads
+ * as `0` — an unknown weight is a light body, not a NaN attribute.
+ */
+export declare function weightToStrength(w: number): number;
+/**
+ * Min–max log normalization — the family's *contrast-stretched* weight shape:
+ *
+ * ```txt
+ * w = (ln(value + 1) − ln(min + 1)) / (ln(max + 1) − ln(min + 1))
+ * ```
+ *
+ * Where {@link logNormalize} anchors zero at zero (absolute consensus — a 10-citation paper
+ * stays light next to a 10,000-citation one), `logNormalizeBetween` stretches the SET's own
+ * range to 0..1 — the lightest member reads 0, the heaviest 1 — which is what the dense
+ * mosaics/front pages use so every tier is visually distinct (market caps, pageviews,
+ * listens, reply tempo). Bit-identical to the pages' hand-rolled
+ * `(Math.log(v + 1) − lmin) / (lmax − lmin)` for finite inputs in range.
+ *
+ * Degenerate set (max ≤ min — all values equal): returns `opts.equal`, default `1` (the
+ * market/newsroom convention: an undifferentiated set reads heavy, not absent). Pass
+ * `{ equal: 0 }` for the inverse convention. Out-of-range values clamp to 0..1; NaN reads 0.
+ */
+export declare function logNormalizeBetween(value: number, min: number, max: number, opts?: {
+    equal?: number;
+}): number;
+//# sourceMappingURL=weights.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"weights.d.ts","sourceRoot":"","sources":["../../src/core/weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAIxC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAI7F;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACxB,MAAM,CAMR"}

package/dist/core/weights.js

@@ -0,0 +1,128 @@
+/**
+ * Weight primitives — the page-weight → body-strength contract made one definition.
+ *
+ * Every page in the example family computes the same two numbers by hand:
+ *
+ *   1. **A weight** — a positive magnitude (citations, market cap, message count) log-normalized
+ *      against the set's max into `0..1`: `ln(x+1) / ln(max+1)`. The log is the family's standard
+ *      "consensus" shape — heavy-tailed data (one work with 6,046 citations next to one with 12)
+ *      compresses into a legible range while zero stays exactly zero and the max reads exactly one.
+ *   2. **A strength** — that weight mapped onto the engine's attract-body range for the
+ *      `data-strength` attribute: `0.4 + w · 1.6`, i.e. `w ∈ 0..1 → strength ∈ 0.4..2.0`. The floor
+ *      keeps even the lightest body *present* in the field (strength 0 would make it inert); the
+ *      ceiling is the range the example family's attract bodies were tuned in.
+ *
+ * That pair IS the contract between page weights and engine body strengths, and it was hand-rolled
+ * at ~38 call sites — drift-prone magic numbers. These primitives are the extraction (the same
+ * ratchet as `temporal.ts`, the sibling module): pure, deterministic maps — zero DOM, zero state.
+ * Degenerate inputs (NaN, ±Infinity, negative magnitudes, `max ≤ 0`) never produce NaN — each
+ * function documents its safe value.
+ *
+ * Equivalences for callers replacing the hand-rolls (the wave-2 spec):
+ *
+ *   - `logNormalize(x, max)` `===` `Math.log(x + 1) / Math.log(max + 1)` for finite `x ≥ 0` and
+ *     finite `max > 0` with `x ≤ max` — bit-for-bit, no epsilon (same expression, then clamped).
+ *     The evidence page's `Math.max(...counts, 1)` guard on the max is subsumed by the `max ≤ 0 → 0`
+ *     rule for integer counts: all-zero counts produce all-zero weights either way.
+ *   - `el.dataset.strength = (0.4 + w * 1.6).toFixed(2)` becomes
+ *     `el.dataset.strength = weightToStrength(w).toFixed(2)` — the function returns the number;
+ *     the two-decimal formatting stays at the attribute write.
+ */
+/**
+ * The `data-strength` floor: `weightToStrength(0)` — the lightest body's strength. A zero-weight
+ * body still participates in the field; it is light, not absent.
+ */
+export const WEIGHT_STRENGTH_BASE = 0.4;
+/**
+ * The `data-strength` span: `weightToStrength(1) − weightToStrength(0)`. Base + span = `2.0`,
+ * the heaviest attract strength the example family uses.
+ */
+export const WEIGHT_STRENGTH_SPAN = 1.6;
+const clamp01 = (n) => (n < 0 ? 0 : n > 1 ? 1 : n);
+/**
+ * Log-normalize a positive magnitude against the set's max:
+ *
+ *     weight = clamp01( ln(value + 1) / ln(max + 1) )
+ *
+ * The family's standard "consensus" shape — heavy tails compress (a 500× citation gap reads as a
+ * legible weight gap, not a 500× one), zero stays exactly `0`, and `value === max` reads exactly
+ * `1`. Monotonically non-decreasing in `value` for a fixed `max > 0`.
+ *
+ * For finite `value ≥ 0` and finite `max > 0` with `value ≤ max` this is bit-for-bit
+ * `Math.log(value + 1) / Math.log(max + 1)` — the exact expression the example pages hand-roll.
+ *
+ * Degenerate inputs: `max ≤ 0` (or non-finite) returns `0` for every value — no max, no scale;
+ * a negative, NaN, or `-Infinity` value reads as `0`; a value above the max (`+Infinity`
+ * included) clamps to `1` — live updates can briefly outrun a stale max; re-normalize via
+ * {@link logNormalizeAll}.
+ */
+export function logNormalize(value, max) {
+    if (!Number.isFinite(max) || max <= 0)
+        return 0;
+    const v = value > 0 ? value : 0; // NaN/negatives/−Infinity read as 0; +Infinity clamps below
+    return clamp01(Math.log(v + 1) / Math.log(max + 1));
+}
+/**
+ * {@link logNormalize} over a whole set in one pass: weights are index-aligned with `values`,
+ * each normalized against the set's own max (negative/NaN entries read as `0`, exactly as in
+ * `logNormalize`). The max is returned too — live pages keep it and re-normalize incoming
+ * single values against it between full passes.
+ *
+ * An empty set, or one with no positive finite value, returns `{ weights: [0, …], max: 0 }`
+ * (all-zero counts produce all-zero weights — the same result as the pages'
+ * `Math.max(...counts, 1)` guard). Otherwise the largest entry's weight is exactly `1`.
+ */
+export function logNormalizeAll(values) {
+    let max = 0;
+    for (const v of values)
+        if (Number.isFinite(v) && v > max)
+            max = v;
+    return { weights: values.map((v) => logNormalize(v, max)), max };
+}
+/**
+ * The page-weight → engine-strength contract:
+ *
+ *     strength = WEIGHT_STRENGTH_BASE + w · WEIGHT_STRENGTH_SPAN    (= 0.4 + w · 1.6)
+ *
+ * so `w ∈ 0..1 → strength ∈ 0.4..2.0` — the attract-body range every example uses for
+ * `data-strength`. The constants are exported so the mapping has ONE definition; the endpoints
+ * are exact: `weightToStrength(0) === 0.4`, `weightToStrength(1) === 2.0`. Monotonically
+ * increasing in `w`.
+ *
+ * Returns the number; callers `.toFixed(2)` at the attribute write
+ * (`el.dataset.strength = weightToStrength(w).toFixed(2)`).
+ *
+ * Degenerate inputs: `w` outside `0..1` clamps to the endpoints (±Infinity included); NaN reads
+ * as `0` — an unknown weight is a light body, not a NaN attribute.
+ */
+export function weightToStrength(w) {
+    return WEIGHT_STRENGTH_BASE + clamp01(Number.isNaN(w) ? 0 : w) * WEIGHT_STRENGTH_SPAN;
+}
+/**
+ * Min–max log normalization — the family's *contrast-stretched* weight shape:
+ *
+ * ```txt
+ * w = (ln(value + 1) − ln(min + 1)) / (ln(max + 1) − ln(min + 1))
+ * ```
+ *
+ * Where {@link logNormalize} anchors zero at zero (absolute consensus — a 10-citation paper
+ * stays light next to a 10,000-citation one), `logNormalizeBetween` stretches the SET's own
+ * range to 0..1 — the lightest member reads 0, the heaviest 1 — which is what the dense
+ * mosaics/front pages use so every tier is visually distinct (market caps, pageviews,
+ * listens, reply tempo). Bit-identical to the pages' hand-rolled
+ * `(Math.log(v + 1) − lmin) / (lmax − lmin)` for finite inputs in range.
+ *
+ * Degenerate set (max ≤ min — all values equal): returns `opts.equal`, default `1` (the
+ * market/newsroom convention: an undifferentiated set reads heavy, not absent). Pass
+ * `{ equal: 0 }` for the inverse convention. Out-of-range values clamp to 0..1; NaN reads 0.
+ */
+export function logNormalizeBetween(value, min, max, opts) {
+    if (!Number.isFinite(value) || Number.isNaN(value))
+        return 0;
+    const lmin = Math.log(Math.max(0, min) + 1);
+    const lmax = Math.log(Math.max(0, max) + 1);
+    if (!(lmax > lmin))
+        return opts?.equal ?? 1;
+    return clamp01((Math.log(Math.max(0, value) + 1) - lmin) / (lmax - lmin));
+}
+//# sourceMappingURL=weights.js.map

package/dist/core/weights.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights.js","sourceRoot":"","sources":["../../src/core/weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAExC;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAExC,MAAM,OAAO,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa,EAAE,GAAW;IACrD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,4DAA4D;IAC7F,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,eAAe,CAAC,MAAyB;IACvD,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,CAAC,IAAI,MAAM;QAAE,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG;YAAE,GAAG,GAAG,CAAC,CAAC;IACnE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAS;IACxC,OAAO,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,oBAAoB,CAAC;AACxF,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAa,EACb,GAAW,EACX,GAAW,EACX,IAAyB;IAEzB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAC7D,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,IAAI,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,IAAI,EAAE,KAAK,IAAI,CAAC,CAAC;IAC5C,OAAO,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC;AAC5E,CAAC"}

package/dist/diagnostics/energy.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Energy diagnostics (visualization-methods-taxonomy §7). Pure accounting over a particle set —
+ * kinetic, thermal, and total energy, plus per-step drift. The data behind the "energy view": it
+ * reads state, never mutates it (the energy view must not affect integration).
+ */
+import type { Particle } from '../core/types.ts';
+/** Kinetic energy Σ ½·m·|v|² — the full 3D speed (vz is 0 in a flat field, z-axis.md). */
+export declare function kineticEnergy(particles: readonly Particle[]): number;
+/** Thermal energy proxy Σ heat (agitation held as per-particle heat ∈ [0,1]). */
+export declare function thermalEnergy(particles: readonly Particle[]): number;
+export interface EnergyReport {
+    kinetic: number;
+    thermal: number;
+    total: number;
+    count: number;
+}
+/** A full energy snapshot for the dashboard. */
+export declare function energyReport(particles: readonly Particle[]): EnergyReport;
+/** Fractional energy drift between two snapshots — for stability/conservation checks. */
+export declare function energyDrift(before: number, after: number): number;
+//# sourceMappingURL=energy.d.ts.map

package/dist/diagnostics/energy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"energy.d.ts","sourceRoot":"","sources":["../../src/diagnostics/energy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAKpE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAIpE;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,gDAAgD;AAChD,wBAAgB,YAAY,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,YAAY,CAIzE;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjE"}

package/dist/diagnostics/energy.js

@@ -0,0 +1,27 @@
+/** Kinetic energy Σ ½·m·|v|² — the full 3D speed (vz is 0 in a flat field, z-axis.md). */
+export function kineticEnergy(particles) {
+    let k = 0;
+    for (const p of particles)
+        k += 0.5 * (p.m || 1) * (p.vx * p.vx + p.vy * p.vy + (p.vz ?? 0) * (p.vz ?? 0));
+    return k;
+}
+/** Thermal energy proxy Σ heat (agitation held as per-particle heat ∈ [0,1]). */
+export function thermalEnergy(particles) {
+    let t = 0;
+    for (const p of particles)
+        t += p.heat;
+    return t;
+}
+/** A full energy snapshot for the dashboard. */
+export function energyReport(particles) {
+    const kinetic = kineticEnergy(particles);
+    const thermal = thermalEnergy(particles);
+    return { kinetic, thermal, total: kinetic + thermal, count: particles.length };
+}
+/** Fractional energy drift between two snapshots — for stability/conservation checks. */
+export function energyDrift(before, after) {
+    if (before === 0)
+        return after === 0 ? 0 : Infinity;
+    return Math.abs(after - before) / Math.abs(before);
+}
+//# sourceMappingURL=energy.js.map

package/dist/diagnostics/energy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"energy.js","sourceRoot":"","sources":["../../src/diagnostics/energy.ts"],"names":[],"mappings":"AAOA,0FAA0F;AAC1F,MAAM,UAAU,aAAa,CAAC,SAA8B;IAC1D,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,MAAM,CAAC,IAAI,SAAS;QACvB,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,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,CAAC,CAAC;IAClF,OAAO,CAAC,CAAC;AACX,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,aAAa,CAAC,SAA8B;IAC1D,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,MAAM,CAAC,IAAI,SAAS;QAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;IACvC,OAAO,CAAC,CAAC;AACX,CAAC;AASD,gDAAgD;AAChD,MAAM,UAAU,YAAY,CAAC,SAA8B;IACzD,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IACzC,MAAM,OAAO,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;IACzC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC;AACjF,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,KAAa;IACvD,IAAI,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACpD,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC"}

package/dist/diagnostics/fields.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Heatmap-variant samplers (visualization-methods-taxonomy §5). The engine ships the density
+ * heatmap; these are the per-particle samplers + a pure grid accumulator for the other documented
+ * variants (heat, velocity). A heatmap is a scalar buffer — pick what each particle deposits.
+ */
+import type { Particle } from '../core/types.ts';
+export type HeatmapKind = 'density' | 'heat' | 'velocity';
+/** What each particle deposits, per heatmap kind. */
+export declare const HEATMAP_SAMPLERS: Readonly<Record<HeatmapKind, (p: Particle) => number>>;
+export interface HeatmapGrid {
+    cols: number;
+    rows: number;
+    resolution: number;
+    values: Float32Array;
+    /** running peak, for [0,1] normalization. */
+    peak: number;
+}
+/**
+ * Accumulate a per-particle scalar (chosen by `kind`) onto a coarse grid — a heatmap variant. Each
+ * particle deposits into its cell; `peak` normalizes the render. Pure.
+ */
+export declare function accumulateHeatmap(particles: readonly Particle[], kind: HeatmapKind, width: number, height: number, resolution?: number): HeatmapGrid;
+//# sourceMappingURL=fields.d.ts.map

package/dist/diagnostics/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/diagnostics/fields.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,CAAC;AAE1D,qDAAqD;AACrD,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,MAAM,CAAC,CAInF,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,YAAY,CAAC;IACrB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,UAAU,SAAI,GACb,WAAW,CAgBb"}

package/dist/diagnostics/fields.js

@@ -0,0 +1,30 @@
+/** What each particle deposits, per heatmap kind. */
+export const HEATMAP_SAMPLERS = {
+    density: () => 1,
+    heat: (p) => p.heat,
+    velocity: (p) => Math.hypot(p.vx, p.vy),
+};
+/**
+ * Accumulate a per-particle scalar (chosen by `kind`) onto a coarse grid — a heatmap variant. Each
+ * particle deposits into its cell; `peak` normalizes the render. Pure.
+ */
+export function accumulateHeatmap(particles, kind, width, height, resolution = 8) {
+    const cols = Math.max(1, Math.ceil(width / resolution));
+    const rows = Math.max(1, Math.ceil(height / resolution));
+    const values = new Float32Array(cols * rows);
+    const sample = HEATMAP_SAMPLERS[kind];
+    let peak = 0;
+    for (const p of particles) {
+        if (p.x < 0 || p.y < 0 || p.x >= width || p.y >= height)
+            continue;
+        const c = Math.min(cols - 1, Math.floor(p.x / resolution));
+        const r = Math.min(rows - 1, Math.floor(p.y / resolution));
+        const i = r * cols + c;
+        const v = (values[i] ?? 0) + sample(p);
+        values[i] = v;
+        if (v > peak)
+            peak = v;
+    }
+    return { cols, rows, resolution, values, peak };
+}
+//# sourceMappingURL=fields.js.map

package/dist/diagnostics/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sourceRoot":"","sources":["../../src/diagnostics/fields.ts"],"names":[],"mappings":"AASA,qDAAqD;AACrD,MAAM,CAAC,MAAM,gBAAgB,GAA2D;IACtF,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC;IAChB,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI;IACnB,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;CACxC,CAAC;AAWF;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAA8B,EAC9B,IAAiB,EACjB,KAAa,EACb,MAAc,EACd,UAAU,GAAG,CAAC;IAEd,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IACzD,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IAC7C,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACtC,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,MAAM,CAAC,IAAI,SAAS,EAAE,CAAC;QAC1B,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,MAAM;YAAE,SAAS;QAClE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;QAC3D,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;QAC3D,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;QACvB,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACvC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACd,IAAI,CAAC,GAAG,IAAI;YAAE,IAAI,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAClD,CAAC"}

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Diagnostics (visualization-methods-taxonomy §3–§7, §11). The data behind the diagnostic overlays —
+ * energy accounting, scalar potential + grid sampling, probe force-vectors + causality, heatmap-variant
+ * samplers — plus `render.ts`, which draws them onto a Canvas 2D context (C1). Nothing mutates physics.
+ */
+export * from './energy.ts';
+export * from './potential.ts';
+export * from './probes.ts';
+export * from './fields.ts';
+export * from './render.ts';
+export * from './modes.ts';
+/** The diagnostics this module provides (inspectable list; canvas drawing is the UI frontier). */
+export declare const DIAGNOSTICS: readonly [{
+    readonly name: "energy";
+    readonly provides: "kinetic / thermal / total energy + drift";
+    readonly reads: "particles";
+}, {
+    readonly name: "potential";
+    readonly provides: "scalar potential Φ + grid sampling for contours";
+    readonly reads: "bodies";
+}, {
+    readonly name: "force-vectors";
+    readonly provides: "a force’s Δv on a probe at a point";
+    readonly reads: "force + probe";
+}, {
+    readonly name: "causality";
+    readonly provides: "per-token contribution to motion (ranked bars + vectors)";
+    readonly reads: "registry + tokens";
+}, {
+    readonly name: "heatmap-variants";
+    readonly provides: "density / heat / velocity scalar grids";
+    readonly reads: "particles";
+}, {
+    readonly name: "topology";
+    readonly provides: "relationship-agent coupling edges (strength / memory)";
+    readonly reads: "relationship agents + positions";
+}, {
+    readonly name: "inspector";
+    readonly provides: "body / agent / metric / contract HUD rows";
+    readonly reads: "system snapshot";
+}, {
+    readonly name: "prediction";
+    readonly provides: "deterministic forward ghost trajectory";
+    readonly reads: "forces + bodies + probe";
+}];
+//# sourceMappingURL=index.d.ts.map

package/dist/diagnostics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/diagnostics/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAE3B,kGAAkG;AAClG,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASd,CAAC"}

package/dist/diagnostics/index.js

@@ -0,0 +1,23 @@
+/**
+ * Diagnostics (visualization-methods-taxonomy §3–§7, §11). The data behind the diagnostic overlays —
+ * energy accounting, scalar potential + grid sampling, probe force-vectors + causality, heatmap-variant
+ * samplers — plus `render.ts`, which draws them onto a Canvas 2D context (C1). Nothing mutates physics.
+ */
+export * from "./energy.js";
+export * from "./potential.js";
+export * from "./probes.js";
+export * from "./fields.js";
+export * from "./render.js";
+export * from "./modes.js";
+/** The diagnostics this module provides (inspectable list; canvas drawing is the UI frontier). */
+export const DIAGNOSTICS = [
+    { name: 'energy', provides: 'kinetic / thermal / total energy + drift', reads: 'particles' },
+    { name: 'potential', provides: 'scalar potential Φ + grid sampling for contours', reads: 'bodies' },
+    { name: 'force-vectors', provides: 'a force’s Δv on a probe at a point', reads: 'force + probe' },
+    { name: 'causality', provides: 'per-token contribution to motion (ranked bars + vectors)', reads: 'registry + tokens' },
+    { name: 'heatmap-variants', provides: 'density / heat / velocity scalar grids', reads: 'particles' },
+    { name: 'topology', provides: 'relationship-agent coupling edges (strength / memory)', reads: 'relationship agents + positions' },
+    { name: 'inspector', provides: 'body / agent / metric / contract HUD rows', reads: 'system snapshot' },
+    { name: 'prediction', provides: 'deterministic forward ghost trajectory', reads: 'forces + bodies + probe' },
+];
+//# sourceMappingURL=index.js.map

package/dist/diagnostics/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/diagnostics/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAE3B,kGAAkG;AAClG,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,0CAA0C,EAAE,KAAK,EAAE,WAAW,EAAE;IAC5F,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,iDAAiD,EAAE,KAAK,EAAE,QAAQ,EAAE;IACnG,EAAE,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,oCAAoC,EAAE,KAAK,EAAE,eAAe,EAAE;IACjG,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,0DAA0D,EAAE,KAAK,EAAE,mBAAmB,EAAE;IACvH,EAAE,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,wCAAwC,EAAE,KAAK,EAAE,WAAW,EAAE;IACpG,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,uDAAuD,EAAE,KAAK,EAAE,iCAAiC,EAAE;IACjI,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,2CAA2C,EAAE,KAAK,EAAE,iBAAiB,EAAE;IACtG,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,wCAAwC,EAAE,KAAK,EAAE,yBAAyB,EAAE;CACpG,CAAC"}

package/dist/diagnostics/modes.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The four debug/graph render modes (visualization-methods-taxonomy "Render Modes Catalog" —
+ * previously `planned`): topology, inspector, causality, prediction. Each is a pure data/geometry
+ * function (testable, no canvas) plus a thin `draw*` helper. Like the C1 overlays these *reveal*
+ * state — they read bodies/agents/forces and never mutate physics.
+ *
+ *   topology    relationship-agent coupling graph (strength → width, memory → glow)
+ *   inspector   a debug HUD of body/agent/metric/contract counts
+ *   causality   per-force contribution to motion at a point (reuses causalityAt)
+ *   prediction  a deterministic forward "ghost" trajectory of a probe under the body forces
+ */
+import type { Body, ForceRegistry } from '../core/types.ts';
+import type { RelationshipAgent } from '../agents/relationship.ts';
+import { type CausalContribution } from './probes.ts';
+type Ctx = CanvasRenderingContext2D;
+type Pt = {
+    x: number;
+    y: number;
+};
+/** A relationship resolved to two endpoint positions, ready to draw. */
+export interface TopologyEdge {
+    from: Pt;
+    to: Pt;
+    type: string;
+    /** active coupling strength ∈ [0,1] → line width. */
+    strength: number;
+    /** accumulated familiarity ∈ [0,1] → persistence glow. */
+    memory: number;
+    active: boolean;
+}
+/** Position lookup for a body id (returns undefined for unplaced bodies). */
+export type PositionOf = (bodyId: string) => Pt | undefined;
+/**
+ * Resolve relationship agents to drawable edges via a position lookup. Agents whose endpoints have
+ * no position are dropped (you can only draw what you can place). Pure.
+ */
+export declare function topologyEdges(agents: readonly RelationshipAgent[], posOf: PositionOf): TopologyEdge[];
+/** Draw the coupling graph: thicker = stronger, brighter = more memory, accent = active this tick. */
+export declare function drawTopology(ctx: Ctx, agents: readonly RelationshipAgent[], posOf: PositionOf, opts?: {
+    color?: string;
+    activeColor?: string;
+    maxWidth?: number;
+}): void;
+/** A snapshot of system counts/metrics for the inspector HUD. */
+export interface InspectorSnapshot {
+    bodies?: number;
+    particles?: number;
+    agents?: number;
+    relationships?: number;
+    contracts?: number;
+    metrics?: Record<string, number | string>;
+}
+export interface InspectorRow {
+    label: string;
+    value: string;
+}
+/** Flatten a snapshot to ordered label/value rows (counts first, then metrics). Pure. */
+export declare function inspectorRows(snap: InspectorSnapshot): InspectorRow[];
+/** Draw the inspector as a compact monospace panel (top-left by default). */
+export declare function drawInspector(ctx: Ctx, snap: InspectorSnapshot, opts?: {
+    x?: number;
+    y?: number;
+    width?: number;
+}): void;
+/** A per-token causal contribution ranked by magnitude, with its share of the total. */
+export interface CausalBar {
+    token: string;
+    magnitude: number;
+    /** share of total |contribution| ∈ [0,1]. */
+    fraction: number;
+}
+/** Rank causal contributions by magnitude (desc) with each one's fraction of the total. Pure. */
+export declare function causalityBars(contribs: readonly CausalContribution[]): CausalBar[];
+/** Draw causality at a point: a vector per contributing force from the origin, plus a ranked bar list. */
+export declare function drawCausality(ctx: Ctx, contribs: readonly CausalContribution[], origin: Pt, opts?: {
+    scale?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+}): void;
+export interface GhostOptions {
+    /** number of forward steps to simulate (default 60). */
+    steps?: number;
+    /** velocity damping per step (default = the integrator's FRICTION). */
+    friction?: number;
+    /** scale applied to summed force Δv per step (default 1). */
+    forceScale?: number;
+    /** the ghost probe's charge (for charge/magnetism forces; default 0). */
+    charge?: number;
+}
+/**
+ * A deterministic forward "ghost" trajectory: integrate one probe under the class-A body forces,
+ * summing each (force, body) Δv per step and damping by friction — the same shape the real
+ * integrator uses, kept dependency-light. Pure and repeatable: same inputs → same path. This is the
+ * *prediction* overlay's data (an expected future path), not the live sim.
+ */
+export declare function ghostTrajectory(forces: ForceRegistry, tokens: readonly string[], bodies: readonly Body[], start: {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+}, opts?: GhostOptions): Pt[];
+/** Draw a ghost trajectory as a dashed path that fades toward the predicted future. */
+export declare function drawPrediction(ctx: Ctx, points: readonly Pt[], opts?: {
+    color?: string;
+}): void;
+export {};
+//# sourceMappingURL=modes.d.ts.map

package/dist/diagnostics/modes.d.ts.map

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