@magield/collectors 0.0.0-stage → 0.7.1

package/dist/registry.js

@@ -0,0 +1,108 @@
+import { adblockCollector } from './signals/adblock.js';
+import { appsCollector } from './signals/apps.js';
+import { audioCollector } from './signals/audio.js';
+import { capabilitiesCollector } from './signals/capabilities.js';
+import { automationCollector } from './signals/automation.js';
+import { devicesCollector } from './signals/devices.js';
+import { displayCollector } from './signals/display.js';
+import { fontsCollector } from './signals/fonts.js';
+import { storageCollector } from './signals/storage.js';
+import { webrtcCollector } from './signals/webrtc.js';
+import { errorsCollector } from './signals/errors.js';
+import { featuresCollector } from './signals/features.js';
+import { integrityCollector } from './signals/integrity.js';
+import { mathCollector } from './signals/math.js';
+import { navigatorCollector } from './signals/navigator.js';
+import { pointerCollector } from './signals/pointer.js';
+import { canvasCollector, webglCollector } from './signals/render.js';
+import { screenCollector } from './signals/screen.js';
+import { timezoneCollector } from './signals/timezone.js';
+/**
+ * Order within a wave is the order they run, so the cheapest and most
+ * universally available come first: when a budget runs out, what survives
+ * should be the signals present on every device rather than the exotic ones.
+ */
+export const ALL_COLLECTORS = [
+    // instant
+    // Automation first. When a slow device runs out of budget, what is lost
+    // must be the ordinary fingerprint, never the detection: the published SDK
+    // ran this sixth, behind a 5 ms budget its obfuscated build could not meet,
+    // and shipped without bot detection for every integrator until 0.7.0.
+    automationCollector,
+    navigatorCollector,
+    screenCollector,
+    featuresCollector,
+    pointerCollector,
+    mathCollector,
+    errorsCollector,
+    // Last in the wave: the slowest instant collector measured (`Intl` calls,
+    // ~7 ms on an Apple M2 before obfuscation was removed).
+    timezoneCollector,
+    // warm
+    canvasCollector,
+    webglCollector,
+    displayCollector,
+    // Last in the wave: it is the only collector that attaches to the document,
+    // so if the budget runs out it is the one to lose.
+    integrityCollector,
+    // deep — every one is optional, so a tenant switching them off costs no
+    // confidence, and a budget overrun loses the expensive signals rather than
+    // the universal ones.
+    audioCollector,
+    devicesCollector,
+    storageCollector,
+    capabilitiesCollector,
+    // Last overall: it appends to the document and does the most DOM work of
+    // anything here, so it is the right thing to lose when the budget ends.
+    fontsCollector,
+];
+export const COLLECTOR_IDS = ALL_COLLECTORS.map((c) => c.id);
+/**
+ * Collectors a deployment must ask for by name.
+ *
+ * Deliberately absent from `ALL_COLLECTORS`, so no default enables them and no
+ * tenant gets them by forgetting to opt out. Everything here reads something
+ * about the person rather than about their browser, which makes enabling it a
+ * decision somebody has to make on purpose and be able to point at a consent
+ * for.
+ *
+ * Pass them explicitly:
+ *
+ *   runCollectors(env, { collectors: [...ALL_COLLECTORS, ...INVASIVE_COLLECTORS] })
+ *
+ * The split is the product position, not a technical one. `docs/` says what
+ * Magic Shield collects by default, and this is the list that is not in it.
+ */
+export const INVASIVE_COLLECTORS = [webrtcCollector, adblockCollector, appsCollector];
+/**
+ * Removed: localPortsCollector.
+ *
+ * It probed nine loopback ports for automation drivers, remote-control tools
+ * and anti-detect control APIs, and it was measured from the wrong place. The
+ * fp-lab page is served from `127.0.0.1`, so the probe was local reaching
+ * local — the one case Chrome does not gate — and it reported nine ports
+ * cleanly probed.
+ *
+ * From a public origin, which is every real deployment, Chrome 153 answers
+ * `navigator.permissions.query({ name: 'local-network-access' })` with
+ * **prompt**. Measured from `https://example.com` against known ports:
+ *
+ *   8791  open    hung until aborted at 1.5 s
+ *   9515  closed  Failed to fetch in 10 ms
+ *   18123 closed  hung until aborted at 2.0 s
+ *
+ * So it does not work, and the way it fails is worse than not working. The
+ * open port did not complete and two results were indistinguishable hangs, so
+ * the answers are noise; and a pending permission decision blocks, which on a
+ * login page means burning the deep wave and showing the visitor a prompt
+ * asking to access their local network. Nobody accepts that prompt, and asking
+ * is itself the harm.
+ *
+ * Not kept behind a flag. A collector that prompts cannot be enabled by a
+ * deployment without the person seeing it, which is the line this set does not
+ * cross — every other member runs silently.
+ *
+ * If it ever comes back it needs the permission requested honestly, at a
+ * moment the person understands, which is a product decision rather than a
+ * collector.
+ */

package/dist/run.d.ts

@@ -0,0 +1,10 @@
+import { type CollectionResult, type Collector, type CollectorEnv, type Wave } from './types.js';
+export interface RunOptions {
+    readonly waves?: readonly Wave[];
+    /** Collector ids switched off by the tenant, for privacy or compatibility. */
+    readonly disabled?: readonly string[];
+    readonly budgets?: Partial<Record<Wave, number>>;
+    readonly collectors?: readonly Collector[];
+    readonly now?: () => number;
+}
+export declare function runCollectors(env: CollectorEnv, options?: RunOptions): Promise<CollectionResult>;

package/dist/run.js

@@ -0,0 +1,128 @@
+import { ALL_COLLECTORS } from './registry.js';
+import { WAVE_BUDGET_MS } from './types.js';
+/**
+ * Runs collectors within their wave budgets.
+ *
+ * The budget is a hard promise to the integrator: a protected action is never
+ * delayed by collection. When a wave runs out of time the remaining collectors
+ * are skipped and reported, and confidence falls — a partial fingerprint is a
+ * normal outcome, not an error. On a slow device that is exactly the right
+ * trade: the user gets their login, and the server scores what it has.
+ */
+/** Returned instead of a result when a collector outlives its budget. */
+const TIMED_OUT = Symbol('timed-out');
+/**
+ * Resolves with the collector's result, or `TIMED_OUT` when the deadline wins.
+ *
+ * The collector is not cancelled — nothing here can cancel a browser API — so
+ * a hung probe keeps its handle until the page goes away. What this bounds is
+ * how long anyone *waits* for it, which is the promise the budget actually
+ * makes.
+ */
+async function withDeadline(work, ms) {
+    if (!(work instanceof Promise))
+        return work;
+    let timer;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(TIMED_OUT), Math.max(0, ms));
+            }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export async function runCollectors(env, options = {}) {
+    const now = options.now ?? (() => performance.now());
+    const waves = options.waves ?? ['instant', 'warm'];
+    const disabled = new Set(options.disabled ?? []);
+    const registry = options.collectors ?? ALL_COLLECTORS;
+    const signals = {};
+    const skipped = [];
+    const errors = [];
+    const startedAll = now();
+    let expected = 0;
+    let obtained = 0;
+    for (const wave of waves) {
+        const budget = options.budgets?.[wave] ?? WAVE_BUDGET_MS[wave];
+        const waveStarted = now();
+        // Set when a collector hits its deadline. A collector that outlived the
+        // remaining budget consumed it by definition, and saying so explicitly is
+        // both more honest and more reliable than inferring it from a clock —
+        // `setTimeout` and `performance.now()` are not the same clock, and a timer
+        // firing a fraction early left the comparison below reading as though
+        // there were budget left when there was not.
+        let exhausted = false;
+        for (const collector of registry.filter((c) => c.wave === wave)) {
+            if (disabled.has(collector.id)) {
+                skipped.push(collector.id);
+                // An optional collector the tenant switched off is a configuration
+                // choice, not missing evidence, so it does not count against
+                // confidence. Otherwise a tenant who disables canvas for privacy pays
+                // a permanently lower confidence on every request — the product
+                // penalising them for using the control it gave them.
+                //
+                // A collector that ran and found nothing still counts. That is a real
+                // absence, and `optional` says the tenant may turn it off, not that
+                // its silence is free.
+                if (collector.optional !== true)
+                    expected++;
+                continue;
+            }
+            expected++;
+            // Checked before starting rather than after: overshooting the budget and
+            // then noticing is the failure this is meant to prevent.
+            if (exhausted || now() - waveStarted >= budget) {
+                skipped.push(collector.id);
+                continue;
+            }
+            try {
+                // Bounded by what is left of the wave, not merely checked before it
+                // starts. The budget is "a protected action is never delayed by
+                // collection", and an unbounded await cannot keep that promise: one
+                // collector whose promise never settles hangs the whole bundle, and
+                // the caller waits forever for a fingerprint that was supposed to be
+                // best-effort.
+                //
+                // Measured: a backgrounded tab never fires `requestAnimationFrame`,
+                // and a browser API that hangs rather than rejecting is an ordinary
+                // hostile-runtime event rather than an exotic one.
+                const remaining = budget - (now() - waveStarted);
+                const result = await withDeadline(collector.collect(env), remaining);
+                if (result === TIMED_OUT) {
+                    skipped.push(collector.id);
+                    errors.push(`${collector.id}: exceeded the ${wave} budget`);
+                    exhausted = true;
+                    continue;
+                }
+                Object.assign(signals, result);
+                // A collector that returns only nulls did not fail, but it did not
+                // contribute either — canvas in an environment with no canvas, for
+                // instance. Confidence has to mean "how much was actually learned",
+                // not "how many collectors avoided throwing".
+                if (Object.values(result).some((value) => value !== null))
+                    obtained++;
+                else
+                    skipped.push(collector.id);
+            }
+            catch (err) {
+                // One broken collector must never cost the whole bundle. Browsers are
+                // a hostile runtime: extensions remove APIs, hardening throws on
+                // property access, and a page can be closed mid-collection.
+                skipped.push(collector.id);
+                errors.push(`${collector.id}: ${err.message}`);
+            }
+        }
+    }
+    return {
+        signals,
+        durationMs: Math.round(now() - startedAll),
+        skipped,
+        errors,
+        confidence: expected === 0 ? 0 : Number((obtained / expected).toFixed(3)),
+    };
+}

package/dist/signals/adblock.d.ts

@@ -0,0 +1,2 @@
+import type { Collector } from '../types.js';
+export declare const adblockCollector: Collector;

package/dist/signals/adblock.js

@@ -0,0 +1,135 @@
+/**
+ * Whether content blocking is active, measured without contacting anyone.
+ *
+ * In `INVASIVE_COLLECTORS` for an operational reason rather than a privacy one.
+ * It is not sensitive — running an ad blocker is not personal data in any
+ * meaningful sense — but the conventional implementation makes outbound
+ * requests to advertising domains from the integrator's login page, and that
+ * costs them CSP violations, latency, and an SDK that looks like adware in
+ * anyone's network tab. That is a decision for the integrator, not a default.
+ *
+ * ## Bait, not requests
+ *
+ * SEON's SDK fetches roughly fifteen real ad-network URLs and times the
+ * failures. This does not. Blockers work primarily from CSS selector and
+ * element-name rules, so the same answer comes from creating elements that
+ * *look* like advertising and asking whether they survived layout:
+ *
+ *   an element with a blocked class name has its height collapsed to zero
+ *   an element with a blocked id is hidden or removed outright
+ *
+ * Nothing leaves the page. No third party learns the visitor was here, no
+ * request appears in the network tab, and there is nothing for a CSP to refuse.
+ *
+ * ## What the answer is worth
+ *
+ * Little on its own, and that is the honest framing. Running a blocker is
+ * enormously common and says nothing about intent — it is weak positive
+ * evidence of a *person*, if anything, since most automation runs a stock
+ * profile with no extensions at all.
+ *
+ * Where it earns its place is as a contradiction: a client claiming a
+ * fully-configured consumer browser that has no blocker, no permissions ever
+ * decided, no touch history and a default everything is claiming a machine
+ * nobody uses. This is one of those, and it is collected for that combination
+ * rather than for itself.
+ */
+/**
+ * Class and id names blockers act on.
+ *
+ * Long-standing entries from the common filter lists rather than anything
+ * exotic: the goal is to be caught by an ordinary blocker in its default
+ * configuration, not to defeat a clever one.
+ */
+const BAIT_CLASSES = ['ad-banner', 'adsbox', 'pub_300x250', 'text-ad', 'sponsored-content'];
+const BAIT_IDS = ['ad-container', 'banner-ad', 'google_ads_frame'];
+export const adblockCollector = {
+    id: 'adblock',
+    wave: 'deep',
+    optional: true,
+    async collect({ document, window }) {
+        const out = {};
+        let holder;
+        try {
+            holder = document.createElement('div');
+            holder.setAttribute('style', 'position:absolute;left:-9999px;top:-9999px;width:1px;height:1px');
+            document.body.appendChild(holder);
+            const baits = [];
+            for (const name of BAIT_CLASSES) {
+                const bait = document.createElement('div');
+                bait.className = name;
+                // An explicit height, so a collapse to zero is the blocker's doing
+                // rather than an empty element being an empty element.
+                bait.setAttribute('style', 'width:300px;height:250px;position:absolute;left:-9999px');
+                bait.innerHTML = ' ';
+                holder.appendChild(bait);
+                baits.push(bait);
+            }
+            for (const name of BAIT_IDS) {
+                const bait = document.createElement('div');
+                bait.id = name;
+                bait.setAttribute('style', 'width:300px;height:250px;position:absolute;left:-9999px');
+                bait.innerHTML = ' ';
+                holder.appendChild(bait);
+                baits.push(bait);
+            }
+            // One frame, so a blocker acting on style has run. Raced against a
+            // deadline because `requestAnimationFrame` never fires in a background
+            // tab, and a collector that waits forever there is worse than one that
+            // answers from an unsettled layout.
+            await nextFrame(window);
+            let blocked = 0;
+            for (const bait of baits) {
+                // Removed outright, collapsed, or hidden — the three shapes a filter
+                // list produces. `offsetParent` is null for `display:none` and is the
+                // cheapest of the three to read.
+                const gone = bait.parentNode === null ||
+                    bait.offsetHeight === 0 ||
+                    bait.clientHeight === 0 ||
+                    window.getComputedStyle(bait).display === 'none';
+                if (gone)
+                    blocked++;
+            }
+            out['adblock.baits'] = baits.length;
+            out['adblock.blocked'] = blocked;
+            // A threshold rather than "any", because one bait collapsing can be a
+            // stylesheet on the host page rather than a blocker. Two agreeing is a
+            // filter list.
+            out['adblock.active'] = blocked >= 2;
+        }
+        catch {
+            out['adblock.baits'] = null;
+            out['adblock.blocked'] = null;
+            out['adblock.active'] = null;
+        }
+        finally {
+            try {
+                if (holder !== undefined && holder.parentNode !== null)
+                    holder.parentNode.removeChild(holder);
+            }
+            catch {
+                // Offscreen and hidden either way.
+            }
+        }
+        return out;
+    },
+};
+/** One paint, or a short deadline — whichever arrives first. */
+function nextFrame(window) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve();
+        };
+        try {
+            window.requestAnimationFrame(() => finish());
+        }
+        catch {
+            // No rAF; the deadline below covers it.
+        }
+        setTimeout(finish, 60);
+    });
+}

package/dist/signals/apps.d.ts

@@ -0,0 +1,2 @@
+import type { Collector } from '../types.js';
+export declare const appsCollector: Collector;

package/dist/signals/apps.js

@@ -0,0 +1,191 @@
+import { hash } from '../hash.js';
+/**
+ * Which applications are installed, probed through a filesystem leak.
+ *
+ * NOT part of `ALL_COLLECTORS`. It ships in `INVASIVE_COLLECTORS`, which a
+ * deployment must pass explicitly, because this reads something about a person
+ * rather than about their browser and that is not a decision a default should
+ * make quietly.
+ *
+ * ## What it is for
+ *
+ * Three entries are the reason it exists: GPS spoofers. A device running one
+ * is a device whose location cannot be believed, which in iGaming is the
+ * difference between a legal bet and an illegal one. The rest are here because
+ * presence *and absence* both carry signal — a machine with no browser but
+ * one, no messenger and no music player is not a person's laptop, it is a
+ * freshly imaged VM.
+ *
+ * ## What it costs, stated plainly
+ *
+ * It reveals which VPN somebody uses, whether they run Tor, and which
+ * encrypted messengers they have. Under GDPR that is ordinary personal data
+ * rather than a special category, but Article 5(1)(c) still asks whether it is
+ * necessary and proportionate for the purpose, and ePrivacy Article 5(3)
+ * treats reading from terminal equipment as requiring consent unless it is
+ * strictly necessary for a service the person asked for.
+ *
+ * A KYC-consented iGaming onboarding has an answer to both. A login page on a
+ * general-purpose site does not. That is the whole reason this is opt-in, and
+ * a deployment enabling it should be able to point at the consent covering it.
+ *
+ * The list is deliberately short. A longer one is more entropy and more
+ * exposure, and the marginal application tells you about a person without
+ * telling you anything about fraud.
+ *
+ * ## How it works
+ *
+ * A `File` is constructed whose *name* is an absolute path, added to a
+ * `DataTransfer`, and read back through a file input's `webkitEntries`. The
+ * resulting `FileSystemEntry` resolves against the real filesystem, so
+ * `getParent` succeeds for a path that exists and fails for one that does not.
+ *
+ * Chromium only, and a leak rather than an API. Every probe reports null
+ * rather than false when the mechanism is unavailable, so a browser without it
+ * reads as "could not look" instead of "nothing installed".
+ *
+ * ## It is already closed on current Chrome
+ *
+ * Measured on Chrome 153, 2026-09-29: `webkitEntries` is present on a file
+ * input and returns an **empty array** for a synthesised `DataTransfer`.
+ * Chrome now populates it only from a real user-initiated drop, so this
+ * collector returns null for every path on a current browser.
+ *
+ * It is kept rather than deleted for one reason: it costs a single probe to
+ * find that out, and older Chromium builds are still in use. It is not kept
+ * because it works here — it does not. Anyone enabling this should measure it
+ * on the browsers their users actually run before believing a negative, and
+ * `apps.probed` is the number that says whether anything was measured at all.
+ *
+ * Worth noting that SEON's SDK still ships this technique against 164 paths.
+ */
+/** Per probe. Several run concurrently, so this is not the total. */
+const PROBE_TIMEOUT_MS = 80;
+const MACOS_APPS = [
+    // The point of the exercise: location cannot be trusted on a machine
+    // running any of these.
+    'MockGo.app',
+    'Tenorshare iAnyGo.app',
+    'iMyFone AnyTo.app',
+    // Remote control. Legitimate constantly, and also how an account comes to be
+    // operated by somebody other than its owner.
+    'AnyDesk.app',
+    'TeamViewer.app',
+    'Parsec.app',
+    // Anti-detect browsers, which say what kind of session this is.
+    'ixBrowser.app',
+    'Multilogin.app',
+    'Dolphin Anty.app',
+    // Ordinary things. A machine with none of them is usually not a person's.
+    'Google Chrome.app',
+    'Firefox.app',
+    'Slack.app',
+    'Spotify.app',
+    'zoom.us.app',
+];
+export const appsCollector = {
+    id: 'apps',
+    wave: 'deep',
+    optional: true,
+    async collect({ document, window }) {
+        const out = {};
+        // The mechanism is Chromium-only and specific to synthesised entries.
+        // Probing for it once keeps every negative below honest.
+        if (!supportsEntryProbe(document, window)) {
+            out['apps.probed'] = null;
+            out['apps.found'] = null;
+            out['apps.hash'] = null;
+            return out;
+        }
+        try {
+            const results = await Promise.all(MACOS_APPS.map(async (name) => ({
+                name,
+                present: await pathExists(document, `/Applications/${name}`),
+            })));
+            const present = results.filter((r) => r.present === true).map((r) => r.name);
+            const measured = results.filter((r) => r.present !== null);
+            out['apps.probed'] = measured.length;
+            out['apps.found'] = present.length;
+            out['apps.hash'] = present.length === 0 ? null : hash([...present].sort().join('|'));
+            // Grouped rather than named individually. A rule that wants to act on a
+            // GPS spoofer should not need to know a hash, and a tenant reading its
+            // own console deserves to see what it acted on — but nothing downstream
+            // needs the specific application, so the specific application does not
+            // leave this file.
+            out['apps.locationSpoofer'] = present.some((n) => /MockGo|iAnyGo|AnyTo/.test(n));
+            out['apps.remoteControl'] = present.some((n) => /AnyDesk|TeamViewer|Parsec/.test(n));
+            out['apps.antiDetect'] = present.some((n) => /ixBrowser|Multilogin|Dolphin/.test(n));
+        }
+        catch {
+            out['apps.probed'] = null;
+            out['apps.found'] = null;
+        }
+        return out;
+    },
+};
+/**
+ * Whether the mechanism actually works, rather than whether the property
+ * exists.
+ *
+ * These are not the same and the difference is the whole collector. Measured
+ * on Chrome 153: `webkitEntries` is present on a file input and returns an
+ * **empty array** for a synthesised `DataTransfer`, so a check for the
+ * property passes and then every probe answers null. Chrome now populates it
+ * only from a real user-initiated drop.
+ *
+ * So this constructs one throwaway entry and checks that something came back.
+ * A browser that has closed the leak is detected in one step instead of
+ * fifteen timeouts.
+ */
+function supportsEntryProbe(document, window) {
+    try {
+        if (typeof window.DataTransfer !== 'function')
+            return false;
+        const transfer = new DataTransfer();
+        transfer.items.add(new File([], 'probe', { type: 'text/plain' }));
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.files = transfer.files;
+        const entries = input.webkitEntries;
+        return Array.isArray(entries) && entries.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a path exists, or null when it could not be determined.
+ *
+ * Never false on a failed mechanism. That is the difference between "this is
+ * not installed" and "this browser does not leak", and a caller conflating
+ * them reports an empty machine for every Firefox user.
+ */
+async function pathExists(document, path) {
+    try {
+        const transfer = new DataTransfer();
+        transfer.items.add(new File([], `${path}/probe`, { type: 'text/plain' }));
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.files = transfer.files;
+        const entry = input.webkitEntries?.[0];
+        if (entry === undefined || typeof entry.getParent !== 'function')
+            return null;
+        return await new Promise((resolve) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
+            // A resolved parent means the directory is really there; an error means
+            // it is not. The timeout means neither answer arrived, which is a third
+            // outcome and is reported as one.
+            entry.getParent(() => finish(true), () => finish(false));
+            setTimeout(() => finish(null), PROBE_TIMEOUT_MS);
+        });
+    }
+    catch {
+        return null;
+    }
+}

package/dist/signals/audio.d.ts

@@ -0,0 +1,16 @@
+import type { Collector } from '../types.js';
+/**
+ * The audio stack, rendered offline.
+ *
+ * An oscillator through a compressor produces a buffer whose exact float
+ * values depend on the platform's audio implementation and its floating-point
+ * behaviour — stable for a machine, different across them. Nothing is played
+ * and no device is opened: `OfflineAudioContext` renders into memory, needs no
+ * permission, and makes no sound.
+ *
+ * Two values rather than one, because they fail differently. The sum survives
+ * small per-sample noise and identifies the platform; the hash does not, and a
+ * client whose sum is ordinary while its hash moves between reads is being
+ * farbled. Reporting only one of them would hide that.
+ */
+export declare const audioCollector: Collector;

package/dist/signals/audio.js

@@ -0,0 +1,63 @@
+import { hash } from '../hash.js';
+/**
+ * The audio stack, rendered offline.
+ *
+ * An oscillator through a compressor produces a buffer whose exact float
+ * values depend on the platform's audio implementation and its floating-point
+ * behaviour — stable for a machine, different across them. Nothing is played
+ * and no device is opened: `OfflineAudioContext` renders into memory, needs no
+ * permission, and makes no sound.
+ *
+ * Two values rather than one, because they fail differently. The sum survives
+ * small per-sample noise and identifies the platform; the hash does not, and a
+ * client whose sum is ordinary while its hash moves between reads is being
+ * farbled. Reporting only one of them would hide that.
+ */
+export const audioCollector = {
+    id: 'audio',
+    wave: 'deep',
+    optional: true,
+    async collect({ window }) {
+        const out = {};
+        const Ctor = window.OfflineAudioContext ??
+            window.webkitOfflineAudioContext;
+        if (Ctor === undefined) {
+            // Present and null: the probe ran and the API is absent. An omitted key
+            // would say the collector never ran, which is a different fact.
+            out['audio.sum'] = null;
+            out['audio.hash'] = null;
+            return out;
+        }
+        try {
+            // 44.1 kHz and 5000 frames: long enough for the compressor to settle,
+            // short enough to render well inside the deep wave's budget.
+            const context = new Ctor(1, 5000, 44100);
+            const oscillator = context.createOscillator();
+            oscillator.type = 'triangle';
+            oscillator.frequency.value = 10000;
+            const compressor = context.createDynamicsCompressor();
+            compressor.threshold.value = -50;
+            compressor.knee.value = 40;
+            compressor.ratio.value = 12;
+            compressor.attack.value = 0;
+            compressor.release.value = 0.25;
+            oscillator.connect(compressor);
+            compressor.connect(context.destination);
+            oscillator.start(0);
+            const buffer = await context.startRendering();
+            const samples = buffer.getChannelData(0);
+            // The tail only. The attack is dominated by the ramp, which is the same
+            // everywhere; the settled region is where implementations diverge.
+            let sum = 0;
+            for (let i = 4500; i < samples.length; i++)
+                sum += Math.abs(samples[i] ?? 0);
+            out['audio.sum'] = Number(sum.toFixed(6));
+            out['audio.hash'] = hash(samples.slice(4500).join(','));
+        }
+        catch {
+            out['audio.sum'] = null;
+            out['audio.hash'] = null;
+        }
+        return out;
+    },
+};

package/dist/signals/automation.d.ts

@@ -0,0 +1,2 @@
+import type { Collector } from '../types.js';
+export declare const automationCollector: Collector;