@rynx-ai/daemon 0.1.9 → 0.1.10-beta.2

package/dist/app-browser-host-supervisor.d.ts

@@ -0,0 +1,97 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+export declare const APP_BROWSER_HOST_SIDECAR_FLAG = "--rynx-browser-host-sidecar";
+export declare const APP_BROWSER_HOST_BOOTSTRAP_TYPE = "rynx.browser-host.bootstrap";
+export declare const APP_BROWSER_HOST_READY_TYPE = "rynx.browser-host.ready";
+declare const IPC_SCHEMA_VERSION = 1;
+export interface AppBrowserHostLaunchConfig {
+    executable: string;
+    appPath?: string;
+}
+export interface AppBrowserHostBootstrapMessage {
+    type: typeof APP_BROWSER_HOST_BOOTSTRAP_TYPE;
+    schemaVersion: typeof IPC_SCHEMA_VERSION;
+    origin: string;
+    managementToken: string;
+}
+export interface AppBrowserHostReadyMessage {
+    type: typeof APP_BROWSER_HOST_READY_TYPE;
+    schemaVersion: typeof IPC_SCHEMA_VERSION;
+}
+export type AppBrowserHostSpawn = (executable: string, args: readonly string[], options: SpawnOptions) => ChildProcess;
+export interface AppBrowserHostSupervisorOptions {
+    launch: AppBrowserHostLaunchConfig;
+    bootstrap: AppBrowserHostBootstrapMessage;
+    env?: NodeJS.ProcessEnv;
+    spawnProcess?: AppBrowserHostSpawn;
+    startupTimeoutMs?: number;
+    stopTimeoutMs?: number;
+    restartDelayMs?: number;
+    /** Prevents the offscreen sidecar from competing with a live App-window Host. */
+    isDesktopHostConnected?: () => boolean;
+}
+/**
+ * Resolve the browser-host launch contract published by the desktop App.
+ *
+ * A standalone CLI/daemon never enables this supervisor. App follow and
+ * resident modes intentionally share the same contract; their lifetime policy
+ * is owned by the daemon composition root, not by this process supervisor.
+ */
+export declare function parseAppBrowserHostLaunchConfig(env?: NodeJS.ProcessEnv): AppBrowserHostLaunchConfig | undefined;
+/**
+ * Validate and copy the only secret-bearing message accepted by the sidecar.
+ * The exact-key check prevents silently widening this IPC boundary.
+ */
+export declare function parseAppBrowserHostBootstrapMessage(value: unknown): AppBrowserHostBootstrapMessage;
+/** Strict type guard for the authenticated-lease readiness acknowledgement. */
+export declare function isAppBrowserHostReadyMessage(value: unknown): value is AppBrowserHostReadyMessage;
+/**
+ * Owns the App browser-host sidecar process and its authenticated IPC
+ * bootstrap. `start` and `ensureConnected` are single-flight. A ready message
+ * means the sidecar has acquired its authenticated host lease; merely spawning
+ * the process is never considered success.
+ */
+export declare class AppBrowserHostSupervisor {
+    private readonly launch;
+    private readonly bootstrap;
+    private readonly childEnv;
+    private readonly spawnProcess;
+    private readonly startupTimeoutMs;
+    private readonly stopTimeoutMs;
+    private readonly restartDelayMs;
+    private readonly isDesktopHostConnected;
+    private child?;
+    private connectedChild?;
+    private connecting?;
+    private restarting?;
+    private restartTimer?;
+    private restartStabilityTimer?;
+    private stopOperation?;
+    private readonly terminationOperations;
+    private desired;
+    private stopped;
+    private consecutiveRestartFailures;
+    constructor(options: AppBrowserHostSupervisorOptions);
+    start(): Promise<void>;
+    /**
+     * Replaces a live process whose authenticated Host lease is no longer
+     * usable. The replacement is single-flight so concurrent Browser opens do
+     * not fan out into multiple Electron sidecars.
+     */
+    restart(): Promise<void>;
+    ensureConnected(): Promise<void>;
+    private ensureConnection;
+    stop(): Promise<void>;
+    private launchAndConnect;
+    private waitForReady;
+    private abandonFailedChild;
+    private childBecameUnavailable;
+    private scheduleRestart;
+    private cancelRestart;
+    private armRestartStabilityReset;
+    private cancelRestartStabilityReset;
+    private stopOwnedProcess;
+    private replaceOwnedProcess;
+    private terminateChild;
+    private performTerminateChild;
+}
+export {};

package/dist/app-browser-host-supervisor.js

@@ -0,0 +1,529 @@
+import { spawn, } from "node:child_process";
+import path from "node:path";
+export const APP_BROWSER_HOST_SIDECAR_FLAG = "--rynx-browser-host-sidecar";
+export const APP_BROWSER_HOST_BOOTSTRAP_TYPE = "rynx.browser-host.bootstrap";
+export const APP_BROWSER_HOST_READY_TYPE = "rynx.browser-host.ready";
+const IPC_SCHEMA_VERSION = 1;
+const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;
+const DEFAULT_STOP_TIMEOUT_MS = 5_000;
+const DEFAULT_RESTART_DELAY_MS = 250;
+const MAX_RESTART_DELAY_MS = 30_000;
+const RESTART_STABILITY_WINDOW_MS = 30_000;
+const MAX_TIMEOUT_MS = 120_000;
+const MAX_PATH_BYTES = 16 * 1024;
+const MIN_MANAGEMENT_TOKEN_BYTES = 32;
+const MAX_MANAGEMENT_TOKEN_BYTES = 256;
+/**
+ * Resolve the browser-host launch contract published by the desktop App.
+ *
+ * A standalone CLI/daemon never enables this supervisor. App follow and
+ * resident modes intentionally share the same contract; their lifetime policy
+ * is owned by the daemon composition root, not by this process supervisor.
+ */
+export function parseAppBrowserHostLaunchConfig(env = process.env) {
+    if (env.RYNX_DISTRIBUTION !== "app")
+        return undefined;
+    const executable = env.RYNX_BROWSER_HOST_EXECUTABLE;
+    if (executable === undefined) {
+        throw new Error("App distribution requires RYNX_BROWSER_HOST_EXECUTABLE");
+    }
+    const parsedExecutable = absolutePath(executable, "RYNX_BROWSER_HOST_EXECUTABLE");
+    const appPath = env.RYNX_BROWSER_HOST_APP_PATH;
+    return appPath === undefined
+        ? { executable: parsedExecutable }
+        : {
+            executable: parsedExecutable,
+            appPath: absolutePath(appPath, "RYNX_BROWSER_HOST_APP_PATH"),
+        };
+}
+/**
+ * Validate and copy the only secret-bearing message accepted by the sidecar.
+ * The exact-key check prevents silently widening this IPC boundary.
+ */
+export function parseAppBrowserHostBootstrapMessage(value) {
+    if (!isRecordWithExactKeys(value, ["type", "schemaVersion", "origin", "managementToken"])) {
+        throw new Error("invalid App browser host bootstrap message");
+    }
+    if (value.type !== APP_BROWSER_HOST_BOOTSTRAP_TYPE) {
+        throw new Error("invalid App browser host bootstrap message type");
+    }
+    if (value.schemaVersion !== IPC_SCHEMA_VERSION) {
+        throw new Error("unsupported App browser host bootstrap schema version");
+    }
+    return {
+        type: APP_BROWSER_HOST_BOOTSTRAP_TYPE,
+        schemaVersion: IPC_SCHEMA_VERSION,
+        origin: loopbackOrigin(value.origin),
+        managementToken: managementToken(value.managementToken),
+    };
+}
+/** Strict type guard for the authenticated-lease readiness acknowledgement. */
+export function isAppBrowserHostReadyMessage(value) {
+    return isRecordWithExactKeys(value, ["type", "schemaVersion"])
+        && value.type === APP_BROWSER_HOST_READY_TYPE
+        && value.schemaVersion === IPC_SCHEMA_VERSION;
+}
+/**
+ * Owns the App browser-host sidecar process and its authenticated IPC
+ * bootstrap. `start` and `ensureConnected` are single-flight. A ready message
+ * means the sidecar has acquired its authenticated host lease; merely spawning
+ * the process is never considered success.
+ */
+export class AppBrowserHostSupervisor {
+    launch;
+    bootstrap;
+    childEnv;
+    spawnProcess;
+    startupTimeoutMs;
+    stopTimeoutMs;
+    restartDelayMs;
+    isDesktopHostConnected;
+    child;
+    connectedChild;
+    connecting;
+    restarting;
+    restartTimer;
+    restartStabilityTimer;
+    stopOperation;
+    terminationOperations = new WeakMap();
+    desired = false;
+    stopped = false;
+    consecutiveRestartFailures = 0;
+    constructor(options) {
+        this.launch = validateLaunchConfig(options.launch);
+        this.bootstrap = parseAppBrowserHostBootstrapMessage(options.bootstrap);
+        this.childEnv = childEnvironment(options.env ?? process.env, this.bootstrap);
+        this.spawnProcess = options.spawnProcess ?? defaultSpawn;
+        this.startupTimeoutMs = positiveDuration(options.startupTimeoutMs, DEFAULT_STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+        this.stopTimeoutMs = positiveDuration(options.stopTimeoutMs, DEFAULT_STOP_TIMEOUT_MS, "stopTimeoutMs");
+        this.restartDelayMs = nonNegativeDuration(options.restartDelayMs, DEFAULT_RESTART_DELAY_MS, "restartDelayMs");
+        this.isDesktopHostConnected = options.isDesktopHostConnected ?? (() => false);
+    }
+    start() {
+        return this.ensureConnected();
+    }
+    /**
+     * Replaces a live process whose authenticated Host lease is no longer
+     * usable. The replacement is single-flight so concurrent Browser opens do
+     * not fan out into multiple Electron sidecars.
+     */
+    restart() {
+        if (this.stopped) {
+            return Promise.reject(new Error("App browser host supervisor is stopped"));
+        }
+        if (this.restarting)
+            return this.restarting;
+        this.desired = true;
+        if (this.isDesktopHostConnected()) {
+            this.cancelRestart();
+            return Promise.resolve();
+        }
+        this.cancelRestart();
+        const operation = this.replaceOwnedProcess();
+        this.restarting = operation;
+        void operation.then(() => {
+            if (this.restarting === operation)
+                this.restarting = undefined;
+        }, () => {
+            if (this.restarting === operation)
+                this.restarting = undefined;
+        });
+        return operation;
+    }
+    ensureConnected() {
+        if (this.restarting)
+            return this.restarting;
+        return this.ensureConnection();
+    }
+    ensureConnection() {
+        if (this.stopped) {
+            return Promise.reject(new Error("App browser host supervisor is stopped"));
+        }
+        this.desired = true;
+        if (this.connectedChild
+            && this.connectedChild === this.child
+            && childIsRunning(this.connectedChild)) {
+            return Promise.resolve();
+        }
+        if (this.isDesktopHostConnected()) {
+            this.cancelRestart();
+            return Promise.resolve();
+        }
+        if (this.connecting)
+            return this.connecting;
+        this.cancelRestart();
+        const operation = this.launchAndConnect();
+        this.connecting = operation;
+        void operation.then(() => {
+            if (this.connecting === operation)
+                this.connecting = undefined;
+        }, () => {
+            if (this.connecting === operation)
+                this.connecting = undefined;
+        });
+        return operation;
+    }
+    stop() {
+        if (this.stopOperation)
+            return this.stopOperation;
+        this.stopped = true;
+        this.desired = false;
+        this.cancelRestart();
+        this.cancelRestartStabilityReset();
+        const operation = this.stopOwnedProcess();
+        this.stopOperation = operation;
+        return operation;
+    }
+    async launchAndConnect() {
+        const args = this.launch.appPath === undefined
+            ? [APP_BROWSER_HOST_SIDECAR_FLAG]
+            : [this.launch.appPath, APP_BROWSER_HOST_SIDECAR_FLAG];
+        let child;
+        try {
+            child = this.spawnProcess(this.launch.executable, args, {
+                env: { ...this.childEnv },
+                stdio: ["ignore", "ignore", "ignore", "ipc"],
+            });
+        }
+        catch (error) {
+            throw supervisorError("failed to spawn App browser host", error);
+        }
+        this.child = child;
+        this.connectedChild = undefined;
+        const onLifecycleError = () => {
+            if (this.connectedChild === child)
+                this.abandonFailedChild(child);
+        };
+        child.on("error", onLifecycleError);
+        child.once("exit", () => {
+            child.off("error", onLifecycleError);
+            this.childBecameUnavailable(child);
+        });
+        try {
+            await this.waitForReady(child);
+            if (this.stopped
+                || this.child !== child
+                || !childIsRunning(child)) {
+                throw new Error("App browser host exited before it became ready");
+            }
+            this.connectedChild = child;
+            this.armRestartStabilityReset(child);
+        }
+        catch (error) {
+            this.abandonFailedChild(child);
+            throw supervisorError("App browser host failed to become ready", error);
+        }
+    }
+    waitForReady(child) {
+        return new Promise((resolve, reject) => {
+            let sent = false;
+            let settled = false;
+            const timer = setTimeout(() => finish(new Error("timed out waiting for App browser host readiness")), this.startupTimeoutMs);
+            timer.unref();
+            const onSpawn = () => {
+                if (settled || sent)
+                    return;
+                sent = true;
+                try {
+                    child.send(this.bootstrap, (error) => {
+                        if (error) {
+                            finish(supervisorError("failed to send App browser host bootstrap", error));
+                        }
+                    });
+                }
+                catch (error) {
+                    finish(supervisorError("failed to send App browser host bootstrap", error));
+                }
+            };
+            const onMessage = (message) => {
+                if (sent && isAppBrowserHostReadyMessage(message))
+                    finish();
+            };
+            const onError = (error) => {
+                finish(supervisorError("App browser host process error", error));
+            };
+            const onExit = (code, signal) => {
+                finish(new Error(`App browser host exited before readiness (code ${String(code)}, signal ${String(signal)})`));
+            };
+            function finish(error) {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                child.off("spawn", onSpawn);
+                child.off("message", onMessage);
+                child.off("error", onError);
+                child.off("exit", onExit);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            }
+            child.once("spawn", onSpawn);
+            child.on("message", onMessage);
+            child.once("error", onError);
+            child.once("exit", onExit);
+        });
+    }
+    abandonFailedChild(child) {
+        if (this.child !== child)
+            return;
+        if (child.pid === undefined || !childIsRunning(child)) {
+            this.childBecameUnavailable(child);
+            return;
+        }
+        void this.terminateChild(child).then(() => {
+            this.childBecameUnavailable(child);
+        }, () => {
+            // Keep ownership of a child that could not be terminated. A later
+            // explicit stop retries cleanup and surfaces the failure to its caller.
+        });
+    }
+    childBecameUnavailable(child) {
+        if (this.child !== child)
+            return;
+        this.cancelRestartStabilityReset();
+        this.child = undefined;
+        if (this.connectedChild === child)
+            this.connectedChild = undefined;
+        if (this.desired && !this.stopped)
+            this.scheduleRestart();
+    }
+    scheduleRestart() {
+        if (this.restartTimer || this.stopped || !this.desired)
+            return;
+        const maximumDelay = Math.max(this.restartDelayMs, MAX_RESTART_DELAY_MS);
+        const delay = Math.min(maximumDelay, this.restartDelayMs * 2 ** Math.min(this.consecutiveRestartFailures, 16));
+        this.consecutiveRestartFailures += 1;
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = undefined;
+            if (this.stopped || !this.desired)
+                return;
+            if (this.isDesktopHostConnected())
+                return;
+            void this.ensureConnected().catch(() => undefined);
+        }, delay);
+        this.restartTimer.unref();
+    }
+    cancelRestart() {
+        if (!this.restartTimer)
+            return;
+        clearTimeout(this.restartTimer);
+        this.restartTimer = undefined;
+    }
+    armRestartStabilityReset(child) {
+        this.cancelRestartStabilityReset();
+        this.restartStabilityTimer = setTimeout(() => {
+            this.restartStabilityTimer = undefined;
+            if (this.connectedChild === child
+                && this.child === child
+                && childIsRunning(child)) {
+                this.consecutiveRestartFailures = 0;
+            }
+        }, RESTART_STABILITY_WINDOW_MS);
+        this.restartStabilityTimer.unref();
+    }
+    cancelRestartStabilityReset() {
+        if (!this.restartStabilityTimer)
+            return;
+        clearTimeout(this.restartStabilityTimer);
+        this.restartStabilityTimer = undefined;
+    }
+    async stopOwnedProcess() {
+        const child = this.child;
+        if (child)
+            await this.terminateChild(child);
+        const connecting = this.connecting;
+        if (connecting)
+            await connecting.catch(() => undefined);
+        if (this.child && this.child !== child) {
+            await this.terminateChild(this.child);
+        }
+        this.child = undefined;
+        this.connectedChild = undefined;
+    }
+    async replaceOwnedProcess() {
+        const child = this.child;
+        this.connectedChild = undefined;
+        if (child) {
+            await this.terminateChild(child);
+            if (this.child === child)
+                this.childBecameUnavailable(child);
+        }
+        const connecting = this.connecting;
+        if (connecting)
+            await connecting.catch(() => undefined);
+        this.cancelRestart();
+        await this.ensureConnection();
+    }
+    terminateChild(child) {
+        const existing = this.terminationOperations.get(child);
+        if (existing)
+            return existing;
+        let resolveOperation;
+        let rejectOperation;
+        const operation = new Promise((resolve, reject) => {
+            resolveOperation = resolve;
+            rejectOperation = reject;
+        });
+        this.terminationOperations.set(child, operation);
+        void this.performTerminateChild(child).then(() => {
+            this.terminationOperations.delete(child);
+            resolveOperation();
+        }, (error) => {
+            this.terminationOperations.delete(child);
+            rejectOperation(error);
+        });
+        return operation;
+    }
+    async performTerminateChild(child) {
+        if (!childIsRunning(child))
+            return;
+        const gracefulExit = waitForExit(child, this.stopTimeoutMs);
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // Escalation below remains the authoritative shutdown path.
+        }
+        if (await gracefulExit)
+            return;
+        const forcedExit = waitForExit(child, this.stopTimeoutMs);
+        let signalSent;
+        try {
+            signalSent = child.kill("SIGKILL");
+        }
+        catch (error) {
+            throw supervisorError("failed to force-stop App browser host", error);
+        }
+        if (!signalSent && childIsRunning(child)) {
+            throw new Error("failed to force-stop App browser host");
+        }
+        if (!await forcedExit) {
+            throw new Error("App browser host did not exit after SIGKILL");
+        }
+    }
+}
+const defaultSpawn = (executable, args, options) => spawn(executable, [...args], options);
+function validateLaunchConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("invalid App browser host launch config");
+    }
+    const keys = Object.keys(value);
+    if (keys.some((key) => key !== "executable" && key !== "appPath")
+        || !keys.includes("executable")) {
+        throw new Error("invalid App browser host launch config");
+    }
+    const executable = absolutePath(value.executable, "launch executable");
+    return value.appPath === undefined
+        ? { executable }
+        : {
+            executable,
+            appPath: absolutePath(value.appPath, "launch appPath"),
+        };
+}
+function childEnvironment(source, bootstrap) {
+    const result = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (key.toUpperCase() === "ELECTRON_RUN_AS_NODE")
+            continue;
+        if (value === bootstrap.origin || value === bootstrap.managementToken)
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+function absolutePath(value, name) {
+    if (typeof value !== "string"
+        || value.length === 0
+        || value.trim() !== value
+        || Buffer.byteLength(value, "utf8") > MAX_PATH_BYTES
+        || /[\u0000-\u001f\u007f]/u.test(value)
+        || !path.isAbsolute(value)) {
+        throw new Error(`${name} must be an absolute path`);
+    }
+    return value;
+}
+function loopbackOrigin(value) {
+    if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+        throw new Error("bootstrap origin must be a canonical loopback HTTP origin");
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error("bootstrap origin must be a canonical loopback HTTP origin");
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        || parsed.origin !== value
+        || parsed.username
+        || parsed.password
+        || parsed.hostname !== "localhost"
+            && parsed.hostname !== "127.0.0.1"
+            && parsed.hostname !== "[::1]") {
+        throw new Error("bootstrap origin must be a canonical loopback HTTP origin");
+    }
+    return parsed.origin;
+}
+function managementToken(value) {
+    if (typeof value !== "string"
+        || value.trim() !== value
+        || /[\u0000-\u001f\u007f]/u.test(value)) {
+        throw new Error("invalid App browser host management token");
+    }
+    const length = Buffer.byteLength(value, "utf8");
+    if (length < MIN_MANAGEMENT_TOKEN_BYTES || length > MAX_MANAGEMENT_TOKEN_BYTES) {
+        throw new Error("invalid App browser host management token");
+    }
+    return value;
+}
+function isRecordWithExactKeys(value, expectedKeys) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const keys = Object.keys(value);
+    return keys.length === expectedKeys.length
+        && keys.every((key) => expectedKeys.includes(key));
+}
+function positiveDuration(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved <= 0 || resolved > MAX_TIMEOUT_MS) {
+        throw new Error(`${name} must be an integer between 1 and ${MAX_TIMEOUT_MS}`);
+    }
+    return resolved;
+}
+function nonNegativeDuration(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved < 0 || resolved > MAX_TIMEOUT_MS) {
+        throw new Error(`${name} must be an integer between 0 and ${MAX_TIMEOUT_MS}`);
+    }
+    return resolved;
+}
+function childIsRunning(child) {
+    return child.exitCode === null && child.signalCode === null;
+}
+function waitForExit(child, timeoutMs) {
+    if (!childIsRunning(child))
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        timer.unref();
+        const onExit = () => finish(true);
+        const onClose = () => finish(true);
+        function finish(exited) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.off("exit", onExit);
+            child.off("close", onClose);
+            resolve(exited);
+        }
+        child.once("exit", onExit);
+        child.once("close", onClose);
+    });
+}
+function supervisorError(message, cause) {
+    return new Error(message, { cause });
+}

package/dist/browser-artifact-management.d.ts

@@ -0,0 +1,20 @@
+import type { DaemonBrowserArtifactCleanResult, DaemonBrowserArtifactInstallInput, DaemonBrowserArtifactInstallResult, DaemonBrowserArtifactUpdateInput, DaemonBrowserArtifactVersionResult } from "@rynx-ai/protocol/control";
+import { type ChromeForTestingReleaseSelector, type ResolvedChromeForTestingRelease } from "./chrome-for-testing-release-resolver.js";
+import { type ChromeForTestingArtifactStore } from "./chrome-for-testing-store.js";
+export interface BrowserArtifactManagementContext {
+    signal?: AbortSignal;
+}
+export interface BrowserArtifactManagementService {
+    install(input: DaemonBrowserArtifactInstallInput, context?: BrowserArtifactManagementContext): Promise<DaemonBrowserArtifactInstallResult>;
+    update(input: DaemonBrowserArtifactUpdateInput, context?: BrowserArtifactManagementContext): Promise<DaemonBrowserArtifactInstallResult>;
+    version(): DaemonBrowserArtifactVersionResult;
+    clean(): DaemonBrowserArtifactCleanResult;
+}
+export interface BrowserArtifactManagementServiceOptions {
+    resolveRelease?: (selector: ChromeForTestingReleaseSelector, options?: {
+        signal?: AbortSignal;
+    }) => Promise<ResolvedChromeForTestingRelease>;
+    createStore?: () => ChromeForTestingArtifactStore;
+}
+/** Daemon-owned Browser artifact operations exposed through local management. */
+export declare function createBrowserArtifactManagementService(options?: BrowserArtifactManagementServiceOptions): BrowserArtifactManagementService;