@sovaria/sdk 0.0.0-stage → 0.5.0

package/dist/passkeys.js

@@ -0,0 +1,76 @@
+/**
+ * WebAuthn (passkey) JSON helpers for the browser: Sovaria sends registration and sign-in options as
+ * JSON with base64url strings (py_webauthn `options_to_json`), the browser API wants ArrayBuffers, and
+ * Sovaria expects the resulting credential back as JSON again. No dependencies.
+ */
+export function base64urlToBuffer(value) {
+    const b64 = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = b64 + '='.repeat((4 - (b64.length % 4)) % 4);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes.buffer;
+}
+export function bufferToBase64url(value) {
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 1)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+const descriptors = (list) => Array.isArray(list)
+    ? list.map((d) => ({ ...d, id: base64urlToBuffer(String(d.id)) }))
+    : undefined;
+/** Registration options JSON → `PublicKeyCredentialCreationOptions`. */
+export function creationOptionsFromJSON(json) {
+    const options = (json.publicKey ?? json);
+    const user = options.user;
+    return {
+        ...options,
+        challenge: base64urlToBuffer(String(options.challenge)),
+        user: { ...user, id: base64urlToBuffer(String(user.id)) },
+        excludeCredentials: descriptors(options.excludeCredentials),
+    };
+}
+/** Sign-in options JSON → `PublicKeyCredentialRequestOptions`. */
+export function requestOptionsFromJSON(json) {
+    const options = (json.publicKey ?? json);
+    return {
+        ...options,
+        challenge: base64urlToBuffer(String(options.challenge)),
+        allowCredentials: descriptors(options.allowCredentials),
+    };
+}
+/** A `PublicKeyCredential` from `navigator.credentials.create()` or `.get()` → the JSON Sovaria verifies. */
+export function credentialToJSON(credential) {
+    const response = credential.response;
+    const out = { clientDataJSON: bufferToBase64url(response.clientDataJSON) };
+    if ('attestationObject' in response) {
+        const attestation = response;
+        out.attestationObject = bufferToBase64url(attestation.attestationObject);
+        const transports = typeof attestation.getTransports === 'function' ? attestation.getTransports() : [];
+        // `transports` is the WebAuthn JSON name; Sovaria also reads `getTransports` to remember them.
+        out.transports = transports;
+        out.getTransports = transports;
+    }
+    if ('authenticatorData' in response) {
+        const assertion = response;
+        out.authenticatorData = bufferToBase64url(assertion.authenticatorData);
+        out.signature = bufferToBase64url(assertion.signature);
+        if (assertion.userHandle)
+            out.userHandle = bufferToBase64url(assertion.userHandle);
+    }
+    return {
+        id: credential.id,
+        rawId: bufferToBase64url(credential.rawId),
+        type: credential.type,
+        response: out,
+        authenticatorAttachment: credential.authenticatorAttachment ?? undefined,
+        clientExtensionResults: typeof credential.getClientExtensionResults === 'function' ? credential.getClientExtensionResults() : {},
+    };
+}
+/** True when this environment can create and use passkeys. */
+export function passkeysSupported() {
+    return typeof globalThis.PublicKeyCredential !== 'undefined' && Boolean(globalThis.navigator?.credentials);
+}

package/dist/perf.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Client performance monitoring: what your users actually wait for, joined to the server's side of each request.
+ *
+ * ```ts
+ * sov.perf.install({ release: '1.4.2' })              // web vitals + timing of every Sovaria request
+ * await sov.perf.trace('checkout', () => pay(cart))   // your own timed step
+ * ```
+ *
+ * - **Web vitals** (browsers, PerformanceObserver): LCP, INP (slowest interaction), CLS, FCP and TTFB, once per
+ *   page load, tagged with the page's route (`/orders/:id`; ids are collapsed on the server).
+ * - **Network spans**: every request the SDK makes, with its method, route, status and duration. Each carries
+ *   the W3C `traceparent` the SDK sent, so in the console a slow call opens the server trace for that request,
+ *   and each route's client time sits next to the gateway's server time.
+ * - **Custom traces**: `trace(name, fn)` or `start(name)` → `end()`.
+ *
+ * Measurements are batched (every 10 s, at most 100 per request, and when the page is hidden) and count
+ * against the plan's `obs.perf_events_month`; `sampleRate` sends a share of page loads.
+ */
+export type PerfKind = 'vital' | 'network' | 'app_start' | 'screen' | 'trace';
+export interface PerfEvent {
+    kind: PerfKind;
+    name: string;
+    value: number;
+    route?: string;
+    release?: string;
+    environment?: string;
+    platform: string;
+    trace_id?: string;
+    session_id?: string;
+    timestamp: string;
+    attributes?: Record<string, string | number | boolean | null>;
+}
+export interface PerfOptions {
+    release?: string;
+    environment?: string;
+    /** 0..1: share of page loads (or app launches) that send measurements (default 1). */
+    sampleRate?: number;
+    /** Time the SDK's own requests (default true). */
+    network?: boolean;
+    /** Web vitals in browsers (default true). */
+    webVitals?: boolean;
+    /** Change or drop (return null) a measurement before it is queued. */
+    beforeSend?: (event: PerfEvent) => PerfEvent | null;
+}
+type Sender = (events: PerfEvent[]) => Promise<unknown>;
+export declare class PerfMonitor {
+    private readonly send;
+    private readonly session;
+    private options;
+    private queue;
+    private timer?;
+    private uninstallers;
+    private sampled;
+    installed: boolean;
+    constructor(send: Sender, session?: () => string | undefined);
+    install(options?: PerfOptions): () => void;
+    uninstall(): void;
+    /** Whether the SDK should time its own requests. */
+    get timesNetwork(): boolean;
+    /** Queue one measurement (any kind). Returns false when not installed, not sampled or dropped. */
+    record(event: Omit<PerfEvent, 'platform' | 'timestamp' | 'release' | 'environment'> & Partial<PerfEvent>): boolean;
+    /** A network span for one request (called by the client for its own requests). */
+    network(method: string, path: string, status: number, durationMs: number, traceId?: string): void;
+    /** Time `fn` as a custom trace called `name` (also when it throws). */
+    trace<T>(name: string, fn: () => Promise<T> | T, attributes?: PerfEvent['attributes']): Promise<T>;
+    /** Start a custom trace; call the returned function to end it. */
+    start(name: string, attributes?: PerfEvent['attributes']): () => void;
+    /** Send queued measurements now. */
+    flush(): Promise<void>;
+    private vitals;
+    private observeVitals;
+    /** LCP, CLS and INP are final when the page is hidden: report them once per page load. */
+    private reportPageVitals;
+}
+export declare function currentRoute(): string | undefined;
+export {};

package/dist/perf.js

@@ -0,0 +1,212 @@
+/**
+ * Client performance monitoring: what your users actually wait for, joined to the server's side of each request.
+ *
+ * ```ts
+ * sov.perf.install({ release: '1.4.2' })              // web vitals + timing of every Sovaria request
+ * await sov.perf.trace('checkout', () => pay(cart))   // your own timed step
+ * ```
+ *
+ * - **Web vitals** (browsers, PerformanceObserver): LCP, INP (slowest interaction), CLS, FCP and TTFB, once per
+ *   page load, tagged with the page's route (`/orders/:id`; ids are collapsed on the server).
+ * - **Network spans**: every request the SDK makes, with its method, route, status and duration. Each carries
+ *   the W3C `traceparent` the SDK sent, so in the console a slow call opens the server trace for that request,
+ *   and each route's client time sits next to the gateway's server time.
+ * - **Custom traces**: `trace(name, fn)` or `start(name)` → `end()`.
+ *
+ * Measurements are batched (every 10 s, at most 100 per request, and when the page is hidden) and count
+ * against the plan's `obs.perf_events_month`; `sampleRate` sends a share of page loads.
+ */
+const FLUSH_MS = 10_000;
+const MAX_QUEUE = 500;
+export class PerfMonitor {
+    send;
+    session;
+    options = {};
+    queue = [];
+    timer;
+    uninstallers = [];
+    sampled = true;
+    installed = false;
+    constructor(send, session = () => undefined) {
+        this.send = send;
+        this.session = session;
+    }
+    install(options = {}) {
+        this.options = options;
+        if (this.installed)
+            return () => this.uninstall();
+        this.installed = true;
+        this.sampled = Math.random() < (options.sampleRate ?? 1);
+        const g = globalThis;
+        if (options.webVitals !== false && typeof g.PerformanceObserver === 'function')
+            this.observeVitals(g);
+        if (typeof g.addEventListener === 'function') {
+            const onHide = () => {
+                if (g.document?.visibilityState === 'hidden' || !g.document)
+                    this.reportPageVitals();
+                void this.flush();
+            };
+            g.addEventListener('visibilitychange', onHide);
+            g.addEventListener('pagehide', onHide);
+            this.uninstallers.push(() => {
+                g.removeEventListener?.('visibilitychange', onHide);
+                g.removeEventListener?.('pagehide', onHide);
+            });
+        }
+        this.timer = setInterval(() => void this.flush(), FLUSH_MS);
+        this.timer.unref?.();
+        return () => this.uninstall();
+    }
+    uninstall() {
+        for (const off of this.uninstallers.splice(0))
+            off();
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.installed = false;
+    }
+    /** Whether the SDK should time its own requests. */
+    get timesNetwork() {
+        return this.installed && this.sampled && this.options.network !== false;
+    }
+    /** Queue one measurement (any kind). Returns false when not installed, not sampled or dropped. */
+    record(event) {
+        if (!this.installed || !this.sampled || !Number.isFinite(event.value) || event.value < 0)
+            return false;
+        let full = {
+            platform: detectPlatform(), release: this.options.release, environment: this.options.environment,
+            route: event.route ?? currentRoute(), session_id: this.session(), timestamp: new Date().toISOString(), ...event,
+            value: Math.round(event.value * 1000) / 1000,
+        };
+        if (this.options.beforeSend)
+            full = this.options.beforeSend(full);
+        if (!full)
+            return false;
+        if (this.queue.length >= MAX_QUEUE)
+            this.queue.shift();
+        this.queue.push(full);
+        return true;
+    }
+    /** A network span for one request (called by the client for its own requests). */
+    network(method, path, status, durationMs, traceId) {
+        this.record({ kind: 'network', name: `${method.toUpperCase()} ${path.split('?')[0]}`, value: durationMs, trace_id: traceId,
+            attributes: { method: method.toUpperCase(), url: path.split('?')[0], status } });
+    }
+    /** Time `fn` as a custom trace called `name` (also when it throws). */
+    async trace(name, fn, attributes) {
+        const end = this.start(name, attributes);
+        try {
+            return await fn();
+        }
+        finally {
+            end();
+        }
+    }
+    /** Start a custom trace; call the returned function to end it. */
+    start(name, attributes) {
+        const t0 = now();
+        let done = false;
+        return () => {
+            if (done)
+                return;
+            done = true;
+            this.record({ kind: 'trace', name, value: now() - t0, attributes });
+        };
+    }
+    /** Send queued measurements now. */
+    async flush() {
+        while (this.queue.length) {
+            const batch = this.queue.splice(0, 100);
+            try {
+                await this.send(batch);
+            }
+            catch {
+                return; // never let monitoring break the app; the batch is dropped
+            }
+        }
+    }
+    // ── web vitals ──────────────────────────────────────────────────────────
+    vitals = { cls: 0, reported: false };
+    observeVitals(g) {
+        const observe = (type, cb, extra = {}) => {
+            try {
+                const po = new g.PerformanceObserver((list) => cb(list.getEntries()));
+                po.observe({ type, buffered: true, ...extra });
+                this.uninstallers.push(() => po.disconnect());
+            }
+            catch {
+                /* not supported in this browser */
+            }
+        };
+        observe('largest-contentful-paint', (entries) => {
+            const last = entries[entries.length - 1];
+            if (last)
+                this.vitals.lcp = last.startTime;
+        });
+        let sessionValue = 0;
+        let sessionEntries = [];
+        observe('layout-shift', (entries) => {
+            for (const e of entries) {
+                if (e.hadRecentInput)
+                    continue;
+                const first = sessionEntries[0];
+                const last = sessionEntries[sessionEntries.length - 1];
+                if (sessionValue && first && last && e.startTime - last.startTime < 1000 && e.startTime - first.startTime < 5000) {
+                    sessionValue += e.value;
+                    sessionEntries.push(e);
+                }
+                else {
+                    sessionValue = e.value;
+                    sessionEntries = [e];
+                }
+                this.vitals.cls = Math.max(this.vitals.cls, sessionValue);
+            }
+        });
+        observe('event', (entries) => {
+            for (const e of entries) {
+                if (!e.interactionId)
+                    continue;
+                this.vitals.inp = Math.max(this.vitals.inp ?? 0, e.duration);
+            }
+        }, { durationThreshold: 40 });
+        observe('paint', (entries) => {
+            for (const e of entries)
+                if (e.name === 'first-contentful-paint')
+                    this.record({ kind: 'vital', name: 'FCP', value: e.startTime });
+        });
+        observe('navigation', (entries) => {
+            const nav = entries[0];
+            if (nav && nav.responseStart > 0)
+                this.record({ kind: 'vital', name: 'TTFB', value: nav.responseStart - (nav.activationStart || 0) });
+        });
+    }
+    /** LCP, CLS and INP are final when the page is hidden: report them once per page load. */
+    reportPageVitals() {
+        if (this.vitals.reported)
+            return;
+        this.vitals.reported = true;
+        if (this.vitals.lcp !== undefined)
+            this.record({ kind: 'vital', name: 'LCP', value: this.vitals.lcp });
+        this.record({ kind: 'vital', name: 'CLS', value: this.vitals.cls });
+        if (this.vitals.inp !== undefined)
+            this.record({ kind: 'vital', name: 'INP', value: this.vitals.inp });
+    }
+}
+function now() {
+    const p = globalThis.performance;
+    return p?.now ? p.now() : Date.now();
+}
+export function currentRoute() {
+    const g = globalThis;
+    return typeof g.location?.pathname === 'string' ? g.location.pathname : undefined;
+}
+function detectPlatform() {
+    const g = globalThis;
+    if (g.navigator?.product === 'ReactNative')
+        return 'react-native';
+    if (typeof g.window !== 'undefined' && typeof g.document !== 'undefined')
+        return 'web';
+    if (g.process?.versions?.node)
+        return 'node';
+    return 'javascript';
+}

package/dist/remote-config.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Remote config and feature flags: values you change in the console (Remote config) without shipping an app.
+ *
+ * ```ts
+ * sov.config.setDefaults({ checkout_v2: false, banner: 'Welcome' })
+ * await sov.config.fetchAndActivate()            // at most every 12 h unless a publish signal arrives
+ * if (sov.config.getBool('checkout_v2')) showNewCheckout()
+ * const off = sov.config.onUpdate((keys) => rerender(keys))   // live: Pulse tells the app a version was published
+ * ```
+ *
+ * The server evaluates targeting (platform, app version, country, language, your attributes, audiences, percent
+ * rollouts, experiments) and returns only this user's values — never the rules. Responses carry an ETag, so an
+ * unchanged config costs a 304. Activated values persist in the storage you pass, so the app starts with the last
+ * values even offline. Reading a value that's part of an experiment logs one `$exposure` analytics event.
+ */
+import type { Analytics } from './analytics.js';
+import type { OfflineStorage } from './offline.js';
+export type ConfigValue = string | number | boolean | null | Record<string, unknown> | unknown[];
+export interface RemoteConfigSettings {
+    /** Minimum time between network fetches (default 12 h, like Firebase). A publish signal bypasses it. */
+    minimumFetchIntervalMs?: number;
+    storage?: OfflineStorage;
+    /** Targeting attributes (`props.<name>` in conditions), e.g. { plan: 'pro', beta: true }. */
+    attributes?: Record<string, string | number | boolean | null>;
+    appVersion?: string;
+    platform?: string;
+    language?: string;
+    /** Listen for publishes over realtime (default true when the plan has config.realtime). */
+    realtime?: boolean;
+}
+interface FetchResult {
+    version: number;
+    values: Record<string, ConfigValue>;
+    experiments: Record<string, {
+        id: string;
+        variant: string;
+    }>;
+    etag: string;
+    realtime_channel?: string | null;
+}
+type Fetcher = (query: Record<string, string>, etag?: string) => Promise<{
+    status: 200 | 304;
+    body?: FetchResult;
+}>;
+type Listen = (channel: string, onMessage: () => void) => {
+    close: () => void;
+};
+export declare class RemoteConfig {
+    private readonly fetcher;
+    private readonly analytics;
+    private readonly listen?;
+    private defaults;
+    private active;
+    private fetched;
+    private lastFetch;
+    private settingsValue;
+    private listeners;
+    private channel?;
+    private loaded?;
+    constructor(fetcher: Fetcher, analytics: Analytics, listen?: Listen | undefined);
+    settings(s: RemoteConfigSettings): void;
+    setDefaults(defaults: Record<string, ConfigValue>): void;
+    private restore;
+    /** Fetch from the server (respecting the minimum interval unless `force`). True when new values arrived. */
+    fetch(opts?: {
+        force?: boolean;
+    }): Promise<boolean>;
+    /** Make fetched values the ones `get*` returns. True when something changed. */
+    activate(): Promise<boolean>;
+    fetchAndActivate(opts?: {
+        force?: boolean;
+    }): Promise<boolean>;
+    private ensureListening;
+    /** Called with the changed keys whenever new values are activated (after a publish, live). */
+    onUpdate(cb: (keys: string[]) => void): () => void;
+    private read;
+    getValue(key: string, fallback?: ConfigValue): ConfigValue | undefined;
+    getBool(key: string, fallback?: boolean): boolean;
+    getString(key: string, fallback?: string): string;
+    getNumber(key: string, fallback?: number): number;
+    getJson<T = unknown>(key: string, fallback: T): T;
+    /** Every key with its current value (defaults included). Doesn't log exposures. */
+    getAll(): Record<string, ConfigValue>;
+    /** The published version these values came from (0 before the first fetch). */
+    get version(): number;
+}
+export {};

package/dist/remote-config.js

@@ -0,0 +1,182 @@
+/**
+ * Remote config and feature flags: values you change in the console (Remote config) without shipping an app.
+ *
+ * ```ts
+ * sov.config.setDefaults({ checkout_v2: false, banner: 'Welcome' })
+ * await sov.config.fetchAndActivate()            // at most every 12 h unless a publish signal arrives
+ * if (sov.config.getBool('checkout_v2')) showNewCheckout()
+ * const off = sov.config.onUpdate((keys) => rerender(keys))   // live: Pulse tells the app a version was published
+ * ```
+ *
+ * The server evaluates targeting (platform, app version, country, language, your attributes, audiences, percent
+ * rollouts, experiments) and returns only this user's values — never the rules. Responses carry an ETag, so an
+ * unchanged config costs a 304. Activated values persist in the storage you pass, so the app starts with the last
+ * values even offline. Reading a value that's part of an experiment logs one `$exposure` analytics event.
+ */
+const KEY = 'sovaria.config.active';
+const TWELVE_HOURS = 12 * 60 * 60 * 1000;
+export class RemoteConfig {
+    fetcher;
+    analytics;
+    listen;
+    defaults = {};
+    active = null;
+    fetched = null;
+    lastFetch = 0;
+    settingsValue = {};
+    listeners = new Set();
+    channel;
+    loaded;
+    constructor(fetcher, analytics, listen) {
+        this.fetcher = fetcher;
+        this.analytics = analytics;
+        this.listen = listen;
+    }
+    settings(s) {
+        this.settingsValue = { ...this.settingsValue, ...s };
+        this.loaded = this.restore();
+    }
+    setDefaults(defaults) {
+        this.defaults = { ...defaults };
+    }
+    async restore() {
+        try {
+            const raw = await this.settingsValue.storage?.get(KEY);
+            if (raw && !this.active)
+                this.active = JSON.parse(raw);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    /** Fetch from the server (respecting the minimum interval unless `force`). True when new values arrived. */
+    async fetch(opts = {}) {
+        await this.loaded;
+        const now = Date.now();
+        const interval = this.settingsValue.minimumFetchIntervalMs ?? TWELVE_HOURS;
+        if (!opts.force && this.lastFetch && now - this.lastFetch < interval)
+            return false;
+        const s = this.settingsValue;
+        const query = { anon_id: this.analytics.anonId };
+        if (s.platform)
+            query.platform = s.platform;
+        if (s.appVersion)
+            query.app_version = s.appVersion;
+        if (s.language)
+            query.language = s.language;
+        if (s.attributes && Object.keys(s.attributes).length)
+            query.attrs = JSON.stringify(s.attributes);
+        const res = await this.fetcher(query, (this.fetched ?? this.active)?.etag);
+        this.lastFetch = now;
+        if (res.status === 304 || !res.body)
+            return false;
+        this.fetched = res.body;
+        if (res.body.realtime_channel && s.realtime !== false)
+            this.ensureListening(res.body.realtime_channel);
+        return true;
+    }
+    /** Make fetched values the ones `get*` returns. True when something changed. */
+    async activate() {
+        if (!this.fetched || this.fetched.etag === this.active?.etag)
+            return false;
+        const before = this.active?.values ?? {};
+        this.active = this.fetched;
+        try {
+            await this.settingsValue.storage?.set(KEY, JSON.stringify(this.active));
+        }
+        catch {
+            /* best effort */
+        }
+        const keys = new Set([...Object.keys(before), ...Object.keys(this.active.values)]);
+        const changed = [...keys].filter((k) => JSON.stringify(before[k]) !== JSON.stringify(this.active.values[k]));
+        if (changed.length)
+            for (const cb of this.listeners)
+                cb(changed);
+        return changed.length > 0;
+    }
+    async fetchAndActivate(opts = {}) {
+        try {
+            await this.fetch(opts);
+        }
+        catch {
+            return false; // offline: keep the last activated values (or defaults)
+        }
+        return this.activate();
+    }
+    ensureListening(channel) {
+        if (this.channel || !this.listen)
+            return;
+        try {
+            this.channel = this.listen(channel, () => void this.fetchAndActivate({ force: true }));
+        }
+        catch {
+            /* realtime is optional */
+        }
+    }
+    /** Called with the changed keys whenever new values are activated (after a publish, live). */
+    onUpdate(cb) {
+        this.listeners.add(cb);
+        return () => {
+            this.listeners.delete(cb);
+            if (!this.listeners.size) {
+                this.channel?.close();
+                this.channel = undefined;
+            }
+        };
+    }
+    read(key) {
+        const active = this.active;
+        if (active && key in active.values) {
+            const exp = active.experiments?.[key];
+            if (exp)
+                this.analytics.trackExposure(exp.id, exp.variant);
+            return active.values[key];
+        }
+        return this.defaults[key];
+    }
+    getValue(key, fallback) {
+        const v = this.read(key);
+        return v === undefined || v === null ? fallback : v;
+    }
+    getBool(key, fallback = false) {
+        const v = this.read(key);
+        if (typeof v === 'boolean')
+            return v;
+        if (v === 'true' || v === 1)
+            return true;
+        if (v === 'false' || v === 0)
+            return false;
+        return fallback;
+    }
+    getString(key, fallback = '') {
+        const v = this.read(key);
+        return v === undefined || v === null ? fallback : typeof v === 'string' ? v : JSON.stringify(v);
+    }
+    getNumber(key, fallback = 0) {
+        const v = this.read(key);
+        const n = typeof v === 'number' ? v : typeof v === 'string' ? Number(v) : NaN;
+        return Number.isFinite(n) ? n : fallback;
+    }
+    getJson(key, fallback) {
+        const v = this.read(key);
+        if (v === undefined || v === null)
+            return fallback;
+        if (typeof v === 'string') {
+            try {
+                return JSON.parse(v);
+            }
+            catch {
+                return fallback;
+            }
+        }
+        return v;
+    }
+    /** Every key with its current value (defaults included). Doesn't log exposures. */
+    getAll() {
+        return { ...this.defaults, ...(this.active?.values ?? {}) };
+    }
+    /** The published version these values came from (0 before the first fetch). */
+    get version() {
+        return this.active?.version ?? 0;
+    }
+}