@magield/collectors 0.0.0-stage → 0.7.1

package/dist/signals/fonts.d.ts

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

package/dist/signals/fonts.js

@@ -0,0 +1,128 @@
+import { hash } from '../hash.js';
+/**
+ * Which fonts are installed, measured rather than asked.
+ *
+ * There is no API for this. The measurement is indirect: render a string in a
+ * candidate font with a known fallback behind it, and compare its width and
+ * height against the fallback alone. A different size means the candidate
+ * resolved; an identical one means it did not and the fallback drew.
+ *
+ * The set is a strong platform signal — a stock Windows install, a Mac with
+ * Office, and a Linux container each carry a distinct list — and it is one of
+ * the few things an anti-detect browser rarely bothers to fake, because faking
+ * it convincingly means faking per-glyph metrics rather than a string.
+ *
+ * Costs are real and the list is sized for them: each candidate is three
+ * measurements, and the DOM work is the reason this sits in the deep wave.
+ */
+/** The three generics every measurement is compared against. */
+const BASELINES = ['monospace', 'sans-serif', 'serif'];
+/**
+ * Candidates chosen to separate platforms rather than to be exhaustive.
+ *
+ * Each is shipped by default on at least one platform and absent from the
+ * others, so presence is informative in both directions. A longer list buys
+ * little: fonts correlate heavily, and the cost is linear.
+ */
+const CANDIDATES = [
+    // macOS
+    'Apple Chancery', 'Apple Color Emoji', 'AppleGothic', 'Avenir', 'Baskerville',
+    'Big Caslon', 'Chalkboard', 'Cochin', 'Copperplate', 'Didot', 'Futura',
+    'Geneva', 'Helvetica Neue', 'Herculanum', 'Hoefler Text', 'Luminari',
+    'Marker Felt', 'Menlo', 'Monaco', 'Optima', 'Papyrus', 'SF Pro', 'Skia', 'Zapfino',
+    // Windows
+    'Arial Black', 'Bahnschrift', 'Calibri', 'Cambria', 'Candara', 'Consolas',
+    'Constantia', 'Corbel', 'Ebrima', 'Franklin Gothic Medium', 'Gabriola',
+    'Gadugi', 'Georgia', 'HoloLens MDL2 Assets', 'Impact', 'Ink Free',
+    'Javanese Text', 'Leelawadee UI', 'Lucida Console', 'Lucida Sans Unicode',
+    'MS Gothic', 'MV Boli', 'Malgun Gothic', 'Marlett', 'Microsoft Himalaya',
+    'Microsoft JhengHei', 'Microsoft YaHei', 'MingLiU-ExtB', 'Mongolian Baiti',
+    'Myanmar Text', 'Nirmala UI', 'Palatino Linotype', 'Segoe UI', 'SimSun',
+    'Sitka', 'Sylfaen', 'Tahoma', 'Trebuchet MS', 'Yu Gothic',
+    // Office, which is itself a signal about the kind of machine
+    'Agency FB', 'Bookman Old Style', 'Bookshelf Symbol 7', 'Garamond',
+    'Goudy Old Style', 'Haettenschweiler', 'Rockwell',
+    // Linux and common free families
+    'Cantarell', 'DejaVu Sans', 'DejaVu Serif', 'FreeSans', 'Liberation Mono',
+    'Liberation Sans', 'Liberation Serif', 'Nimbus Roman', 'Noto Sans',
+    'Ubuntu', 'URW Bookman',
+    // Android
+    'Droid Sans', 'Roboto', 'sans-serif-thin',
+];
+/** Long enough to accumulate per-glyph differences, short enough to measure fast. */
+const PROBE = 'mmmmmmmmmmlli WWWWWWW 0123456789';
+export const fontsCollector = {
+    id: 'fonts',
+    wave: 'deep',
+    optional: true,
+    collect({ document, window }) {
+        const out = {};
+        let holder;
+        try {
+            // One offscreen holder, one span per baseline, reused across candidates.
+            // Creating an element per font is what makes naive versions of this cost
+            // hundreds of milliseconds.
+            holder = document.createElement('div');
+            holder.setAttribute('style', 'position:absolute;left:-9999px;top:-9999px;visibility:hidden;' +
+                'font-size:72px;line-height:normal;white-space:nowrap');
+            document.body.appendChild(holder);
+            const spans = {};
+            const base = {};
+            for (const baseline of BASELINES) {
+                const span = document.createElement('span');
+                span.style.fontFamily = baseline;
+                span.textContent = PROBE;
+                holder.appendChild(span);
+                spans[baseline] = span;
+                base[baseline] = { w: span.offsetWidth, h: span.offsetHeight };
+            }
+            const present = [];
+            for (const candidate of CANDIDATES) {
+                // A candidate counts as installed if it shifts the metrics against ANY
+                // baseline. Requiring all three misses fonts that happen to match one
+                // generic's metrics, which is common for the generic a platform maps
+                // to its own default.
+                let found = false;
+                for (const baseline of BASELINES) {
+                    const span = spans[baseline];
+                    const reference = base[baseline];
+                    if (span === undefined || reference === undefined)
+                        continue;
+                    span.style.fontFamily = `'${candidate}',${baseline}`;
+                    if (span.offsetWidth !== reference.w || span.offsetHeight !== reference.h) {
+                        found = true;
+                    }
+                    span.style.fontFamily = baseline;
+                    if (found)
+                        break;
+                }
+                if (found)
+                    present.push(candidate);
+            }
+            out['fonts.count'] = present.length;
+            out['fonts.probed'] = CANDIDATES.length;
+            out['fonts.hash'] = hash(present.join('|'));
+            // A device with no candidate at all is not a device with unusual taste in
+            // typography — it is a headless container, or a client that broke the
+            // measurement. Distinguishing that from a short list needs the count,
+            // which is why it is reported beside the hash rather than folded in.
+            const ratio = present.length / CANDIDATES.length;
+            out['fonts.ratio'] = Number(ratio.toFixed(3));
+        }
+        catch {
+            out['fonts.count'] = null;
+            out['fonts.hash'] = null;
+        }
+        finally {
+            try {
+                if (holder !== undefined && holder.parentNode !== null)
+                    holder.parentNode.removeChild(holder);
+            }
+            catch {
+                // A document that will not let us clean up is not worth a thrown signal.
+            }
+        }
+        void window;
+        return out;
+    },
+};

package/dist/signals/integrity.d.ts

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

package/dist/signals/integrity.js

@@ -0,0 +1,216 @@
+import { hash } from '../hash.js';
+import { isNativeSource, nameMatchesSource } from '../native.js';
+/**
+ * Native integrity, checked from a realm the page did not get to patch.
+ *
+ * `bot.patchedNatives` asks `Function.prototype.toString` whether the natives
+ * have been replaced — including whether `Function.prototype.toString` itself
+ * has been replaced. That is circular, and it is the first thing a stealth
+ * plugin breaks: `puppeteer-extra-plugin-stealth` carries a `patchToString`
+ * helper whose whole purpose is to make replaced functions stringify as
+ * `[native code]`. Once it runs, every probe over there reads clean.
+ *
+ * A fresh same-origin iframe gets its own realm with its own untouched
+ * intrinsics. Stringifying the *main* realm's functions with the *iframe's*
+ * `toString` asks the question without using the answer, so a patch applied
+ * *by page script* does not survive the comparison.
+ *
+ * Specified as `iframe.native_recovery` in docs/signals.md section 4 and never
+ * built until now.
+ *
+ * **What this does not catch, measured rather than reasoned about.** A tool
+ * driving the browser over CDP does not patch from page script. It installs its
+ * evasions with `Page.addScriptToEvaluateOnNewDocument`, which runs in *every*
+ * new document — including this iframe. Measured against a real
+ * `puppeteer-extra-plugin-stealth` on Chrome 141: the iframe reports the same
+ * spoofed `Intel Iris OpenGL Engine` as the page, and all six probes read clean
+ * while `WebGLRenderingContext.prototype.getParameter` is demonstrably wrapped.
+ * There is no untouched realm to borrow, so the comparison agrees with itself.
+ *
+ * That is a real ceiling and not a bug to fix here: any realm this collector can
+ * create, the debugger can reach first. The probe that does see through it is
+ * `bot.proxiedNatives` in automation.ts, which reads the stack the engine builds
+ * rather than asking the page anything. This collector still earns its place
+ * against page-script patching — user-script managers, injected XSS, and the
+ * older plugins that patch without a debugger attached.
+ *
+ * **This is the only collector that touches the document.** Everything else
+ * creates elements without attaching them (see render.ts), but an iframe has no
+ * `contentWindow` until it is in the tree, so there is no version of this that
+ * does not. It is appended hidden, read, and removed in a `finally` — and it
+ * runs in the warm wave, because the instant wave's whole budget is 5 ms across
+ * seven collectors and nothing interrupts a collector that overruns.
+ */
+/**
+ * Split by what patching each one would mean.
+ *
+ * Privacy extensions genuinely replace canvas and WebGL readback — that is
+ * their entire function, and treating it as concealment would flag the most
+ * privacy-conscious users on the web. Almost nothing legitimate replaces
+ * `Function.prototype.toString`: its only use is to make *other* replacements
+ * invisible. The exception is zone.js, which every Angular app loads, and it is
+ * recognised by name below rather than counted. So the two are counted separately and weighted separately, rather
+ * than summed into a number that cannot tell a Brave user from a stealth
+ * plugin.
+ */
+const CONCEALMENT = [
+    { name: 'Function.toString', path: ['Function', 'prototype', 'toString'] },
+    { name: 'Object.getOwnPropertyDescriptor', path: ['Object', 'getOwnPropertyDescriptor'] },
+    { name: 'Reflect.get', path: ['Reflect', 'get'] },
+];
+const SURFACE = [
+    { name: 'Canvas.toDataURL', path: ['HTMLCanvasElement', 'prototype', 'toDataURL'] },
+    { name: 'Canvas.getContext', path: ['HTMLCanvasElement', 'prototype', 'getContext'] },
+    { name: 'WebGL.getParameter', path: ['WebGLRenderingContext', 'prototype', 'getParameter'] },
+];
+export const integrityCollector = {
+    id: 'integrity',
+    wave: 'warm',
+    // Tenants whose CSP forbids frames, or who would rather not have one created
+    // at all, can turn this off by id without losing the rest of the bot family.
+    optional: true,
+    collect({ window, document }) {
+        const out = {};
+        const pristine = borrowToString(window, document);
+        if (pristine === undefined) {
+            // No realm to compare against — a `frame-src` CSP, a sandboxed document,
+            // a page torn down mid-collection. Zero probes is the honest report, and
+            // the consistency check abstains on it. Reporting zero *divergences*
+            // instead would be a clean bill of health nobody earned.
+            out['bot.realmProbes'] = 0;
+            out['bot.realmDivergence'] = 0;
+            out['bot.realmDetail'] = null;
+            return out;
+        }
+        const diverged = [];
+        const zoned = [];
+        let probes = 0;
+        for (const spec of [...CONCEALMENT, ...SURFACE]) {
+            const target = resolve(window, spec.path);
+            if (typeof target !== 'function')
+                continue;
+            probes++;
+            try {
+                if (isNativeIn(pristine, target))
+                    continue;
+                // zone.js — loaded by every Angular app — replaces
+                // `Function.prototype.toString` so the functions it patches still read
+                // as native. That is the one legitimate concealment there is, and
+                // counting it put +38 on every visitor of every Angular site. Its
+                // wrapper keeps the original under `__zone_symbol__OriginalDelegate`;
+                // when that original is itself native, the replacement is zone's and
+                // nothing else. A tool that wraps again on top replaces the function
+                // and loses the marker, so this exempts zone and nothing layered on it.
+                // (Stealth plugins are not caught here anyway: they patch the borrowed
+                // realm too. `bot.proxiedNatives` is what sees them.)
+                if (isZoneWrapper(window, pristine, target)) {
+                    zoned.push(spec.name);
+                    continue;
+                }
+                diverged.push(spec.name);
+            }
+            catch {
+                diverged.push(spec.name);
+            }
+        }
+        // Reported, never scored: which natives zone.js owns on this page, so an
+        // explanation can say why the realm looked touched and still read clean.
+        out['bot.realmZone'] = zoned.join(',') || null;
+        out['bot.realmProbes'] = probes;
+        out['bot.realmDivergence'] = diverged.length;
+        out['bot.realmDetail'] = diverged.join(',') || null;
+        // Counted apart so a check can weigh "hid the evidence" differently from
+        // "blocked fingerprinting", which is the difference between an attacker and
+        // a customer with an ad blocker.
+        out['bot.realmConcealment'] = diverged.filter((name) => CONCEALMENT.some((spec) => spec.name === name)).length;
+        // The companion to `bot.spoofHash`: which natives a tool had to wrap, as a
+        // cluster key. Kept separate from the navigator one rather than combined,
+        // because they identify different things — what a tool rewrites about the
+        // browser, and what it wraps to hide the rewriting — and a tool can do
+        // either without the other.
+        out['bot.realmHash'] = diverged.length === 0 ? null : hash(diverged.join(','));
+        return out;
+    },
+};
+/**
+ * Two ways a function fails to be native. The source is not a native stub at
+ * all — an ordinary replacement — or it is a native stub that has lost the name
+ * the function still claims, which is what a Proxy around an intrinsic looks
+ * like. The second matters because `patchToString` installs exactly that, and a
+ * source check alone reads it as clean.
+ */
+function isNativeIn(pristine, target) {
+    const source = pristine.call(target);
+    const claimed = typeof target.name === 'string' ? target.name : '';
+    return isNativeSource(source) && nameMatchesSource(claimed, source);
+}
+/** zone.js's own wrapper over a native, and only that. See the call site. */
+function isZoneWrapper(window, pristine, target) {
+    const zone = window.Zone;
+    if (zone === undefined || typeof zone.__symbol__ !== 'function')
+        return false;
+    const original = target.__zone_symbol__OriginalDelegate;
+    if (typeof original !== 'function' || original === target)
+        return false;
+    try {
+        return isNativeIn(pristine, original);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A `Function.prototype.toString` from a realm the page has not touched.
+ *
+ * Every step can fail in an ordinary browser — CSP, a detached document, a
+ * sandbox without `allow-same-origin` — and every failure means "cannot tell",
+ * never "clean".
+ */
+function borrowToString(window, document) {
+    let frame;
+    try {
+        const host = document.body ?? document.documentElement;
+        if (host === null || host === undefined)
+            return undefined;
+        frame = document.createElement('iframe');
+        // Not `display: none`: a display:none frame does not load a document in
+        // every engine, and without a document there is no realm to borrow from.
+        frame.setAttribute('style', 'position:absolute;width:0;height:0;border:0;opacity:0;pointer-events:none;left:-9999px');
+        frame.setAttribute('aria-hidden', 'true');
+        frame.setAttribute('tabindex', '-1');
+        // Left as about:blank. A same-origin frame inherits the origin without a
+        // network request, which is what makes this cheap enough for the warm wave.
+        host.appendChild(frame);
+        const realm = frame.contentWindow;
+        const borrowed = realm?.Function?.prototype?.toString;
+        // Bound to the iframe's own realm before the frame is removed, so the
+        // reference stays usable after the element is gone.
+        return typeof borrowed === 'function' ? borrowed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        try {
+            frame?.remove();
+        }
+        catch {
+            // A frame we cannot remove is a leaked element, not a failed measurement.
+        }
+    }
+}
+/** Walks a dotted path without invoking anything, as features.ts does. */
+function resolve(window, path) {
+    let current = window;
+    for (const key of path) {
+        if (current === null || current === undefined)
+            return undefined;
+        try {
+            current = current[key];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return current;
+}

package/dist/signals/math.d.ts

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

package/dist/signals/math.js

@@ -0,0 +1,43 @@
+import { hashRecord } from '../hash.js';
+/**
+ * Floating-point quirks.
+ *
+ * Transcendental functions are not specified to the last bit, so their results
+ * differ between engines, libm implementations and CPU architectures. Nothing
+ * a spoofing tool normally thinks to patch, and cheap to collect — it is pure
+ * arithmetic with no DOM involved.
+ */
+const PROBES = {
+    acos: () => Math.acos(0.123456789),
+    acosh: () => Math.acosh(1e308),
+    asin: () => Math.asin(0.123456789),
+    asinh: () => Math.asinh(1),
+    atanh: () => Math.atanh(0.5),
+    cbrt: () => Math.cbrt(100),
+    cosh: () => Math.cosh(1),
+    expm1: () => Math.expm1(1),
+    log1p: () => Math.log1p(10),
+    sinh: () => Math.sinh(1),
+    tanh: () => Math.tanh(1),
+    pow: () => Math.pow(Math.PI, -100),
+    exp: () => Math.exp(1),
+    sin: () => Math.sin(1e10),
+    tan: () => Math.tan(1e10),
+};
+export const mathCollector = {
+    id: 'math',
+    wave: 'instant',
+    collect() {
+        const results = {};
+        for (const [name, probe] of Object.entries(PROBES)) {
+            try {
+                results[name] = String(probe());
+            }
+            catch {
+                results[name] = 'error';
+            }
+        }
+        const out = { 'math.quirksHash': hashRecord(results) };
+        return out;
+    },
+};

package/dist/signals/navigator.d.ts

@@ -0,0 +1,10 @@
+import type { Collector } from '../types.js';
+/**
+ * The navigator surface.
+ *
+ * Every value here is trivially spoofable, and none of it is trusted on its
+ * own. It earns its place by being cross-checked: against the HTTP headers the
+ * server saw, against client hints, and against what the rendering stack
+ * implies. Contradictions between these sources are the actual signal.
+ */
+export declare const navigatorCollector: Collector;

package/dist/signals/navigator.js

@@ -0,0 +1,81 @@
+import { hashRecord } from '../hash.js';
+/**
+ * The navigator surface.
+ *
+ * Every value here is trivially spoofable, and none of it is trusted on its
+ * own. It earns its place by being cross-checked: against the HTTP headers the
+ * server saw, against client hints, and against what the rendering stack
+ * implies. Contradictions between these sources are the actual signal.
+ */
+export const navigatorCollector = {
+    id: 'nav',
+    wave: 'instant',
+    collect({ navigator }) {
+        const out = {
+            'nav.userAgent': navigator.userAgent ?? null,
+            'nav.platform': read(() => navigator.platform),
+            'nav.vendor': read(() => navigator.vendor),
+            'nav.language': navigator.language ?? null,
+            'nav.languages': (navigator.languages ?? []).join(','),
+            'nav.hardwareConcurrency': read(() => navigator.hardwareConcurrency),
+            'nav.deviceMemory': read(() => navigator.deviceMemory),
+            'nav.maxTouchPoints': read(() => navigator.maxTouchPoints),
+            'nav.cookieEnabled': read(() => navigator.cookieEnabled),
+            'nav.pdfViewerEnabled': read(() => navigator.pdfViewerEnabled),
+            'nav.doNotTrack': read(() => navigator.doNotTrack),
+            // Honest drivers set this. It is never enough on its own — every stealth
+            // plugin deletes it — but a `true` is close to conclusive.
+            'nav.webdriver': read(() => navigator.webdriver),
+            // Brave ships `navigator.brave` deliberately so that sites can identify
+            // it, which makes this the vendor's own answer rather than an inference.
+            // It is collected as a fact and scored at nothing: a privacy browser is
+            // a privacy-conscious person, and what a tenant does about that is the
+            // tenant's policy, not this engine's opinion.
+            //
+            // Anyone who deletes it is simply not identified as Brave, which is the
+            // correct outcome — they are then judged on everything else, like any
+            // other client.
+            'nav.brave': read(() => 'brave' in navigator),
+        };
+        // Plugin *shape* is browser-family specific and survives spoofing of the
+        // user agent, because faking it convincingly means faking a whole list.
+        const plugins = read(() => navigator.plugins?.length);
+        // Chromium-only. Firefox and Safari have declined to implement it, so a
+        // client claiming Gecko while exposing it is claiming two things that have
+        // never been true together.
+        out['nav.hasUserAgentData'] = navigator.userAgentData !== undefined;
+        out['nav.pluginCount'] = plugins;
+        if (typeof plugins === 'number' && plugins > 0) {
+            const names = [];
+            for (let i = 0; i < navigator.plugins.length; i++) {
+                const plugin = navigator.plugins.item(i);
+                if (plugin !== null)
+                    names.push(`${plugin.name}:${plugin.filename}`);
+            }
+            out['nav.pluginsHash'] = hashRecord({ names: names.sort().join('|') });
+        }
+        // Emitted whether or not NetworkInformation exists, because its absence is
+        // itself a signal and an omitted key cannot carry it: a reader cannot tell
+        // "this browser has no such API" from "this collector never ran". Brave
+        // removes the API, and that difference is only legible if the probe says
+        // so out loud.
+        const connection = navigator
+            .connection;
+        out['nav.connectionType'] = connection?.effectiveType ?? null;
+        // Compared against the RTT the server actually measured. A claim of 4G
+        // from an address that pings like a datacenter is a contradiction.
+        out['nav.connectionRtt'] = connection?.rtt ?? null;
+        out['nav.connectionDownlink'] = connection?.downlink ?? null;
+        return out;
+    },
+};
+/** Property access can throw in hardened or instrumented environments. */
+function read(fn) {
+    try {
+        const value = fn();
+        return value === undefined ? null : value;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/signals/pointer.d.ts

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

package/dist/signals/pointer.js

@@ -0,0 +1,93 @@
+import { hash } from '../hash.js';
+/**
+ * What kind of input this device has, asked of the platform rather than the
+ * user agent.
+ *
+ * `nav.maxTouchPoints` was the only thing here, and it is one number that a
+ * profile rewrites in one edit. These ask the same question several ways: the
+ * event constructors that exist, the properties those constructors expose, and
+ * what the media queries say about the primary pointer.
+ *
+ * Contradiction is the point. A client claiming a phone should have coarse
+ * pointer, no hover, touch events and touch points; a desktop should have the
+ * inverse. Profiles that fake mobile usually set the user agent and the touch
+ * count and leave the rest, so the disagreement is what carries the signal —
+ * not any one value.
+ */
+/**
+ * PointerEvent properties, probed on the prototype.
+ *
+ * The set differs between engines and between versions, and unlike a feature
+ * hash built from global names these are specifically about input hardware.
+ */
+const POINTER_PROPS = [
+    'altitudeAngle', 'azimuthAngle', 'height', 'isPrimary', 'pointerId', 'pointerType',
+    'pressure', 'tangentialPressure', 'tiltX', 'tiltY', 'twist', 'width',
+    'getCoalescedEvents', 'getPredictedEvents', 'persistentDeviceId',
+];
+const TOUCH_PROPS = [
+    'force', 'identifier', 'pageX', 'pageY', 'radiusX', 'radiusY',
+    'rotationAngle', 'screenX', 'screenY', 'altitudeAngle', 'azimuthAngle', 'touchType',
+];
+const QUERIES = {
+    'pointer.primaryCoarse': '(pointer: coarse)',
+    'pointer.primaryFine': '(pointer: fine)',
+    'pointer.primaryNone': '(pointer: none)',
+    'pointer.anyFine': '(any-pointer: fine)',
+    'pointer.anyHover': '(any-hover: hover)',
+};
+export const pointerCollector = {
+    id: 'pointer',
+    wave: 'instant',
+    optional: true,
+    collect({ window, navigator }) {
+        const out = {};
+        for (const [key, query] of Object.entries(QUERIES)) {
+            try {
+                const result = window.matchMedia(query);
+                // An engine that does not know the query normalises it to 'not all',
+                // where `matches` would otherwise report a confident false.
+                out[key] = result.media === 'not all' ? null : result.matches;
+            }
+            catch {
+                out[key] = null;
+            }
+        }
+        out['pointer.pointerEvent'] = 'PointerEvent' in window;
+        out['pointer.touchEvent'] = 'TouchEvent' in window;
+        out['pointer.ontouchstart'] = 'ontouchstart' in window;
+        out['pointer.propsHash'] = protoHash(window, 'PointerEvent', POINTER_PROPS);
+        out['pointer.touchPropsHash'] = protoHash(window, 'TouchEvent' in window ? 'Touch' : '', TOUCH_PROPS);
+        // Reported beside the media queries on purpose. A desktop that claims five
+        // touch points while every query says fine-pointer-with-hover is the
+        // contradiction this collector exists to make visible, and it is only
+        // visible when both sides are recorded.
+        try {
+            out['pointer.maxTouchPoints'] = navigator.maxTouchPoints;
+        }
+        catch {
+            out['pointer.maxTouchPoints'] = null;
+        }
+        return out;
+    },
+};
+/** Which of a set of properties the constructor's prototype actually carries. */
+function protoHash(window, constructorName, props) {
+    try {
+        if (constructorName === '')
+            return null;
+        const ctor = window[constructorName];
+        if (typeof ctor !== 'function')
+            return null;
+        const proto = ctor.prototype;
+        if (proto === undefined)
+            return null;
+        let bits = '';
+        for (const prop of props)
+            bits += prop in proto ? '1' : '0';
+        return hash(bits);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/signals/render.d.ts

@@ -0,0 +1,12 @@
+import type { Collector } from '../types.js';
+/**
+ * Canvas and WebGL: what the GPU and driver actually produce.
+ *
+ * These are the highest-entropy signals available to a page, because the output
+ * depends on the whole rendering stack — GPU, driver version, OS text
+ * rasteriser, font hinting. They are also the ones privacy browsers
+ * deliberately poison, so the *stability* of the result is collected alongside
+ * it: real hardware is deterministic, injected noise is not.
+ */
+export declare const canvasCollector: Collector;
+export declare const webglCollector: Collector;