@mindpeeker/negentropy 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mindpeeker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,160 @@
+# @mindpeeker/negentropy
+
+Measure order in noise, and manufacture order from noise.
+
+Companion to [`@mindpeeker/entropy`](../entropy): where entropy *sources*
+randomness, negentropy asks two questions about it —
+
+1. **Is there any order in this noise, and when did it appear?**
+   GCP-style network statistics, information-theoretic negentropy estimators,
+   and a pre-registered experiment layer over live entropy streams.
+2. **How do I concentrate raw noise into uniform bits?**
+   Von Neumann/Peres debiasing, SP 800-90B vetted conditioning,
+   Toeplitz-hashing extraction, and honest min-entropy accounting.
+
+Zero dependencies, browser-safe (only `Math`, typed arrays,
+`crypto.subtle`), ESM. Every `@mindpeeker/entropy` provider works as an
+input source *structurally* — the packages share a shape, not code:
+
+```ts
+interface TrialSource {
+  readonly name: string
+  stream(opts?: { signal?: AbortSignal; chunkBytes?: number }): AsyncIterable<Uint8Array>
+}
+```
+
+> Erwin Schrödinger described life as feeding on "negative entropy";
+> Léon Brillouin shortened it to *negentropy*. Here it is a number: how far
+> a stream sits from maximal disorder, and how much usable order you can
+> pull back out of it.
+
+## Detection: is there order in this noise?
+
+The unit of analysis is the **trial** — the number of one-bits among
+`bitsPerTrial` consecutive bits (default 200, the Global Consciousness
+Project convention, so a trial is Binomial(200, ½): mean 100, variance 50).
+
+```ts
+import {
+  trialsFromBytes, theoreticalCalibration, zScores,
+  netvar, devvar, interSourceCorrelation,
+  cumulativeDeviation, significanceEnvelope, stoufferZ,
+} from '@mindpeeker/negentropy'
+
+const series = trialsFromBytes(recordedBytes, 'anu')
+const zs = zScores(series, theoreticalCalibration('anu'))
+```
+
+Network statistics over step-aligned z-matrices from N sources:
+
+| statistic | question it asks | null distribution |
+|---|---|---|
+| `netvar` | do the sources deviate *together*? (GCP standard) | χ²(steps) |
+| `devvar` | is any source's variance off on its own? | χ²(steps × N) |
+| `interSourceCorrelation` | are pairwise products elevated? | N(0, 1) |
+
+`cumulativeDeviation(stoufferZs)` gives the classic cumsum(Z²−1) plot and
+`significanceEnvelope(steps, p)` its exact χ²-quantile envelope. **The
+envelope is pointwise**: an H0 path crosses it *somewhere* far more often
+than p — only a pre-registered endpoint carries the stated significance.
+(There is a test in this repo that proves that caveat by simulation.)
+
+### Negentropy estimators
+
+J(x) = H(gaussian of equal variance) − H(x) ≥ 0, zero iff Gaussian —
+"how far from maximally random":
+
+- `negentropyKurtosis` — classic moment approximation (skew²/12 + exkurt²/48)
+- `negentropyLogcosh`, `negentropyExp` — Hyvärinen contrasts with honestly
+  calibrated null z-scores (the delta-method variance under empirical
+  standardization, ~34× smaller than the naive Var[G] for logcosh; constants
+  frozen from mpmath). Positive z ⇒ sub-Gaussian, negative ⇒ super-Gaussian.
+- `vasicekEntropy` / `negentropyVasicek` — m-spacings differential entropy,
+  validated against `scipy.stats.differential_entropy`
+- `windowedNegentropy` — rolling "when did order appear?" stream whose
+  emissions exactly equal the batch estimator per slice
+
+Lattice-valued data (bytes, trial sums) needs dithering first:
+`ditheredTrialZ` (trials → continuous z) or `probitBytes`
+(bytes → *exactly* standard normal under H0).
+
+### Experiment layer
+
+```ts
+import { registerExperiment, session } from '@mindpeeker/negentropy'
+import { drand, nistBeacon, cryptoProvider } from '@mindpeeker/entropy'
+
+const registration = await registerExperiment({
+  trial: { clock: { mode: 'interval', intervalMs: 1000 } },
+  calibration: { trials: 600 }, // burn-in window, disjoint by construction
+  events: [{
+    id: 'meditation-1', label: 'group session 19:00–19:20',
+    statistic: 'netvar',
+    start: new Date('2026-07-08T19:00:00Z'), end: new Date('2026-07-08T19:20:00Z'),
+  }],
+})
+
+const live = session({
+  sources: [drand(), nistBeacon(), cryptoProvider()],
+  registration,
+})
+for await (const tick of live) {
+  render(tick.stouffer, tick.netvar, tick.cumdev, tick.activeEvents)
+}
+const result = live.stop() // batch-exact analysis + composite + archival series
+```
+
+Sessions run in lock-step rounds (one trial per source per tick, bounded
+memory), tolerate slow/dead sources with `missing: 'skip'`, and `stop()`
+delegates to `analyzeTrials` — re-analyzing `result.series` later reproduces
+the result exactly. `registerExperiment` freezes the config and embeds its
+SHA-256 in the result: the pre-registration paper trail.
+
+Batch equivalents: `analyzeBytes(recordings, config)` /
+`analyzeTrials(series, config)`; multi-event runs combine via the Stouffer
+`composite` (with `bonferroni` for individual-event claims).
+
+## Extraction: manufacture order from noise
+
+```ts
+import {
+  vonNeumann, peres, peresRate,             // debiasing (iid bits in!)
+  sha256Condition, hmacCondition, conditionStream, // SP 800-90B vetted
+  toeplitzExtractor, toeplitzOutputBits,    // seeded strong extractor
+  ContinuousHealth,                          // RCT + APT, observational or strict
+  claimBytes, debiasAccounted, conditionAccounted, extractAccounted,
+} from '@mindpeeker/negentropy'
+
+// honest pipeline: claims only ever shrink, every step in the trace
+let x = claimBytes(rawBytes, 2 /* measured bits/byte */, 'measured')
+x = debiasAccounted(x, 'peres')          // full credit under the iid assumption
+x = await conditionAccounted(x)          // h_out = min(h_in, 0.999·256)
+// or: extractAccounted(x, toeplitzExtractor(seed, n, m)) — leftover hash lemma enforced
+```
+
+- **Peres** debiasing recycles what von Neumann discards; rate → H(p)
+  (exact recurrence in `peresRate`). Verified *exhaustively*: over every
+  input at two biases, outputs of equal length are equiprobable.
+- **Toeplitz** extraction is a strong extractor — the seed may be public,
+  but must be uniform and independent of the input.
+- **Health tests** (SP 800-90B RCT/APT) run observationally by default
+  (alarms, keep going — the anomaly-logger stance) or `strict` (throw —
+  the randomness-supplier stance).
+
+## What this package will not tell you
+
+Statistical tests can only *fail* a source — passing proves nothing about
+physical unpredictability (any CSPRNG passes everything). The detection
+module presents GCP-style methodology as neutral statistical tooling; the
+underlying mind-matter hypothesis is contested, and nothing here settles
+it. What the tooling does guarantee: exact null distributions (validated
+against scipy/mpmath fixtures), pre-registration discipline, and honest
+p-values either way.
+
+## Development
+
+```sh
+bun test                      # fixtures are checked in — no Python needed
+uv run scripts/fixtures/generate.py   # regenerate fixtures (scipy/mpmath)
+cd ../entropy && bun run demo:negentropy   # live session demo over real providers
+```

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export type NegentropyErrorCode = 'insufficient_data' | 'calibration_required' | 'invalid_window' | 'invalid_config' | 'source_ended' | 'source_failed' | 'health_test' | 'timeout' | 'aborted';
+export interface NegentropyErrorOptions {
+    source?: string;
+    cause?: unknown;
+}
+export declare class NegentropyError extends Error {
+    readonly code: NegentropyErrorCode;
+    readonly source?: string;
+    readonly cause?: unknown;
+    constructor(code: NegentropyErrorCode, message: string, opts?: NegentropyErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAC3B,mBAAmB,GACnB,sBAAsB,GACtB,gBAAgB,GAChB,gBAAgB,GAChB,cAAc,GACd,eAAe,GACf,aAAa,GACb,SAAS,GACT,SAAS,CAAA;AAEb,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,SAAiB,KAAK,CAAC,EAAE,OAAO,CAAA;gBAEpB,IAAI,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,sBAA2B;CAM1F"}

package/dist/errors.js

@@ -0,0 +1,11 @@
+export class NegentropyError extends Error {
+    code;
+    source;
+    constructor(code, message, opts = {}) {
+        super(message, opts.cause !== undefined ? { cause: opts.cause } : undefined);
+        this.name = 'NegentropyError';
+        this.code = code;
+        this.source = opts.source;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAgBA,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAqB;IACzB,MAAM,CAAS;IAGxB,YAAY,IAAyB,EAAE,OAAe,EAAE,OAA+B,EAAE;QACvF,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;QAC5E,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;IAC3B,CAAC;CACF"}

package/dist/estimators/entropy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Entropy estimators over raw bytes/bits. These can only ever FAIL a source —
+ * passing proves nothing about physical unpredictability (any CSPRNG passes
+ * everything). Meaningful on RAW source output; whitened output looks perfect
+ * by construction.
+ */
+export { toBits } from '../internal/bytes.js';
+/** Shannon entropy in bits per byte (upper bound on min-entropy). */
+export declare function shannonEntropy(data: Uint8Array): number;
+/**
+ * NIST SP 800-90B §6.3.1 Most Common Value min-entropy estimate (bits/byte):
+ * upper-bounds the most common symbol's probability at 99% confidence.
+ */
+export declare function mcvMinEntropy(data: Uint8Array): number;
+/**
+ * NIST SP 800-90B §6.3.3 Markov min-entropy estimate for binary sequences,
+ * in bits per bit: the most probable 128-step path through the first-order
+ * transition model bounds per-bit entropy. Catches serial dependence that
+ * per-symbol counting misses (e.g. …010101… scores 0 here, 1.0 on MCV).
+ */
+export declare function markovMinEntropyPerBit(bits: Uint8Array): number;
+//# sourceMappingURL=entropy.d.ts.map

package/dist/estimators/entropy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.d.ts","sourceRoot":"","sources":["../../src/estimators/entropy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAE7C,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAUvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAMtD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAkC/D"}

package/dist/estimators/entropy.js

@@ -0,0 +1,78 @@
+/**
+ * Entropy estimators over raw bytes/bits. These can only ever FAIL a source —
+ * passing proves nothing about physical unpredictability (any CSPRNG passes
+ * everything). Meaningful on RAW source output; whitened output looks perfect
+ * by construction.
+ */
+export { toBits } from '../internal/bytes.js';
+/** Shannon entropy in bits per byte (upper bound on min-entropy). */
+export function shannonEntropy(data) {
+    const counts = new Array(256).fill(0);
+    for (const byte of data)
+        counts[byte] = counts[byte] + 1;
+    let h = 0;
+    for (const count of counts) {
+        if (count === 0)
+            continue;
+        const p = count / data.length;
+        h -= p * Math.log2(p);
+    }
+    return h;
+}
+/**
+ * NIST SP 800-90B §6.3.1 Most Common Value min-entropy estimate (bits/byte):
+ * upper-bounds the most common symbol's probability at 99% confidence.
+ */
+export function mcvMinEntropy(data) {
+    const counts = new Array(256).fill(0);
+    for (const byte of data)
+        counts[byte] = counts[byte] + 1;
+    const pHat = Math.max(...counts) / data.length;
+    const pUpper = Math.min(1, pHat + 2.576 * Math.sqrt((pHat * (1 - pHat)) / (data.length - 1)));
+    return -Math.log2(pUpper);
+}
+/**
+ * NIST SP 800-90B §6.3.3 Markov min-entropy estimate for binary sequences,
+ * in bits per bit: the most probable 128-step path through the first-order
+ * transition model bounds per-bit entropy. Catches serial dependence that
+ * per-symbol counting misses (e.g. …010101… scores 0 here, 1.0 on MCV).
+ */
+export function markovMinEntropyPerBit(bits) {
+    const n = bits.length;
+    if (n < 2)
+        return 0;
+    let ones = 0;
+    const transitions = [
+        [0, 0],
+        [0, 0],
+    ];
+    for (let i = 0; i < n; i++) {
+        if (bits[i] === 1)
+            ones++;
+        if (i < n - 1) {
+            const row = transitions[bits[i]];
+            row[bits[i + 1]] = row[bits[i + 1]] + 1;
+        }
+    }
+    const p1 = ones / n;
+    const p0 = 1 - p1;
+    const prob = (row, next) => {
+        const total = row[0] + row[1];
+        return total === 0 ? 0 : row[next] / total;
+    };
+    const log2 = (p) => (p > 0 ? Math.log2(p) : Number.NEGATIVE_INFINITY);
+    // dynamic program over the most probable 128-bit path (in log space)
+    let l0 = log2(p0);
+    let l1 = log2(p1);
+    for (let step = 1; step < 128; step++) {
+        const n0 = Math.max(l0 + log2(prob(transitions[0], 0)), l1 + log2(prob(transitions[1], 0)));
+        const n1 = Math.max(l0 + log2(prob(transitions[0], 1)), l1 + log2(prob(transitions[1], 1)));
+        l0 = n0;
+        l1 = n1;
+    }
+    const maxLog = Math.max(l0, l1);
+    if (!Number.isFinite(maxLog))
+        return 0;
+    return Math.min(1, Math.max(0, -maxLog / 128));
+}
+//# sourceMappingURL=entropy.js.map

package/dist/estimators/entropy.js.map

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

package/dist/estimators/frequency.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Chi-square statistic over the byte histogram (255 degrees of freedom),
+ * with an exact incomplete-gamma p-value.
+ */
+export declare function chiSquareBytes(data: Uint8Array): {
+    statistic: number;
+    pValue: number;
+};
+/** ent-style lag-1 serial correlation coefficient over bytes (0 is ideal). */
+export declare function serialCorrelation(data: Uint8Array): number;
+/** Fraction of one-bits (0.5 is ideal) plus its z-score. */
+export declare function monobit(bits: Uint8Array): {
+    onesFraction: number;
+    z: number;
+};
+/** Wald–Wolfowitz runs test z-score over the bit sequence. */
+export declare function runsTest(bits: Uint8Array): number;
+//# sourceMappingURL=frequency.d.ts.map

package/dist/estimators/frequency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frequency.d.ts","sourceRoot":"","sources":["../../src/estimators/frequency.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAOtF;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAc1D;AAED,4DAA4D;AAC5D,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAK7E;AAED,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAajD"}

package/dist/estimators/frequency.js

@@ -0,0 +1,57 @@
+import { chi2Sf } from '../internal/special.js';
+/**
+ * Chi-square statistic over the byte histogram (255 degrees of freedom),
+ * with an exact incomplete-gamma p-value.
+ */
+export function chiSquareBytes(data) {
+    const counts = new Array(256).fill(0);
+    for (const byte of data)
+        counts[byte] = counts[byte] + 1;
+    const expected = data.length / 256;
+    let statistic = 0;
+    for (const count of counts)
+        statistic += (count - expected) ** 2 / expected;
+    return { statistic, pValue: chi2Sf(statistic, 255) };
+}
+/** ent-style lag-1 serial correlation coefficient over bytes (0 is ideal). */
+export function serialCorrelation(data) {
+    const n = data.length;
+    let sum = 0;
+    let sumSq = 0;
+    let sumLag = 0;
+    for (let i = 0; i < n; i++) {
+        const value = data[i];
+        sum += value;
+        sumSq += value * value;
+        sumLag += value * data[(i + 1) % n];
+    }
+    const numerator = n * sumLag - sum * sum;
+    const denominator = n * sumSq - sum * sum;
+    return denominator === 0 ? 1 : numerator / denominator;
+}
+/** Fraction of one-bits (0.5 is ideal) plus its z-score. */
+export function monobit(bits) {
+    let ones = 0;
+    for (const bit of bits)
+        ones += bit;
+    const fraction = ones / bits.length;
+    return { onesFraction: fraction, z: (2 * ones - bits.length) / Math.sqrt(bits.length) };
+}
+/** Wald–Wolfowitz runs test z-score over the bit sequence. */
+export function runsTest(bits) {
+    const n = bits.length;
+    let ones = 0;
+    let runs = 1;
+    for (let i = 0; i < n; i++) {
+        ones += bits[i];
+        if (i > 0 && bits[i] !== bits[i - 1])
+            runs++;
+    }
+    const zeros = n - ones;
+    if (ones === 0 || zeros === 0)
+        return Number.POSITIVE_INFINITY;
+    const expected = (2 * ones * zeros) / n + 1;
+    const variance = ((expected - 1) * (expected - 2)) / (n - 1);
+    return variance <= 0 ? 0 : (runs - expected) / Math.sqrt(variance);
+}
+//# sourceMappingURL=frequency.js.map

package/dist/estimators/frequency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frequency.js","sourceRoot":"","sources":["../../src/estimators/frequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAE/C;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,IAAgB;IAC7C,MAAM,MAAM,GAAG,IAAI,KAAK,CAAS,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IAC7C,KAAK,MAAM,IAAI,IAAI,IAAI;QAAE,MAAM,CAAC,IAAI,CAAC,GAAI,MAAM,CAAC,IAAI,CAAY,GAAG,CAAC,CAAA;IACpE,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,CAAA;IAClC,IAAI,SAAS,GAAG,CAAC,CAAA;IACjB,KAAK,MAAM,KAAK,IAAI,MAAM;QAAE,SAAS,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAA;IAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,EAAE,CAAA;AACtD,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,iBAAiB,CAAC,IAAgB;IAChD,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAA;IACrB,IAAI,GAAG,GAAG,CAAC,CAAA;IACX,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAW,CAAA;QAC/B,GAAG,IAAI,KAAK,CAAA;QACZ,KAAK,IAAI,KAAK,GAAG,KAAK,CAAA;QACtB,MAAM,IAAI,KAAK,GAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAY,CAAA;IACjD,CAAC;IACD,MAAM,SAAS,GAAG,CAAC,GAAG,MAAM,GAAG,GAAG,GAAG,GAAG,CAAA;IACxC,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,GAAG,GAAG,GAAG,GAAG,CAAA;IACzC,OAAO,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,WAAW,CAAA;AACxD,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,OAAO,CAAC,IAAgB;IACtC,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,KAAK,MAAM,GAAG,IAAI,IAAI;QAAE,IAAI,IAAI,GAAG,CAAA;IACnC,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC,MAAM,CAAA;IACnC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAA;AACzF,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,QAAQ,CAAC,IAAgB;IACvC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAA;IACrB,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,IAAI,IAAI,CAAC,CAAC,CAAW,CAAA;QACzB,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;YAAE,IAAI,EAAE,CAAA;IAC9C,CAAC;IACD,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAA;IACtB,IAAI,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC,iBAAiB,CAAA;IAC9D,MAAM,QAAQ,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAC3C,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;IAC5D,OAAO,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;AACpE,CAAC"}

package/dist/estimators/negentropy.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Scalar negentropy estimators: J(x) = H(gaussian of equal variance) − H(x),
+ * the canonical "how far from maximally random" measure — J ≥ 0, zero iff
+ * Gaussian. All estimators standardize internally with POPULATION moments
+ * (divide by n), so inputs need no preprocessing. Outputs of one family are
+ * comparable with each other, not across families (proportionality constants
+ * are set to 1).
+ */
+/** Null constants E[G(ν)], Var[G(ν)] for ν ~ N(0,1) — frozen from mpmath (see fixtures). */
+export declare const LOGCOSH_GAUSSIAN_MEAN = 0.37456720749143796;
+export declare const LOGCOSH_GAUSSIAN_VARIANCE = 0.18976744917236543;
+export declare const EXP_GAUSSIAN_MEAN: number;
+export declare const EXP_GAUSSIAN_VARIANCE: number;
+/**
+ * Asymptotic variance of √n·(E[G(y)] − E[G(ν)]) under H0 with EMPIRICAL
+ * standardization — the constant that actually calibrates the z detector.
+ * Delta method: Var[G(ν) − (b/2)(ν² − 1)] with b = E[ν·G′(ν)]. For logcosh
+ * this is ~34× smaller than Var[G(ν)]: standardization removes G's quadratic
+ * component almost entirely. Frozen from mpmath (see fixtures).
+ */
+export declare const LOGCOSH_NULL_VARIANCE = 0.0063278669911599715;
+export declare const EXP_NULL_VARIANCE = 0.014850269189625764;
+export interface MomentNegentropy {
+    /** J ≈ skew²/12 + exkurt²/48 (nats, proportional). NaN when degenerate. */
+    j: number;
+    skew: number;
+    /** Excess kurtosis E[y⁴] − 3. */
+    exkurt: number;
+    n: number;
+    /** True when the input is constant — maximally ordered but not standardizable. */
+    degenerate: boolean;
+}
+/**
+ * Classic moment approximation (Jones–Sibson/Comon): J ≈ (1/12)E[y³]² +
+ * (1/48)(E[y⁴] − 3)². The y⁴ term makes it very outlier-sensitive — prefer
+ * the contrast estimators for heavy-tailed data. Null level: E[J] ≈ 1/n.
+ */
+export declare function negentropyKurtosis(x: ArrayLike<number>): MomentNegentropy;
+export interface ContrastNegentropy {
+    /** J ≈ (E[G(y)] − E[G(ν)])² (proportional). NaN when degenerate. */
+    j: number;
+    /**
+     * Null-calibrated detector: √n·(E[G(y)] − E[G(ν)])/√nullVariance ~ N(0,1)
+     * under H0 (the delta-method variance accounts for empirical
+     * standardization). Sign: ln cosh u ≈ u²/2 − u⁴/12, so E[G] ≈ ½ − kurt/12
+     * — POSITIVE z ⇒ sub-Gaussian (uniform, bimodal), NEGATIVE ⇒ super-Gaussian
+     * (heavy tails/peaked); same direction for the exp contrast.
+     */
+    z: number;
+    meanG: number;
+    n: number;
+    degenerate: boolean;
+}
+/**
+ * Hyvärinen's log-cosh contrast (a = 1, fixed — the null constants are
+ * a-specific). Robust general-purpose default; see `ContrastNegentropy.z`
+ * for the sign convention.
+ */
+export declare function negentropyLogcosh(x: ArrayLike<number>): ContrastNegentropy;
+/** Hyvärinen's Gaussian contrast G(u) = −exp(−u²/2) — most sensitive to peaked/super-Gaussian sources. */
+export declare function negentropyExp(x: ArrayLike<number>): ContrastNegentropy;
+//# sourceMappingURL=negentropy.d.ts.map

package/dist/estimators/negentropy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negentropy.d.ts","sourceRoot":"","sources":["../../src/estimators/negentropy.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,4FAA4F;AAC5F,eAAO,MAAM,qBAAqB,sBAAsB,CAAA;AACxD,eAAO,MAAM,yBAAyB,sBAAsB,CAAA;AAC5D,eAAO,MAAM,iBAAiB,EAAE,MAAsB,CAAA;AACtD,eAAO,MAAM,qBAAqB,EAAE,MAA+B,CAAA;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,wBAAwB,CAAA;AAC1D,eAAO,MAAM,iBAAiB,uBAAuB,CAAA;AA8BrD,MAAM,WAAW,gBAAgB;IAC/B,2EAA2E;IAC3E,CAAC,EAAE,MAAM,CAAA;IACT,IAAI,EAAE,MAAM,CAAA;IACZ,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,CAAC,EAAE,MAAM,CAAA;IACT,kFAAkF;IAClF,UAAU,EAAE,OAAO,CAAA;CACpB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,gBAAgB,CAsBzE;AAED,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,CAAC,EAAE,MAAM,CAAA;IACT;;;;;;OAMG;IACH,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,CAAC,EAAE,MAAM,CAAA;IACT,UAAU,EAAE,OAAO,CAAA;CACpB;AA0BD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,kBAAkB,CAE1E;AAED,0GAA0G;AAC1G,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,kBAAkB,CAEtE"}

package/dist/estimators/negentropy.js

@@ -0,0 +1,104 @@
+import { NegentropyError } from '../errors.js';
+/**
+ * Scalar negentropy estimators: J(x) = H(gaussian of equal variance) − H(x),
+ * the canonical "how far from maximally random" measure — J ≥ 0, zero iff
+ * Gaussian. All estimators standardize internally with POPULATION moments
+ * (divide by n), so inputs need no preprocessing. Outputs of one family are
+ * comparable with each other, not across families (proportionality constants
+ * are set to 1).
+ */
+/** Null constants E[G(ν)], Var[G(ν)] for ν ~ N(0,1) — frozen from mpmath (see fixtures). */
+export const LOGCOSH_GAUSSIAN_MEAN = 0.37456720749143796;
+export const LOGCOSH_GAUSSIAN_VARIANCE = 0.18976744917236543;
+export const EXP_GAUSSIAN_MEAN = -Math.SQRT1_2; // exact: −1/√2
+export const EXP_GAUSSIAN_VARIANCE = 1 / Math.sqrt(3) - 0.5; // exact: 1/√3 − ½
+/**
+ * Asymptotic variance of √n·(E[G(y)] − E[G(ν)]) under H0 with EMPIRICAL
+ * standardization — the constant that actually calibrates the z detector.
+ * Delta method: Var[G(ν) − (b/2)(ν² − 1)] with b = E[ν·G′(ν)]. For logcosh
+ * this is ~34× smaller than Var[G(ν)]: standardization removes G's quadratic
+ * component almost entirely. Frozen from mpmath (see fixtures).
+ */
+export const LOGCOSH_NULL_VARIANCE = 0.0063278669911599715;
+export const EXP_NULL_VARIANCE = 0.014850269189625764;
+const MIN_SAMPLES = 8;
+function standardize(x) {
+    const n = x.length;
+    if (n < MIN_SAMPLES) {
+        throw new NegentropyError('insufficient_data', `negentropy estimators need ≥ ${MIN_SAMPLES} samples, got ${n}`);
+    }
+    let sum = 0;
+    for (let i = 0; i < n; i++)
+        sum += x[i];
+    const mean = sum / n;
+    let m2 = 0;
+    for (let i = 0; i < n; i++)
+        m2 += (x[i] - mean) ** 2;
+    const sd = Math.sqrt(m2 / n);
+    if (!(sd > 0))
+        return null;
+    const y = new Float64Array(n);
+    for (let i = 0; i < n; i++)
+        y[i] = (x[i] - mean) / sd;
+    return { y, mean, sd };
+}
+/**
+ * Classic moment approximation (Jones–Sibson/Comon): J ≈ (1/12)E[y³]² +
+ * (1/48)(E[y⁴] − 3)². The y⁴ term makes it very outlier-sensitive — prefer
+ * the contrast estimators for heavy-tailed data. Null level: E[J] ≈ 1/n.
+ */
+export function negentropyKurtosis(x) {
+    const standardized = standardize(x);
+    if (!standardized) {
+        return { j: Number.NaN, skew: Number.NaN, exkurt: Number.NaN, n: x.length, degenerate: true };
+    }
+    const { y } = standardized;
+    let m3 = 0;
+    let m4 = 0;
+    for (const value of y) {
+        const cubed = value * value * value;
+        m3 += cubed;
+        m4 += cubed * value;
+    }
+    const skew = m3 / y.length;
+    const exkurt = m4 / y.length - 3;
+    return {
+        j: (skew * skew) / 12 + (exkurt * exkurt) / 48,
+        skew,
+        exkurt,
+        n: y.length,
+        degenerate: false,
+    };
+}
+function contrast(x, g, gaussianMean, nullVariance) {
+    const standardized = standardize(x);
+    if (!standardized) {
+        return { j: Number.NaN, z: Number.NaN, meanG: Number.NaN, n: x.length, degenerate: true };
+    }
+    const { y } = standardized;
+    let sum = 0;
+    for (const value of y)
+        sum += g(value);
+    const meanG = sum / y.length;
+    const delta = meanG - gaussianMean;
+    return {
+        j: delta * delta,
+        z: (Math.sqrt(y.length) * delta) / Math.sqrt(nullVariance),
+        meanG,
+        n: y.length,
+        degenerate: false,
+    };
+}
+/**
+ * Hyvärinen's log-cosh contrast (a = 1, fixed — the null constants are
+ * a-specific). Robust general-purpose default; see `ContrastNegentropy.z`
+ * for the sign convention.
+ */
+export function negentropyLogcosh(x) {
+    return contrast(x, (u) => Math.log(Math.cosh(u)), LOGCOSH_GAUSSIAN_MEAN, LOGCOSH_NULL_VARIANCE);
+}
+/** Hyvärinen's Gaussian contrast G(u) = −exp(−u²/2) — most sensitive to peaked/super-Gaussian sources. */
+export function negentropyExp(x) {
+    return contrast(x, (u) => -Math.exp((-u * u) / 2), EXP_GAUSSIAN_MEAN, EXP_NULL_VARIANCE);
+}
+//# sourceMappingURL=negentropy.js.map

package/dist/estimators/negentropy.js.map

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

package/dist/estimators/pipeline.d.ts

@@ -0,0 +1,25 @@
+import type { Calibration, TrialSeries } from '../types.js';
+/**
+ * Bridges from lattice-valued randomness (bytes, trial sums) to the
+ * continuous-sample negentropy estimators. Dither noise comes from a seeded
+ * internal PRNG: deterministic per seed, and never drawn from the randomness
+ * under test.
+ */
+export interface DitherOptions {
+    seed?: number;
+}
+/**
+ * Trial sums → z-scores + uniform dither over one lattice cell. The dithered
+ * variable is continuous, and its differential entropy equals the discrete
+ * entropy of the lattice variable (in lattice-spacing log units) — which is
+ * what makes Vasicek meaningful on trial data. Under H0 the result is
+ * approximately N(0, 1 + 1/(12·k/4)) with excess kurtosis −2/k + O(1/k²).
+ */
+export declare function ditheredTrialZ(series: TrialSeries, cal: Calibration, opts?: DitherOptions): Float64Array;
+/**
+ * Bytes → exactly standard normal samples under H0: u = (b + U(0,1))/256 is
+ * uniform when bytes are, and Φ⁻¹(u) is then exactly N(0,1). The exact-null
+ * mode — ideal for calibrating estimators and byte-level (non-trial) analysis.
+ */
+export declare function probitBytes(bytes: Uint8Array, opts?: DitherOptions): Float64Array;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/estimators/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/estimators/pipeline.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE3D;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,WAAW,EAChB,IAAI,GAAE,aAAkB,GACvB,YAAY,CAKd;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,GAAE,aAAkB,GAAG,YAAY,CAKrF"}