browxai 0.7.0

package/dist/engine/adapters/safaridriver-hybrid.d.ts

@@ -0,0 +1,56 @@
+import type { EngineCapabilities, EngineKind } from "../types.js";
+import { SafariWebDriverClient } from "./safari/webdriver-client.js";
+import { SafariBidiClient } from "./safari/bidi-client.js";
+import { type SafariDriverProcess, type SafariLaunchDeps } from "./safari/launch.js";
+/** A live Safari session — the adapter's native return (NOT yet an `EngineSession`;
+ *  the no-Playwright-Page seam wires that in a later increment). Owns the WebDriver
+ *  Classic client (always) and the BiDi client (only when the experimental cap
+ *  yielded a socket). */
+export interface SafariSessionHandle {
+    readonly engine: EngineKind;
+    readonly capabilities: EngineCapabilities;
+    readonly sessionId: string;
+    /** The Classic workhorse — always present. */
+    readonly webDriver: SafariWebDriverClient;
+    /** The BiDi event/script layer — present only when BiDi negotiated (the
+     *  experimental cap returned a real ws:// URL). Undefined ⇒ Classic-only. */
+    readonly bidi: SafariBidiClient | undefined;
+    /** Whether the bidirectional (BiDi) layer is live. */
+    readonly hasBidi: boolean;
+    close(): Promise<void>;
+}
+/** Raised when session creation is rejected because Safari's "Allow Remote
+ *  Automation" is off — the most common first-run failure on a fresh host. Names
+ *  the exact fix. */
+export declare class SafariRemoteAutomationDisabledError extends Error {
+    constructor(detail: string);
+}
+/** Raised when a second session is requested while one is already live —
+ *  safaridriver is single-session. */
+export declare class SafariSessionBusyError extends Error {
+    constructor();
+}
+/** Injectable seams so the orchestration tests without a real safaridriver. */
+export interface SafariAdapterDeps {
+    /** Launch safaridriver (defaults to the real `launchSafaridriver`). */
+    launch?: (deps?: SafariLaunchDeps) => Promise<SafariDriverProcess>;
+    launchDeps?: SafariLaunchDeps;
+    webDriverFactory?: (baseUrl: string) => SafariWebDriverClient;
+    bidiFactory?: (url: string) => SafariBidiClient;
+}
+export declare class SafaridriverHybridAdapter {
+    readonly engine: EngineKind;
+    readonly capabilities: EngineCapabilities;
+    private readonly deps;
+    /** The single live session (safaridriver is single-session). */
+    private active;
+    constructor(deps?: SafariAdapterDeps);
+    /** Launch a managed, isolated Safari automation window and create a hybrid
+     *  Classic+BiDi session. Single-session: refuses if one is already live. */
+    launchManaged(): Promise<SafariSessionHandle>;
+    /** Attach is NOT supported: safaridriver hard-isolates automation into a clean
+     *  ephemeral window and cannot attach to the user's live, logged-in Safari (the
+     *  XPC surface is categorically closed to third parties). Structured
+     *  refusal, never a vague failure. */
+    attach(): Promise<never>;
+}

package/dist/engine/adapters/safaridriver-hybrid.js

@@ -0,0 +1,127 @@
+// SafaridriverHybridAdapter — the FIFTH BrowserEngine adapter and
+// the FIRST non-Playwright one. It drives real Safari.app over safaridriver in
+// non-BYOB isolated automation windows, hybridising two protocols (confirmed
+// against a live Safari automation probe):
+//   - WebDriver CLASSIC (SafariWebDriverClient) — the complete workhorse:
+//     navigation, element find/click/sendKeys, screenshot, cookies, executeScript
+//     (the seam the Safari snapshot substrate ships browxai's DOM-walk through).
+//   - WebDriver BiDi (SafariBidiClient) — the ADDITIVE bidirectional layer, gated
+//     behind the vendor cap `safari:experimentalWebSocketUrl:true`: live console
+//     (`log.entryAdded`) + navigation-lifecycle events + multi-realm script. It is
+//     STRICTLY OPTIONAL — if the cap does not yield a ws:// URL the adapter runs
+//     Classic-only, losing only the event streams.
+//
+// Unlike the other four adapters this returns NO Playwright `Page` and NO CDP —
+// Safari has neither. The session it yields is Safari-native (a `SafariSessionHandle`);
+// the session-layer seam that lets the rest of the server consume it (the
+// no-Playwright-Page contract) is a later increment. This module
+// is the lifecycle + transport orchestration, fully unit-tested with mocks; the
+// real IO is covered by the Safari-gated keystone.
+//
+// safaridriver allows ONE session at a time, so this adapter enforces single-session
+// at the adapter level (a second launch while one is live is a structured refusal)
+// rather than letting safaridriver fail opaquely on the second POST /session.
+import { capabilitiesFor } from "../capabilities.js";
+import { SafariWebDriverClient, WebDriverError } from "./safari/webdriver-client.js";
+import { SafariBidiClient } from "./safari/bidi-client.js";
+import { launchSafaridriver, } from "./safari/launch.js";
+/** Raised when session creation is rejected because Safari's "Allow Remote
+ *  Automation" is off — the most common first-run failure on a fresh host. Names
+ *  the exact fix. */
+export class SafariRemoteAutomationDisabledError extends Error {
+    constructor(detail) {
+        super(`safari-remote-automation-disabled: safaridriver refused the session (${detail}). ` +
+            'Run `sudo safaridriver --enable` and enable Safari ▸ Develop ▸ "Allow Remote Automation".');
+        this.name = "SafariRemoteAutomationDisabledError";
+    }
+}
+/** Raised when a second session is requested while one is already live —
+ *  safaridriver is single-session. */
+export class SafariSessionBusyError extends Error {
+    constructor() {
+        super("safari-session-busy: safaridriver hosts ONE session at a time and a Safari session is " +
+            "already open. Close it before opening another.");
+        this.name = "SafariSessionBusyError";
+    }
+}
+export class SafaridriverHybridAdapter {
+    engine = "safari";
+    capabilities;
+    deps;
+    /** The single live session (safaridriver is single-session). */
+    active;
+    constructor(deps = {}) {
+        // safari always has a declaration (see capabilities.ts).
+        this.capabilities = capabilitiesFor("safari");
+        this.deps = deps;
+    }
+    /** Launch a managed, isolated Safari automation window and create a hybrid
+     *  Classic+BiDi session. Single-session: refuses if one is already live. */
+    async launchManaged() {
+        if (this.active)
+            throw new SafariSessionBusyError();
+        const launch = this.deps.launch ?? launchSafaridriver;
+        const driver = await launch(this.deps.launchDeps);
+        const webDriver = (this.deps.webDriverFactory ?? ((baseUrl) => new SafariWebDriverClient({ baseUrl })))(driver.baseUrl);
+        let session;
+        try {
+            // Request BiDi (experimental cap) AND Classic — BiDi is additive; a boolean
+            // placeholder (cap off) simply means no ws:// URL, so we stay Classic-only.
+            session = await webDriver.newSession({ webSocketUrl: true, experimentalWebSocketUrl: true });
+        }
+        catch (err) {
+            driver.stop();
+            throw mapSessionError(err);
+        }
+        let bidi;
+        if (session.webSocketUrl) {
+            const client = (this.deps.bidiFactory ?? ((url) => new SafariBidiClient({ url })))(session.webSocketUrl);
+            try {
+                await client.connect();
+                bidi = client;
+            }
+            catch {
+                // BiDi is optional — a failed connect degrades to Classic-only, never
+                // fails the session.
+                bidi = undefined;
+            }
+        }
+        const handle = {
+            engine: this.engine,
+            capabilities: this.capabilities,
+            sessionId: session.sessionId,
+            webDriver,
+            bidi,
+            hasBidi: bidi !== undefined,
+            close: async () => {
+                bidi?.close();
+                await webDriver.deleteSession(session.sessionId).catch(() => undefined);
+                driver.stop();
+                this.active = undefined;
+            },
+        };
+        this.active = handle;
+        return handle;
+    }
+    /** Attach is NOT supported: safaridriver hard-isolates automation into a clean
+     *  ephemeral window and cannot attach to the user's live, logged-in Safari (the
+     *  XPC surface is categorically closed to third parties). Structured
+     *  refusal, never a vague failure. */
+    attach() {
+        return Promise.reject(new Error("safari-attach-not-supported: real Safari automation is non-BYOB by construction — " +
+            "safaridriver hard-isolates each session into a clean ephemeral automation window (no " +
+            "cookies/localStorage/Keychain/history from the real profile), and the webinspectord XPC " +
+            "surface that would allow attach is closed to third parties. Use a managed session."));
+    }
+}
+/** Map a session-create failure to a structured, actionable error. safaridriver
+ *  signals "Allow Remote Automation" being off as a `session not created`. */
+function mapSessionError(err) {
+    if (err instanceof WebDriverError) {
+        if (err.code === "session not created" || /automation/i.test(err.message)) {
+            return new SafariRemoteAutomationDisabledError(err.message || err.code);
+        }
+        return err;
+    }
+    return err instanceof Error ? err : new Error(String(err));
+}

package/dist/engine/adapters/webkit.engine.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/engine/adapters/webkit.engine.js

@@ -0,0 +1,47 @@
+// WebKit engine registration (RFC 0004 D1). Registers the one `EngineEntry` for
+// the webkit engine (Playwright's bundled WebKit build — the WebKit-ENGINE
+// correctness lane, NOT Safari). No adapter logic moves: launch stays in
+// `PlaywrightWebKitAdapter`; the substrate bundle is the shared Playwright one
+// (WebKit has a Page, no CDP → page-side snapshot walker + Playwright network
+// substrate); the post-wire is the full Playwright set. BYOB attach surfaces the
+// adapter's structured `webkit-attach-not-supported`.
+import { registerEngine } from "../registry.js";
+import { capabilitiesFor } from "../capabilities.js";
+import { PlaywrightWebKitAdapter } from "./playwright-webkit.js";
+import { playwrightSubstrateBundle } from "../../page/substrate-bundle.js";
+import { playwrightPostWire } from "../../session/playwright-post-wire.js";
+import { buildManagedLaunch, buildIncognitoContextOptions, finalizeManagedSession, finalizeIncognitoSession, } from "../../session/launch-options.js";
+import { assertByobAttach } from "../../session/byob-attach.js";
+async function makeWebKitAdapter(opts) {
+    const mode = opts.launchMode ?? "managed";
+    if (mode === "byob") {
+        // Playwright's WebKit build has no CDP/BiDi attach client, and real Safari
+        // attach is impossible regardless. Surface the structured
+        // `webkit-attach-not-supported` error (no silent fail).
+        const url = assertByobAttach(opts);
+        await new PlaywrightWebKitAdapter().attach(url);
+        throw new Error("unreachable: webkit attach always refuses");
+    }
+    if (mode === "incognito") {
+        const adapter = new PlaywrightWebKitAdapter();
+        const { browser, context, page } = await adapter.launchEphemeral({
+            launchOptions: { headless: !!opts.headless },
+            contextOptions: buildIncognitoContextOptions(opts),
+        });
+        return finalizeIncognitoSession("webkit", { browser, context, page });
+    }
+    // WebKit DOES support launchPersistentContext (measured), so managed mode is
+    // real. The chromium-only `args` splice never reaches it (the adapter takes
+    // only the shared options).
+    const { profileDir, options } = buildManagedLaunch("webkit", opts);
+    const adapter = new PlaywrightWebKitAdapter();
+    const { context, page } = await adapter.launchPersistent({ profileDir, options });
+    return finalizeManagedSession("webkit", opts, profileDir, { context, page });
+}
+registerEngine({
+    kind: "webkit",
+    capabilities: capabilitiesFor("webkit"),
+    makeAdapter: makeWebKitAdapter,
+    makeSubstrates: (deps) => playwrightSubstrateBundle(deps),
+    postWire: (entry, deps) => playwrightPostWire(entry, deps),
+});

package/dist/engine/capabilities.d.ts

@@ -0,0 +1,53 @@
+import type { EngineCapabilities, EngineKind } from "./types.js";
+/** Chromium supports the whole port surface, including the CDP escape hatch.
+ *  Declaring everything is what makes the chromium path byte-identical: the
+ *  engine dimension is present but gates nothing. */
+export declare const CHROMIUM_CAPABILITIES: EngineCapabilities;
+/** Firefox (Playwright's bundled Juggler build, the default cross-browser lane).
+ *  It serves the same cross-browser sub-interfaces as Chromium — Playwright
+ *  abstracts navigation, input, storage, script, emulation, capture, and the
+ *  snapshot / network substrates (the latter two move onto Playwright-portable
+ *  mechanisms) — but exposes NO `deep` (raw-CDP) escape hatch. `deep: false` is what
+ *  the engine gate keys on to refuse the ~19 CDP-hard tools (perf / coverage /
+ *  heap / CPU throttle / SW interception / extensions / pdf) with a hint. */
+export declare const FIREFOX_CAPABILITIES: EngineCapabilities;
+/** WebKit (Playwright's bundled WebKit build — the WebKit-ENGINE correctness lane,
+ *  NOT Safari). It serves the same nine cross-browser sub-interfaces
+ *  as Chromium/Firefox (Playwright abstracts navigation, input, storage, script,
+ *  emulation, capture, and the snapshot substrate — the page-side walker serves
+ *  WebKit just as it serves Firefox; the network substrate ports onto Playwright
+ *  events) — but exposes NO `deep` (raw-CDP) escape hatch. WebKit has no
+ *  CDP at all (measured: `newCDPSession` throws "CDP session is only available in
+ *  Chromium"), so `deep: false` is what the CAPABILITY-based engine gate keys on
+ *  to refuse the ~26 CDP-deep tools with a hint — no per-engine gate edit. */
+export declare const WEBKIT_CAPABILITIES: EngineCapabilities;
+/** Android (real Chrome-on-Android attached over adb + CDP). The
+ *  STANDOUT among the non-chromium engines: Android Chrome speaks FULL CDP, so
+ *  this engine exposes the `deep` (raw-CDP) escape hatch just like desktop
+ *  Chromium — `deep: true`. That single fact is why Android needs NO new
+ *  substrate: the CDP capability signal routes it through the EXISTING
+ *  `CdpSnapshotSubstrate` + `CdpNetworkSubstrate` (via `snapshotSubstrateFor` /
+ *  `networkSubstrateFor`, which key on CDP presence), and the capability-based
+ *  engine gate auto-ALLOWS every tool (it refuses only on `deep: false`). So
+ *  unlike firefox/webkit, EVERYTHING works on Android — the CDP-deep tools too
+ *  (perf / coverage / heap / cpu / clock / CDP input dispatch / closed-shadow).
+ *  The only Android-specific limits are launch-shape, not capability: managed /
+ *  ephemeral launch isn't a thing on a phone (the adapter's launch path returns
+ *  a structured `android-launch-not-supported` — Android is attach-only). */
+export declare const ANDROID_CAPABILITIES: EngineCapabilities;
+/** Safari (real Safari.app over safaridriver, the FIRST non-Playwright,
+ *  non-CDP engine). A curated SUBSET, not the full port:
+ *  Classic owns input/capture(screenshot)/cookies + navigation + exec; experimental
+ *  BiDi owns script + browsingContext nav/lifecycle/viewport + the console/nav
+ *  events. NETWORK is omitted entirely — Safari has no protocol-level network tap
+ *  or interception at all (worse than firefox/webkit, which get the Playwright-event
+ *  substrate), so the network tools must REFUSE on Safari, not skip. EMULATION is
+ *  omitted too — only `browsingContext.setViewport` works; the rest of the emulation
+ *  surface (geolocation/locale/timezone/UA/network-conditions/CPU/clock) is absent,
+ *  so it gates uniformly. `deep: false` (no CDP) gates the ~26 CDP-deep tools via the
+ *  existing caps.deep gate with no per-engine edit. */
+export declare const SAFARI_CAPABILITIES: EngineCapabilities;
+/** The capability declaration for an engine. Chromium + Firefox + WebKit +
+ *  Android all have declarations; the partial map keeps room
+ *  for engines whose adapter hasn't landed yet (returns undefined for those). */
+export declare function capabilitiesFor(engine: EngineKind): EngineCapabilities | undefined;

package/dist/engine/capabilities.js

@@ -0,0 +1,122 @@
+// Per-engine capability declarations — the ENGINE dimension that composes with
+// the per-tool capability system in util/capabilities.ts. An adapter declares
+// which port sub-interfaces it implements and whether it exposes the `Deep`
+// (raw-CDP) escape hatch; the per-tool gate consults this to refuse a CDP-hard
+// tool on an engine that can't run it.
+//
+// Chromium declares EVERYTHING — every sub-interface plus `deep` — so no tool
+// is newly gated; that is what makes the chromium path byte-identical.
+// Firefox declares the cross-browser sub-interfaces but `deep: false`: the
+// Juggler build over Playwright has no raw-CDP escape hatch (`newCDPSession`
+// throws on Firefox — measured), so the ~19 CDP-hard tools
+// structured-refuse on it. WebKit is the same shape — all nine cross-
+// browser sub-interfaces, `deep: false` (WebKit has no CDP at all — measured:
+// `newCDPSession` throws "CDP session is only available in Chromium"). Android
+// is the standout: it IS Chromium (attached over adb + CDP), so it declares
+// `deep: true` like desktop Chromium — every tool, including the CDP-deep ones,
+// works, and no new substrate is needed (the CDP substrates serve it verbatim).
+// The full Playwright-backed sub-interface set — every cross-browser
+// sub-interface PLUS `page` (RFC 0004 D5: chromium / firefox / webkit / android
+// all back a real Playwright `Page`). Safari declares its own subset below and
+// omits `page` (no-Playwright-Page), which is what its post-wire keys off.
+const ALL_SUB_INTERFACES = [
+    "lifecycle",
+    "navigation",
+    "snapshot",
+    "input",
+    "network",
+    "storage",
+    "script",
+    "emulation",
+    "capture",
+    "page",
+];
+/** Chromium supports the whole port surface, including the CDP escape hatch.
+ *  Declaring everything is what makes the chromium path byte-identical: the
+ *  engine dimension is present but gates nothing. */
+export const CHROMIUM_CAPABILITIES = {
+    engine: "chromium",
+    subInterfaces: new Set(ALL_SUB_INTERFACES),
+    deep: true,
+};
+/** Firefox (Playwright's bundled Juggler build, the default cross-browser lane).
+ *  It serves the same cross-browser sub-interfaces as Chromium — Playwright
+ *  abstracts navigation, input, storage, script, emulation, capture, and the
+ *  snapshot / network substrates (the latter two move onto Playwright-portable
+ *  mechanisms) — but exposes NO `deep` (raw-CDP) escape hatch. `deep: false` is what
+ *  the engine gate keys on to refuse the ~19 CDP-hard tools (perf / coverage /
+ *  heap / CPU throttle / SW interception / extensions / pdf) with a hint. */
+export const FIREFOX_CAPABILITIES = {
+    engine: "firefox",
+    subInterfaces: new Set(ALL_SUB_INTERFACES),
+    deep: false,
+};
+/** WebKit (Playwright's bundled WebKit build — the WebKit-ENGINE correctness lane,
+ *  NOT Safari). It serves the same nine cross-browser sub-interfaces
+ *  as Chromium/Firefox (Playwright abstracts navigation, input, storage, script,
+ *  emulation, capture, and the snapshot substrate — the page-side walker serves
+ *  WebKit just as it serves Firefox; the network substrate ports onto Playwright
+ *  events) — but exposes NO `deep` (raw-CDP) escape hatch. WebKit has no
+ *  CDP at all (measured: `newCDPSession` throws "CDP session is only available in
+ *  Chromium"), so `deep: false` is what the CAPABILITY-based engine gate keys on
+ *  to refuse the ~26 CDP-deep tools with a hint — no per-engine gate edit. */
+export const WEBKIT_CAPABILITIES = {
+    engine: "webkit",
+    subInterfaces: new Set(ALL_SUB_INTERFACES),
+    deep: false,
+};
+/** Android (real Chrome-on-Android attached over adb + CDP). The
+ *  STANDOUT among the non-chromium engines: Android Chrome speaks FULL CDP, so
+ *  this engine exposes the `deep` (raw-CDP) escape hatch just like desktop
+ *  Chromium — `deep: true`. That single fact is why Android needs NO new
+ *  substrate: the CDP capability signal routes it through the EXISTING
+ *  `CdpSnapshotSubstrate` + `CdpNetworkSubstrate` (via `snapshotSubstrateFor` /
+ *  `networkSubstrateFor`, which key on CDP presence), and the capability-based
+ *  engine gate auto-ALLOWS every tool (it refuses only on `deep: false`). So
+ *  unlike firefox/webkit, EVERYTHING works on Android — the CDP-deep tools too
+ *  (perf / coverage / heap / cpu / clock / CDP input dispatch / closed-shadow).
+ *  The only Android-specific limits are launch-shape, not capability: managed /
+ *  ephemeral launch isn't a thing on a phone (the adapter's launch path returns
+ *  a structured `android-launch-not-supported` — Android is attach-only). */
+export const ANDROID_CAPABILITIES = {
+    engine: "android",
+    subInterfaces: new Set(ALL_SUB_INTERFACES),
+    deep: true,
+};
+/** Safari (real Safari.app over safaridriver, the FIRST non-Playwright,
+ *  non-CDP engine). A curated SUBSET, not the full port:
+ *  Classic owns input/capture(screenshot)/cookies + navigation + exec; experimental
+ *  BiDi owns script + browsingContext nav/lifecycle/viewport + the console/nav
+ *  events. NETWORK is omitted entirely — Safari has no protocol-level network tap
+ *  or interception at all (worse than firefox/webkit, which get the Playwright-event
+ *  substrate), so the network tools must REFUSE on Safari, not skip. EMULATION is
+ *  omitted too — only `browsingContext.setViewport` works; the rest of the emulation
+ *  surface (geolocation/locale/timezone/UA/network-conditions/CPU/clock) is absent,
+ *  so it gates uniformly. `deep: false` (no CDP) gates the ~26 CDP-deep tools via the
+ *  existing caps.deep gate with no per-engine edit. */
+export const SAFARI_CAPABILITIES = {
+    engine: "safari",
+    subInterfaces: new Set([
+        "lifecycle",
+        "navigation",
+        "snapshot",
+        "input",
+        "storage",
+        "script",
+        "capture",
+    ]),
+    deep: false,
+};
+const DECLARATIONS = {
+    chromium: CHROMIUM_CAPABILITIES,
+    firefox: FIREFOX_CAPABILITIES,
+    webkit: WEBKIT_CAPABILITIES,
+    android: ANDROID_CAPABILITIES,
+    safari: SAFARI_CAPABILITIES,
+};
+/** The capability declaration for an engine. Chromium + Firefox + WebKit +
+ *  Android all have declarations; the partial map keeps room
+ *  for engines whose adapter hasn't landed yet (returns undefined for those). */
+export function capabilitiesFor(engine) {
+    return DECLARATIONS[engine];
+}

package/dist/engine/capability-registry.d.ts

@@ -0,0 +1,9 @@
+import type { EngineKind, EngineCapabilities } from "./types.js";
+/** Record an engine's declared capabilities. Called by `registerEngine`. */
+export declare function setEngineCapabilities(kind: EngineKind, caps: EngineCapabilities): void;
+/** Non-throwing capability lookup — `undefined` when the engine has not
+ *  registered. The engine gate consults this so the registry's capability record
+ *  is the source of truth (RFC 0004 P1), which is what gates a runtime-only
+ *  engine (the synthetic contract-test engine) correctly without a per-engine edit
+ *  to capabilities.ts or tool-gate.ts. */
+export declare function engineCapabilities(kind: EngineKind): EngineCapabilities | undefined;

package/dist/engine/capability-registry.js

@@ -0,0 +1,20 @@
+// A minimal engine→capabilities side-table, decoupled from the full EngineRegistry
+// so the engine gate (`tool-gate.ts`) can read an engine's declared capabilities
+// WITHOUT importing `registry.ts` (which pulls in the substrate-port types and would
+// form an import cycle tool-gate → registry → page/*-substrate → engine/index →
+// tool-gate). This module imports only the capability TYPES, so it sits cleanly
+// beneath both the registry (which writes it on `registerEngine`) and the gate
+// (which reads it).
+const CAPS = new Map();
+/** Record an engine's declared capabilities. Called by `registerEngine`. */
+export function setEngineCapabilities(kind, caps) {
+    CAPS.set(kind, caps);
+}
+/** Non-throwing capability lookup — `undefined` when the engine has not
+ *  registered. The engine gate consults this so the registry's capability record
+ *  is the source of truth (RFC 0004 P1), which is what gates a runtime-only
+ *  engine (the synthetic contract-test engine) correctly without a per-engine edit
+ *  to capabilities.ts or tool-gate.ts. */
+export function engineCapabilities(kind) {
+    return CAPS.get(kind);
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,18 @@
+export type { EngineKind, EngineCapabilities, EngineSession, EngineSubInterface, EngineLaunchHandles, } from "./types.js";
+export { ENGINE_KINDS } from "./types.js";
+export { resolveBrowserType, EngineNotYetSupportedError, IMPLEMENTED_ENGINES, UnknownEngineError, validateEngine, resolveEngineSelection, } from "./select.js";
+export { capabilitiesFor, CHROMIUM_CAPABILITIES, FIREFOX_CAPABILITIES, WEBKIT_CAPABILITIES, ANDROID_CAPABILITIES, SAFARI_CAPABILITIES, } from "./capabilities.js";
+export { requireCdp, type CdpCapable } from "./session-cdp.js";
+export { assertEngineSupports, DEEP_TOOLS, type EngineRefusal } from "./tool-gate.js";
+export { PlaywrightChromiumAdapter } from "./adapters/playwright-chromium.js";
+export type { PersistentLaunchSpec, EphemeralLaunchSpec } from "./adapters/playwright-chromium.js";
+export { PlaywrightFirefoxAdapter, firefoxChannelFromEnv, MOZ_FIREFOX_CHANNEL, } from "./adapters/playwright-firefox.js";
+export type { FirefoxPersistentLaunchSpec, FirefoxEphemeralLaunchSpec, } from "./adapters/playwright-firefox.js";
+export { PlaywrightWebKitAdapter } from "./adapters/playwright-webkit.js";
+export type { WebKitPersistentLaunchSpec, WebKitEphemeralLaunchSpec, } from "./adapters/playwright-webkit.js";
+export { AndroidCdpAdapter } from "./adapters/android-cdp.js";
+export type { AndroidAttachHandles, AndroidAdapterDeps } from "./adapters/android-cdp.js";
+export { SafaridriverHybridAdapter, SafariSessionBusyError, SafariRemoteAutomationDisabledError, } from "./adapters/safaridriver-hybrid.js";
+export type { SafariSessionHandle, SafariAdapterDeps } from "./adapters/safaridriver-hybrid.js";
+export { CHROME_ANDROID_SOCKET, AdbNotInstalledError, NoAndroidDeviceError, ChromeSocketUnreachableError, devicesArgs, forwardArgs, forwardRemoveArgs, parseDevices, selectDevice, devToolsBaseUrl, versionUrl, extractWsUrl, pickFreePort, defaultAdbRunner, defaultFetcher, } from "./adapters/adb.js";
+export type { AdbDevice, AdbRunner, Fetcher } from "./adapters/adb.js";

package/dist/engine/index.js

@@ -0,0 +1,14 @@
+// The engine port — public surface of src/engine/. The session layer imports
+// from here; tools never reach past the session into an adapter or Playwright
+// directly. See docs/ai-context/architecture/engine-adapters.md.
+export { ENGINE_KINDS } from "./types.js";
+export { resolveBrowserType, EngineNotYetSupportedError, IMPLEMENTED_ENGINES, UnknownEngineError, validateEngine, resolveEngineSelection, } from "./select.js";
+export { capabilitiesFor, CHROMIUM_CAPABILITIES, FIREFOX_CAPABILITIES, WEBKIT_CAPABILITIES, ANDROID_CAPABILITIES, SAFARI_CAPABILITIES, } from "./capabilities.js";
+export { requireCdp } from "./session-cdp.js";
+export { assertEngineSupports, DEEP_TOOLS } from "./tool-gate.js";
+export { PlaywrightChromiumAdapter } from "./adapters/playwright-chromium.js";
+export { PlaywrightFirefoxAdapter, firefoxChannelFromEnv, MOZ_FIREFOX_CHANNEL, } from "./adapters/playwright-firefox.js";
+export { PlaywrightWebKitAdapter } from "./adapters/playwright-webkit.js";
+export { AndroidCdpAdapter } from "./adapters/android-cdp.js";
+export { SafaridriverHybridAdapter, SafariSessionBusyError, SafariRemoteAutomationDisabledError, } from "./adapters/safaridriver-hybrid.js";
+export { CHROME_ANDROID_SOCKET, AdbNotInstalledError, NoAndroidDeviceError, ChromeSocketUnreachableError, devicesArgs, forwardArgs, forwardRemoveArgs, parseDevices, selectDevice, devToolsBaseUrl, versionUrl, extractWsUrl, pickFreePort, defaultAdbRunner, defaultFetcher, } from "./adapters/adb.js";

package/dist/engine/register-engines.d.ts

@@ -0,0 +1,5 @@
+import "./adapters/chromium.engine.js";
+import "./adapters/firefox.engine.js";
+import "./adapters/webkit.engine.js";
+import "./adapters/android.engine.js";
+import "./adapters/safari.engine.js";

package/dist/engine/register-engines.js

@@ -0,0 +1,16 @@
+// The engine-registration barrel (RFC 0004 D1). Importing this module runs every
+// engine's `registerEngine(...)` call exactly once, populating the EngineRegistry.
+// The composition root (createServer / the session factories) imports it for its
+// side effect so the registry is fully populated before any session opens.
+//
+// Adding a sixth engine = one new `adapters/<engine>.engine.ts` module + one line
+// here. No edit to any session factory, the session registry, or host-build —
+// which is the open-closed claim the ocp-engine-contract keystone proves.
+//
+// Each import is side-effect-only (the module body calls registerEngine at load);
+// `import "./…"` form makes that explicit and keeps the barrel a pure wiring point.
+import "./adapters/chromium.engine.js";
+import "./adapters/firefox.engine.js";
+import "./adapters/webkit.engine.js";
+import "./adapters/android.engine.js";
+import "./adapters/safari.engine.js";