@magield/collectors 0.0.0-stage → 0.7.1

package/dist/signals/automation.js

@@ -0,0 +1,346 @@
+import { hash } from '../hash.js';
+import { applyTrapIsObservable, interposesApplyTrap, isNativeSource } from '../native.js';
+/**
+ * Traces left by automation frameworks and the plugins that hide them.
+ *
+ * None of these is conclusive alone and all of them are defeatable — that is
+ * assumed, not a flaw. Their value is cumulative and, more importantly,
+ * *contradictory*: a stealth plugin that deletes `navigator.webdriver` usually
+ * leaves a patched `Function.prototype.toString` behind, and patching that
+ * leaves something else. The goal is to make a clean pass expensive.
+ */
+const DRIVER_GLOBALS = [
+    '__webdriver_evaluate',
+    '__selenium_evaluate',
+    '__webdriver_script_function',
+    '__webdriver_script_func',
+    '__webdriver_script_fn',
+    '__fxdriver_evaluate',
+    '__driver_unwrapped',
+    '__webdriver_unwrapped',
+    '__driver_evaluate',
+    '__selenium_unwrapped',
+    '__fxdriver_unwrapped',
+    '_phantom',
+    '__nightmare',
+    'callPhantom',
+    '_selenium',
+    'calledSelenium',
+    '$cdc_asdjflasutopfhvcZLmcfl_',
+    '$chrome_asyncScriptInfo',
+    '__$webdriverAsyncExecutor',
+    '__lastWatirAlert',
+    '__playwright_target__',
+    '__pw_manual',
+    '__puppeteer_evaluation_script__',
+];
+export const automationCollector = {
+    id: 'bot',
+    wave: 'instant',
+    collect({ window, document, navigator }) {
+        const out = {};
+        const found = DRIVER_GLOBALS.filter((name) => {
+            try {
+                return name in window || name in document;
+            }
+            catch {
+                return false;
+            }
+        });
+        out['bot.driverGlobals'] = found.length;
+        // The names matter for triage: knowing it was Playwright rather than
+        // Selenium changes what a tenant does about it.
+        out['bot.driverNames'] = found.join(',') || null;
+        // Selenium and some drivers mark the document element.
+        out['bot.documentAttributes'] = attributeMarkers(document);
+        // Chrome exposes window.chrome to every page. Headless Chrome historically
+        // did not, and stealth plugins add a hollow stand-in whose shape is wrong.
+        const chrome = window.chrome;
+        out['bot.hasChromeObject'] = chrome !== undefined;
+        out['bot.chromeKeys'] = chrome === undefined ? null : Object.keys(chrome).sort().join(',');
+        // Native functions stringify to "[native code]". A patched one does not,
+        // which is how a stealth plugin gives itself away while hiding something else.
+        //
+        // Circular on its own, and deliberately kept anyway. The test below runs
+        // `Function.prototype.toString`, which is itself the first thing a serious
+        // stealth plugin replaces — after which every probe here reads clean. It
+        // still catches the plugins that do not bother, which is most of them.
+        // `integrity.ts` is what sees through the ones that do.
+        out['bot.patchedNatives'] = countPatched(window, navigator);
+        // Where the patch is, rather than whether it stringifies. A replaced getter
+        // is invisible above — `countPatched` only looks at functions — and
+        // replacing a getter is how `navigator.webdriver` is actually hidden.
+        const proto = describeAnomalies(window, navigator);
+        out['bot.protoAnomalies'] = proto.length;
+        out['bot.protoDetail'] = proto.join(',') || null;
+        // How it hides, as an identifier.
+        //
+        // A tool that conceals itself has to patch a particular set of properties
+        // in a particular way, and it does the same thing every session. So the
+        // shape of the concealment is a fingerprint of the tool — and unlike a
+        // device id, the attacker cannot rotate it without rebuilding their
+        // tooling. Rotating device ids per attempt defeats the fanout panel; it
+        // does not defeat this.
+        //
+        // Null when nothing was tampered with, so an ordinary browser contributes
+        // no identifier at all rather than a shared "clean" bucket that would be
+        // the largest cluster in the system.
+        out['bot.spoofHash'] = proto.length === 0 ? null : hash(proto.join(','));
+        // A spoofed permissions state and the real Notification state disagree —
+        // the classic headless tell that survived years of patching.
+        out['bot.notificationPermission'] = read(() => window.Notification?.permission);
+        // A `Proxy` around a native, which is the one thing a stealth plugin cannot
+        // hide by rewriting what it reports. See PROXY_PROBES for the measurement
+        // that made this necessary.
+        const proxied = countProxied(window);
+        out['bot.proxyProbes'] = proxied.probes;
+        out['bot.proxiedNatives'] = proxied.names.length;
+        out['bot.proxiedDetail'] = proxied.names.join(',') || null;
+        // Languages present but empty is not a configuration a real browser reaches.
+        out['bot.emptyLanguages'] = (navigator.languages?.length ?? 1) === 0;
+        return out;
+    },
+};
+function attributeMarkers(document) {
+    try {
+        const element = document.documentElement;
+        if (element === null)
+            return null;
+        const markers = element
+            .getAttributeNames()
+            .filter((name) => name.startsWith('webdriver') || name.startsWith('selenium') || name.startsWith('driver'));
+        return markers.length > 0 ? markers.join(',') : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Properties a stock browser defines as accessors on `Navigator.prototype`.
+ *
+ * All three are spoofed by automation, and spoofing them leaves a shape the
+ * real browser never has. `navigator.webdriver` reading `false` proves nothing
+ * on its own — that is what it reads on a real browser too — but `false`
+ * arriving from an own data property on the instance means someone wrote it
+ * there, because Chrome puts it on the prototype behind a getter.
+ */
+const NAVIGATOR_ACCESSORS = ['webdriver', 'plugins', 'languages'];
+/**
+ * Descriptor shapes that disagree with a stock browser.
+ *
+ * Reads only: `getOwnPropertyDescriptor` and `hasOwnProperty` invoke nothing,
+ * so a getter that throws when read cannot be triggered from here.
+ *
+ * Returns the names rather than a bare count, for the same reason
+ * `bot.driverNames` exists — knowing it was `plugins` rather than `webdriver`
+ * changes what a tenant concludes, and an extension that spoofs the plugin list
+ * is a different animal from one hiding a driver flag.
+ */
+function describeAnomalies(window, navigator) {
+    const realm = window;
+    const found = [];
+    for (const name of NAVIGATOR_ACCESSORS) {
+        try {
+            // An own property on the instance shadows the prototype's getter. No
+            // stock browser ships one, and `defineProperty(navigator, ...)` is the
+            // single most common way these values are spoofed.
+            if (Object.prototype.hasOwnProperty.call(navigator, name)) {
+                found.push(`own:${name}`);
+                continue;
+            }
+            const prototype = realm.Navigator?.prototype;
+            if (prototype === undefined)
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+            if (descriptor === undefined) {
+                // Deleted outright. puppeteer-extra's webdriver evasion does exactly
+                // this, and it leaves `navigator.webdriver` reading `undefined` rather
+                // than the `false` a real browser reports.
+                found.push(`missing:${name}`);
+                continue;
+            }
+            // Redefined as a value rather than a getter. A real browser has neither
+            // a `value` nor a writable data property here.
+            if (descriptor.get === undefined)
+                found.push(`data:${name}`);
+        }
+        catch {
+            // Hardened or exotic environments throw on property access. Unknown is
+            // not an anomaly — saying otherwise would accuse a browser for being
+            // unusual rather than for lying.
+            continue;
+        }
+    }
+    return found;
+}
+function countPatched(window, navigator) {
+    // Reached through the window rather than the ambient globals: a collector
+    // must inspect the page's realm, not the one this module was compiled into.
+    const realm = window;
+    const candidates = [
+        realm['Function']?.prototype?.['toString'],
+        navigator.permissions?.query,
+        navigator.mediaDevices?.enumerateDevices,
+        realm['HTMLCanvasElement']?.prototype?.['toDataURL'],
+        realm['HTMLCanvasElement']?.prototype?.['getContext'],
+        realm['WebGLRenderingContext']?.prototype?.['getParameter'],
+    ];
+    let patched = 0;
+    for (const candidate of candidates) {
+        if (typeof candidate !== 'function')
+            continue;
+        try {
+            if (!isNativeSource(Function.prototype.toString.call(candidate)))
+                patched++;
+        }
+        catch {
+            patched++;
+        }
+    }
+    return patched;
+}
+function read(fn) {
+    try {
+        const value = fn();
+        return value === undefined ? null : value;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Natives wrapped in a `Proxy`, found from the stack instead of by asking.
+ *
+ * This is the only probe in the package that catches
+ * `puppeteer-extra-plugin-stealth`, and it exists because everything else here
+ * was measured failing against it.
+ *
+ * The plugin wraps `WebGLRenderingContext.prototype.getParameter` in a `Proxy`
+ * to spoof the GPU strings. Measured against the real plugin on Chrome 141,
+ * that wrapper is invisible to every claim-based test — source, name, length,
+ * own keys and property descriptor are byte-identical to the untouched
+ * function, because V8 hands back a native stub for any callable proxy and the
+ * proxy forwards the rest:
+ *
+ *   getParameter, main-realm toString      function getParameter() { [native code] }
+ *   getParameter, iframe-borrowed toString function getParameter() { [native code] }
+ *   webgl.renderer, real Chrome            ANGLE (Apple, ANGLE Metal Renderer: Apple M2 Max)
+ *   webgl.renderer, through the proxy      Intel Iris OpenGL Engine
+ *
+ * `integrity.ts` does not see it either, and the reason is worth writing down:
+ * the plugin installs itself through CDP `addScriptToEvaluateOnNewDocument`,
+ * which runs in *every* new document — including the same-origin iframe that
+ * collector creates to borrow a clean realm. Measured: the iframe reports the
+ * same spoofed renderer as the page. There is no clean realm to borrow.
+ *
+ * What the plugin cannot reach is the stack, because the engine builds it at
+ * throw time from frames that no longer exist. Provoking a `TypeError` through
+ * each candidate, measured three ways on the same page:
+ *
+ *   untouched native      no trap frame — see TRAP_WINDOW in native.ts for why
+ *                         this is not the same as "no frame at all"
+ *   plain function        a frame named after the function — and its source no
+ *                         longer claims to be native, so `countPatched` has it
+ *   Proxy                 a frame naming the `apply` trap, and the source still
+ *                         claims to be native
+ *
+ * Only the third case is counted, and that conjunction is the whole
+ * false-positive argument. A privacy extension that replaces canvas readback
+ * installs an ordinary function: it interposes a frame but stops claiming to be
+ * native, so it lands in `bot.patchedNatives` where its benign notes already
+ * live. Counting something here requires a wrapper that interposes *and* lies
+ * about being native, and nothing legitimate needs to do both.
+ *
+ * **Cost, measured rather than assumed**, because seven thrown exceptions in the
+ * instant wave is exactly the kind of thing that turns out to be expensive: 200
+ * runs on Chrome 141, median under 0.1 ms and p95 0.2 ms for the whole set. The
+ * instant wave budgets 5 ms across seven collectors, so this stays in it.
+ */
+const PROXY_PROBES = [
+    { name: 'Function.toString', path: ['Function', 'prototype', 'toString'] },
+    { name: 'WebGL.getParameter', path: ['WebGLRenderingContext', 'prototype', 'getParameter'] },
+    { name: 'WebGL2.getParameter', path: ['WebGL2RenderingContext', 'prototype', 'getParameter'] },
+    { name: 'Canvas.toDataURL', path: ['HTMLCanvasElement', 'prototype', 'toDataURL'] },
+    { name: 'Canvas.getContext', path: ['HTMLCanvasElement', 'prototype', 'getContext'] },
+    { name: 'Media.canPlayType', path: ['HTMLMediaElement', 'prototype', 'canPlayType'] },
+    // Listed and, on Chrome, never reached: `query` rejects a promise rather than
+    // throwing on a bad receiver, so the probe cannot provoke it and abstains.
+    // That is why a healthy Chrome reports 6 probes from 7 candidates, and it is
+    // left in because an engine that does throw here would be measured for free.
+    { name: 'Permissions.query', path: ['Permissions', 'prototype', 'query'] },
+];
+/**
+ * Does this engine print proxy traps on the stack at all?
+ *
+ * A positive control, run on a proxy this function builds itself, so the answer
+ * is measured in the visitor's browser rather than assumed from V8's behaviour
+ * on the developer's. Firefox and Safari format stacks differently and may not
+ * name the trap; if this control fails, the technique does not work here and
+ * every probe abstains rather than reporting a clean bill of health nobody
+ * earned.
+ *
+ * The control proxies a function that is never installed anywhere, so no page
+ * behaviour changes and nothing else can observe it. `toDataURL` is the subject
+ * because it throws on an illegal receiver in every engine that has a canvas.
+ */
+function applyTrapIsVisible(window) {
+    const realm = window;
+    const native = realm['HTMLCanvasElement']?.prototype?.['toDataURL'];
+    if (typeof native !== 'function')
+        return false;
+    return applyTrapIsObservable(native);
+}
+/**
+ * The probe, as counts rather than a verdict.
+ *
+ * Reports how many candidates could be tested alongside how many were wrapped,
+ * following `bot.realmProbes` — a consistency check cannot tell "nothing is
+ * wrapped" from "nothing could be measured" unless the collector says which.
+ */
+function countProxied(window) {
+    if (!applyTrapIsVisible(window))
+        return { probes: 0, names: [] };
+    const names = [];
+    let probes = 0;
+    for (const probe of PROXY_PROBES) {
+        const target = resolvePath(window, probe.path);
+        if (typeof target !== 'function')
+            continue;
+        let source;
+        try {
+            source = Function.prototype.toString.call(target);
+        }
+        catch {
+            // A target that will not stringify is already an anomaly, and one that
+            // `countPatched` records. Not this probe's finding.
+            continue;
+        }
+        // The conjunction. A wrapper that admits to being a wrapper belongs to
+        // `bot.patchedNatives`, whose benign notes cover privacy extensions; this
+        // probe is only for the ones whose source still claims to be native.
+        if (!isNativeSource(source))
+            continue;
+        const interposed = interposesApplyTrap(target);
+        if (interposed === undefined)
+            continue;
+        probes++;
+        if (interposed)
+            names.push(probe.name);
+    }
+    return { probes, names };
+}
+/** Walks a dotted path without invoking anything, as integrity.ts does. */
+function resolvePath(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/behavior.d.ts

@@ -0,0 +1,17 @@
+import type { BehaviorRecorder } from '../behavior/recorder.js';
+import type { Collector } from '../types.js';
+/**
+ * Reads whatever the recorder has accumulated.
+ *
+ * A collector rather than a direct call so behavioural signals travel the same
+ * path as every other signal — same wave budget, same disable switch, same
+ * skipped-and-reported handling when something throws.
+ *
+ * `instant`, because reading folded statistics is a few field accesses. The
+ * work happened as the user moved and typed; none of it is on the submit path.
+ *
+ * Optional, because an integrator who never calls `observe()` is not broken —
+ * they get no behavioural evidence, which the engine treats as unobserved
+ * rather than suspicious.
+ */
+export declare function behaviorCollector(recorder: () => BehaviorRecorder | undefined): Collector;

package/dist/signals/behavior.js

@@ -0,0 +1,31 @@
+/**
+ * Reads whatever the recorder has accumulated.
+ *
+ * A collector rather than a direct call so behavioural signals travel the same
+ * path as every other signal — same wave budget, same disable switch, same
+ * skipped-and-reported handling when something throws.
+ *
+ * `instant`, because reading folded statistics is a few field accesses. The
+ * work happened as the user moved and typed; none of it is on the submit path.
+ *
+ * Optional, because an integrator who never calls `observe()` is not broken —
+ * they get no behavioural evidence, which the engine treats as unobserved
+ * rather than suspicious.
+ */
+export function behaviorCollector(recorder) {
+    return {
+        id: 'behavior',
+        wave: 'instant',
+        optional: true,
+        collect() {
+            const active = recorder();
+            // Nothing observing is not the same as observing nothing. The first is
+            // an integration that did not opt in; the second is a form submitted
+            // without a single input event, which is worth knowing about. Emitting
+            // no keys at all keeps them distinguishable downstream.
+            if (active === undefined)
+                return {};
+            return { ...active.summary() };
+        },
+    };
+}

package/dist/signals/capabilities.d.ts

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

package/dist/signals/capabilities.js

@@ -0,0 +1,235 @@
+import { hash } from '../hash.js';
+/**
+ * What the platform will admit to when asked directly.
+ *
+ * Five probes that share a property: each is an API that answers about the
+ * machine or its configuration rather than about the page, and each is one an
+ * anti-detect browser has to remember to fake separately. A profile that
+ * rewrites its user agent, its GPU string and its core count will usually
+ * still report the voice list of the machine it is actually running on.
+ *
+ * None of them prompts. Geolocation and camera access are deliberately absent
+ * from this file: both require permission, both are visible to the user, and a
+ * login page that asks is a login page people abandon.
+ */
+/**
+ * Permissions worth asking the *state* of.
+ *
+ * `permissions.query` returns granted / denied / prompt without prompting, and
+ * the pattern across them is a configuration fingerprint: a fresh automation
+ * profile answers `prompt` to everything, where a machine somebody actually
+ * uses has a scatter of granted and denied.
+ *
+ * The list is the subset Chromium answers for. Querying a name an engine does
+ * not know throws, which is caught and recorded as unsupported — itself a
+ * difference between engines.
+ */
+const PERMISSIONS = [
+    'accelerometer', 'background-sync', 'camera', 'clipboard-read', 'clipboard-write',
+    'geolocation', 'gyroscope', 'idle-detection', 'local-fonts', 'magnetometer',
+    'microphone', 'midi', 'notifications', 'payment-handler', 'persistent-storage',
+    'push', 'screen-wake-lock', 'storage-access', 'window-management',
+];
+export const capabilitiesCollector = {
+    id: 'cap',
+    wave: 'deep',
+    optional: true,
+    async collect({ navigator, window }) {
+        const out = {};
+        // ── User-agent client hints, actually read ───────────────────────────
+        // The navigator surface reports whether this API exists and has never
+        // called it. Presence is one bit; the values are the platform version,
+        // the architecture, the bitness and the device model, and they are what a
+        // user agent string no longer carries since it was frozen.
+        try {
+            const uaData = navigator.userAgentData;
+            if (uaData?.getHighEntropyValues === undefined) {
+                out['cap.uaPlatformVersion'] = null;
+                out['cap.uaArchitecture'] = null;
+                out['cap.uaModel'] = null;
+                out['cap.uaBitness'] = null;
+                out['cap.uaFullVersion'] = null;
+            }
+            else {
+                const values = await uaData.getHighEntropyValues([
+                    'platformVersion', 'architecture', 'model', 'bitness', 'uaFullVersion', 'fullVersionList', 'wow64',
+                ]);
+                out['cap.uaPlatformVersion'] = asString(values['platformVersion']);
+                out['cap.uaArchitecture'] = asString(values['architecture']);
+                out['cap.uaModel'] = asString(values['model']);
+                out['cap.uaBitness'] = asString(values['bitness']);
+                out['cap.uaFullVersion'] = asString(values['uaFullVersion']);
+                out['cap.uaWow64'] = typeof values['wow64'] === 'boolean' ? values['wow64'] : null;
+                // The brand list is ordered and padded with a deliberately absurd
+                // entry by design, so its shape carries more than its contents.
+                const brands = uaData.brands ?? [];
+                out['cap.uaBrands'] = brands.map((b) => `${b.brand}/${b.version}`).sort().join(',');
+            }
+        }
+        catch {
+            out['cap.uaPlatformVersion'] = null;
+        }
+        // ── Speech synthesis voices ──────────────────────────────────────────
+        // A strong OS and locale signal: the set is installed by the operating
+        // system, differs between macOS, Windows and every Linux distribution,
+        // and grows with the languages a person has added.
+        try {
+            const synth = window.speechSynthesis;
+            if (synth === undefined) {
+                out['cap.voices'] = null;
+                out['cap.voicesHash'] = null;
+            }
+            else {
+                // Populated asynchronously, and the wait is not optional: a real
+                // Firefox reported zero voices through a flat 120 ms sleep where
+                // Chrome reported 199 through the same one. `voiceschanged` is the
+                // event that says when the list is actually ready, raced against a
+                // deadline so an engine that never fires it cannot hold up the wave.
+                let voices = synth.getVoices();
+                if (voices.length === 0) {
+                    await new Promise((resolve) => {
+                        let settled = false;
+                        const done = () => {
+                            if (settled)
+                                return;
+                            settled = true;
+                            try {
+                                synth.removeEventListener('voiceschanged', done);
+                            }
+                            catch {
+                                // Older engines expose only the onvoiceschanged property.
+                            }
+                            resolve();
+                        };
+                        try {
+                            synth.addEventListener('voiceschanged', done, { once: true });
+                        }
+                        catch {
+                            // Nothing to listen to; the deadline below still applies.
+                        }
+                        setTimeout(done, 400);
+                    });
+                    voices = synth.getVoices();
+                }
+                out['cap.voices'] = voices.length;
+                // An empty list hashes to the FNV offset basis, which reads like a
+                // value and is not one. Firefox produced exactly that before the wait
+                // above was fixed, so the empty case reports null.
+                out['cap.voicesHash'] =
+                    voices.length === 0
+                        ? null
+                        : hash(voices.map((v) => `${v.name}|${v.lang}|${v.localService}`).sort().join(','));
+                out['cap.voiceDefault'] = voices.find((v) => v.default)?.lang ?? null;
+            }
+        }
+        catch {
+            out['cap.voices'] = null;
+        }
+        // ── WebGPU adapter ───────────────────────────────────────────────────
+        // A second, independent account of the GPU. It matters because it comes
+        // from a different subsystem than WebGL: a profile that rewrites the
+        // ANGLE renderer string has to rewrite this one too, and the two
+        // disagreeing is a contradiction nothing benign produces.
+        try {
+            const gpu = navigator.gpu;
+            if (gpu?.requestAdapter === undefined) {
+                out['cap.gpuVendor'] = null;
+                out['cap.gpuArchitecture'] = null;
+            }
+            else {
+                const adapter = (await gpu.requestAdapter());
+                if (adapter === null) {
+                    // Present but refusing: a real answer, and common in containers.
+                    out['cap.gpuVendor'] = null;
+                    out['cap.gpuArchitecture'] = null;
+                    out['cap.gpuAdapter'] = 'unavailable';
+                }
+                else {
+                    out['cap.gpuVendor'] = adapter.info?.vendor ?? null;
+                    out['cap.gpuArchitecture'] = adapter.info?.architecture ?? null;
+                    // The limits are the driver's own numbers — the WebGPU equivalent of
+                    // `webgl.parametersHash`, and the measurement that a renderer string
+                    // rewritten by hand does not move.
+                    //
+                    // `GPUSupportedLimits` exposes them as prototype getters, so
+                    // `Object.keys` returns nothing and an obvious implementation
+                    // silently reports an empty hash. Measured on a real Chrome:
+                    // 0 own keys, 36 enumerable through the chain.
+                    const limits = adapter.limits;
+                    const entries = [];
+                    if (limits !== undefined && limits !== null) {
+                        for (const key in limits) {
+                            const value = limits[key];
+                            if (typeof value === 'number')
+                                entries.push(`${key}=${value}`);
+                        }
+                    }
+                    entries.sort();
+                    out['cap.gpuLimits'] = entries.length;
+                    out['cap.gpuLimitsHash'] = entries.length === 0 ? null : hash(entries.join('|'));
+                }
+            }
+        }
+        catch {
+            out['cap.gpuVendor'] = null;
+        }
+        // ── Battery ──────────────────────────────────────────────────────────
+        // Presence separates desktops from laptops and both from most automation
+        // images. The level is deliberately rounded: it is enough to tell a
+        // plugged-in server from a phone at 12%, and not enough to follow anyone
+        // between sites as it drains.
+        try {
+            const getBattery = navigator.getBattery;
+            if (getBattery === undefined) {
+                out['cap.batteryPresent'] = false;
+                out['cap.batteryCharging'] = null;
+            }
+            else {
+                const battery = await getBattery.call(navigator);
+                out['cap.batteryPresent'] = true;
+                out['cap.batteryCharging'] = battery.charging;
+                out['cap.batteryLevel'] = Math.round(battery.level * 10) / 10;
+            }
+        }
+        catch {
+            out['cap.batteryPresent'] = null;
+        }
+        // ── Permission states ────────────────────────────────────────────────
+        try {
+            const permissions = navigator.permissions;
+            if (permissions?.query === undefined) {
+                out['cap.permHash'] = null;
+            }
+            else {
+                const states = [];
+                let granted = 0;
+                let denied = 0;
+                for (const name of PERMISSIONS) {
+                    try {
+                        const status = await permissions.query({ name });
+                        states.push(`${name}=${status.state}`);
+                        if (status.state === 'granted')
+                            granted++;
+                        else if (status.state === 'denied')
+                            denied++;
+                    }
+                    catch {
+                        // An engine that does not know the name. Recorded, because which
+                        // names an engine knows differs as much as what it answers.
+                        states.push(`${name}=unsupported`);
+                    }
+                }
+                out['cap.permHash'] = hash(states.join('|'));
+                out['cap.permGranted'] = granted;
+                out['cap.permDenied'] = denied;
+            }
+        }
+        catch {
+            out['cap.permHash'] = null;
+        }
+        return out;
+    },
+};
+function asString(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}

package/dist/signals/devices.d.ts

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