@ressjs/platform 0.6.0-experimental.0

package/dist/rules/edge.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDGE_PRESETS = void 0;
+exports.readEdgeHeaders = readEdgeHeaders;
+const headers_1 = require("./headers");
+/**
+ * Definiciones listas para redes conocidas.
+ *
+ * Ninguna está activa por defecto: el proyecto declara la suya.
+ *
+ * ```ts
+ * createPlatformRegistry({ edge: EDGE_PRESETS.cloudflare })
+ * ```
+ *
+ * No hace falta un preset para funcionar. Cualquier red que sepa reescribir
+ * cabeceras —Workers, Lambda@Edge, VCL, EdgeWorkers— puede setear
+ * `x-ressjs-device` directamente, que el framework ya lee sin configurar nada y
+ * sin atarse a nadie.
+ */
+exports.EDGE_PRESETS = {
+    cloudflare: [
+        {
+            header: 'cf-device-type',
+            axis: 'device',
+            map: { mobile: 'phone', tablet: 'tablet', desktop: 'desktop' },
+        },
+    ],
+    cloudfront: [
+        { header: 'cloudfront-is-smarttv-viewer', axis: 'device', map: { true: 'tv' } },
+        { header: 'cloudfront-is-tablet-viewer', axis: 'device', map: { true: 'tablet' } },
+        { header: 'cloudfront-is-mobile-viewer', axis: 'device', map: { true: 'phone' } },
+        { header: 'cloudfront-is-desktop-viewer', axis: 'device', map: { true: 'desktop' } },
+    ],
+    akamai: [
+        {
+            header: 'x-akamai-device-type',
+            axis: 'device',
+            map: { mobile: 'phone', tablet: 'tablet', desktop: 'desktop', tv: 'tv' },
+        },
+    ],
+};
+/**
+ * Lee lo que la red ya resolvió, según las reglas que el proyecto declaró.
+ *
+ * El orden de las reglas decide: la primera que aporta un eje lo fija, igual que
+ * en el resto del pipeline.
+ */
+function readEdgeHeaders(headers, rules) {
+    const result = {};
+    for (const rule of rules) {
+        if (result[rule.axis])
+            continue;
+        const raw = (0, headers_1.header)(headers, rule.header)?.toLowerCase();
+        if (!raw)
+            continue;
+        const value = rule.map[raw];
+        if (!value)
+            continue;
+        result[rule.axis] = {
+            value,
+            confidence: rule.confidence ?? 'high',
+            rule: `edge:${rule.header}`,
+        };
+    }
+    return result;
+}

package/dist/rules/headers.d.ts

@@ -0,0 +1,48 @@
+import type { Confidence, NativeAppInfo } from '../model/types';
+/** Cabeceras de una petición, tal como las entrega un servidor HTTP. */
+export type Headers = Record<string, string | string[] | undefined>;
+/** Lo que una capa afirma, con la confianza de cada afirmación. */
+export interface LayerResult {
+    webview?: {
+        value: boolean;
+        confidence: Confidence;
+        rule: string;
+    };
+    os?: {
+        value: string;
+        confidence: Confidence;
+        rule: string;
+    };
+    device?: {
+        value: string;
+        confidence: Confidence;
+        rule: string;
+    };
+    nativeApp?: Partial<NativeAppInfo>;
+    capabilities?: readonly string[];
+}
+/** Lee una cabecera colapsando el caso de valores repetidos. */
+export declare function header(headers: Headers, name: string): string | undefined;
+/**
+ * Contrato v2: el cliente declara lo que es.
+ *
+ * Cada cabecera aporta **sólo** el campo que nombra. Ninguna completa un campo
+ * que el cliente no declaró — eso es lo que hacía que una tableta con React
+ * Native se sirviera como teléfono.
+ */
+export declare function readExplicitHeaders(headers: Headers): LayerResult;
+/**
+ * Contrato v1 y cabeceras de proveedor.
+ *
+ * Los clientes ya publicados mandan estas cabeceras y no se pueden actualizar de
+ * golpe, así que se traducen. La tabla es declarada a propósito: es lo que
+ * permite verificar que ninguna entrada aporta un campo que el cliente no dijo.
+ */
+export declare function readLegacyHeaders(headers: Headers): LayerResult;
+/**
+ * Pistas de plataforma que el navegador manda por su cuenta.
+ *
+ * `sec-ch-ua-mobile: ?0` no aporta nada: cubre escritorio, tableta y televisor
+ * por igual, así que afirmar `desktop` con eso sería inventar.
+ */
+export declare function readClientHints(headers: Headers): LayerResult;

package/dist/rules/headers.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.header = header;
+exports.readExplicitHeaders = readExplicitHeaders;
+exports.readLegacyHeaders = readLegacyHeaders;
+exports.readClientHints = readClientHints;
+/** Lee una cabecera colapsando el caso de valores repetidos. */
+function header(headers, name) {
+    const raw = headers[name] ?? headers[name.toLowerCase()];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+const isTrue = (v) => v === 'true' || v === '1' || v === 'yes';
+const isFalse = (v) => v === 'false' || v === '0' || v === 'no';
+/**
+ * Contrato v2: el cliente declara lo que es.
+ *
+ * Cada cabecera aporta **sólo** el campo que nombra. Ninguna completa un campo
+ * que el cliente no declaró — eso es lo que hacía que una tableta con React
+ * Native se sirviera como teléfono.
+ */
+function readExplicitHeaders(headers) {
+    const result = {};
+    const webview = header(headers, 'x-ressjs-webview');
+    if (webview && (isTrue(webview) || isFalse(webview))) {
+        result.webview = {
+            value: isTrue(webview),
+            confidence: 'exact',
+            rule: 'h2:x-ressjs-webview',
+        };
+    }
+    const os = header(headers, 'x-ressjs-os');
+    if (os)
+        result.os = { value: os.toLowerCase(), confidence: 'exact', rule: 'h2:x-ressjs-os' };
+    const device = header(headers, 'x-ressjs-device');
+    if (device) {
+        result.device = {
+            value: device.toLowerCase(),
+            confidence: 'exact',
+            rule: 'h2:x-ressjs-device',
+        };
+    }
+    const appId = header(headers, 'x-ressjs-app-id');
+    const appVersion = header(headers, 'x-ressjs-app-version');
+    const osVersion = header(headers, 'x-ressjs-os-version');
+    if (appId || appVersion || osVersion) {
+        result.nativeApp = { id: appId, version: appVersion, osVersion };
+        // Una app que se identifica está, por definición, embebiendo la página.
+        if (appId && !result.webview) {
+            result.webview = { value: true, confidence: 'exact', rule: 'h2:x-ressjs-app-id' };
+        }
+    }
+    const capabilities = header(headers, 'x-ressjs-capabilities');
+    if (capabilities) {
+        result.capabilities = capabilities
+            .split(',')
+            .map((c) => c.trim())
+            .filter(Boolean);
+    }
+    return result;
+}
+/**
+ * Contrato v1 y cabeceras de proveedor.
+ *
+ * Los clientes ya publicados mandan estas cabeceras y no se pueden actualizar de
+ * golpe, así que se traducen. La tabla es declarada a propósito: es lo que
+ * permite verificar que ninguna entrada aporta un campo que el cliente no dijo.
+ */
+function readLegacyHeaders(headers) {
+    const result = {};
+    const nativeApp = {};
+    const platform = header(headers, 'x-ressjs-platform')?.toLowerCase();
+    if (platform === 'webview' || platform === 'native') {
+        result.webview = { value: true, confidence: 'high', rule: 'h1:x-ressjs-platform' };
+    }
+    const webview = header(headers, 'x-webview');
+    if (!result.webview && webview && isTrue(webview)) {
+        result.webview = { value: true, confidence: 'high', rule: 'h1:x-webview' };
+    }
+    const rn = header(headers, 'x-rn-platform')?.toLowerCase();
+    if (rn) {
+        result.os = { value: rn, confidence: 'high', rule: 'h1:x-rn-platform' };
+        if (!result.webview) {
+            result.webview = { value: true, confidence: 'high', rule: 'h1:x-rn-platform' };
+        }
+        nativeApp.id ??= 'react-native';
+    }
+    const os = header(headers, 'x-ressjs-os')?.toLowerCase();
+    if (os && !result.os)
+        result.os = { value: os, confidence: 'high', rule: 'h1:x-ressjs-os' };
+    const generic = header(headers, 'x-platform')?.toLowerCase();
+    if (generic && !result.os) {
+        result.os = { value: generic, confidence: 'medium', rule: 'h1:x-platform' };
+    }
+    const device = header(headers, 'x-ressjs-device')?.toLowerCase();
+    if (device) {
+        result.device = { value: device, confidence: 'high', rule: 'h1:x-ressjs-device' };
+    }
+    const requestedWith = header(headers, 'x-requested-with');
+    if (requestedWith && !result.webview) {
+        result.webview = { value: true, confidence: 'medium', rule: 'h1:x-requested-with' };
+        result.os ??= { value: 'android', confidence: 'medium', rule: 'h1:x-requested-with' };
+    }
+    const osVersion = header(headers, 'x-ressjs-version');
+    if (osVersion)
+        nativeApp.osVersion ??= osVersion;
+    const appVersion = header(headers, 'x-ressjs-app-version') ?? header(headers, 'x-rn-version');
+    if (appVersion)
+        nativeApp.version ??= appVersion;
+    if (Object.keys(nativeApp).length > 0)
+        result.nativeApp = nativeApp;
+    return result;
+}
+/**
+ * Pistas de plataforma que el navegador manda por su cuenta.
+ *
+ * `sec-ch-ua-mobile: ?0` no aporta nada: cubre escritorio, tableta y televisor
+ * por igual, así que afirmar `desktop` con eso sería inventar.
+ */
+function readClientHints(headers) {
+    const result = {};
+    const platform = header(headers, 'sec-ch-ua-platform')?.replace(/"/g, '').toLowerCase();
+    const os = CLIENT_HINT_OS[platform ?? ''];
+    if (os)
+        result.os = { value: os, confidence: 'high', rule: 'ch:sec-ch-ua-platform' };
+    const formFactors = header(headers, 'sec-ch-ua-form-factors')?.toLowerCase();
+    if (formFactors) {
+        const device = /tv/.test(formFactors)
+            ? 'tv'
+            : /tablet/.test(formFactors)
+                ? 'tablet'
+                : /mobile/.test(formFactors)
+                    ? 'phone'
+                    : /desktop/.test(formFactors)
+                        ? 'desktop'
+                        : undefined;
+        if (device) {
+            result.device = { value: device, confidence: 'high', rule: 'ch:sec-ch-ua-form-factors' };
+        }
+    }
+    const mobile = header(headers, 'sec-ch-ua-mobile');
+    if (!result.device && mobile === '?1') {
+        // El hint no distingue teléfono de tableta; sólo afirma que es chico.
+        result.device = { value: 'phone', confidence: 'medium', rule: 'ch:sec-ch-ua-mobile' };
+    }
+    return result;
+}
+const CLIENT_HINT_OS = {
+    android: 'android',
+    ios: 'ios',
+    windows: 'windows',
+    macos: 'macos',
+    linux: 'linux',
+    'chrome os': 'linux',
+    chromeos: 'linux',
+};

package/dist/rules/request-headers.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Las cabeceras que la detección lee.
+ *
+ * Existe una sola lista y de ella salen dos cosas: lo que el pipeline consulta y
+ * lo que la respuesta declara en `Vary`. Que sean la misma es lo que impide que
+ * se desincronicen la próxima vez que se agregue una cabecera — y una respuesta
+ * que varía por una cabecera sin declararla es servida por un CDN al cliente
+ * equivocado.
+ */
+/** Contrato v2: el cliente declara lo que es. */
+export declare const HEADERS_V2: readonly ["x-ressjs-webview", "x-ressjs-os", "x-ressjs-device", "x-ressjs-app-id", "x-ressjs-app-version", "x-ressjs-os-version", "x-ressjs-capabilities"];
+/** Contrato v1 y cabeceras de proveedor, que se siguen aceptando. */
+export declare const HEADERS_LEGACY: readonly ["x-ressjs-platform", "x-ressjs-version", "x-webview", "x-rn-platform", "x-rn-version", "x-platform", "x-requested-with"];
+/** Pistas que el navegador manda por su cuenta. */
+export declare const HEADERS_CLIENT_HINTS: readonly ["sec-ch-ua-platform", "sec-ch-ua-form-factors", "sec-ch-ua-mobile"];
+/** Forzado de plataforma para depurar. Sólo se lee si está habilitado. */
+export declare const HEADER_OVERRIDE = "x-ress-force-platform";
+/** Todo lo que la detección puede llegar a leer de una petición. */
+export declare const PLATFORM_REQUEST_HEADERS: readonly ["x-ressjs-webview", "x-ressjs-os", "x-ressjs-device", "x-ressjs-app-id", "x-ressjs-app-version", "x-ressjs-os-version", "x-ressjs-capabilities", "x-ressjs-platform", "x-ressjs-version", "x-webview", "x-rn-platform", "x-rn-version", "x-platform", "x-requested-with", "sec-ch-ua-platform", "sec-ch-ua-form-factors", "sec-ch-ua-mobile"];
+/**
+ * Lo que se declara en `Vary` cuando la detección está activa.
+ *
+ * `User-Agent` va primero porque es el de mayor cardinalidad y el que un CDN va
+ * a querer normalizar en el borde.
+ */
+export declare const PLATFORM_VARY_HEADERS: readonly ["User-Agent", "x-ressjs-webview", "x-ressjs-os", "x-ressjs-device", "x-ressjs-app-id", "x-ressjs-app-version", "x-ressjs-os-version", "x-ressjs-capabilities", "x-ressjs-platform", "x-ressjs-version", "x-webview", "x-rn-platform", "x-rn-version", "x-platform", "x-requested-with", "sec-ch-ua-platform", "sec-ch-ua-form-factors", "sec-ch-ua-mobile"];
+/**
+ * Qué cabeceras alimentan cada eje.
+ *
+ * Sirve para declarar en `Vary` sólo lo que puede cambiar **esta** respuesta. Una
+ * página que no tiene variantes no depende de ninguna; una que sólo distingue
+ * televisores depende de las de `device` y de nada más.
+ *
+ * Declarar las dieciocho en toda respuesta es correcto pero caro: cada campo
+ * multiplica las entradas que una caché intermedia tiene que guardar, y hay
+ * proveedores que directamente ignoran un `Vary` largo.
+ */
+export declare const HEADERS_BY_AXIS: {
+    readonly context: readonly ["x-ressjs-webview", "x-ressjs-app-id", "x-ressjs-platform", "x-webview", "x-rn-platform", "x-requested-with"];
+    readonly os: readonly ["x-ressjs-os", "x-rn-platform", "x-platform", "x-ressjs-platform", "sec-ch-ua-platform"];
+    readonly device: readonly ["x-ressjs-device", "sec-ch-ua-form-factors", "sec-ch-ua-mobile"];
+};
+/**
+ * Las cabeceras a declarar para una respuesta que varía por estos ejes.
+ *
+ * `User-Agent` afecta a los tres y se lista primero: es el de mayor cardinalidad
+ * y el que conviene normalizar en el borde. Sin ejes, la lista es vacía — y una
+ * respuesta que no varía por nada no debe declarar `Vary`.
+ */
+export declare function varyHeadersForAxes(axes: readonly ('context' | 'os' | 'device')[], options?: {
+    includeUserAgent?: boolean;
+    /**
+     * Cabeceras que el proyecto declaró para su red de distribución. Se suman
+     * porque también cambian la respuesta; si no declaró ninguna, no aparece
+     * ninguna, que es lo que evita declarar campos que nadie manda.
+     */
+    edge?: readonly {
+        header: string;
+        axis: string;
+    }[];
+}): string[];

package/dist/rules/request-headers.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Las cabeceras que la detección lee.
+ *
+ * Existe una sola lista y de ella salen dos cosas: lo que el pipeline consulta y
+ * lo que la respuesta declara en `Vary`. Que sean la misma es lo que impide que
+ * se desincronicen la próxima vez que se agregue una cabecera — y una respuesta
+ * que varía por una cabecera sin declararla es servida por un CDN al cliente
+ * equivocado.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEADERS_BY_AXIS = exports.PLATFORM_VARY_HEADERS = exports.PLATFORM_REQUEST_HEADERS = exports.HEADER_OVERRIDE = exports.HEADERS_CLIENT_HINTS = exports.HEADERS_LEGACY = exports.HEADERS_V2 = void 0;
+exports.varyHeadersForAxes = varyHeadersForAxes;
+/** Contrato v2: el cliente declara lo que es. */
+exports.HEADERS_V2 = [
+    'x-ressjs-webview',
+    'x-ressjs-os',
+    'x-ressjs-device',
+    'x-ressjs-app-id',
+    'x-ressjs-app-version',
+    'x-ressjs-os-version',
+    'x-ressjs-capabilities',
+];
+/** Contrato v1 y cabeceras de proveedor, que se siguen aceptando. */
+exports.HEADERS_LEGACY = [
+    'x-ressjs-platform',
+    'x-ressjs-version',
+    'x-webview',
+    'x-rn-platform',
+    'x-rn-version',
+    'x-platform',
+    'x-requested-with',
+];
+/** Pistas que el navegador manda por su cuenta. */
+exports.HEADERS_CLIENT_HINTS = [
+    'sec-ch-ua-platform',
+    'sec-ch-ua-form-factors',
+    'sec-ch-ua-mobile',
+];
+/** Forzado de plataforma para depurar. Sólo se lee si está habilitado. */
+exports.HEADER_OVERRIDE = 'x-ress-force-platform';
+/** Todo lo que la detección puede llegar a leer de una petición. */
+exports.PLATFORM_REQUEST_HEADERS = [
+    ...exports.HEADERS_V2,
+    ...exports.HEADERS_LEGACY,
+    ...exports.HEADERS_CLIENT_HINTS,
+];
+/**
+ * Lo que se declara en `Vary` cuando la detección está activa.
+ *
+ * `User-Agent` va primero porque es el de mayor cardinalidad y el que un CDN va
+ * a querer normalizar en el borde.
+ */
+exports.PLATFORM_VARY_HEADERS = [
+    'User-Agent',
+    ...exports.PLATFORM_REQUEST_HEADERS,
+];
+/**
+ * Qué cabeceras alimentan cada eje.
+ *
+ * Sirve para declarar en `Vary` sólo lo que puede cambiar **esta** respuesta. Una
+ * página que no tiene variantes no depende de ninguna; una que sólo distingue
+ * televisores depende de las de `device` y de nada más.
+ *
+ * Declarar las dieciocho en toda respuesta es correcto pero caro: cada campo
+ * multiplica las entradas que una caché intermedia tiene que guardar, y hay
+ * proveedores que directamente ignoran un `Vary` largo.
+ */
+exports.HEADERS_BY_AXIS = {
+    context: [
+        'x-ressjs-webview',
+        'x-ressjs-app-id',
+        'x-ressjs-platform',
+        'x-webview',
+        'x-rn-platform',
+        'x-requested-with',
+    ],
+    os: [
+        'x-ressjs-os',
+        'x-rn-platform',
+        'x-platform',
+        'x-ressjs-platform',
+        'sec-ch-ua-platform',
+    ],
+    device: [
+        'x-ressjs-device',
+        'sec-ch-ua-form-factors',
+        'sec-ch-ua-mobile',
+    ],
+};
+/**
+ * Las cabeceras a declarar para una respuesta que varía por estos ejes.
+ *
+ * `User-Agent` afecta a los tres y se lista primero: es el de mayor cardinalidad
+ * y el que conviene normalizar en el borde. Sin ejes, la lista es vacía — y una
+ * respuesta que no varía por nada no debe declarar `Vary`.
+ */
+function varyHeadersForAxes(axes, options = {}) {
+    if (axes.length === 0)
+        return [];
+    const fields = new Set();
+    if (options.includeUserAgent ?? true)
+        fields.add('User-Agent');
+    for (const axis of axes) {
+        for (const header of exports.HEADERS_BY_AXIS[axis])
+            fields.add(header);
+    }
+    for (const rule of options.edge ?? []) {
+        if (axes.includes(rule.axis))
+            fields.add(rule.header);
+    }
+    return [...fields];
+}

package/dist/rules/user-agent.d.ts

@@ -0,0 +1,25 @@
+import type { UserAgentRule } from '../registry/types';
+/**
+ * Reglas de detección por User-Agent.
+ *
+ * Son datos, no condicionales: se leen de corrido, se auditan y un proyecto
+ * puede agregar las suyas sin tocar el código que las recorre.
+ *
+ * **El orden es normativo**, no un detalle de implementación. Los bloques van de
+ * lo específico a lo genérico, y esa es exactamente la propiedad que el modelo
+ * anterior no tenía: ahí la primera rama que matcheaba devolvía un resultado
+ * completo, así que un Android TV se resolvía como teléfono Android antes de que
+ * ninguna regla de televisor llegara a evaluarse.
+ *
+ * | Bloque | Qué reconoce |
+ * |---|---|
+ * | 100 | televisores y aparatos de streaming |
+ * | 200 | contenedores de escritorio |
+ * | 300 | páginas incrustadas en una app |
+ * | 400 | sistema operativo |
+ * | 500 | forma del aparato |
+ *
+ * Ninguna regla corta la evaluación: cada una aporta lo que sabe y las que
+ * siguen completan lo que falta. Un campo ya resuelto no se sobrescribe.
+ */
+export declare const DEFAULT_RULES: readonly UserAgentRule[];

package/dist/rules/user-agent.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RULES = void 0;
+/**
+ * Reglas de detección por User-Agent.
+ *
+ * Son datos, no condicionales: se leen de corrido, se auditan y un proyecto
+ * puede agregar las suyas sin tocar el código que las recorre.
+ *
+ * **El orden es normativo**, no un detalle de implementación. Los bloques van de
+ * lo específico a lo genérico, y esa es exactamente la propiedad que el modelo
+ * anterior no tenía: ahí la primera rama que matcheaba devolvía un resultado
+ * completo, así que un Android TV se resolvía como teléfono Android antes de que
+ * ninguna regla de televisor llegara a evaluarse.
+ *
+ * | Bloque | Qué reconoce |
+ * |---|---|
+ * | 100 | televisores y aparatos de streaming |
+ * | 200 | contenedores de escritorio |
+ * | 300 | páginas incrustadas en una app |
+ * | 400 | sistema operativo |
+ * | 500 | forma del aparato |
+ *
+ * Ninguna regla corta la evaluación: cada una aporta lo que sabe y las que
+ * siguen completan lo que falta. Un campo ya resuelto no se sobrescribe.
+ */
+exports.DEFAULT_RULES = [
+    // ---------------------------------------------------------------- 100 · TV
+    // Van primero porque casi todos los televisores mienten: se presentan como
+    // Linux, como Android o como un navegador de escritorio.
+    {
+        name: 'ua:tizen',
+        test: /\bTizen\b/i,
+        set: { os: 'tizen', device: 'tv' },
+        confidence: 'high',
+        priority: 100,
+    },
+    {
+        name: 'ua:webos',
+        test: /\b(?:web0S|webOS)\b.*\b(?:TV|SmartTV|LargeScreen)\b|\bWebAppManager\b/i,
+        set: { os: 'webos', device: 'tv' },
+        confidence: 'high',
+        priority: 101,
+    },
+    {
+        name: 'ua:android-tv',
+        test: /\bAndroid\b.*\b(?:TV|BRAVIA|AFT[A-Z0-9]+|SHIELD|Chromecast|GoogleTV)\b/i,
+        set: { os: 'android', device: 'tv' },
+        confidence: 'high',
+        priority: 102,
+    },
+    {
+        name: 'ua:fire-tv',
+        test: /\bAFT[A-Z0-9]+\b/,
+        set: { os: 'android', device: 'tv' },
+        confidence: 'high',
+        priority: 103,
+    },
+    {
+        name: 'ua:chromecast',
+        test: /\bCrKey\b/,
+        set: { os: 'android', device: 'tv' },
+        confidence: 'high',
+        priority: 104,
+    },
+    {
+        name: 'ua:generic-smarttv',
+        test: /\b(?:SMART-TV|SmartTV|HbbTV|NetCast|Viera|AppleTV|Roku|PlayStation|Xbox)\b/i,
+        set: { device: 'tv' },
+        confidence: 'medium',
+        priority: 110,
+    },
+    // ------------------------------------------- 200 · contenedor de escritorio
+    // Una app de escritorio que muestra HTML embebe la página igual que un
+    // WebView de teléfono: la diferencia es el aparato, no el alojamiento.
+    {
+        name: 'ua:electron',
+        test: /\bElectron\/[\d.]+/,
+        set: { webview: true, device: 'desktop' },
+        confidence: 'high',
+        priority: 200,
+    },
+    {
+        name: 'ua:tauri',
+        test: /\bTauri\/[\d.]+/i,
+        set: { webview: true, device: 'desktop' },
+        confidence: 'high',
+        priority: 201,
+    },
+    // ---------------------------------------------- 300 · incrustada en una app
+    {
+        name: 'ua:react-native',
+        test: /\bReactNative\b/i,
+        set: { webview: true },
+        confidence: 'high',
+        priority: 300,
+    },
+    {
+        name: 'ua:android-webview',
+        test: /;\s*wv[);]/,
+        set: { webview: true, os: 'android' },
+        confidence: 'high',
+        priority: 301,
+    },
+    {
+        name: 'ua:android-webview-legacy',
+        test: /\bAndroid\b.*\bVersion\/[\d.]+\b.*\bChrome\//,
+        set: { webview: true, os: 'android' },
+        confidence: 'medium',
+        priority: 302,
+    },
+    {
+        // Un WKWebView omite el token `Safari` que Safari móvil sí trae. Es
+        // heurístico y por eso la confianza es media.
+        name: 'ua:ios-webview',
+        test: /\((?:iPhone|iPad|iPod);(?:(?!Safari).)*$/,
+        set: { webview: true, os: 'ios' },
+        confidence: 'medium',
+        priority: 303,
+    },
+    {
+        name: 'ua:inapp-browser',
+        test: /\b(?:FBAN|FBAV|Instagram|Line\/|Twitter|GSA\/|MicroMessenger)\b/,
+        set: { webview: true },
+        confidence: 'medium',
+        priority: 304,
+    },
+    // --------------------------------------------------------------- 400 · OS
+    {
+        // Sólo tokens delimitados: el modelo anterior buscaba la subcadena `ios`, y
+        // por eso cualquier User-Agent que dijera `axios` se detectaba como iOS.
+        name: 'ua:ios',
+        test: /\b(?:iPhone|iPad|iPod)\b|\biOS\b|\biPhone OS\b/,
+        set: { os: 'ios' },
+        confidence: 'high',
+        priority: 400,
+    },
+    {
+        name: 'ua:android',
+        test: /\bAndroid\b/,
+        set: { os: 'android' },
+        confidence: 'high',
+        priority: 401,
+    },
+    {
+        name: 'ua:windows',
+        test: /\bWindows NT\b|\bWindows\b/,
+        set: { os: 'windows' },
+        confidence: 'high',
+        priority: 402,
+    },
+    {
+        name: 'ua:macos',
+        test: /\bMac OS X\b|\bMacintosh\b/,
+        set: { os: 'macos' },
+        confidence: 'high',
+        priority: 403,
+    },
+    {
+        name: 'ua:linux',
+        test: /\b(?:Linux|X11|CrOS)\b/,
+        set: { os: 'linux' },
+        confidence: 'medium',
+        priority: 404,
+    },
+    // ----------------------------------------------------------- 500 · aparato
+    {
+        name: 'ua:ipad',
+        test: /\biPad\b/,
+        set: { device: 'tablet' },
+        confidence: 'high',
+        priority: 500,
+    },
+    {
+        name: 'ua:iphone',
+        test: /\b(?:iPhone|iPod)\b/,
+        set: { device: 'phone' },
+        confidence: 'high',
+        priority: 501,
+    },
+    {
+        // Android sin el token `Mobile` es una tableta. Es la convención que
+        // Google documenta, y es lo que hace que un Galaxy Tab deje de detectarse
+        // como un escritorio.
+        name: 'ua:android-tablet',
+        test: /\bAndroid\b(?:(?!\bMobile\b).)*$/,
+        set: { device: 'tablet' },
+        confidence: 'medium',
+        priority: 502,
+    },
+    {
+        name: 'ua:android-phone',
+        test: /\bAndroid\b.*\bMobile\b/,
+        set: { device: 'phone' },
+        confidence: 'high',
+        priority: 503,
+    },
+    {
+        name: 'ua:tablet-generic',
+        test: /\b(?:Tablet|Silk|Kindle|PlayBook)\b/i,
+        set: { device: 'tablet' },
+        confidence: 'medium',
+        priority: 510,
+    },
+    {
+        name: 'ua:mobile-generic',
+        test: /\b(?:Mobile|Mobi|Phone)\b/i,
+        set: { device: 'phone' },
+        confidence: 'low',
+        priority: 511,
+    },
+];