@mercuryo-ai/agentbrowse 0.2.60 → 0.2.61

package/dist/sticky-owner.js

@@ -0,0 +1,431 @@
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { chromium } from 'playwright-core';
+import { buildStickyOwnerMetadata, isSessionAlive, resolveBrowserSessionId, } from './browser-session-state.js';
+import { connectPlaywright, disconnectPlaywright } from './playwright-runtime.js';
+const HOST_READY_TIMEOUT_MS = 5_000;
+const HOST_READY_POLL_MS = 50;
+const HOST_CONNECT_TIMEOUT_MS = 3_000;
+const HOST_STOP_TIMEOUT_MS = 1_000;
+const DEFAULT_STICKY_OWNER_TTL_MS = 30 * 60 * 1_000;
+const STICKY_OWNER_HEARTBEAT_FLOOR_MS = 5_000;
+const STICKY_OWNER_HEARTBEAT_CEILING_MS = 60_000;
+const inProcessOwners = new WeakMap();
+function resolveStickyOwnerBootstrapMode() {
+    const explicit = process.env.AGENTBROWSE_STICKY_OWNER_MODE?.trim().toLowerCase();
+    if (explicit === 'detached_process') {
+        return 'detached_process';
+    }
+    if (explicit === 'in_process') {
+        return 'in_process';
+    }
+    if (process.env.VITEST) {
+        return 'in_process';
+    }
+    return 'detached_process';
+}
+function createHostId() {
+    return `owner_${randomUUID().replace(/-/g, '')}`;
+}
+function resolveStickyOwnerTtlMs() {
+    const raw = process.env.AGENTBROWSE_STICKY_OWNER_TTL_MS?.trim();
+    if (!raw) {
+        return DEFAULT_STICKY_OWNER_TTL_MS;
+    }
+    const ttlMs = Number(raw);
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+        return DEFAULT_STICKY_OWNER_TTL_MS;
+    }
+    return ttlMs;
+}
+function getStickyOwnerTouchPath(hostId) {
+    return join(tmpdir(), `agentbrowse-sticky-owner-${hostId}.touch`);
+}
+function buildInProcessStickyOwner(session, options = {}) {
+    return buildStickyOwnerMetadata({
+        hostId: options.hostId ?? session.stickyOwner?.hostId ?? createHostId(),
+        state: options.state ?? 'active',
+        startedAt: options.startedAt ?? session.stickyOwner?.startedAt ?? new Date().toISOString(),
+        browserSessionId: resolveBrowserSessionId(session),
+        transport: {
+            type: 'in_process',
+        },
+    });
+}
+function readStickyOwnerLastUsedMs(stickyOwner) {
+    if (stickyOwner.touchPath) {
+        try {
+            if (existsSync(stickyOwner.touchPath)) {
+                return statSync(stickyOwner.touchPath).mtimeMs;
+            }
+        }
+        catch {
+            // Fall through to metadata timestamps.
+        }
+    }
+    const candidate = stickyOwner.lastUsedAt ?? stickyOwner.startedAt;
+    const parsed = Date.parse(candidate);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function isStickyOwnerExpired(stickyOwner) {
+    if (stickyOwner.transport.type !== 'playwright_bind') {
+        return false;
+    }
+    const ttlMs = stickyOwner.ttlMs ?? DEFAULT_STICKY_OWNER_TTL_MS;
+    return Date.now() - readStickyOwnerLastUsedMs(stickyOwner) >= ttlMs;
+}
+function removeStickyOwnerTouchFile(stickyOwner) {
+    if (!stickyOwner?.touchPath) {
+        return;
+    }
+    rmSync(stickyOwner.touchPath, { force: true });
+}
+function touchStickyOwnerLease(session) {
+    if (!session.stickyOwner || session.stickyOwner.transport.type !== 'playwright_bind') {
+        return;
+    }
+    const touchedAt = new Date().toISOString();
+    if (session.stickyOwner.touchPath) {
+        writeFileSync(session.stickyOwner.touchPath, touchedAt);
+    }
+    session.stickyOwner = {
+        ...session.stickyOwner,
+        lastUsedAt: touchedAt,
+    };
+}
+function startStickyOwnerLeaseHeartbeat(session) {
+    if (!session.stickyOwner || session.stickyOwner.transport.type !== 'playwright_bind') {
+        return () => undefined;
+    }
+    const ttlMs = session.stickyOwner.ttlMs ?? DEFAULT_STICKY_OWNER_TTL_MS;
+    const heartbeatMs = Math.max(STICKY_OWNER_HEARTBEAT_FLOOR_MS, Math.min(Math.floor(ttlMs / 3), STICKY_OWNER_HEARTBEAT_CEILING_MS));
+    const timer = setInterval(() => {
+        try {
+            touchStickyOwnerLease(session);
+        }
+        catch {
+            // Best-effort heartbeat; restore path will handle stale or dead owners later.
+        }
+    }, heartbeatMs);
+    timer.unref?.();
+    return () => clearInterval(timer);
+}
+function markStickyOwnerState(session, state) {
+    if (!session.stickyOwner) {
+        return;
+    }
+    session.stickyOwner = {
+        ...session.stickyOwner,
+        state,
+    };
+}
+function isProcessAlive(pid) {
+    if (typeof pid !== 'number' || !Number.isFinite(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        await sleep(50);
+    }
+    return !isProcessAlive(pid);
+}
+async function canConnectToStickyOwnerEndpoint(endpoint) {
+    let browser = null;
+    try {
+        browser = await chromium.connect(endpoint, {
+            timeout: HOST_CONNECT_TIMEOUT_MS,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (browser) {
+            await disconnectPlaywright(browser);
+        }
+    }
+}
+function getStickyOwnerHostEntryPath() {
+    const currentPath = fileURLToPath(import.meta.url);
+    const suffix = currentPath.endsWith('.ts') ? '.ts' : '.js';
+    return fileURLToPath(new URL(`./sticky-owner-host-entry${suffix}`, import.meta.url));
+}
+function getStickyOwnerHostSpawnArgs(entryPath, manifestPath, cdpUrl, hostId, browserSessionId, touchPath, ttlMs) {
+    const args = [
+        entryPath,
+        '--manifest',
+        manifestPath,
+        '--cdp-url',
+        cdpUrl,
+        '--host-id',
+        hostId,
+        '--browser-session-id',
+        browserSessionId,
+        '--touch-path',
+        touchPath,
+        '--ttl-ms',
+        String(ttlMs),
+    ];
+    if (entryPath.endsWith('.ts')) {
+        return ['--import', 'tsx', ...args];
+    }
+    return args;
+}
+async function waitForStickyOwnerManifest(manifestPath) {
+    const deadline = Date.now() + HOST_READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (existsSync(manifestPath)) {
+            const payload = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+            if (typeof payload.endpoint === 'string' &&
+                payload.endpoint.trim().length > 0 &&
+                typeof payload.pid === 'number' &&
+                Number.isFinite(payload.pid) &&
+                payload.pid > 0 &&
+                typeof payload.startedAt === 'string' &&
+                payload.startedAt.trim().length > 0) {
+                rmSync(manifestPath, { force: true });
+                return {
+                    endpoint: payload.endpoint,
+                    pid: payload.pid,
+                    startedAt: payload.startedAt,
+                };
+            }
+        }
+        await sleep(HOST_READY_POLL_MS);
+    }
+    throw new Error('sticky_owner_bootstrap_timeout');
+}
+async function bootstrapDetachedStickyOwner(session) {
+    const hostId = session.stickyOwner?.hostId ?? createHostId();
+    const browserSessionId = resolveBrowserSessionId(session);
+    const ttlMs = session.stickyOwner?.ttlMs ?? resolveStickyOwnerTtlMs();
+    const manifestPath = join(tmpdir(), `agentbrowse-sticky-owner-${hostId}.json`);
+    const touchPath = session.stickyOwner?.touchPath ?? getStickyOwnerTouchPath(hostId);
+    const touchedAt = new Date().toISOString();
+    writeFileSync(touchPath, touchedAt);
+    const entryPath = getStickyOwnerHostEntryPath();
+    const child = spawn(process.execPath, getStickyOwnerHostSpawnArgs(entryPath, manifestPath, session.cdpUrl, hostId, browserSessionId, touchPath, ttlMs), {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    try {
+        const ready = await waitForStickyOwnerManifest(manifestPath);
+        return buildStickyOwnerMetadata({
+            hostId,
+            state: 'active',
+            startedAt: ready.startedAt,
+            lastUsedAt: touchedAt,
+            ttlMs,
+            touchPath,
+            browserSessionId,
+            pid: ready.pid,
+            transport: {
+                type: 'playwright_bind',
+                endpoint: ready.endpoint,
+                mode: 'pipe',
+            },
+        });
+    }
+    catch (error) {
+        if (isProcessAlive(child.pid)) {
+            process.kill(child.pid, 'SIGTERM');
+            await waitForProcessExit(child.pid, HOST_STOP_TIMEOUT_MS).catch(() => undefined);
+        }
+        rmSync(manifestPath, { force: true });
+        rmSync(touchPath, { force: true });
+        throw error;
+    }
+}
+async function ensureInProcessOwner(session) {
+    const existing = inProcessOwners.get(session);
+    if (existing) {
+        return existing;
+    }
+    const browser = await connectPlaywright(session.cdpUrl);
+    const owner = {
+        browser,
+        hostId: session.stickyOwner?.hostId ?? createHostId(),
+        startedAt: session.stickyOwner?.startedAt ?? new Date().toISOString(),
+    };
+    inProcessOwners.set(session, owner);
+    session.stickyOwner = buildInProcessStickyOwner(session, {
+        hostId: owner.hostId,
+        startedAt: owner.startedAt,
+    });
+    return owner;
+}
+export async function initializeBrowserSessionOwner(session) {
+    if (resolveStickyOwnerBootstrapMode() === 'in_process') {
+        session.stickyOwner = buildInProcessStickyOwner(session, {
+            state: 'active',
+        });
+        return session;
+    }
+    session.stickyOwner = await bootstrapDetachedStickyOwner(session);
+    return session;
+}
+export async function terminateBrowserSessionOwner(session) {
+    if (!session?.stickyOwner) {
+        return;
+    }
+    if (session.stickyOwner.transport.type === 'in_process') {
+        const owner = inProcessOwners.get(session);
+        inProcessOwners.delete(session);
+        if (owner) {
+            await disconnectPlaywright(owner.browser);
+        }
+        markStickyOwnerState(session, 'dead');
+        return;
+    }
+    const ownerPid = session.stickyOwner.pid;
+    if (isProcessAlive(ownerPid)) {
+        process.kill(ownerPid, 'SIGTERM');
+        const exited = await waitForProcessExit(ownerPid, HOST_STOP_TIMEOUT_MS);
+        if (!exited && isProcessAlive(ownerPid)) {
+            process.kill(ownerPid, 'SIGKILL');
+            await waitForProcessExit(ownerPid, HOST_STOP_TIMEOUT_MS).catch(() => undefined);
+        }
+    }
+    removeStickyOwnerTouchFile(session.stickyOwner);
+    markStickyOwnerState(session, 'dead');
+}
+export async function restoreBrowserSessionOwner(session) {
+    const stickyOwner = session.stickyOwner;
+    if (!stickyOwner) {
+        if (resolveStickyOwnerBootstrapMode() === 'in_process') {
+            try {
+                await ensureInProcessOwner(session);
+                return {
+                    success: true,
+                    session,
+                    restored: true,
+                };
+            }
+            catch {
+                return {
+                    success: false,
+                    reason: 'sticky_owner_unrecoverable',
+                };
+            }
+        }
+        if (!(await isSessionAlive(session))) {
+            return {
+                success: false,
+                reason: 'sticky_owner_unrecoverable',
+            };
+        }
+        try {
+            session.stickyOwner = await bootstrapDetachedStickyOwner(session);
+            return {
+                success: true,
+                session,
+                restored: true,
+            };
+        }
+        catch {
+            return {
+                success: false,
+                reason: 'sticky_owner_unrecoverable',
+            };
+        }
+    }
+    if (stickyOwner.transport.type === 'in_process') {
+        try {
+            await ensureInProcessOwner(session);
+            return {
+                success: true,
+                session,
+                restored: false,
+            };
+        }
+        catch {
+            return {
+                success: false,
+                reason: 'sticky_owner_unrecoverable',
+            };
+        }
+    }
+    if (stickyOwner.state === 'active' &&
+        !isStickyOwnerExpired(stickyOwner) &&
+        isProcessAlive(stickyOwner.pid) &&
+        (await canConnectToStickyOwnerEndpoint(stickyOwner.transport.endpoint))) {
+        return {
+            success: true,
+            session,
+            restored: false,
+        };
+    }
+    await terminateBrowserSessionOwner(session);
+    if (!(await isSessionAlive(session))) {
+        return {
+            success: false,
+            reason: 'sticky_owner_unrecoverable',
+        };
+    }
+    try {
+        markStickyOwnerState(session, 'recovering');
+        session.stickyOwner = await bootstrapDetachedStickyOwner(session);
+        return {
+            success: true,
+            session,
+            restored: true,
+        };
+    }
+    catch {
+        session.stickyOwner = {
+            ...stickyOwner,
+            state: 'dead',
+        };
+        return {
+            success: false,
+            reason: 'sticky_owner_unrecoverable',
+        };
+    }
+}
+export async function withStickyOwnerBrowser(session, operation) {
+    const stickyOwner = session.stickyOwner;
+    if (!stickyOwner || stickyOwner.transport.type === 'playwright_bind') {
+        const restored = await restoreBrowserSessionOwner(session);
+        if (!restored.success || !session.stickyOwner) {
+            throw new Error('sticky_owner_unrecoverable');
+        }
+    }
+    if (session.stickyOwner?.transport.type === 'playwright_bind') {
+        touchStickyOwnerLease(session);
+        const browser = await chromium.connect(session.stickyOwner.transport.endpoint, {
+            timeout: HOST_CONNECT_TIMEOUT_MS,
+        });
+        const stopHeartbeat = startStickyOwnerLeaseHeartbeat(session);
+        try {
+            return await operation(browser);
+        }
+        finally {
+            stopHeartbeat();
+            touchStickyOwnerLease(session);
+            await disconnectPlaywright(browser);
+        }
+    }
+    const owner = await ensureInProcessOwner(session);
+    return operation(owner.browser);
+}

package/docs/configuration.md

@@ -15,6 +15,12 @@ Most applications can start with this mental model:
 2. keep the returned `session` in memory
 3. pass that `session` into later calls
 
+Both bootstrap the same sticky-owner lifecycle. AgentBrowse may keep that
+owner in-process or in an internal detached host, but consumers do not manage
+that host directly. Detached hosts default to a 30 minute TTL and may be
+recreated on the next browser command if the browser session itself is still
+alive.
+
 You only need more configuration when you want one of these:
 
 - custom LLM integration
@@ -43,6 +49,10 @@ const attached = await attach(remoteCdpUrl, {
 The provider label is metadata only — AgentBrowse treats the connection as
 a generic CDP-attached browser session regardless of the label.
 
+`attach(...)` creates the same sticky-owner metadata as `launch(...)`. Later
+browser commands reuse that owner and only attempt a fresh root attach again
+as a repair path after owner loss.
+
 ## Client Configuration
 
 ```ts
@@ -68,6 +78,9 @@ configuration is the cleaner embedded pattern.
 Persistence is optional. Use it when you want to restore a browser session
 after a process restart.
 
+Persisted session files store browser identity plus versioned sticky-owner
+metadata. They do not serialize a live Playwright connection.
+
 ### Default Store
 
 ```ts
@@ -76,12 +89,12 @@ import { loadBrowserSession, saveBrowserSession, status } from '@mercuryo-ai/age
 saveBrowserSession(session);
 const restored = loadBrowserSession();
 
-// Always check a restored session before using it — the browser it points
-// at may already be gone.
+// `null` means there is no usable persisted session. That includes
+// incompatible reconnect-era records and incomplete owner metadata.
 if (restored) {
   const check = await status(restored);
-  if (!check.success) {
-    // The session is no longer reachable. Discard and relaunch.
+  if (!check.alive) {
+    // The session is no longer reachable. Discard and relaunch or re-attach.
   }
 }
 ```
@@ -90,6 +103,21 @@ Default path:
 
 `~/.agentbrowse/browse-session.json`
 
+If the detached owner host is gone but the underlying browser session is still
+alive, the first command after restore may repair ownership. If the browser is
+gone, AgentBrowse fails closed and you should start a fresh session.
+
+### Sticky Owner TTL
+
+Detached sticky-owner hosts use a bounded lifetime by default:
+
+- default TTL: `30` minutes
+- env override: `AGENTBROWSE_STICKY_OWNER_TTL_MS=<milliseconds>`
+
+This TTL is a resource guard for the detached owner host, not for the browser
+session itself. If the TTL expires and the browser is still reachable, the next
+browser command may bootstrap a fresh owner and continue.
+
 ### Custom Store
 
 For embedded apps, prefer an explicit store root:
@@ -108,6 +136,10 @@ store.delete();
 
 This avoids hidden machine-level coupling to `~/.agentbrowse`.
 
+`store.load()` follows the same contract as `loadBrowserSession()`: it returns
+`null` for missing files, incompatible old records, or unusable sticky-owner
+metadata.
+
 ## Proxy Configuration
 
 The clearest way to use a proxy is to pass it directly to `launch(...)`.

package/docs/getting-started.md

@@ -19,9 +19,18 @@ The normal flow is:
 5. `close(session)` ends the browser session
 
 The `session` is the key object in the whole API. It is the handle that keeps
-the browser connection and runtime state together between calls. A session
-stays valid while the underlying browser connection is live; call
-`status(session)` to check if you need to.
+the browser connection, runtime state, and sticky-owner metadata together
+between calls. Healthy commands reuse that sticky owner instead of issuing a
+fresh root attach on every call. If you persist the session and restart your
+process, the next command may repair the owner while the underlying browser is
+still alive; otherwise the session fails closed and you start fresh. Detached
+sticky owners also have a bounded lifetime, so an idle or expired owner may be
+recreated on the next browser command while the underlying browser session is
+still live.
+
+The sticky owner may live in-process or in an internal detached host. That is
+an implementation detail of AgentBrowse, not a daemon you manage separately.
+Detached hosts default to a 30 minute TTL.
 
 Refs returned by `observe(...)` (target refs, scope refs, fill refs) are
 valid for the page state that produced them, not forever. Any of these
@@ -116,6 +125,11 @@ Success result includes:
 - current `url`
 - current `title`
 
+`attach(...)` bootstraps the same sticky-owner lifecycle as `launch(...)`.
+After attach succeeds, later browser commands use that owner. A new provider-
+level root attach is only attempted again as an explicit repair path after
+owner loss.
+
 ### `observe(session, goal?)`
 
 Reads the current page and returns what AgentBrowse found.
@@ -172,12 +186,17 @@ before calling it.
 Returns local browser/runtime diagnostics for an existing session.
 
 Use it when you want to know whether the browser is still reachable and what
-page AgentBrowse believes it is on.
+page AgentBrowse believes it is on. After restoring a persisted session,
+`status(session)` is the cheapest explicit health check before more expensive
+workflows.
 
 ### `close(session)`
 
 Closes the browser session.
 
+This also terminates the internal sticky owner. Repeated closes and already-
+dead owner hosts are treated as idempotent.
+
 ## How To Handle Results
 
 All main commands use the same broad pattern:
@@ -233,6 +252,11 @@ If you want to restore a browser session between process runs, use:
 - `loadBrowserSession()`
 - `createBrowserSessionStore({ rootDir })`
 
+Persisted session records now require restorable sticky-owner metadata.
+Incompatible reconnect-era records are rejected at load time instead of being
+auto-migrated. Treat `loadBrowserSession() === null` as "no usable session",
+not as a recoverable partial state.
+
 See:
 
 - [Configuration Guide](./configuration.md)

package/docs/troubleshooting.md

@@ -23,7 +23,9 @@ Inspect the `error` and `reason` fields on the `launch(...)` failure result
 - **Unreachable CDP WebSocket URL.** Verify the URL with a simple
   WebSocket client or `curl`.
 - **Session already owned.** Some providers reject a second CDP attach for
-  the same session.
+  the same session. In the sticky-owner architecture this should only happen
+  during the initial `attach(...)` or an explicit repair attempt after the
+  original owner was lost, not during every healthy command.
 - **Version mismatch.** Very old or very new Chrome versions may not match
   Playwright's expected CDP shape; `status(session)` after attach returns
   details in that case.
@@ -33,13 +35,47 @@ Inspect the `error` and `reason` fields on the `launch(...)` failure result
 A `session` handle is valid only while the underlying browser connection
 is live.
 
-- If the browser process died, the next `act(...)` / `observe(...)` call
-  will fail with a connection error. Use `status(session)` to confirm, then
-  call `launch(...)` or `attach(...)` again.
+- If the detached sticky owner died but the browser is still alive,
+  AgentBrowse may repair ownership on the next command or explicit restore
+  path.
+- If the detached sticky owner hit its TTL, the next browser command may
+  recycle the owner and continue as long as the browser session is still live.
+- If the browser process or remote CDP session died, the next
+  `act(...)` / `observe(...)` call fails closed. Use `status(session)` to
+  confirm, then call `launch(...)` or `attach(...)` again.
 - If you restored a session from `loadBrowserSession()` or a custom store,
   call `status(session)` right after loading. If it reports the session is
-  no longer reachable, discard it and start fresh.
-- `close(session)` called twice is safe — the second call is a no-op.
+  no longer reachable, or a later command fails with
+  `sticky_owner_unrecoverable`, discard it and start fresh.
+- `close(session)` called twice is safe — the second call is a no-op, and an
+  already-dead owner host is treated as already closed.
+
+## Restored Session Loads As `null`
+
+`loadBrowserSession()` and custom stores intentionally reject incompatible
+older session records that do not contain persistable sticky-owner metadata.
+
+If a session that used to restore now loads as `null`:
+
+- treat it as a stale local record, not as a partial session you should patch
+  by hand;
+- delete the old session file if it is still on disk;
+- run `launch(...)` or `attach(...)` again to create a new session record.
+
+AgentBrowse does not auto-migrate reconnect-era session files.
+
+## `close(session)` Seems Stuck Or The Owner Host Already Died
+
+`close(session)` first terminates the sticky owner and then closes the managed
+browser when the session owns it.
+
+- If the owner host is already gone, close remains idempotent.
+- For detached owner hosts, AgentBrowse escalates from graceful termination to
+  a forced kill internally; there is no separate daemon command to run.
+- In CLI wrappers, a successful close also clears the locally persisted browser
+  session and workflow bindings.
+- If closing the managed browser itself fails, AgentBrowse reports that failure
+  and keeps the session record so you can inspect or retry.
 
 ## Why The Package Uses Both Puppeteer And Playwright
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercuryo-ai/agentbrowse",
-  "version": "0.2.60",
+  "version": "0.2.61",
   "type": "module",
   "description": "Browser automation primitives library for AI agents",
   "license": "MIT",

package/dist/protected-fill-browser.d.ts

@@ -1,22 +0,0 @@
-import type { BrowserSessionState } from './browser-session-state.js';
-import { type ProtectedFillExecutionResult } from './secrets/protected-fill.js';
-import type { PersistedFillableForm, StoredSecretFieldPolicies, StoredSecretFieldKey } from './secrets/types.js';
-export type FillProtectedFormBrowserResult = {
-    success: true;
-    pageRef: string;
-    url: string;
-    title: string;
-    execution: ProtectedFillExecutionResult;
-} | {
-    success: false;
-    error: 'browser_connection_failed' | 'page_resolution_failed';
-    message: string;
-    reason: string;
-};
-export declare function fillProtectedFormBrowser(params: {
-    session: BrowserSessionState;
-    fillableForm: PersistedFillableForm;
-    protectedValues: Partial<Record<StoredSecretFieldKey, string>>;
-    fieldPolicies?: StoredSecretFieldPolicies;
-}): Promise<FillProtectedFormBrowserResult>;
-//# sourceMappingURL=protected-fill-browser.d.ts.map

package/dist/protected-fill-browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protected-fill-browser.d.ts","sourceRoot":"","sources":["../src/protected-fill-browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAOtE,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,8BAA8B,GACtC;IACE,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,4BAA4B,CAAC;CACzC,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,2BAA2B,GAAG,wBAAwB,CAAC;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEN,wBAAsB,wBAAwB,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,mBAAmB,CAAC;IAC7B,YAAY,EAAE,qBAAqB,CAAC;IACpC,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/D,aAAa,CAAC,EAAE,yBAAyB,CAAC;CAC3C,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAqD1C"}