@parall/daemon 1.32.1 → 1.34.0

package/dist/clip-runtime/browser-profile-manager.js

@@ -0,0 +1,608 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import * as net from 'node:net';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const BB_BROWSER_DAEMON_START_TIMEOUT_MS = 15_000;
+class BrowserCommandError extends Error {
+    method;
+    account;
+    constructor(message, method, account) {
+        super(message);
+        this.method = method;
+        this.account = account;
+        this.name = 'BrowserCommandError';
+    }
+}
+export class BrowserProfileManager {
+    opts;
+    daemon = null;
+    starting = null;
+    restarting = null;
+    ensuredAccounts = new Set();
+    ensuringAccounts = new Map();
+    reportedStatuses = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        mkdirSync(this.opts.homeDir, { recursive: true });
+    }
+    async invoke({ profileId, account, command, input }) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        if (!account)
+            throw new Error('browser account is required');
+        try {
+            await this.withDaemonRecovery(() => this.prepareInvokeAccount(account), `prepare invoke ${command} for ${profileId}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+        let request;
+        try {
+            request = await this.buildCommandRequest(account, command, input);
+        }
+        catch (err) {
+            if (isRecoverableBrowserDaemonError(err)) {
+                await this.recoverInvokeAvailability(`build invoke ${command} for ${profileId}`, profileId, err);
+            }
+            throw err;
+        }
+        try {
+            // Do not replay arbitrary forwarded browser commands: click/type/eval can
+            // have user-visible side effects if Chrome consumed the first attempt.
+            const result = await this.sendCommand(request);
+            this.reportStatus(profileId, 'running');
+            return result;
+        }
+        catch (err) {
+            if (isRecoverableBrowserDaemonError(err)) {
+                await this.recoverInvokeAvailability(`invoke ${command} for ${profileId}`, profileId, err);
+            }
+            throw err;
+        }
+    }
+    async ensureRuntime(profileId) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        try {
+            await this.withDaemonRecovery(() => this.ensureAccount(profileId), `ensure runtime for ${profileId}`);
+            this.reportStatus(profileId, 'running');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+    }
+    async openProfile(profileId, startUrl) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        // Explicit lifecycle actions must always report their outcome: the server
+        // resets the profile to `pending` on the API call, so a deduped repeat of
+        // our previous report (same status+message marker) would leave the profile
+        // stuck in pending forever. Clearing the marker keeps the dedup for the
+        // chatty invoke path while making lifecycle outcomes authoritative.
+        this.reportedStatuses.delete(profileId);
+        const url = normalizeStartUrl(startUrl);
+        try {
+            await this.withDaemonRecovery(async () => {
+                const prepareResult = await this.prepareOpenProfile(profileId, url);
+                await this.openProfileTabOnce(profileId, url, prepareResult.accountCreated);
+            }, `open profile ${profileId}`);
+            this.reportStatus(profileId, 'running');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+    }
+    async stopProfile(profileId) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        this.reportedStatuses.delete(profileId); // see openProfile — lifecycle outcomes always report
+        // bb-browser-pro does not expose a single-account "dispose context" command.
+        // Server-side stopped status is the authority that gates future invokes.
+        this.reportStatus(profileId, 'stopped');
+    }
+    async resetProfile(profileId) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        this.reportedStatuses.delete(profileId); // see openProfile — lifecycle outcomes always report
+        try {
+            await this.withDaemonRecovery(() => this.resetProfileOnce(profileId), `reset profile ${profileId}`);
+            this.reportStatus(profileId, 'stopped');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+    }
+    async stop() {
+        const daemon = this.daemon;
+        this.daemon = null;
+        this.starting = null;
+        this.ensuredAccounts.clear();
+        this.ensuringAccounts.clear();
+        this.reportedStatuses.clear();
+        if (!daemon)
+            return;
+        try {
+            await this.post('/shutdown', daemon, undefined, 3_000);
+        }
+        catch {
+            /* best-effort */
+        }
+        if (daemon.child.exitCode === null && daemon.child.signalCode === null) {
+            daemon.child.kill('SIGTERM');
+        }
+    }
+    async prepareOpenProfile(profileId, url) {
+        const accountCreated = await this.ensureAccount(profileId, url !== 'about:blank' ? url : undefined);
+        await this.sendCommand({ method: 'tab_list', account: profileId });
+        return { accountCreated };
+    }
+    async openProfileTabOnce(profileId, url, accountCreated) {
+        if (accountCreated)
+            return;
+        if (await this.profileAlreadyHasOpenTab(profileId, url))
+            return;
+        await this.sendCommand({ method: 'tab_new', account: profileId, url });
+    }
+    async resetProfileOnce(profileId) {
+        if (await this.accountExists(profileId)) {
+            await this.sendCommand({ method: 'account_delete', account: profileId });
+        }
+        this.ensuredAccounts.delete(profileId);
+    }
+    async prepareInvokeAccount(account) {
+        await this.ensureAccount(account);
+        await this.sendCommand({ method: 'tab_list', account });
+    }
+    async recoverInvokeAvailability(label, profileId, err) {
+        try {
+            await this.restartDaemon(label, err);
+            this.reportStatus(profileId, 'running');
+        }
+        catch (restartErr) {
+            const message = restartErr instanceof Error ? restartErr.message : String(restartErr);
+            this.reportStatus(profileId, 'error', message);
+            throw restartErr;
+        }
+    }
+    async accountExists(account) {
+        try {
+            await this.sendCommand({ method: 'account_info', account });
+            return true;
+        }
+        catch (err) {
+            if (isBrowserAccountInfoUnauthenticatedError(err))
+                return true;
+            if (isBrowserAccountNotFoundError(err))
+                return false;
+            throw err;
+        }
+    }
+    async buildCommandRequest(account, command, input) {
+        const body = input && typeof input === 'object' && !Array.isArray(input)
+            ? { ...input }
+            : { value: input };
+        const request = body;
+        request.method = command;
+        request.account = account;
+        if (command === 'eval' && typeof request.domain === 'string' && request.tabId === undefined) {
+            const tabRef = await this.resolveAccountDomainTab(account, request.domain);
+            if (tabRef !== undefined)
+                request.tabId = tabRef;
+        }
+        return request;
+    }
+    /**
+     * Account-scoped version of bb-browser's `resolveTabByDomain` (which is
+     * account-blind — the reason for this daemon-side preselection workaround).
+     * Two properties the bare `tab_new` + eval approach lacked, both caught on
+     * the staging closed-loop E2E (2026-06-04):
+     *
+     * 1. Reuse: an existing account tab already on the domain is reused instead
+     *    of opening a new tab per eval (upstream reuses matching tabs too).
+     * 2. Load wait: after creating a tab, wait for the navigation to commit
+     *    before eval — upstream waits (~10s poll + settle); without it the clip
+     *    script races `about:blank` and relative fetches fail
+     *    ("Failed to parse URL from /hot.json").
+     */
+    async resolveAccountDomainTab(account, domain) {
+        const url = normalizeDomainUrl(domain);
+        let host = '';
+        try {
+            host = new URL(url).host;
+        }
+        catch {
+            /* fall through — tab_new with whatever bb-browser makes of it */
+        }
+        if (host) {
+            const existing = await this.findAccountTabOnHost(account, host);
+            if (existing !== undefined)
+                return existing;
+        }
+        const tab = await this.sendCommand({ method: 'tab_new', url, account });
+        const tabRef = (tab?.tab ?? tab?.tabId);
+        if (tabRef === undefined || !host)
+            return tabRef;
+        // Wait for the created tab to actually reach the domain (navigation
+        // committed). Mirrors upstream resolveTabByDomain's bounded wait + settle.
+        const deadline = Date.now() + 10_000;
+        while (Date.now() < deadline) {
+            const found = await this.findAccountTabOnHost(account, host, tabRef);
+            if (found !== undefined)
+                break;
+            await sleep(300);
+        }
+        await sleep(750); // post-commit settle (upstream uses a flat 2s)
+        return tabRef;
+    }
+    /** Find an account-owned tab whose URL host matches (optionally a specific tab). */
+    async findAccountTabOnHost(account, host, onlyTabRef) {
+        const list = await this.sendCommand({ method: 'tab_list', account });
+        const tabs = Array.isArray(list.tabs)
+            ? list.tabs
+            : [];
+        for (const t of tabs) {
+            if (t?.account !== account)
+                continue;
+            const ref = (t.tab ?? t.tabId);
+            if (onlyTabRef !== undefined && ref !== onlyTabRef && t.tabId !== onlyTabRef)
+                continue;
+            if (typeof t.url !== 'string')
+                continue;
+            try {
+                if (hostsMatch(new URL(t.url).host, host))
+                    return ref;
+            }
+            catch {
+                /* non-URL tab (about:blank etc.) — skip */
+            }
+        }
+        return undefined;
+    }
+    async ensureAccount(account, accountUrl) {
+        if (this.ensuredAccounts.has(account))
+            return false;
+        const inflight = this.ensuringAccounts.get(account);
+        if (inflight)
+            return inflight;
+        const ensure = (async () => {
+            let accountCreated = false;
+            try {
+                await this.sendCommand({ method: 'account_info', account });
+            }
+            catch (err) {
+                if (!isBrowserAccountInfoUnauthenticatedError(err)) {
+                    if (!isBrowserAccountNotFoundError(err))
+                        throw err;
+                    await this.sendCommand({
+                        method: 'account_create',
+                        account,
+                        ...(accountUrl ? { accountUrl } : {}),
+                    });
+                    accountCreated = true;
+                }
+            }
+            if (!accountUrl) {
+                await this.ensureAccountOwnedTab(account);
+            }
+            this.ensuredAccounts.add(account);
+            return accountCreated;
+        })();
+        this.ensuringAccounts.set(account, ensure);
+        try {
+            return await ensure;
+        }
+        finally {
+            this.ensuringAccounts.delete(account);
+        }
+    }
+    async ensureAccountOwnedTab(account) {
+        if (await this.hasAccountOwnedTab(account))
+            return;
+        await this.sendCommand({ method: 'tab_new', account, url: 'about:blank' });
+    }
+    async profileAlreadyHasOpenTab(profileId, url) {
+        // Lifecycle `open` can be delivered more than once (WS + pending reconcile,
+        // retry, or duplicate user action). Treat only the requested target URL as
+        // already-open; a same-host different path is still a distinct user intent.
+        if (url === 'about:blank')
+            return this.hasAccountOwnedTab(profileId);
+        return this.findAccountTabMatchingUrl(profileId, url);
+    }
+    async hasAccountOwnedTab(account) {
+        const list = await this.sendCommand({ method: 'tab_list', account });
+        const tabs = Array.isArray(list.tabs)
+            ? list.tabs
+            : [];
+        return tabs.some((tab) => tab?.account === account);
+    }
+    async findAccountTabMatchingUrl(account, url) {
+        const expected = comparableUrl(url);
+        if (!expected)
+            return false;
+        const list = await this.sendCommand({ method: 'tab_list', account });
+        const tabs = Array.isArray(list.tabs)
+            ? list.tabs
+            : [];
+        for (const tab of tabs) {
+            if (tab?.account !== account || typeof tab.url !== 'string')
+                continue;
+            const actual = comparableUrl(tab.url);
+            if (!actual)
+                continue;
+            const sameResource = hostsMatch(actual.host, expected.host) && actual.target === expected.target;
+            const sameProtocol = actual.protocol === expected.protocol;
+            const redirectedUpgrade = expected.protocol === 'http:' && actual.protocol === 'https:';
+            if (sameResource && (sameProtocol || redirectedUpgrade))
+                return true;
+        }
+        return false;
+    }
+    reportStatus(profileId, status, errorMsg) {
+        const marker = `${status}\u0000${errorMsg ?? ''}`;
+        if (this.reportedStatuses.get(profileId) === marker)
+            return;
+        this.reportedStatuses.set(profileId, marker);
+        this.opts.reportStatus?.(profileId, status, errorMsg);
+    }
+    async sendCommand(request) {
+        const daemon = await this.ensureDaemon();
+        const response = await this.post('/command', daemon, request, 30_000);
+        if (response.error) {
+            throw new BrowserCommandError(response.error.message || 'bb-browser command failed', request.method, request.account);
+        }
+        return response.result ?? {};
+    }
+    async ensureDaemon() {
+        if (this.restarting)
+            await this.restarting;
+        if (this.daemon &&
+            this.daemon.child.exitCode === null &&
+            this.daemon.child.signalCode === null) {
+            return this.daemon;
+        }
+        if (this.starting)
+            return this.starting;
+        this.starting = this.startDaemon();
+        try {
+            this.daemon = await this.starting;
+            return this.daemon;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    async withDaemonRecovery(operation, label) {
+        try {
+            return await operation();
+        }
+        catch (err) {
+            if (!isRecoverableBrowserDaemonError(err))
+                throw err;
+            await this.restartDaemon(label, err);
+            return operation();
+        }
+    }
+    async restartDaemon(label, err) {
+        if (this.restarting)
+            return this.restarting;
+        this.restarting = this.restartDaemonOnce(label, err);
+        try {
+            await this.restarting;
+        }
+        finally {
+            this.restarting = null;
+        }
+    }
+    async restartDaemonOnce(label, err) {
+        const daemon = this.daemon;
+        this.daemon = null;
+        this.starting = null;
+        this.ensuredAccounts.clear();
+        this.ensuringAccounts.clear();
+        this.opts.log.warn(`[bb-browser] ${label} hit an unavailable Chrome/CDP page target; restarting bb-browser-daemon (${formatErrorForLog(err)})`);
+        if (!daemon)
+            return;
+        try {
+            await this.post('/shutdown', daemon, undefined, 3_000);
+        }
+        catch {
+            /* best-effort */
+        }
+        if (daemon.child.exitCode === null && daemon.child.signalCode === null) {
+            daemon.child.kill('SIGTERM');
+        }
+    }
+    async startDaemon() {
+        const host = '127.0.0.1';
+        const port = await findFreePort();
+        const token = randomToken();
+        const daemonPath = resolveBbBrowserDaemonPath();
+        const child = spawn(process.execPath, [daemonPath, '--host', host, '--port', String(port), '--token', token], {
+            env: {
+                ...process.env,
+                BB_BROWSER_HOME: this.opts.homeDir,
+            },
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        // A spawn/exec failure (ENOENT, EACCES, …) emits 'error' on the child, which
+        // — with no listener — Node re-throws as an uncaught exception and crashes
+        // the daemon. Capture it so startup fails through the normal path instead.
+        let childError = null;
+        child.once('error', (err) => {
+            childError = err;
+        });
+        child.stderr?.on('data', (chunk) => {
+            const text = chunk.toString('utf8').trim();
+            if (text)
+                this.opts.log.warn(`[bb-browser] ${text}`);
+        });
+        const state = { child, host, port, token };
+        const deadline = Date.now() + BB_BROWSER_DAEMON_START_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (childError) {
+                throw childError;
+            }
+            if (child.exitCode !== null || child.signalCode !== null) {
+                throw new Error(`bb-browser-daemon exited during startup`);
+            }
+            try {
+                await this.post('/status', state, undefined, 2_000);
+                this.opts.log.info(`[bb-browser] daemon ready at ${host}:${port}`);
+                return state;
+            }
+            catch {
+                await sleep(200);
+            }
+        }
+        child.kill('SIGTERM');
+        throw new Error('bb-browser-daemon did not start in time');
+    }
+    async post(pathName, daemon, body, timeoutMs = 10_000) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(`http://${daemon.host}:${daemon.port}${pathName}`, {
+                method: pathName === '/status' ? 'GET' : 'POST',
+                headers: {
+                    Authorization: `Bearer ${daemon.token}`,
+                    ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await resp.text();
+            if (!resp.ok) {
+                throw new Error(`bb-browser ${pathName} returned ${resp.status}: ${text}`);
+            }
+            return (text ? JSON.parse(text) : {});
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** Host comparison tolerant of a `www.` prefix on either side. */
+function hostsMatch(a, b) {
+    const norm = (h) => h.toLowerCase().replace(/^www\./, '');
+    return norm(a) === norm(b);
+}
+function normalizeDomainUrl(domain) {
+    const trimmed = domain.trim();
+    if (!trimmed)
+        return 'about:blank';
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+function normalizeStartUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return 'about:blank';
+    if (trimmed === 'about:blank')
+        return trimmed;
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+function isBrowserAccountNotFoundError(err) {
+    if (!(err instanceof BrowserCommandError) || err.method !== 'account_info')
+        return false;
+    const message = err.message.trim().toLowerCase();
+    if (!message)
+        return false;
+    const notFound = message === 'not found' ||
+        message.includes('account not found') ||
+        message.includes('account does not exist') ||
+        message.includes('unknown account') ||
+        message.includes('missing account') ||
+        // bb-browser-pro 0.15.x interpolates the account name into the message:
+        // `Account "<id>" not found`. Without this arm the matcher misses the
+        // real daemon's format entirely, so account_create never runs and every
+        // open of a fresh profile fails (caught on staging E2E 2026-06-04 with a
+        // real local daemon + Chrome).
+        /^account\s+"[^"]*"\s+not found\b/.test(message);
+    return notFound;
+}
+function isBrowserAccountInfoUnauthenticatedError(err) {
+    if (!(err instanceof BrowserCommandError) || err.method !== 'account_info')
+        return false;
+    const message = err.message.trim().toLowerCase();
+    return message.includes('not logged in') || message.includes('not authenticated');
+}
+function isRecoverableBrowserDaemonError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const lower = message.toLowerCase();
+    return (lower.includes('chrome not connected') ||
+        lower.includes('cdp at 127.0.0.1') ||
+        lower.includes('no page target found') ||
+        (lower.includes('bb-browser /command returned 503') &&
+            (lower.includes('chrome') || lower.includes('cdp'))));
+}
+function comparableUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return {
+            protocol: parsed.protocol,
+            host: parsed.host,
+            target: `${parsed.pathname}${parsed.search}${parsed.hash}`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function formatErrorForLog(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.replace(/\s+/g, ' ').slice(0, 300);
+}
+function resolveBbBrowserDaemonPath() {
+    // Bundle channels (CDN self-update, desktop, npm bin — all run the flat
+    // esbuild artifact with NO node_modules) ship bb-browser as a sibling flat
+    // artifact (scripts/bundle-daemon.mjs). Prefer it; fall through to normal
+    // package resolution for dev/dist runs. Without this, every bundle-delivered
+    // daemon failed browser profiles with "Cannot find module
+    // '@pinixai/bb-browser-pro/package.json'" (desktop staging, 2026-06-04).
+    const sibling = path.join(path.dirname(fileURLToPath(import.meta.url)), 'bb-browser-daemon.js');
+    if (existsSync(sibling))
+        return sibling;
+    const require = createRequire(import.meta.url);
+    const pkgPath = require.resolve('@pinixai/bb-browser-pro/package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const rel = typeof pkg.bin === 'string' ? pkg.bin : (pkg.bin?.['bb-browser-daemon'] ?? './dist/daemon.js');
+    const full = path.resolve(path.dirname(pkgPath), rel);
+    if (!existsSync(full)) {
+        throw new Error(`bb-browser-daemon entrypoint not found at ${full}`);
+    }
+    return full;
+}
+async function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            server.close(() => {
+                if (address && typeof address === 'object') {
+                    resolve(address.port);
+                }
+                else {
+                    reject(new Error('failed to allocate free port'));
+                }
+            });
+        });
+    });
+}
+function randomToken() {
+    return randomBytes(16).toString('hex');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/clip-runtime/clip-provider.d.ts

@@ -31,6 +31,14 @@ export interface ClipProviderOptions {
         warn(msg: string): void;
         error(msg: string): void;
     };
+    /**
+     * Invoked after several consecutive reconnect failures (throttled by backoff).
+     * Lets the supervisor refetch machine config and, if the endpoint changed,
+     * rebuild this provider — e.g. when clip_provider_url rolls out server-side
+     * after this daemon booted while its ws-gateway WS never bounced to
+     * re-trigger machine.hello. Optional.
+     */
+    onPersistentFailure?: () => void;
 }
 export declare class ClipProvider {
     private readonly opts;
@@ -44,10 +52,11 @@ export declare class ClipProvider {
     private statusUnsubscribe;
     private manifestUnsubscribe;
     private needsReregister;
-    private intentionalClose;
+    private streamGeneration;
     private static RECONNECT_BASE_MS;
     private static RECONNECT_MAX_MS;
     private static HEARTBEAT_INTERVAL_MS;
+    private static PERSISTENT_FAILURE_ATTEMPT;
     constructor(opts: ClipProviderOptions);
     /** Connect to the Clip Service and register local clips. Reconnects on failure. */
     connect(): Promise<void>;

package/dist/clip-runtime/clip-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clip-provider.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/clip-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AA0I/D,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,WAAW,EAAE,kBAAkB,CAAC;IAChC,mBAAmB;IACnB,GAAG,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACrF;AAED,qBAAa,YAAY;IAiBX,OAAO,CAAC,QAAQ,CAAC,IAAI;IAhBjC,OAAO,CAAC,OAAO,CAAyC;IACxD,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,gBAAgB,CAAS;IAEjC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAS;IACzC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAU;IACzC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAU;gBAEjB,IAAI,EAAE,mBAAmB;IAEtD,mFAAmF;IAC7E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B,wCAAwC;IAClC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjC,WAAW,IAAI,OAAO;YAQR,UAAU;IAoExB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,cAAc;IAyBtB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,sBAAsB;IAyB9B,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,gBAAgB;YAeV,mBAAmB;YAyDnB,YAAY;YAUZ,mBAAmB;IAiBjC,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,cAAc;CAUvB"}
+{"version":3,"file":"clip-provider.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/clip-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AA+I/D,MAAM,WAAW,mBAAmB;IAClC,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,WAAW,EAAE,kBAAkB,CAAC;IAChC,mBAAmB;IACnB,GAAG,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpF;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;CAClC;AAED,qBAAa,YAAY;IAwBX,OAAO,CAAC,QAAQ,CAAC,IAAI;IAvBjC,OAAO,CAAC,OAAO,CAAyC;IACxD,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,iBAAiB,CAA6B;IACtD,OAAO,CAAC,mBAAmB,CAA6B;IACxD,OAAO,CAAC,eAAe,CAAS;IAIhC,OAAO,CAAC,gBAAgB,CAAK;IAE7B,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAS;IACzC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAU;IACzC,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAU;IAI9C,OAAO,CAAC,MAAM,CAAC,0BAA0B,CAAK;gBAEjB,IAAI,EAAE,mBAAmB;IAEtD,mFAAmF;IAC7E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B,wCAAwC;IAClC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjC,WAAW,IAAI,OAAO;YAQR,UAAU;IAuExB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,cAAc;IAuBtB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,sBAAsB;IAyB9B,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,gBAAgB;YAeV,mBAAmB;YA0EnB,YAAY;YAUZ,mBAAmB;IAiBjC,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,cAAc;CAUvB"}