@reticlehq/server 3.7.0 → 3.8.1

package/dist/portal/bridge/origin/origin-follow.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Canonical comparable form of a WS `Origin`. Web origins collapse to scheme://host[:port]. An
+ * OPAQUE origin — a desktop webview (`tauri://localhost`, `app://.`) or `file://`, whose `URL.origin`
+ * is the string "null" — is kept VERBATIM instead, so it survives into the allow-list and can be
+ * compared. Collapsing those to "null" would both merge every desktop scheme into one bucket and
+ * feed an unparseable string to `new URL`. Returns null only for a header that is not an origin.
+ */
+export declare function normalizeOrigin(origin: string): string | null;
+/** One move the host is asked to allow. */
+export interface OriginFollowRequest {
+    /** The session the new page claims, as its HELLO names it. */
+    sessionId: string;
+    /** The origin this session was last admitted from. */
+    from: string;
+    /** The origin the new page dialled from. */
+    to: string;
+    /** The page address the new page reports. Its origin is `to`. */
+    url: string;
+}
+/** The host's decision. Return `true` only for a navigation the host's own drive caused. */
+export type FollowNavigation = (request: OriginFollowRequest) => boolean;
+/** True for an http(s) origin. Only a web page can follow; opaque and other schemes cannot. */
+export declare function isWebOrigin(origin: string): boolean;
+export declare class OriginFollower {
+    #private;
+    constructor(policy: FollowNavigation);
+    /** True when a page on this normalized origin may be judged at its HELLO: web origins only. */
+    mayDial(origin: string | null): boolean;
+    /** Record the origin a session was admitted from. Non-web origins are never followed. */
+    remember(sessionId: string, origin: string | null): void;
+    /**
+     * Why this HELLO may not follow to `to`, or undefined when it may.
+     *
+     * A policy that throws refuses: a failure to decide is never permission.
+     */
+    refusal(hello: {
+        sessionId: string;
+        url: string;
+    }, to: string): string | undefined;
+}
+/** Close reasons for a refused follow. Each is under the 123-byte limit of a close frame. */
+export declare const FollowRefusal: {
+    readonly UNKNOWN_SESSION: "refused: a page on a new origin may only continue a session this bridge admitted";
+    readonly URL_MISMATCH: "refused: the page address is not on the origin the socket dialled from";
+    readonly POLICY_REFUSED: "refused: the host did not allow this session to follow to the new origin";
+};

package/dist/portal/bridge/origin/origin-follow.js

@@ -0,0 +1,110 @@
+/**
+ * Let a session follow its own top-level navigation to another origin, when the host says so.
+ *
+ * The bridge checks a WebSocket's `Origin` against an allow-list fixed when the bridge is built. A
+ * daemon on a developer's machine never needs more: the app is on localhost. A hosted verifier does.
+ * A journey that starts on `www.wikipedia.org` and clicks through to `en.wikipedia.org` loads a new
+ * page on a new origin, and the injected SDK in it dials the same bridge with the same session id.
+ * The bridge refused it, so the drive lost its session on the step it was there to check.
+ *
+ * Nothing is followed by default. The host passes `followNavigation`, and the bridge asks it only
+ * after every other gate has passed. A page on an origin nobody admitted may follow only when ALL of
+ * these hold:
+ *
+ *  - its HELLO names a session this bridge already admitted: first from an allowed origin, then from
+ *    each origin it followed to. A new origin can never START a session, so an arbitrary page cannot
+ *    open one of its own;
+ *  - its HELLO passed the token or nonce check, the same as any other page;
+ *  - the page address in the HELLO is on the origin the socket came from;
+ *  - the host returns `true` for this move. The host is the one party that knows whether its own
+ *    drive caused the navigation (its browser's top frame is now on `to`), so it decides.
+ */
+import { OPAQUE_ORIGIN } from '@reticlehq/core';
+/**
+ * Canonical comparable form of a WS `Origin`. Web origins collapse to scheme://host[:port]. An
+ * OPAQUE origin — a desktop webview (`tauri://localhost`, `app://.`) or `file://`, whose `URL.origin`
+ * is the string "null" — is kept VERBATIM instead, so it survives into the allow-list and can be
+ * compared. Collapsing those to "null" would both merge every desktop scheme into one bucket and
+ * feed an unparseable string to `new URL`. Returns null only for a header that is not an origin.
+ */
+export function normalizeOrigin(origin) {
+    if (origin === OPAQUE_ORIGIN)
+        return OPAQUE_ORIGIN;
+    try {
+        const web = new URL(origin).origin;
+        return web === OPAQUE_ORIGIN ? origin : web;
+    }
+    catch {
+        return null;
+    }
+}
+/** Origins remembered per session. Bounded so a long-lived bridge does not grow without end. */
+const MAX_REMEMBERED = 1000;
+const WEB_PROTOCOLS = new Set(['http:', 'https:']);
+/** True for an http(s) origin. Only a web page can follow; opaque and other schemes cannot. */
+export function isWebOrigin(origin) {
+    try {
+        return WEB_PROTOCOLS.has(new URL(origin).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+function originOf(url) {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+export class OriginFollower {
+    #policy;
+    /** The origin each session was last admitted from. Insertion order is age, for the bound. */
+    #admitted = new Map();
+    constructor(policy) {
+        this.#policy = policy;
+    }
+    /** True when a page on this normalized origin may be judged at its HELLO: web origins only. */
+    mayDial(origin) {
+        return origin !== null && isWebOrigin(origin);
+    }
+    /** Record the origin a session was admitted from. Non-web origins are never followed. */
+    remember(sessionId, origin) {
+        if (!this.mayDial(origin) || null === origin)
+            return;
+        this.#admitted.delete(sessionId);
+        this.#admitted.set(sessionId, origin);
+        if (this.#admitted.size > MAX_REMEMBERED) {
+            const oldest = this.#admitted.keys().next().value;
+            if (oldest !== undefined)
+                this.#admitted.delete(oldest);
+        }
+    }
+    /**
+     * Why this HELLO may not follow to `to`, or undefined when it may.
+     *
+     * A policy that throws refuses: a failure to decide is never permission.
+     */
+    refusal(hello, to) {
+        const from = this.#admitted.get(hello.sessionId);
+        if (from === undefined)
+            return FollowRefusal.UNKNOWN_SESSION;
+        if (originOf(hello.url) !== to)
+            return FollowRefusal.URL_MISMATCH;
+        let allowed = false;
+        try {
+            allowed = this.#policy({ sessionId: hello.sessionId, from, to, url: hello.url });
+        }
+        catch {
+            allowed = false;
+        }
+        return allowed ? undefined : FollowRefusal.POLICY_REFUSED;
+    }
+}
+/** Close reasons for a refused follow. Each is under the 123-byte limit of a close frame. */
+export const FollowRefusal = {
+    UNKNOWN_SESSION: 'refused: a page on a new origin may only continue a session this bridge admitted',
+    URL_MISMATCH: 'refused: the page address is not on the origin the socket dialled from',
+    POLICY_REFUSED: 'refused: the host did not allow this session to follow to the new origin',
+};

package/dist/portal/bridge/pairing-token.d.ts

@@ -42,6 +42,12 @@ export declare function pairingTokenSource(input: {
  * the daemon refuse the only app it was started to verify (#1251).
  */
 export declare function configuredPairingToken(env: NodeJS.ProcessEnv, deps: PairingTokenDeps): Promise<string | undefined>;
+/**
+ * The token a local command shows the daemon: `RETICLE_TOKEN`, else the stored file. Never creates
+ * one, because a new token is not the token the running daemon holds.
+ */
+export declare function storedPairingToken(env?: NodeJS.ProcessEnv): string | undefined;
+/** The token file in `dir`, with `dir` resolved by the same rule as `RETICLE_PAIRING_TOKEN_DIR`. */
 export declare function pairingTokenPath(dir: string): string;
 /** Production IO adapter: 0600 file + 0700 dir so only the owner can read the secret. */
 export declare function nodePairingTokenDeps(): PairingTokenDeps;

package/dist/portal/bridge/pairing-token.js

@@ -2,18 +2,29 @@ import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { ReticleDir, ReticleEnv } from '@reticlehq/core';
+import { isAbsolute, join, resolve, sep } from 'node:path';
+import { ReticleDir, ReticleEnv, resolveStateDir } from '@reticlehq/core';
+import { log } from '../../log.js';
 /** 24 random bytes → 48 hex chars: well under MAX_TOKEN_LENGTH, ample entropy for a local secret. */
 const TOKEN_BYTES = 24;
 /** Env override for the token directory (`RETICLE_PAIRING_TOKEN_DIR`) — relocate the secret off $HOME. */
 export const PAIRING_TOKEN_DIR_ENV = ReticleEnv.PAIRING_TOKEN_DIR;
+/** The warnings already written, so that each one is written once for each process. */
+const warnedOnce = new Set();
+function warnOnce(warning) {
+    if (warnedOnce.has(warning)) {
+        return;
+    }
+    warnedOnce.add(warning);
+    log('state_dir_warning', { warning });
+}
+/** The token folder for `override`, by the shared rule. A setting that cannot be used warns and never throws. */
+function tokenDir(override) {
+    return resolveStateDir(override, join(homedir(), ReticleDir.ROOT), { isAbsolute, resolve, sep }, warnOnce);
+}
 /** The default directory that holds the token — the per-user ~/.reticle so it's shared across projects. */
 export function defaultPairingTokenDir() {
-    const override = process.env[PAIRING_TOKEN_DIR_ENV];
-    if (override !== undefined && override.length > 0)
-        return override;
-    return join(homedir(), ReticleDir.ROOT);
+    return tokenDir(process.env[PAIRING_TOKEN_DIR_ENV]);
 }
 /**
  * Which of the three sources supplied the token this process is using.
@@ -58,8 +69,26 @@ export async function configuredPairingToken(env, deps) {
         return undefined;
     return readOrCreatePairingToken(dir, deps);
 }
+/**
+ * The token a local command shows the daemon: `RETICLE_TOKEN`, else the stored file. Never creates
+ * one, because a new token is not the token the running daemon holds.
+ */
+export function storedPairingToken(env = process.env) {
+    const fromEnv = env[ReticleEnv.TOKEN]?.trim();
+    if (fromEnv !== undefined && 0 < fromEnv.length) {
+        return fromEnv;
+    }
+    try {
+        const stored = readFileSync(pairingTokenPath(defaultPairingTokenDir()), 'utf8').trim();
+        return 0 < stored.length ? stored : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The token file in `dir`, with `dir` resolved by the same rule as `RETICLE_PAIRING_TOKEN_DIR`. */
 export function pairingTokenPath(dir) {
-    return join(dir, ReticleDir.PAIRING_TOKEN_FILE);
+    return join(tokenDir(dir), ReticleDir.PAIRING_TOKEN_FILE);
 }
 /** Production IO adapter: 0600 file + 0700 dir so only the owner can read the secret. */
 export function nodePairingTokenDeps() {
@@ -82,9 +111,10 @@ export function nodePairingTokenDeps() {
  * fails, so the caller degrades to the prior tokenless behavior rather than bricking the daemon.
  */
 export async function readOrCreatePairingToken(dir, deps) {
-    const path = pairingTokenPath(dir);
+    const folder = tokenDir(dir);
+    const file = join(folder, ReticleDir.PAIRING_TOKEN_FILE);
     try {
-        const existing = (await deps.readFile(path)).trim();
+        const existing = (await deps.readFile(file)).trim();
         if (existing.length > 0)
             return existing;
     }
@@ -95,8 +125,8 @@ export async function readOrCreatePairingToken(dir, deps) {
         const token = deps.randomToken().trim();
         if (0 === token.length)
             return undefined;
-        await deps.mkdir(dir);
-        await deps.writeFile(path, token);
+        await deps.mkdir(folder);
+        await deps.writeFile(file, token);
         return token;
     }
     catch {
@@ -108,9 +138,10 @@ export async function readOrCreatePairingToken(dir, deps) {
  * synchronous, and a snippet printed with no token is a page that can never authenticate.
  */
 export function readOrCreatePairingTokenSync(dir) {
-    const path = pairingTokenPath(dir);
+    const folder = tokenDir(dir);
+    const file = join(folder, ReticleDir.PAIRING_TOKEN_FILE);
     try {
-        const existing = readFileSync(path, 'utf8').trim();
+        const existing = readFileSync(file, 'utf8').trim();
         if (existing.length > 0)
             return existing;
     }
@@ -121,9 +152,9 @@ export function readOrCreatePairingTokenSync(dir) {
         const token = randomBytes(TOKEN_BYTES).toString('hex');
         if (0 === token.length)
             return undefined;
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-        writeFileSync(path, token, { encoding: 'utf8', mode: 0o600 });
-        chmodSync(path, 0o600);
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        writeFileSync(file, token, { encoding: 'utf8', mode: 0o600 });
+        chmodSync(file, 0o600);
         return token;
     }
     catch {

package/dist/portal/bridge/protocol-skew.d.ts

@@ -1,3 +1,4 @@
+import type { RefusedPage } from '../session/session-manager.js';
 /**
  * Which side of a protocol mismatch is the stale one, and therefore what to tell the user to do.
  *
@@ -22,8 +23,11 @@
  */
 /** The page is older than the daemon: its SDK cannot speak the protocol the daemon expects. */
 export declare const BROWSER_IS_OLDER = "protocol mismatch \u2014 upgrade @reticlehq/browser in this app";
-/** The daemon is older than the page. Usually an npx cache serving a stale @reticlehq/server. */
-export declare const DAEMON_IS_OLDER = "protocol mismatch \u2014 the daemon is older; run `reticle stop`, then retry";
+/**
+ * The daemon is older than the page. Usually an npx cache serving a stale @reticlehq/server. The
+ * MCP server starts the daemon, so it is named first: a stop alone brings the same old daemon back.
+ */
+export declare const DAEMON_IS_OLDER = "protocol mismatch \u2014 the daemon is older; update the MCP server or plugin, then `reticle stop`";
 /** The versions disagree but not in a direction we can read. */
 export declare const SKEW_UNKNOWN = "protocol version mismatch \u2014 @reticlehq/browser and server disagree";
 /** The cap a WebSocket close reason must fit inside, in bytes. */
@@ -35,3 +39,24 @@ export declare const CLOSE_REASON_MAX_BYTES = 123;
  * all falls back to naming both, which is vague but never actively misleading.
  */
 export declare const protocolSkewReason: (got: number | null, expected: number) => string;
+/**
+ * When a message fails the strict schema, detect the specific case of a HELLO whose protocolVersion
+ * differs from ours — so we can tell the operator "upgrade @reticlehq/browser" instead of dropping the
+ * connection into the generic NO_SESSION_CONNECTED path, which misdiagnoses it as a port mismatch.
+ * Returns the mismatched version, or null when it isn't a version-mismatched HELLO.
+ */
+export declare function helloProtocolMismatch(text: string): number | null;
+/**
+ * What a HELLO says about the page it came from, read loosely enough to survive the schema failing.
+ * Null when the message is not a hello at all — only an SDK sends one, so only then is a refusal
+ * evidence about an app.
+ */
+export declare function peekHelloPage(text: string): RefusedPage | null;
+/**
+ * The `kind` and event `type` of a frame that failed the schema, for the log: never its payload,
+ * which can carry anything the page sent. Each is a bounded string or absent.
+ */
+export declare function peekFrameKind(text: string): {
+    kind?: string;
+    eventType?: string;
+};

package/dist/portal/bridge/protocol-skew.js

@@ -1,3 +1,4 @@
+import { MessageKind, RETICLE_PROTOCOL_VERSION } from '@reticlehq/core';
 /**
  * Which side of a protocol mismatch is the stale one, and therefore what to tell the user to do.
  *
@@ -22,8 +23,11 @@
  */
 /** The page is older than the daemon: its SDK cannot speak the protocol the daemon expects. */
 export const BROWSER_IS_OLDER = 'protocol mismatch — upgrade @reticlehq/browser in this app';
-/** The daemon is older than the page. Usually an npx cache serving a stale @reticlehq/server. */
-export const DAEMON_IS_OLDER = 'protocol mismatch — the daemon is older; run `reticle stop`, then retry';
+/**
+ * The daemon is older than the page. Usually an npx cache serving a stale @reticlehq/server. The
+ * MCP server starts the daemon, so it is named first: a stop alone brings the same old daemon back.
+ */
+export const DAEMON_IS_OLDER = 'protocol mismatch — the daemon is older; update the MCP server or plugin, then `reticle stop`';
 /** The versions disagree but not in a direction we can read. */
 export const SKEW_UNKNOWN = 'protocol version mismatch — @reticlehq/browser and server disagree';
 /** The cap a WebSocket close reason must fit inside, in bytes. */
@@ -43,3 +47,63 @@ export const protocolSkewReason = (got, expected) => {
         return DAEMON_IS_OLDER;
     return SKEW_UNKNOWN;
 };
+/**
+ * When a message fails the strict schema, detect the specific case of a HELLO whose protocolVersion
+ * differs from ours — so we can tell the operator "upgrade @reticlehq/browser" instead of dropping the
+ * connection into the generic NO_SESSION_CONNECTED path, which misdiagnoses it as a port mismatch.
+ * Returns the mismatched version, or null when it isn't a version-mismatched HELLO.
+ */
+export function helloProtocolMismatch(text) {
+    try {
+        const json = JSON.parse(text);
+        if (json.kind === MessageKind.HELLO &&
+            'number' === typeof json.protocolVersion &&
+            json.protocolVersion !== RETICLE_PROTOCOL_VERSION) {
+            return json.protocolVersion;
+        }
+    }
+    catch {
+        /* not JSON — fall through to the generic invalid-message path */
+    }
+    return null;
+}
+/**
+ * What a HELLO says about the page it came from, read loosely enough to survive the schema failing.
+ * Null when the message is not a hello at all — only an SDK sends one, so only then is a refusal
+ * evidence about an app.
+ */
+export function peekHelloPage(text) {
+    try {
+        const json = JSON.parse(text);
+        if (json.kind !== MessageKind.HELLO)
+            return null;
+        return {
+            ...('string' === typeof json.url ? { url: json.url } : {}),
+            ...('string' === typeof json.projectId ? { projectId: json.projectId } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The `kind` and event `type` of a frame that failed the schema, for the log: never its payload,
+ * which can carry anything the page sent. Each is a bounded string or absent.
+ */
+export function peekFrameKind(text) {
+    const short = (v) => 'string' === typeof v ? v.slice(0, MAX_LOGGED_FRAME_FIELD) : undefined;
+    try {
+        const json = JSON.parse(text);
+        const kind = short(json?.kind);
+        const eventType = short(json?.event?.type);
+        return {
+            ...(kind === undefined ? {} : { kind }),
+            ...(eventType === undefined ? {} : { eventType }),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+/** How much of a frame's `kind` or event `type` the drop log keeps. */
+const MAX_LOGGED_FRAME_FIELD = 64;

package/dist/portal/bridge/session-nonces.d.ts

@@ -0,0 +1,46 @@
+import { ProductionDrive, type ProductionGrant } from '../production/production-drive.js';
+/**
+ * Single-use HELLO tokens with a time limit, accepted beside the machine's pairing token.
+ *
+ * The pairing token is a machine-local secret, so it can never ship in a page that somebody else
+ * serves. A page on a production origin gets a nonce instead: the daemon mints it for one drive,
+ * the page presents it in its HELLO, and it stops working when the drive's time is up.
+ *
+ * Only a local caller (the MCP tools, the CLI) can mint one. Nothing on the bridge socket reaches
+ * `mint`, so a page cannot give itself a token.
+ */
+/** How long a nonce stays valid when the caller does not say: one drive. */
+export declare const SESSION_NONCE_TTL_MS: number;
+/** What a redeemed nonce grants the session that presented it. */
+export interface NonceGrant {
+    /** The page origin this nonce was minted for. The bridge admits a WebSocket from it. */
+    origin?: string;
+    expiresAt: number;
+    /** Set when the nonce was minted for a production drive. Its session runs under the policy. */
+    production?: ProductionDrive;
+}
+export interface MintOptions {
+    origin?: string;
+    ttlMs?: number;
+    production?: ProductionGrant;
+}
+export declare class SessionNonces {
+    #private;
+    constructor(deps: {
+        clock: () => number;
+        random?: () => string;
+    });
+    mint(options: MintOptions): {
+        nonce: string;
+        expiresAt: number;
+        production?: ProductionDrive;
+    };
+    /**
+     * The grant for this token, or undefined when it is not a live nonce or another session holds it.
+     * The first redeem binds the nonce to `sessionId`. The same tab may present it again (a reload
+     * sends a new HELLO); a second tab, or a replay under another id, may not.
+     */
+    redeem(token: string | undefined, sessionId: string): NonceGrant | undefined;
+    /** True while a live nonce was minted for this origin. */
+    admitsOrigin(origin: string): boolean;
+}

package/dist/portal/bridge/session-nonces.js

@@ -0,0 +1,72 @@
+import { randomBytes } from 'node:crypto';
+import { ProductionDrive } from '../production/production-drive.js';
+/**
+ * Single-use HELLO tokens with a time limit, accepted beside the machine's pairing token.
+ *
+ * The pairing token is a machine-local secret, so it can never ship in a page that somebody else
+ * serves. A page on a production origin gets a nonce instead: the daemon mints it for one drive,
+ * the page presents it in its HELLO, and it stops working when the drive's time is up.
+ *
+ * Only a local caller (the MCP tools, the CLI) can mint one. Nothing on the bridge socket reaches
+ * `mint`, so a page cannot give itself a token.
+ */
+/** How long a nonce stays valid when the caller does not say: one drive. */
+export const SESSION_NONCE_TTL_MS = 60 * 60 * 1000;
+/** 24 random bytes: the same entropy as the pairing token. */
+const NONCE_BYTES = 24;
+export class SessionNonces {
+    #entries = new Map();
+    #clock;
+    #random;
+    constructor(deps) {
+        this.#clock = deps.clock;
+        this.#random = deps.random ?? (() => randomBytes(NONCE_BYTES).toString('hex'));
+    }
+    mint(options) {
+        this.#sweep();
+        const nonce = this.#random();
+        const expiresAt = this.#clock() + (options.ttlMs ?? SESSION_NONCE_TTL_MS);
+        // One drive per nonce, shared by every reconnect of its tab, so what it created survives a reload.
+        const production = options.production === undefined
+            ? undefined
+            : new ProductionDrive({ ...options.production, expiresAt }, this.#clock);
+        this.#entries.set(nonce, {
+            ...(options.origin === undefined ? {} : { origin: options.origin }),
+            ...(production === undefined ? {} : { production }),
+            expiresAt,
+        });
+        return { nonce, expiresAt, ...(production === undefined ? {} : { production }) };
+    }
+    /**
+     * The grant for this token, or undefined when it is not a live nonce or another session holds it.
+     * The first redeem binds the nonce to `sessionId`. The same tab may present it again (a reload
+     * sends a new HELLO); a second tab, or a replay under another id, may not.
+     */
+    redeem(token, sessionId) {
+        if (token === undefined)
+            return undefined;
+        this.#sweep();
+        const entry = this.#entries.get(token);
+        if (entry === undefined)
+            return undefined;
+        if (entry.boundTo !== undefined && entry.boundTo !== sessionId)
+            return undefined;
+        entry.boundTo = sessionId;
+        return entry;
+    }
+    /** True while a live nonce was minted for this origin. */
+    admitsOrigin(origin) {
+        this.#sweep();
+        for (const entry of this.#entries.values())
+            if (entry.origin === origin)
+                return true;
+        return false;
+    }
+    #sweep() {
+        const now = this.#clock();
+        for (const [nonce, entry] of this.#entries) {
+            if (entry.expiresAt <= now)
+                this.#entries.delete(nonce);
+        }
+    }
+}

package/dist/portal/input/viewport-tools.d.ts

@@ -1,2 +1,33 @@
+import { z } from 'zod';
 import type { ToolDef } from '../../surface/tools/tool-kit.js';
+import { type LeaseEmulation, type LeaseMedia } from '../pool/lease-emulation.js';
+export declare const COLOR_SCHEME_ARG: z.ZodOptional<z.ZodEnum<{
+    light: "light";
+    dark: "dark";
+    "no-preference": "no-preference";
+}>>;
+export declare const REDUCED_MOTION_ARG: z.ZodOptional<z.ZodEnum<{
+    reduce: "reduce";
+    "no-preference": "no-preference";
+}>>;
+export declare const LEASE_EMULATE_ARG: z.ZodOptional<z.ZodObject<{
+    colorScheme: z.ZodOptional<z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+        "no-preference": "no-preference";
+    }>>;
+    reducedMotion: z.ZodOptional<z.ZodEnum<{
+        reduce: "reduce";
+        "no-preference": "no-preference";
+    }>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>>;
+/** The media part of what a caller asked for, or undefined when it asked for none. */
+export declare function mediaOf(raw: {
+    colorScheme?: unknown;
+    reducedMotion?: unknown;
+}): LeaseMedia | undefined;
+/** A lease's `emulate` argument, read; a value it does not know is refused by name. */
+export declare function leaseEmulationOf(raw: unknown): LeaseEmulation | undefined;
 export declare const VIEWPORT_TOOLS: ToolDef[];