@sable-ai/sdk-core 0.1.0

package/dist/types/browser-bridge/actions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Action dispatcher for `browser.execute_action`.
+ *
+ * The canonical wire contract lives in the Python bridge
+ * (`sable_agentkit/components/browser/bridges/wire.py`). The `kind` tag and
+ * payload shape of each variant must stay in lock-step with it — if a new
+ * action lands on the Python side, mirror it here.
+ *
+ * Target resolution: actions can target an element either by CSS selector
+ * string or by `{ x, y }` coordinates (for vision-driven clicks where the
+ * agent only knows pixel positions). See `resolveTarget`.
+ */
+export interface ActionEnvelope {
+    kind: string;
+    payload?: unknown;
+    button?: string;
+    key?: string;
+    text?: string;
+    delay?: number;
+    replace?: boolean;
+    url?: string;
+    expression?: string;
+    start?: unknown;
+    end?: unknown;
+    steps?: number;
+}
+export declare function dispatchAction(action: ActionEnvelope): Promise<void>;

package/dist/types/browser-bridge/dom-state.d.ts

@@ -0,0 +1,37 @@
+/**
+ * DOM-state capture for `browser.get_dom_state`.
+ *
+ * The agent calls `browser.get_dom_state` when it needs a fresh snapshot of
+ * the page before deciding on the next action. The response carries three
+ * things:
+ *
+ *   - `screenshot_jpeg_b64` — a wireframe-rendered image of `document.body`
+ *     (the field name is historical; the bytes are PNG — Northstar treats
+ *     it as an opaque image and doesn't enforce the codec)
+ *   - `elements` — the visible-element list produced by `visible-dom.js`,
+ *     an agent-friendly structured summary of the interactive DOM
+ *   - `viewport` + `url` — so the agent can reason about pixel coordinates
+ *     and the current page identity
+ *
+ * `visible-dom.js` is shipped as a text asset and eval'd once on first use.
+ * `settle()` is also here — it's a mutation-observer quiet-period wait used
+ * by the `browser.settle` RPC to let animations/transitions finish before
+ * the agent reads DOM state again.
+ */
+export interface DomStateResponse {
+    screenshot_jpeg_b64: string;
+    elements: unknown;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    url: string;
+}
+export declare function captureDomState(): Promise<DomStateResponse>;
+/**
+ * Mutation-observer quiet-period wait. Mirrors `visible_dom.py`'s settle —
+ * return as soon as the DOM has been quiet for `QUIET_MS`, or after
+ * `MAX_MS`, whichever comes first. Bookended by two double-rAFs so any
+ * in-flight layout/paint work gets flushed before and after the wait.
+ */
+export declare function settle(): Promise<void>;

package/dist/types/browser-bridge/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SDK side of the Sable browser bridge.
+ *
+ * Registers six LiveKit RPC handlers that the agent's UserBrowserBridge
+ * (`sable-agentkit/components/browser/bridges/user.py`) calls into:
+ *
+ *   browser.execute_action  → dispatches an Action variant against the page
+ *   browser.get_dom_state   → wireframe screenshot + visible-element list
+ *   browser.get_url         → window.location.href
+ *   browser.get_viewport    → window.innerWidth/innerHeight
+ *   browser.verify_selector → !!document.querySelector(selector)
+ *   browser.settle          → mutation-observer quiet-period wait
+ *
+ * The wire contract is the canonical Python implementation in
+ * `sable_agentkit/components/browser/bridges/wire.py` — every field shape
+ * and Action `kind` tag must match it exactly.
+ */
+import type { RpcRoom } from "../rpc";
+export declare function registerBrowserHandlers(room: RpcRoom): void;

package/dist/types/connection/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * sable-api `/connection-details` fetch.
+ *
+ * Isolated in its own file because this is the ONE thing that changes when
+ * the backend flips from raw agent IDs (`?agentPublicId=...`) to publishable
+ * keys (`?publicKey=pk_live_...` + per-agent allowed-domains origin check).
+ * When that lands, the diff is contained to this file.
+ *
+ * Until then: we accept `publicKey` from the customer and pass it through as
+ * `?agentPublicId=...` on the wire, which keeps the current sable-api
+ * contract working while the public-facing option name is already the one
+ * we want long-term.
+ */
+export declare const DEFAULT_API_URL = "https://sable-api-gateway-9dfmhij9.wl.gateway.dev";
+export interface ConnectionDetails {
+    serverUrl: string;
+    roomName: string;
+    participantToken: string;
+    participantName: string;
+}
+export interface FetchConnectionDetailsInput {
+    apiUrl: string;
+    /** Either a `pk_live_...` publishable key or a raw `agt_...` agent ID. */
+    publicKey: string;
+}
+export declare function fetchConnectionDetails(input: FetchConnectionDetailsInput): Promise<ConnectionDetails>;

package/dist/types/events/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Typed event emitter for the SDK's public event surface.
+ *
+ * Intentionally tiny — one map, one loop, no dependency on any EventTarget
+ * polyfill. We keep fire-and-forget semantics: handler exceptions are caught
+ * and logged so one misbehaving subscriber can't break the session.
+ */
+import type { SableEventHandler, SableEvents } from "../types";
+export declare class SableEventEmitter {
+    private readonly listeners;
+    on<E extends keyof SableEvents>(event: E, handler: SableEventHandler<E>): () => void;
+    emit<E extends keyof SableEvents>(event: E, payload: SableEvents[E]): void;
+    /** Drop every handler. Called on session teardown to avoid leaks. */
+    clear(): void;
+}

package/dist/types/global.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `window.Sable` installer.
+ *
+ * The SDK ships in two distribution formats that MUST present the same
+ * runtime singleton:
+ *
+ *   1. IIFE bundle (`<script src="https://sdk.withsable.com/v1/sable.js">`)
+ *      — auto-installs `window.Sable` on load.
+ *
+ *   2. npm ESM (`import Sable from "@sable-ai/sdk-core"`) — the `index.ts`
+ *      barrel calls `installGlobal()` in addition to exporting `Sable` as
+ *      its default export. If the customer also loaded the IIFE in the
+ *      same page, the second install is a no-op (first-write-wins), so
+ *      framework apps and script-tag users see the exact same session
+ *      object. This is the Stripe/Intercom pattern: one global, multiple
+ *      ways to reach it.
+ */
+import type { SableAPI } from "./types";
+/** The process-wide Sable singleton. Used by both `index.ts` and `installGlobal`. */
+export declare const Sable: SableAPI;
+/**
+ * Attach `Sable` to `window.Sable`, unless something already claimed that
+ * slot. First-write-wins so mixed script-tag + npm usage doesn't swap the
+ * singleton mid-session.
+ */
+export declare function installGlobal(): void;

package/dist/types/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @sable-ai/sdk-core — public entry point.
+ *
+ * Two ways to use this package, both backed by the same singleton:
+ *
+ *   1. Script tag (IIFE bundle):
+ *      `<script src="https://sdk.withsable.com/v1/sable.js"></script>`
+ *      — auto-installs `window.Sable`, good for no-build sites and the
+ *        Chrome extension's inject script.
+ *
+ *   2. npm package (ESM):
+ *      `import Sable from "@sable-ai/sdk-core"`
+ *      — good for framework apps. Importing also installs `window.Sable`
+ *        so mixed usage (one page, two entry points) stays coherent.
+ *
+ * This file is a barrel: all real code lives in sibling folders. Keep it
+ * that way — the build output is what customers see, and a lean entry
+ * module minimises tree-shake surprises.
+ */
+import { Sable } from "./global";
+export { VERSION } from "./version";
+export type { SableAPI, SableEvents, SableEventHandler, StartOptions, VisionOptions, FrameSource, WireframeFrameSource, FnFrameSource, RuntimeMethod, RuntimeMethods, } from "./types";
+export default Sable;

package/dist/types/rpc.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared LiveKit RPC primitives.
+ *
+ * Both `runtime/` (agent → page method calls) and `browser-bridge/` (agent
+ * driving the user's browser) register handlers on the room via
+ * `registerRpcMethod`. They don't need the full LiveKit `Room` type — just the
+ * single method — so we describe the minimum shape here. This keeps the heavy
+ * `livekit-client` import dynamic and out of the IIFE entry bundle.
+ */
+export interface RpcRoom {
+    registerRpcMethod(method: string, handler: (data: {
+        payload: string;
+    }) => Promise<string>): void;
+}
+/**
+ * Parse an RPC payload string into a plain object. RPC payloads are JSON but
+ * we don't want a single malformed call from the agent to throw inside a
+ * handler — LiveKit RPC propagates exceptions back to the caller and the
+ * agent's tool use logic treats that as a hard error that can derail the
+ * conversation. Soft-failing to `{}` lets the handler decide what to do.
+ */
+export declare function safeParse(payload: string): Record<string, unknown>;

package/dist/types/runtime/clipboard.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Clipboard runtime methods.
+ *
+ * `sendToolMessage` and its legacy alias `sendCopyableText` carry text the
+ * user is supposed to act on (URLs, code snippets, prompts). Parley renders
+ * them as chat bubbles; the standalone SDK has no chat surface, so we copy
+ * to the clipboard so the user can ⌘V into whatever the agent is guiding
+ * them through. URL wins over message when both are present — agents put
+ * explanatory text in `message` and the actual thing-to-copy in `url`.
+ */
+export declare function handleCopyable(rpcName: string, payload: Record<string, unknown>): Promise<{
+    success: boolean;
+    error?: string;
+}>;

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Runtime: the set of methods the agent can RPC into the page.
+ *
+ * Historically these were called "UI stubs" because they originated as
+ * no-op placeholders for methods parley implements in its call overlay.
+ * That framing no longer fits: half of them now do real work, and the
+ * public API lets customers replace any of them AND add new ones through
+ * the same `Sable.start({ runtime })` surface.
+ *
+ * The shape:
+ *
+ *   1. `DEFAULT_RUNTIME` — built-in implementations shipped with the SDK.
+ *      A few do real work (clipboard copy, video overlay); the rest are
+ *      no-ops for methods that only make sense in a host-app call UI.
+ *
+ *   2. `installRuntime(room, userRuntime)` — merges `userRuntime` over the
+ *      defaults and registers every entry as a LiveKit RPC handler on
+ *      `room`. Agent RPC calls → run the matching method → return a
+ *      JSON-encoded result.
+ *
+ * Customers extend the runtime by passing new keys in `userRuntime`:
+ * anything you put in becomes callable by the agent as-is. This means
+ * the same surface handles both "override a built-in" and "expose a
+ * business-logic tool" — one concept, not two.
+ */
+import { type RpcRoom } from "../rpc";
+import type { RuntimeMethods } from "../types";
+export declare const DEFAULT_RUNTIME: RuntimeMethods;
+/**
+ * Merge the user-provided runtime over `DEFAULT_RUNTIME` and register every
+ * entry as a LiveKit RPC handler on `room`. Later keys win — so passing
+ * `{ switchView: myImpl }` replaces the default video-overlay behaviour,
+ * while passing `{ activateTrial: ... }` exposes a new method the agent
+ * can call without touching the built-ins.
+ */
+export declare function installRuntime(room: RpcRoom, userRuntime?: RuntimeMethods): void;

package/dist/types/runtime/video-overlay.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Default `switchView({ mode: "video", url })` implementation.
+ *
+ * Mounts a centred floating video clip in the page. Host apps with their own
+ * call UI would override `switchView` in `runtime` to render into their own
+ * surface; the standalone SDK uses this simple overlay as the built-in
+ * default so agents that call `switchView` Just Work out of the box.
+ *
+ * Module-level state (`activeViewOverlay`) keeps at most one overlay mounted
+ * — calling `mountVideoOverlay` while another is showing tears the old one
+ * down first.
+ */
+export declare function removeViewOverlay(): void;
+export declare function mountVideoOverlay(url: string): void;

package/dist/types/session/debug-panel.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Floating debug panel — "what the agent sees".
+ *
+ * When debug is on, we mount the vision capture canvas as a draggable
+ * preview in the host page. The panel renders the *exact* pixels that get
+ * encoded into the LiveKit video track, so "what you see in the panel" is
+ * literally "what the agent sees". Position + minimized state persist in
+ * `localStorage` so customers don't have to re-place the panel every
+ * reload.
+ *
+ * Opt-in signals (any of these enables the panel):
+ *   - `Sable.start({ debug: true })`
+ *   - `?sable-debug=1` anywhere in the page URL
+ *   - `localStorage.setItem('sable:debug', '1')`
+ */
+/**
+ * Opt-in check: does ANY of the debug signals say we should show the panel?
+ * Called by the session before deciding whether to mount.
+ */
+export declare function shouldShowDebugPanel(debugOpt: boolean | undefined): boolean;
+/**
+ * Mount `canvas` as a floating preview in the page. Returns a teardown that
+ * removes the wrapper and detaches listeners.
+ *
+ * The wrapper is pointer-events:none by default; only the header bar and
+ * its minimize button re-enable pointer events, so the panel never blocks
+ * clicks on the underlying page.
+ */
+export declare function mountDebugPanel(canvas: HTMLCanvasElement): () => void;

package/dist/types/session/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Session lifecycle.
+ *
+ * `Session` is the glue layer: it fetches connection details, dynamically
+ * imports `livekit-client`, connects, publishes the mic, registers the
+ * runtime + browser-bridge RPCs, and — if vision is enabled — starts the
+ * frame source + video publisher and mounts the debug panel. `start()`
+ * returns once the room is live and mic is publishing; events are emitted
+ * via the `SableEventEmitter`.
+ *
+ * Only one session is allowed at a time. `start()` throws if a session is
+ * already active; callers must `stop()` first. `stop()` is idempotent.
+ *
+ * `livekit-client` is imported dynamically (not statically) so the IIFE
+ * entry bundle stays small — the heavy client only loads when a customer
+ * actually calls `start()`.
+ */
+import type { SableAPI, SableEventHandler, SableEvents, StartOptions } from "../types";
+/**
+ * One active session at a time. The class is internal — customers interact
+ * with the `SableAPI` singleton installed on `window.Sable` (see `global.ts`).
+ * Keeping a class here (rather than a bag of module-level vars) makes the
+ * state ownership explicit and the teardown path easier to reason about.
+ */
+export declare class Session implements SableAPI {
+    readonly version = "0.1.0";
+    private readonly emitter;
+    private activeRoom;
+    private visionHandle;
+    private unmountDebugPanel;
+    on<E extends keyof SableEvents>(event: E, handler: SableEventHandler<E>): () => void;
+    start(opts: StartOptions): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Subscribe to LiveKit room events and translate the interesting ones into
+     * `SableEvents`. Keeps the Session → customer event surface decoupled from
+     * the LiveKit event names so we can swap the transport later without
+     * breaking subscribers.
+     */
+    private wireRoomEvents;
+}

package/dist/types/types/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Public type surface for @sable-ai/sdk-core.
+ *
+ * Everything a consumer can touch lives here. Internal types stay in their
+ * respective modules so we never accidentally ship them in the published
+ * `.d.ts` bundle.
+ */
+export interface WireframeFrameSource {
+    type: "wireframe";
+    /** Capture rate in frames per second. Default: 2. */
+    rate?: number;
+    features?: {
+        /**
+         * Include rendered images in the wireframe (instead of placeholder boxes).
+         * Slightly higher CPU + bandwidth. Default: false.
+         */
+        includeImages?: boolean;
+    };
+}
+export interface FnFrameSource {
+    type: "fn";
+    /** Capture rate in frames per second. Default: 2. */
+    rate?: number;
+    /**
+     * Called at `rate` Hz. Return an `HTMLCanvasElement` or `ImageBitmap` that
+     * the SDK will publish to the agent as a video track. Useful for feeding
+     * custom sources like a 3D scene, a `<video>` element, or a WebGL surface
+     * that the DOM walker can't introspect.
+     */
+    captureFn: () => HTMLCanvasElement | ImageBitmap;
+}
+export type FrameSource = WireframeFrameSource | FnFrameSource;
+export interface VisionOptions {
+    /**
+     * Whether to publish a video track of the page to the agent. Default: false.
+     * Turn this on for agents that should be able to *see* the user's screen
+     * in addition to hearing them.
+     */
+    enabled?: boolean;
+    /**
+     * Where video frames come from. Defaults to the built-in wireframe renderer
+     * at 2 fps with images disabled.
+     */
+    frameSource?: FrameSource;
+}
+export type RuntimeMethod = (payload: Record<string, unknown>) => unknown | Promise<unknown>;
+/**
+ * Map of method name → handler. Used both for the user-provided overrides
+ * passed to `Sable.start({ runtime })` and for the SDK's internal defaults.
+ */
+export interface RuntimeMethods {
+    [method: string]: RuntimeMethod;
+}
+export interface StartOptions {
+    /**
+     * Publishable key for the agent (from platform.withsable.com → your agent
+     * → Web SDK → Public key). Safe to ship in client-side code — the security
+     * boundary is the allowed-domains list configured alongside the key.
+     *
+     * During beta, raw agent IDs (e.g. `agt_...`) are accepted here too.
+     */
+    publicKey?: string;
+    /**
+     * @deprecated Use `publicKey` instead. Accepted as an alias during beta and
+     * will be removed before 1.0. If both are set, `publicKey` wins.
+     */
+    agentPublicId?: string;
+    /**
+     * What the agent can see. Off by default — opt in for vision-enabled agents.
+     */
+    vision?: VisionOptions;
+    /**
+     * Overrides + extensions for methods the agent can RPC into the page.
+     * Unspecified methods fall back to the SDK's default implementations. New
+     * methods become callable by the agent as-is.
+     */
+    runtime?: RuntimeMethods;
+    /**
+     * Arbitrary metadata forwarded to the agent at session start. Surfaces
+     * verbatim in the agent's initial prompt.
+     */
+    context?: Record<string, unknown>;
+    /**
+     * Dev-only: mount a floating preview panel showing the exact wireframe
+     * canvas being published to the agent. Can also be enabled via
+     * `?sable-debug=1` or `localStorage["sable:debug"]="1"`.
+     */
+    debug?: boolean;
+    /**
+     * Override the sable-api base URL. Dev/test only. Defaults to the
+     * production gateway.
+     * @internal
+     */
+    apiUrl?: string;
+}
+export interface SableEvents {
+    /** Fired once the room is connected, mic is live, and handshake is done. */
+    "session:started": {
+        roomName: string;
+        participantName: string;
+    };
+    /** Fired once when the session ends for any reason. */
+    "session:ended": {
+        reason?: string;
+    };
+    /** Fired whenever the agent starts or stops speaking. */
+    "agent:speaking": boolean;
+    /** Fired whenever the local user starts or stops speaking. */
+    "user:speaking": boolean;
+    /** Fired for any non-fatal error during the session. */
+    error: Error;
+}
+export type SableEventHandler<E extends keyof SableEvents> = (payload: SableEvents[E]) => void;
+export interface SableAPI {
+    /** SDK version string, matches the npm package version. */
+    version: string;
+    /** Start a voice (and optionally vision) session with the agent. */
+    start(opts: StartOptions): Promise<void>;
+    /** Tear down the active session. No-op if none. */
+    stop(): Promise<void>;
+    /**
+     * Subscribe to a session event. Returns an unsubscribe function. Fire-and-
+     * forget — the SDK does not care whether you subscribe.
+     */
+    on<E extends keyof SableEvents>(event: E, handler: SableEventHandler<E>): () => void;
+}
+declare global {
+    interface Window {
+        Sable?: SableAPI;
+    }
+}

package/dist/types/version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Single source of truth for the SDK version string.
+ *
+ * Kept in a standalone file so build tooling (GitHub Actions release workflow)
+ * can replace it at publish time without touching anything else.
+ */
+export declare const VERSION = "0.1.0";

package/dist/types/vision/frame-source.d.ts

@@ -0,0 +1,34 @@
+/**
+ * FrameSource dispatcher.
+ *
+ * The public API lets customers choose what the agent sees via
+ * `vision: { frameSource: { type: "wireframe" | "fn", ... } }`. This module
+ * hides the strategy behind one entrypoint — `startFrameSource` — which
+ * returns a stop function. The target canvas is passed in so the caller
+ * (vision/index.ts) can hand the same canvas to `canvas.captureStream()`.
+ *
+ * Two built-in sources:
+ *
+ *   1. `{ type: "wireframe", rate, features: { includeImages } }`
+ *      — Runs the Wireframe library against `document.body` at `rate` Hz.
+ *        This is the default, tuned for low bandwidth + agent-readable
+ *        structure. `includeImages: true` fetches cover photos/avatars/
+ *        thumbnails via CORS and draws real pixels; otherwise the agent
+ *        gets labelled placeholder boxes.
+ *
+ *   2. `{ type: "fn", rate, captureFn }`
+ *      — The user supplies a function that returns a canvas or ImageBitmap
+ *        on each tick. Useful for custom sources the DOM walker can't
+ *        introspect: `<video>` elements, WebGL/3D scenes, off-screen canvases.
+ *
+ * Adding a new source (e.g. `{ type: "video" }`) is a matter of:
+ *   - adding a variant in `types.ts`
+ *   - adding a case here.
+ */
+import type { FrameSource } from "../types";
+/**
+ * Start capturing frames from `source` into `canvas`. Returns a stop function
+ * that halts the loop. Errors inside a single tick are logged and skipped —
+ * one bad frame shouldn't kill vision for the rest of the session.
+ */
+export declare function startFrameSource(source: FrameSource, canvas: HTMLCanvasElement): () => void;

package/dist/types/vision/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vision entry point.
+ *
+ * `startVision` owns the full lifecycle of "what the agent sees":
+ *
+ *   1. create a capture canvas sized to the viewport
+ *   2. start the configured frame source, drawing into that canvas
+ *   3. publish the canvas as a LiveKit screenshare video track
+ *
+ * Returns both the canvas (so the session can hand it to the debug panel,
+ * which just renders the exact pixels we publish) and a combined async stop
+ * function. Everything is off by default — callers pass `vision: { enabled:
+ * true }` in `Sable.start({ ... })` to opt in.
+ */
+import type { VisionOptions } from "../types";
+import { type LiveKitPublishLib, type PublishCapableRoom } from "./publisher";
+export type { LiveKitPublishLib, PublishCapableRoom } from "./publisher";
+export interface StartVisionArgs {
+    room: PublishCapableRoom;
+    lib: LiveKitPublishLib;
+    options: VisionOptions;
+}
+export interface VisionHandle {
+    /** The canvas being published. Useful for the debug panel. */
+    canvas: HTMLCanvasElement;
+    /** Stop the frame loop and unpublish the track. */
+    stop: () => Promise<void>;
+}
+export declare function startVision(args: StartVisionArgs): Promise<VisionHandle>;

package/dist/types/vision/publisher.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Publish a canvas as a LiveKit screenshare video track.
+ *
+ * Vision is delivered as a regular LiveKit video track rather than raw
+ * bytes: we draw each frame into a persistent canvas (see `frame-source.ts`)
+ * and hand that canvas to `canvas.captureStream(fps)`. The resulting
+ * MediaStreamTrack gets wrapped in a LocalVideoTrack and published as
+ * `Track.Source.ScreenShare`, so the agent subscribes to it the same way
+ * it would subscribe to any screenshare — no custom byte-stream handler,
+ * no per-frame PNG decode, and the codec delta-compresses mostly-static
+ * pages so bandwidth stays low.
+ *
+ * The fps passed to `captureStream` should match the frame source's render
+ * rate; a mismatch either drops frames (encoder faster than source) or
+ * wastes bandwidth (encoder slower than source). `vision/index.ts` owns
+ * the pairing.
+ */
+interface LocalTrackPublication {
+    trackSid?: string;
+}
+export interface PublishCapableRoom {
+    localParticipant: {
+        publishTrack(track: unknown, options?: {
+            source?: unknown;
+            name?: string;
+        }): Promise<LocalTrackPublication>;
+        unpublishTrack(track: unknown, stopOnUnpublish?: boolean): Promise<unknown>;
+    };
+}
+export interface LiveKitPublishLib {
+    LocalVideoTrack: new (mediaStreamTrack: MediaStreamTrack, constraints?: unknown, userProvidedTrack?: boolean) => unknown;
+    Track: {
+        Source: {
+            ScreenShare: unknown;
+        };
+    };
+}
+/**
+ * Publish `canvas` as a screenshare track at `fps` frames per second.
+ * Returns an async teardown that unpublishes the track and stops the
+ * underlying MediaStreamTrack.
+ */
+export declare function publishCanvasAsVideoTrack(room: PublishCapableRoom, lib: LiveKitPublishLib, canvas: HTMLCanvasElement, fps: number): Promise<() => Promise<void>>;
+export {};

package/dist/types/vision/wireframe.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Lazy bootstrap for the Wireframe class.
+ *
+ * `wireframe.js` is shipped as a text asset (see `assets/wireframe.js.txt`)
+ * and eval'd once at first use. Evaluating inside an IIFE with a shadowed
+ * `console` keeps the library's per-capture "[wireframe] drew N elements"
+ * log out of the host page's devtools — at 1 fps it would flood the console.
+ * `.warn`/`.error` still go through so real problems surface.
+ *
+ * Used by:
+ *   - `vision/frame-source.ts` — to render the wireframe canvas at `rate` Hz
+ *   - `browser-bridge/dom-state.ts` — to produce the `screenshot_jpeg_b64`
+ *     field returned by `browser.get_dom_state`
+ */
+export type WireframeInstance = {
+    toDataURL(): Promise<string>;
+    capture: () => Promise<{
+        canvas: HTMLCanvasElement;
+    }>;
+};
+export type WireframeCtor = new (root?: Element, opts?: Record<string, unknown>) => WireframeInstance;
+export declare function getWireframeCtor(): WireframeCtor;