@ressjs/platform 0.6.0-experimental.0

package/README.md

@@ -0,0 +1,95 @@
+# @ressjs/platform
+
+Responde una sola pregunta: **qué es el cliente que está del otro lado**.
+
+La responden igual el router, el puente del WebView, el cliente y cualquier
+consumidor externo. Por eso vive en su propio paquete y no depende de nada.
+
+```ts
+import { detect } from '@ressjs/platform'
+
+const platform = detect({ userAgent, headers })
+// { webview: false, os: 'tizen', device: 'tv', ... }
+```
+
+## El modelo
+
+Tres ejes ortogonales. Cualquier combinación es expresable.
+
+| Eje | Valores | Qué describe |
+|---|---|---|
+| `context` | `webview` | la página está incrustada dentro de una app; su ausencia es un navegador |
+| `os` | `ios` `android` `tizen` `webos` `windows` `macos` `linux` | sistema operativo |
+| `device` | `phone` `tablet` `tv` `desktop` | forma del aparato y modo de operación |
+
+Los datos de la app que embebe la página —cuál es, en qué versión, sobre qué
+versión del sistema— llegan en `nativeApp` y **nunca** eligen qué archivo servir.
+
+## Cómo se decide
+
+Seis capas, de lo que el cliente afirma a lo que se adivina. Cada una aporta
+sólo los campos que puede determinar, y un campo ya resuelto no se sobrescribe.
+Ninguna capa devuelve un resultado completo ni corta la evaluación: por eso
+ninguna puede volver inalcanzable a la siguiente.
+
+1. `override` — forzado para depurar, apagado salvo que se habilite
+2. `explicit-headers` — el contrato v2
+3. `legacy-headers` — el contrato v1 de los clientes ya publicados
+4. `client-hints` — lo que el navegador manda por su cuenta
+5. `user-agent` — la tabla de reglas
+6. `default` — lo que quede sin resolver
+
+Cada campo del resultado declara de qué capa salió y con cuánta confianza:
+
+```ts
+platform.detection.fields.device
+// { layer: 'user-agent', confidence: 'high', rule: 'ua:android-tv' }
+```
+
+Un `webview: false` que nadie afirmó se distingue así de uno detectado.
+
+## Cabeceras
+
+| Cabecera | Aporta |
+|---|---|
+| `x-ressjs-webview` | `webview` |
+| `x-ressjs-os` | `os` |
+| `x-ressjs-device` | `device` |
+| `x-ressjs-app-id` | `nativeApp.id`, e implica `webview: true` |
+| `x-ressjs-app-version` | `nativeApp.version` |
+| `x-ressjs-os-version` | `nativeApp.osVersion` |
+| `x-ressjs-capabilities` | `capabilities`, separadas por comas |
+
+Las del contrato anterior —`x-ressjs-platform`, `x-webview`, `x-rn-platform`,
+`x-ressjs-version`— se siguen aceptando y se traducen.
+
+## Agregar una plataforma
+
+Es un dato, no un cambio de código:
+
+```ts
+const registry = createPlatformRegistry({
+  values: [{ token: 'kaios', axis: 'os' }],
+  detect: [
+    {
+      name: 'ua:kaios',
+      test: /KAIOS/i,
+      set: { os: 'kaios', device: 'phone' },
+      confidence: 'high',
+      priority: 150,
+    },
+  ],
+})
+```
+
+A partir de ahí `index.kaios.scss` es una variante válida.
+
+## Desde el navegador
+
+```ts
+import { getPlatform } from '@ressjs/platform/client'
+```
+
+Lee lo que el servidor serializó en `window.__RESS_PLATFORM__`, de modo que
+cliente y servidor coinciden exactamente. Sólo detecta por su cuenta si no hay
+nada serializado.

package/dist/client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * La plataforma, del lado del navegador.
+ *
+ * Lo normal es que el servidor ya la haya resuelto y serializado en el HTML: el
+ * cliente la lee de ahí en vez de volver a detectarla, y así el marcado que
+ * hidrata coincide exactamente con el que se envió. Detectar de nuevo abriría la
+ * puerta a que servidor y cliente discrepen, que es la clase de desajuste que
+ * rompe la hidratación de React.
+ */
+import type { PlatformInfo } from './model/types';
+declare global {
+    interface Window {
+        __RESS_PLATFORM__?: PlatformInfo;
+    }
+}
+/**
+ * Qué plataforma es esta.
+ *
+ * Sólo detecta por su cuenta si el servidor no dejó nada, que es lo que pasa en
+ * una página estática servida desde un CDN.
+ */
+export declare function getPlatform(): PlatformInfo;
+/**
+ * Detección desde el navegador, con las señales que sólo existen acá.
+ *
+ * `window.ReactNativeWebView` es una certeza y no una heurística: el puente sólo
+ * existe si el contenedor lo inyectó.
+ */
+export declare function detectClient(): PlatformInfo;
+export { DEFAULT_PLATFORM } from './model/defaults';
+export { hasCapability, isHandheld, isTV, isWebView } from './predicates';
+export type { NativeAppInfo, PlatformDevice, PlatformInfo, PlatformOS } from './model/types';

package/dist/client.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * La plataforma, del lado del navegador.
+ *
+ * Lo normal es que el servidor ya la haya resuelto y serializado en el HTML: el
+ * cliente la lee de ahí en vez de volver a detectarla, y así el marcado que
+ * hidrata coincide exactamente con el que se envió. Detectar de nuevo abriría la
+ * puerta a que servidor y cliente discrepen, que es la clase de desajuste que
+ * rompe la hidratación de React.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWebView = exports.isTV = exports.isHandheld = exports.hasCapability = exports.DEFAULT_PLATFORM = void 0;
+exports.getPlatform = getPlatform;
+exports.detectClient = detectClient;
+const defaults_1 = require("./model/defaults");
+const pipeline_1 = require("./detect/pipeline");
+/**
+ * Qué plataforma es esta.
+ *
+ * Sólo detecta por su cuenta si el servidor no dejó nada, que es lo que pasa en
+ * una página estática servida desde un CDN.
+ */
+function getPlatform() {
+    if (typeof window === 'undefined')
+        return defaults_1.DEFAULT_PLATFORM;
+    return window.__RESS_PLATFORM__ ?? detectClient();
+}
+/**
+ * Detección desde el navegador, con las señales que sólo existen acá.
+ *
+ * `window.ReactNativeWebView` es una certeza y no una heurística: el puente sólo
+ * existe si el contenedor lo inyectó.
+ */
+function detectClient() {
+    if (typeof navigator === 'undefined')
+        return defaults_1.DEFAULT_PLATFORM;
+    const base = (0, pipeline_1.detect)({ userAgent: navigator.userAgent });
+    const inReactNativeWebView = typeof window !== 'undefined' && 'ReactNativeWebView' in window;
+    if (!inReactNativeWebView || base.webview)
+        return base;
+    return {
+        ...base,
+        webview: true,
+        detection: {
+            ...base.detection,
+            fields: {
+                ...base.detection.fields,
+                context: { layer: 'client-signals', confidence: 'exact', rule: 'ReactNativeWebView' },
+            },
+        },
+    };
+}
+var defaults_2 = require("./model/defaults");
+Object.defineProperty(exports, "DEFAULT_PLATFORM", { enumerable: true, get: function () { return defaults_2.DEFAULT_PLATFORM; } });
+var predicates_1 = require("./predicates");
+Object.defineProperty(exports, "hasCapability", { enumerable: true, get: function () { return predicates_1.hasCapability; } });
+Object.defineProperty(exports, "isHandheld", { enumerable: true, get: function () { return predicates_1.isHandheld; } });
+Object.defineProperty(exports, "isTV", { enumerable: true, get: function () { return predicates_1.isTV; } });
+Object.defineProperty(exports, "isWebView", { enumerable: true, get: function () { return predicates_1.isWebView; } });

package/dist/compat.d.ts

@@ -0,0 +1,9 @@
+import type { PlatformInfo } from './model/types';
+import type { Headers } from './rules/headers';
+/**
+ * Firma del modelo v1, conservada para no obligar a tocar a quien ya la usa.
+ *
+ * Lo nuevo se escribe contra `detect()`, que recibe un objeto y admite el
+ * registro del proyecto.
+ */
+export declare function detectPlatform(userAgent: string, headers?: Headers): PlatformInfo;

package/dist/compat.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatform = detectPlatform;
+const pipeline_1 = require("./detect/pipeline");
+/**
+ * Firma del modelo v1, conservada para no obligar a tocar a quien ya la usa.
+ *
+ * Lo nuevo se escribe contra `detect()`, que recibe un objeto y admite el
+ * registro del proyecto.
+ */
+function detectPlatform(userAgent, headers = {}) {
+    return (0, pipeline_1.detect)({ userAgent, headers });
+}

package/dist/detect/layers.d.ts

@@ -0,0 +1,40 @@
+import type { DetectionLayerId } from '../model/types';
+import type { PlatformRegistry } from '../registry/types';
+import type { Headers, LayerResult } from '../rules/headers';
+/** Lo que ve una capa. */
+export interface DetectionInput {
+    userAgent?: string;
+    headers?: Headers;
+    /** Permite forzar una plataforma para reproducir un caso. Apagado por defecto. */
+    allowOverride?: boolean;
+    /**
+     * Si la tabla de User-Agent participa de la decisión.
+     *
+     * Se apaga cuando la respuesta no va a declarar `Vary: User-Agent`. Resolver
+     * por algo que no se declara es servir la variante equivocada apenas haya una
+     * caché intermedia: mejor no usarlo que usarlo a escondidas.
+     */
+    useUserAgent?: boolean;
+    registry?: PlatformRegistry;
+}
+export interface DetectionLayer {
+    id: DetectionLayerId;
+    read(input: DetectionInput, registry: PlatformRegistry): LayerResult;
+}
+/**
+ * Las capas, en orden de precedencia. **Este es el único lugar donde ese orden
+ * existe**: no hay ninguna otra parte del sistema con un criterio propio.
+ *
+ * Van de lo que el cliente afirma a lo que se adivina:
+ *
+ * 1. `override` — forzado para depurar, sólo si está habilitado
+ * 2. `explicit-headers` — el contrato v2, el cliente diciendo lo que es
+ * 3. `legacy-headers` — el contrato v1 de los clientes ya publicados
+ * 4. `edge` — lo que la red de distribución ya resolvió, si el proyecto la declaró
+ * 5. `client-hints` — lo que el navegador manda por su cuenta
+ * 6. `user-agent` — la tabla de reglas
+ *
+ * La capa `default` no está en la lista porque no lee nada: es lo que queda
+ * cuando ninguna de las anteriores resolvió un campo.
+ */
+export declare const DETECTION_LAYERS: readonly DetectionLayer[];

package/dist/detect/layers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DETECTION_LAYERS = void 0;
+const headers_1 = require("../rules/headers");
+const edge_1 = require("../rules/edge");
+const apply_1 = require("../rules/apply");
+const override_1 = require("./override");
+/**
+ * Las capas, en orden de precedencia. **Este es el único lugar donde ese orden
+ * existe**: no hay ninguna otra parte del sistema con un criterio propio.
+ *
+ * Van de lo que el cliente afirma a lo que se adivina:
+ *
+ * 1. `override` — forzado para depurar, sólo si está habilitado
+ * 2. `explicit-headers` — el contrato v2, el cliente diciendo lo que es
+ * 3. `legacy-headers` — el contrato v1 de los clientes ya publicados
+ * 4. `edge` — lo que la red de distribución ya resolvió, si el proyecto la declaró
+ * 5. `client-hints` — lo que el navegador manda por su cuenta
+ * 6. `user-agent` — la tabla de reglas
+ *
+ * La capa `default` no está en la lista porque no lee nada: es lo que queda
+ * cuando ninguna de las anteriores resolvió un campo.
+ */
+exports.DETECTION_LAYERS = [
+    { id: 'override', read: (input) => (input.allowOverride ? (0, override_1.readOverride)(input.headers ?? {}) : {}) },
+    { id: 'explicit-headers', read: (input) => (0, headers_1.readExplicitHeaders)(input.headers ?? {}) },
+    { id: 'legacy-headers', read: (input) => (0, headers_1.readLegacyHeaders)(input.headers ?? {}) },
+    { id: 'edge', read: (input, registry) => (0, edge_1.readEdgeHeaders)(input.headers ?? {}, registry.edge) },
+    { id: 'client-hints', read: (input) => (0, headers_1.readClientHints)(input.headers ?? {}) },
+    {
+        id: 'user-agent',
+        read: (input, registry) => (input.useUserAgent ?? true) ? (0, apply_1.readUserAgent)(input.userAgent ?? '', registry) : {},
+    },
+];

package/dist/detect/merge.d.ts

@@ -0,0 +1,30 @@
+import type { Axis } from '../model/known';
+import type { DetectionLayerId, FieldOrigin, NativeAppInfo } from '../model/types';
+import type { LayerResult } from '../rules/headers';
+/**
+ * Lo que el pipeline va llenando: cada eje se fija una sola vez.
+ *
+ * Es un acumulador y no un `PlatformInfo` a medio construir a propósito: los
+ * campos que todavía nadie resolvió están ausentes, no puestos en un valor por
+ * defecto que después habría que distinguir del valor real.
+ */
+export interface Accumulator {
+    webview?: boolean;
+    os?: string;
+    device?: string;
+    nativeApp?: Partial<NativeAppInfo>;
+    capabilities: string[];
+    fields: Partial<Record<Axis, FieldOrigin>>;
+}
+export declare function createAccumulator(): Accumulator;
+/**
+ * Incorpora lo que aportó una capa. **El primero que fija un campo gana.**
+ *
+ * Esa regla es lo que vuelve imposible el defecto que motivaba esta spec: no hay
+ * ninguna capa que devuelva un resultado completo ni que corte la evaluación, así
+ * que ninguna puede volver inalcanzable a la siguiente. Cada una aporta lo que
+ * sabe y lo que no sabe lo resuelven las de abajo.
+ */
+export declare function absorb(acc: Accumulator, layer: DetectionLayerId, result: LayerResult): void;
+/** Los tres ejes ya resueltos, o `false` si alguno falta. */
+export declare function isComplete(acc: Accumulator): boolean;

package/dist/detect/merge.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccumulator = createAccumulator;
+exports.absorb = absorb;
+exports.isComplete = isComplete;
+function createAccumulator() {
+    return { capabilities: [], fields: {} };
+}
+/**
+ * Incorpora lo que aportó una capa. **El primero que fija un campo gana.**
+ *
+ * Esa regla es lo que vuelve imposible el defecto que motivaba esta spec: no hay
+ * ninguna capa que devuelva un resultado completo ni que corte la evaluación, así
+ * que ninguna puede volver inalcanzable a la siguiente. Cada una aporta lo que
+ * sabe y lo que no sabe lo resuelven las de abajo.
+ */
+function absorb(acc, layer, result) {
+    if (result.webview !== undefined && acc.webview === undefined) {
+        acc.webview = result.webview.value;
+        acc.fields.context = origin(layer, result.webview.confidence, result.webview.rule);
+    }
+    if (result.os !== undefined && acc.os === undefined) {
+        acc.os = result.os.value;
+        acc.fields.os = origin(layer, result.os.confidence, result.os.rule);
+    }
+    if (result.device !== undefined && acc.device === undefined) {
+        acc.device = result.device.value;
+        acc.fields.device = origin(layer, result.device.confidence, result.device.rule);
+    }
+    // Los metadatos se acumulan campo a campo, con la misma regla: el primero que
+    // lo dijo gana. Un cliente puede declarar su versión por el contrato nuevo y
+    // su identificador por el viejo.
+    if (result.nativeApp) {
+        const merged = { ...result.nativeApp, ...acc.nativeApp };
+        acc.nativeApp = Object.fromEntries(Object.entries(merged).filter(([, v]) => v !== undefined));
+    }
+    if (result.capabilities?.length) {
+        for (const capability of result.capabilities) {
+            if (!acc.capabilities.includes(capability))
+                acc.capabilities.push(capability);
+        }
+    }
+}
+function origin(layer, confidence, rule) {
+    return rule ? { layer, confidence, rule } : { layer, confidence };
+}
+/** Los tres ejes ya resueltos, o `false` si alguno falta. */
+function isComplete(acc) {
+    return acc.webview !== undefined && acc.os !== undefined && acc.device !== undefined;
+}

package/dist/detect/override.d.ts

@@ -0,0 +1,9 @@
+import { type Headers, type LayerResult } from '../rules/headers';
+/**
+ * Forzado de plataforma para reproducir un caso sin tener el aparato a mano.
+ *
+ * Está apagado salvo que quien monta el servidor lo habilite explícitamente: es
+ * una cabecera que cualquiera puede mandar, y con ella se elige qué variante
+ * recibe. En producción eso es una superficie de ataque, no una comodidad.
+ */
+export declare function readOverride(headers: Headers): LayerResult;

package/dist/detect/override.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOverride = readOverride;
+const headers_1 = require("../rules/headers");
+const request_headers_1 = require("../rules/request-headers");
+/**
+ * Forzado de plataforma para reproducir un caso sin tener el aparato a mano.
+ *
+ * Está apagado salvo que quien monta el servidor lo habilite explícitamente: es
+ * una cabecera que cualquiera puede mandar, y con ella se elige qué variante
+ * recibe. En producción eso es una superficie de ataque, no una comodidad.
+ */
+function readOverride(headers) {
+    const raw = (0, headers_1.header)(headers, request_headers_1.HEADER_OVERRIDE);
+    if (!raw)
+        return {};
+    const result = {};
+    for (const part of raw.split(/[,;]/)) {
+        const [key, value] = part.split('=').map((s) => s.trim().toLowerCase());
+        if (!key || !value)
+            continue;
+        if (key === 'webview') {
+            result.webview = { value: value !== 'false' && value !== '0', confidence: 'exact', rule: 'override' };
+        }
+        else if (key === 'os') {
+            result.os = { value, confidence: 'exact', rule: 'override' };
+        }
+        else if (key === 'device') {
+            result.device = { value, confidence: 'exact', rule: 'override' };
+        }
+    }
+    return result;
+}

package/dist/detect/pipeline.d.ts

@@ -0,0 +1,10 @@
+import type { PlatformInfo } from '../model/types';
+import { type DetectionInput } from './layers';
+/**
+ * Qué es el cliente que está del otro lado.
+ *
+ * Es una función pura: las mismas entradas producen siempre la misma salida, sin
+ * estado, sin reloj, sin red ni disco. Es lo que permite correrla igual en el
+ * servidor y en el navegador, y probarla sin montar nada.
+ */
+export declare function detect(input?: DetectionInput): PlatformInfo;

package/dist/detect/pipeline.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detect = detect;
+const defaults_1 = require("../model/defaults");
+const create_1 = require("../registry/create");
+const merge_1 = require("./merge");
+const layers_1 = require("./layers");
+/**
+ * Qué es el cliente que está del otro lado.
+ *
+ * Es una función pura: las mismas entradas producen siempre la misma salida, sin
+ * estado, sin reloj, sin red ni disco. Es lo que permite correrla igual en el
+ * servidor y en el navegador, y probarla sin montar nada.
+ */
+function detect(input = {}) {
+    const registry = input.registry ?? create_1.defaultPlatformRegistry;
+    const acc = (0, merge_1.createAccumulator)();
+    for (const layer of layers_1.DETECTION_LAYERS) {
+        if ((0, merge_1.isComplete)(acc) && acc.capabilities.length > 0)
+            break;
+        (0, merge_1.absorb)(acc, layer.id, layer.read(input, registry));
+    }
+    const fields = {
+        context: acc.fields.context ?? defaults_1.DEFAULT_PLATFORM.detection.fields.context,
+        os: acc.fields.os ?? defaults_1.DEFAULT_PLATFORM.detection.fields.os,
+        device: acc.fields.device ?? defaults_1.DEFAULT_PLATFORM.detection.fields.device,
+    };
+    const info = {
+        webview: acc.webview ?? defaults_1.DEFAULT_PLATFORM.webview,
+        os: acc.os ?? defaults_1.DEFAULT_PLATFORM.os,
+        device: acc.device ?? defaults_1.DEFAULT_PLATFORM.device,
+        capabilities: acc.capabilities,
+        detection: {
+            source: weakestLayer(fields),
+            confidence: weakestConfidence(fields),
+            fields,
+        },
+        source: cameFromHeaders(fields) ? 'headers' : 'user-agent',
+    };
+    // Basta con que el cliente haya declarado algo: un contrato viejo puede
+    // aportar la versión sin poder aportar el identificador.
+    if (acc.nativeApp && Object.keys(acc.nativeApp).length > 0) {
+        info.nativeApp = { ...acc.nativeApp };
+    }
+    return info;
+}
+/** Orden de las capas, de la que más afirma a la que menos. */
+const LAYER_ORDER = [
+    'override',
+    'explicit-headers',
+    'legacy-headers',
+    'edge',
+    'client-hints',
+    'user-agent',
+    'client-signals',
+    'default',
+];
+const CONFIDENCE_ORDER = ['exact', 'high', 'medium', 'low', 'none'];
+/**
+ * La confianza del resultado es la del eje peor resuelto.
+ *
+ * Reportar el promedio, o la del mejor, escondería justamente el campo del que
+ * hay que desconfiar.
+ */
+function weakestConfidence(fields) {
+    return Object.values(fields).reduce((worst, f) => CONFIDENCE_ORDER.indexOf(f.confidence) > CONFIDENCE_ORDER.indexOf(worst)
+        ? f.confidence
+        : worst, 'exact');
+}
+function weakestLayer(fields) {
+    return Object.values(fields).reduce((worst, f) => LAYER_ORDER.indexOf(f.layer) > LAYER_ORDER.indexOf(worst) ? f.layer : worst, 'override');
+}
+function cameFromHeaders(fields) {
+    return Object.values(fields).some((f) => f.layer === 'explicit-headers' || f.layer === 'legacy-headers');
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Modelo de plataforma de ress.js.
+ *
+ * Responde una sola pregunta —qué es el cliente que está del otro lado— y la
+ * responde igual para todos: el router, el puente del WebView, el cliente y
+ * cualquier consumidor externo. Por eso vive en su propio paquete y no depende
+ * de nada.
+ */
+export { detect } from './detect/pipeline';
+export { detectPlatform } from './compat';
+export { DETECTION_LAYERS } from './detect/layers';
+export type { DetectionInput, DetectionLayer } from './detect/layers';
+export { createPlatformRegistry, defaultPlatformRegistry } from './registry/create';
+export { parseVariantSuffix } from './registry/parse';
+export { ALL_AXES, DEFAULT_AXIS_PRECEDENCE, DEFAULT_VALUES, RETIRED_TOKENS, } from './registry/defaults';
+export { DEFAULT_RULES } from './rules/user-agent';
+export { EDGE_PRESETS, readEdgeHeaders } from './rules/edge';
+export type { EdgeHintRule } from './rules/edge';
+export { HEADER_OVERRIDE, HEADERS_CLIENT_HINTS, HEADERS_LEGACY, HEADERS_V2, PLATFORM_REQUEST_HEADERS, PLATFORM_VARY_HEADERS, HEADERS_BY_AXIS, varyHeadersForAxes, } from './rules/request-headers';
+export { DEFAULT_PLATFORM } from './model/defaults';
+export { hasCapability, isHandheld, isTV, isWebView } from './predicates';
+export { platformScriptTag, serializePlatform } from './serialize';
+export type { Axis, KnownContext, KnownDevice, KnownOS } from './model/known';
+export type { Confidence, DetectionLayerId, FieldOrigin, NativeAppInfo, PlatformDevice, PlatformInfo, PlatformOS, PlatformValueMap, } from './model/types';
+export type { AxisValueDef, PlatformRegistry, RegistryOptions, RetiredTokenDef, RuleEffect, UserAgentRule, VariantTag, } from './registry/types';
+export type { Headers } from './rules/headers';

package/dist/index.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Modelo de plataforma de ress.js.
+ *
+ * Responde una sola pregunta —qué es el cliente que está del otro lado— y la
+ * responde igual para todos: el router, el puente del WebView, el cliente y
+ * cualquier consumidor externo. Por eso vive en su propio paquete y no depende
+ * de nada.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializePlatform = exports.platformScriptTag = exports.isWebView = exports.isTV = exports.isHandheld = exports.hasCapability = exports.DEFAULT_PLATFORM = exports.varyHeadersForAxes = exports.HEADERS_BY_AXIS = exports.PLATFORM_VARY_HEADERS = exports.PLATFORM_REQUEST_HEADERS = exports.HEADERS_V2 = exports.HEADERS_LEGACY = exports.HEADERS_CLIENT_HINTS = exports.HEADER_OVERRIDE = exports.readEdgeHeaders = exports.EDGE_PRESETS = exports.DEFAULT_RULES = exports.RETIRED_TOKENS = exports.DEFAULT_VALUES = exports.DEFAULT_AXIS_PRECEDENCE = exports.ALL_AXES = exports.parseVariantSuffix = exports.defaultPlatformRegistry = exports.createPlatformRegistry = exports.DETECTION_LAYERS = exports.detectPlatform = exports.detect = void 0;
+var pipeline_1 = require("./detect/pipeline");
+Object.defineProperty(exports, "detect", { enumerable: true, get: function () { return pipeline_1.detect; } });
+var compat_1 = require("./compat");
+Object.defineProperty(exports, "detectPlatform", { enumerable: true, get: function () { return compat_1.detectPlatform; } });
+var layers_1 = require("./detect/layers");
+Object.defineProperty(exports, "DETECTION_LAYERS", { enumerable: true, get: function () { return layers_1.DETECTION_LAYERS; } });
+var create_1 = require("./registry/create");
+Object.defineProperty(exports, "createPlatformRegistry", { enumerable: true, get: function () { return create_1.createPlatformRegistry; } });
+Object.defineProperty(exports, "defaultPlatformRegistry", { enumerable: true, get: function () { return create_1.defaultPlatformRegistry; } });
+var parse_1 = require("./registry/parse");
+Object.defineProperty(exports, "parseVariantSuffix", { enumerable: true, get: function () { return parse_1.parseVariantSuffix; } });
+var defaults_1 = require("./registry/defaults");
+Object.defineProperty(exports, "ALL_AXES", { enumerable: true, get: function () { return defaults_1.ALL_AXES; } });
+Object.defineProperty(exports, "DEFAULT_AXIS_PRECEDENCE", { enumerable: true, get: function () { return defaults_1.DEFAULT_AXIS_PRECEDENCE; } });
+Object.defineProperty(exports, "DEFAULT_VALUES", { enumerable: true, get: function () { return defaults_1.DEFAULT_VALUES; } });
+Object.defineProperty(exports, "RETIRED_TOKENS", { enumerable: true, get: function () { return defaults_1.RETIRED_TOKENS; } });
+var user_agent_1 = require("./rules/user-agent");
+Object.defineProperty(exports, "DEFAULT_RULES", { enumerable: true, get: function () { return user_agent_1.DEFAULT_RULES; } });
+var edge_1 = require("./rules/edge");
+Object.defineProperty(exports, "EDGE_PRESETS", { enumerable: true, get: function () { return edge_1.EDGE_PRESETS; } });
+Object.defineProperty(exports, "readEdgeHeaders", { enumerable: true, get: function () { return edge_1.readEdgeHeaders; } });
+var request_headers_1 = require("./rules/request-headers");
+Object.defineProperty(exports, "HEADER_OVERRIDE", { enumerable: true, get: function () { return request_headers_1.HEADER_OVERRIDE; } });
+Object.defineProperty(exports, "HEADERS_CLIENT_HINTS", { enumerable: true, get: function () { return request_headers_1.HEADERS_CLIENT_HINTS; } });
+Object.defineProperty(exports, "HEADERS_LEGACY", { enumerable: true, get: function () { return request_headers_1.HEADERS_LEGACY; } });
+Object.defineProperty(exports, "HEADERS_V2", { enumerable: true, get: function () { return request_headers_1.HEADERS_V2; } });
+Object.defineProperty(exports, "PLATFORM_REQUEST_HEADERS", { enumerable: true, get: function () { return request_headers_1.PLATFORM_REQUEST_HEADERS; } });
+Object.defineProperty(exports, "PLATFORM_VARY_HEADERS", { enumerable: true, get: function () { return request_headers_1.PLATFORM_VARY_HEADERS; } });
+Object.defineProperty(exports, "HEADERS_BY_AXIS", { enumerable: true, get: function () { return request_headers_1.HEADERS_BY_AXIS; } });
+Object.defineProperty(exports, "varyHeadersForAxes", { enumerable: true, get: function () { return request_headers_1.varyHeadersForAxes; } });
+var defaults_2 = require("./model/defaults");
+Object.defineProperty(exports, "DEFAULT_PLATFORM", { enumerable: true, get: function () { return defaults_2.DEFAULT_PLATFORM; } });
+var predicates_1 = require("./predicates");
+Object.defineProperty(exports, "hasCapability", { enumerable: true, get: function () { return predicates_1.hasCapability; } });
+Object.defineProperty(exports, "isHandheld", { enumerable: true, get: function () { return predicates_1.isHandheld; } });
+Object.defineProperty(exports, "isTV", { enumerable: true, get: function () { return predicates_1.isTV; } });
+Object.defineProperty(exports, "isWebView", { enumerable: true, get: function () { return predicates_1.isWebView; } });
+var serialize_1 = require("./serialize");
+Object.defineProperty(exports, "platformScriptTag", { enumerable: true, get: function () { return serialize_1.platformScriptTag; } });
+Object.defineProperty(exports, "serializePlatform", { enumerable: true, get: function () { return serialize_1.serializePlatform; } });

package/dist/model/defaults.d.ts

@@ -0,0 +1,8 @@
+import type { PlatformInfo } from './types';
+/**
+ * Lo que se responde cuando nadie dijo nada.
+ *
+ * Cada eje queda marcado con confianza `none`, que es lo que distingue este
+ * `webview: false` de uno que una capa afirmó.
+ */
+export declare const DEFAULT_PLATFORM: PlatformInfo;

package/dist/model/defaults.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PLATFORM = void 0;
+/**
+ * Lo que se responde cuando nadie dijo nada.
+ *
+ * Cada eje queda marcado con confianza `none`, que es lo que distingue este
+ * `webview: false` de uno que una capa afirmó.
+ */
+exports.DEFAULT_PLATFORM = Object.freeze({
+    webview: false,
+    os: 'unknown',
+    device: 'desktop',
+    capabilities: Object.freeze([]),
+    detection: Object.freeze({
+        source: 'default',
+        confidence: 'none',
+        fields: Object.freeze({
+            context: Object.freeze({ layer: 'default', confidence: 'none' }),
+            os: Object.freeze({ layer: 'default', confidence: 'none' }),
+            device: Object.freeze({ layer: 'default', confidence: 'none' }),
+        }),
+    }),
+    source: 'user-agent',
+});

package/dist/model/known.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Vocabulario que el framework conoce de fábrica.
+ *
+ * Un proyecto puede agregar valores a los ejes `os` y `device` desde su propia
+ * configuración; lo que no puede es agregar un eje. Agregar un valor es un dato,
+ * agregar un eje es un cambio de arquitectura.
+ */
+/**
+ * Las tres preguntas con las que se describe un cliente.
+ *
+ * - `context`: ¿la página está incrustada dentro de una app?
+ * - `os`: ¿qué sistema operativo corre debajo?
+ * - `device`: ¿qué forma tiene el aparato y cómo se lo opera?
+ *
+ * Son ortogonales: cualquier combinación es expresable. Una WebView dentro de
+ * una app de Android TV es `webview` + `android` + `tv`.
+ */
+export type Axis = 'context' | 'os' | 'device';
+/**
+ * Único token del eje `context`.
+ *
+ * No hay un token para "navegador" porque su ausencia ya lo dice, y porque un
+ * token que nombra la situación normal obliga a escribirlo en todas partes.
+ */
+export type KnownContext = 'webview';
+/**
+ * `unknown` no es un token del registro: nadie puede escribir `index.unknown.scss`.
+ * Es el valor que toma `os` cuando ninguna capa de detección lo resolvió.
+ */
+export type KnownOS = 'ios' | 'android' | 'tizen' | 'webos' | 'windows' | 'macos' | 'linux' | 'unknown';
+export type KnownDevice = 'phone' | 'tablet' | 'tv' | 'desktop';