@bowmark/web 1.23.0 → 1.24.1

package/dist/generated/library.d.ts

@@ -5,8 +5,8 @@
 // rather than imported. An `import` or `export` at the top level of this file would
 // turn it into a module and every declaration below would stop being global.
 //
-// Manifest version: 33a70781b68188bc68feb315e91e0c61cb56ecb49e10d82f223e4feb9d6b3399
-// 50 capabilities, 418 providers, 1121 typed functions, 20 refused.
+// Manifest version: 83b6073de78d83a7366cd17844242d5703320faa6ea88973baea85a98639f7d0
+// 51 capabilities, 419 providers, 1122 typed functions, 20 refused.
 // 51,715 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
 //
 // REFUSED — these functions are real and callable, and their declared arguments
@@ -225,9 +225,10 @@ type CallOptions = {
     /**
      * Starts a hosted browser agent on `task` and returns at once with its session `id` and a
      * `watchUrl`. Use ONLY after the library had nothing for this site or a function failed — each
-     * turn spends real vendor money, charged to the account. Show `watchUrl` to your user: it lets
-     * them watch the agent and take over the browser (log in, solve a captcha). Then poll with
-     * `status`.
+     * turn spends real vendor money, charged to the account. Your account may hold up to 3
+     * concurrent sessions; call `list()` before starting if looping over multiple tasks. Show
+     * `watchUrl` to your user: it lets them watch the agent and take over the browser (log in,
+     * solve a captcha). Then poll with `status`. Always `stop()` a session when done.
      */
     start(options: StartBrowserAgentOptions): Promise<StartBrowserAgentResult>;
 
@@ -247,15 +248,17 @@ type CallOptions = {
     send(id: string, message: string, options?: SendBrowserAgentOptions): Promise<SendBrowserAgentResult>;
 
     /**
-     * Stops the agent and shuts its browser; the watch link stops working. Always stop a session
-     * you are done with — an open browser keeps costing money until Bowmark closes it after 20
-     * idle minutes.
+     * Stops the agent and shuts its browser; the watch link stops working. Always `stop()` a
+     * session when you are done with it — an open browser keeps costing money until Bowmark closes
+     * it after 20 idle minutes, and the session counts against your 3-session concurrent limit
+     * even while idle.
      */
     stop(id: string): Promise<StopBrowserAgentResult>;
 
     /**
-     * Lists this account's browser agent sessions, open ones by default — how to recover an id you
-     * lost.
+     * Lists this account's browser agent sessions (open ones by default) — check how many you're
+     * holding before starting a new one, especially when looping. Idle sessions count against the
+     * 3-session concurrent limit until you `stop()` them.
      */
     list(options?: ListBrowserAgentsOptions): Promise<ListBrowserAgentsResult>;
 
@@ -2356,7 +2359,13 @@ type RetailOffer = {
                                   // across stores as one normalized fact
 }
 type RetailSearchResult = {
-  results: RetailOffer[]   // ONE query across ALL stores, price-sorted (cheapest first)
+  results: RetailOffer[]   // ONE query across ALL stores, price-sorted (cheapest first).
+                           // These are each STORE'S OWN keyword results, so a search for
+                           // a product also returns its ACCESSORIES and its lookalikes —
+                           // and because the list is price-sorted, those sort ABOVE it.
+                           // "AirPods Pro 3" puts ~20 cases from $8.50 ahead of the
+                           // $199 earbuds. FILTER ON title before reading a cheapest
+                           // price off the top row.
   warnings: string[]       // always present; names any store that did not answer. A
                            // store named here priced NOTHING, so read this before
                            // concluding a store has no stock or a worse price
@@ -2371,17 +2380,22 @@ type CallOptions = {
   /**
    * General-merchandise retail across Walmart, Target and Best Buy — one keyword search, fanned
    * out in parallel and returned price-sorted, so an agent can answer 'where can I actually buy
-   * this and what does it cost' without querying each store by hand. Best Buy's leg needs the
-   * caller's own Best Buy developer key; without one the search still returns Walmart + Target
-   * with a `warnings` entry naming the drop.
+   * this and what does it cost' without querying each store by hand. Rows are the stores' own
+   * keyword results, so accessories and lookalikes come back too and sort above the product;
+   * filter on `title`. Best Buy's leg needs the caller's own Best Buy developer key; without one
+   * the search still returns Walmart + Target with a `warnings` entry naming the drop.
    */
   interface Unit {
     /**
      * Searches Walmart, Target and Best Buy in parallel for a keyword and returns one price-sorted
-     * list of offers across all stores, each tagged with which store it's from. `warnings` names
-     * any store that did not answer — including Best Buy when the caller holds no Best Buy
-     * developer key — so a caller can tell a genuinely cheaper/only offer from one where a store
-     * simply didn't answer.
+     * list of offers across all stores, each tagged with which store it's from. THE ROWS ARE EACH
+     * STORE'S OWN KEYWORD RESULTS, so a product search also returns that product's accessories and
+     * its lookalikes, and price-sorting puts those FIRST — filter on `title` for the thing you
+     * were actually asked about before reading a price off the top row. Everything you need is in
+     * one call; a store returning accessories is not a reason to go query that store directly.
+     * `warnings` names any store that did not answer — including Best Buy when the caller holds no
+     * Best Buy developer key — so a caller can tell a genuinely cheaper/only offer from one where
+     * a store simply didn't answer.
      */
     search(args: { query: string }): Promise<RetailSearchResult>;
   }
@@ -2768,6 +2782,52 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_stream_channel {
+  // ── Stream channel settings — read and change your own channel's title, category and language — the unit's own declarations, verbatim ──
+interface ChannelSettings {
+  platform: "twitch"       // the default, and the only one today
+  id: string               // the site's own id for these broadcast settings
+  title: string            // the channel title shown on the stream page
+  language: string         // ISO 639-1, e.g. "en"
+  gameId: string           // the category; empty strings when never set
+  gameName: string
+  warnings: string[]       // always present
+}
+interface SetChannelOptions {
+  platform?: "twitch"      // the default, and the only one today
+  title?: string           // the channel title shown on the stream page
+  language?: string        // ISO 639-1, e.g. "en"
+  game?: string            // category NAME, e.g. "Wetrix" — not a category id
+}
+
+type CallOptions = {
+  timeoutMs?: number   // per-provider budget in ms, default 30000, clamped to 1000-55000.
+                       // A provider slower than this is DROPPED from the results and
+                       // NAMED in warnings — never silently absent
+}
+
+  /**
+   * Reads and updates a streamer's own Twitch channel settings — the title shown on the stream
+   * page, the category being played, and the language. Needs the streamer's Twitch sign-in: the
+   * first run answers needs_user with a link to sign in, and later runs reuse it.
+   */
+  interface Unit {
+    /**
+     * Reads the signed-in streamer's own channel settings: the title shown on the stream page, the
+     * category being played, and the language. Takes no arguments. Needs a Twitch sign-in.
+     */
+    get(): Promise<ChannelSettings>;
+
+    /**
+     * Updates the signed-in streamer's own channel settings and returns them as they now stand.
+     * Pass only the fields you are changing; anything you leave out is left alone. `game` is the
+     * category NAME, e.g. "Wetrix". It cannot set tags — Twitch's own update input has no tags
+     * field. Needs a Twitch sign-in.
+     */
+    set(options: SetChannelOptions): Promise<ChannelSettings>;
+  }
+}
+
 declare namespace BowmarkCapability_stream_highlights {
   // ── Stream highlights — cut a highlight of your own live broadcast — the unit's own declarations, verbatim ──
 interface CreateHighlightOptions {
@@ -5204,6 +5264,36 @@ interface AppleRefurbishedCatalog {
   category: "mac" | "ipad" | "iphone" | "watch" | "appletv" | "homepod" | "airpods" | "accessories";
   listings: AppleRefurbishedListing[];
 }
+interface AppleAccessoryListing {
+  partNumber: string;
+  name: string;
+  price: number | null;
+  priceCurrency: string | null;
+  url: string;
+  image: string | null;
+}
+interface AppleAccessoryCatalog {
+  category:
+    | "cases-protection"
+    | "chargers-adapters"
+    | "headphones-speakers"
+    | "drives-storage"
+    | "mice-keyboards"
+    | "gaming"
+    | "office"
+    | "travel-essentials"
+    | "college-essentials"
+    | "software"
+    | "homekit"
+    | "content-creation"
+    | "health-fitness"
+    | "new-arrivals"
+    | "made-by-apple"
+    | "accessibility";
+  page: number;
+  hasMore: boolean;
+  listings: AppleAccessoryListing[];
+}
 interface AppleTradeInEstimate {
   device: string;
   upToUsd: number;
@@ -5429,6 +5519,15 @@ interface AppleCompareModels {
      */
     listRefurbished(category: "mac" | "ipad" | "iphone" | "watch" | "appletv" | "homepod" | "airpods" | "accessories"): Promise<AppleRefurbishedCatalog>;
 
+    /**
+     * Everything Apple sells that is not a device, browsable by the sixteen categories apple.com's
+     * own accessories store uses — cases, chargers, headphones, drives, keyboards and the rest —
+     * each listing with its real name, current price and the part number that resolves it straight
+     * through getProductByPartNumber. Apple paginates this store server-side (up to 30 listings a
+     * page); `hasMore` says whether another page exists, since apple.com publishes no total count.
+     */
+    listAccessories(category: "cases-protection" | "chargers-adapters" | "headphones-speakers" | "drives-storage" | "mice-keyboards" | "gaming" | "office" | "travel-essentials" | "college-essentials" | "software" | "homekit" | "content-creation" | "health-fitness" | "new-arrivals" | "made-by-apple" | "accessibility", page?: number): Promise<AppleAccessoryCatalog>;
+
     /**
      * Reads apple.com's own trade-in value table and returns the CEILING ("up to $X")
      * cash-or-credit estimate it publishes for one device — a human name ("iPhone 14 Pro") or the
@@ -7607,8 +7706,11 @@ interface FormField {
     /** List BionicPO inquiry and service categories from the inquiry-services page. */
     listInquiryServices(): Promise<{ services: InquiryService[]; warnings: string[] }>;
 
-    /** Get a BionicPO inquiry service's form fields and details. */
-    getInquiryServiceDetails(serviceName: string): Promise<ServiceDetails>;
+    /**
+     * Look up one BionicPO inquiry service by name or id and return the site's own description for
+     * it.
+     */
+    getInquiryServiceDetails(service: string): Promise<ServiceDetails>;
   }
 }
 
@@ -8501,107 +8603,6 @@ interface BrixtonCheckoutLink {
   }
 }
 
-declare namespace BowmarkProvider_browser_use {
-  // ── Browser Use — the unit's own declarations, verbatim ──
-type BrowserUseRunStatus = "queued" | "dispatching" | "running" | "completed" | "failed" | "cancelled";
-
-interface BrowserUseCreateRunArgs {
-  task: string;
-  model?: string;             // e.g. "claude-sonnet-5"; absent = vendor default
-  sessionId?: string;         // continue a session
-  maxCostUsd?: number;
-  proxyCountryCode?: string;  // e.g. "us"
-}
-
-interface BrowserUseRunStatusReading { runId: string; status: BrowserUseRunStatus }
-interface BrowserUseCreatedRun { id: string; status: BrowserUseRunStatus; model: string; sessionId: string; workspaceId: string }
-
-interface BrowserUseRun {
-  id: string; sessionId: string; task: string; title: string | null; model: string;
-  status: BrowserUseRunStatus; result: string | null; error: string | null;
-  inputTokens: number; outputTokens: number;
-  costUsd: number;            // LLM cost only
-  createdAt: string; updatedAt: string;
-}
-
-interface BrowserUseRunList { runs: BrowserUseRun[]; hasMore: boolean }
-interface BrowserUseEvent { id: number; ts: string; type: string; data: Record<string, unknown> }
-interface BrowserUseEventsPage { events: BrowserUseEvent[]; nextAfter: number | null; hasMore: boolean }
-interface BrowserUseEventsArgs { runId: string; after?: number; limit?: number }
-
-interface BrowserUseSession { sessionId: string; latestRunId: string; status: string; title: string | null; createdAt: string; updatedAt: string }
-
-interface BrowserUseQueueArgs { sessionId: string; text: string; interrupt?: boolean }
-interface BrowserUseQueuedMessage { id: number; sessionId: string; status: string; mode: string }
-
-interface BrowserUseBrowser {
-  id: string; status: string;
-  liveUrl: string | null;     // interactive; whoever holds it drives the browser
-  agentSessionId: string | null;
-  timeoutAt: string; startedAt: string; finishedAt: string | null;
-  browserCostUsd: number; proxyCostUsd: number; proxyUsedMb: number;
-}
-
-  /**
-   * Browser Use Cloud's hosted browser agent. Not callable directly: use
-   * `bowmark.browser_agent`, which runs it for you with a private watch link and bills the
-   * session to your account.
-   */
-  interface Unit {
-    /**
-     * Starts a Browser Use agent run on a natural-language task, optionally continuing an existing
-     * session. Returns immediately; the run executes on Browser Use's cloud for seconds to
-     * minutes. Spends money.
-     */
-    createRun(args: BrowserUseCreateRunArgs): Promise<BrowserUseCreatedRun>;
-
-    /** Reads one run: status, final result or error, token totals and LLM cost. */
-    getRun(runId: string): Promise<BrowserUseRun>;
-
-    /** The cheap status poll for one run. */
-    getRunStatus(runId: string): Promise<BrowserUseRunStatusReading>;
-
-    /**
-     * A run's step-by-step event stream after a cursor — the agent's reasoning, tool calls, and
-     * the `browser.ready` event carrying the live view url.
-     */
-    listRunEvents(args: BrowserUseEventsArgs): Promise<BrowserUseEventsPage>;
-
-    /**
-     * Lists every run (agent turn) in a session, newest first, each with its status and LLM cost —
-     * how a session's whole spend is read.
-     */
-    listSessionRuns(sessionId: string): Promise<BrowserUseRunList>;
-
-    /**
-     * Cancels an in-flight run; idempotent on a finished one. The browser keeps running — stop it
-     * separately.
-     */
-    cancelRun(runId: string): Promise<BrowserUseRun>;
-
-    /** Reads a session, including the id of its latest run (a queued message becomes a new run). */
-    getSession(sessionId: string): Promise<BrowserUseSession>;
-
-    /**
-     * Sends a follow-up instruction into a session: it runs as the next turn when the current one
-     * ends, or at once with `interrupt: true`.
-     */
-    queueMessage(args: BrowserUseQueueArgs): Promise<BrowserUseQueuedMessage>;
-
-    /** The cloud browser attached to a session, with its live view url and running cost, or null. */
-    findSessionBrowser(sessionId: string): Promise<BrowserUseBrowser | null>;
-
-    /** Reads one cloud browser: status, live view url, browser and proxy cost. */
-    getBrowser(browserId: string): Promise<BrowserUseBrowser>;
-
-    /**
-     * Stops a cloud browser (cannot be undone). Its cost is then settled down to the time actually
-     * used.
-     */
-    stopBrowser(browserId: string): Promise<BrowserUseBrowser>;
-  }
-}
-
 declare namespace BowmarkProvider_builder_strucsure_com {
   // ── StrucSure Home Warranty — the unit's own declarations, verbatim ──
 interface StrucsureRegistrationState {
@@ -16788,8 +16789,9 @@ interface Photo {
     getPlace(args: GetPlaceArgs): Promise<GetPlaceResult>;
 
     /**
-     * The reviews Google Maps shows on a business's own panel — up to 5, each with author, star
-     * rating, review text and the site's own relative date. A FOURTH reading of searchPlaces' door
+     * The reviews Google Maps shows on a business's own panel — a handful, each with author, star
+     * rating, review text and the site's own relative date; the count varies by response, so this
+     * retries a few times and keeps the longest list seen. A FOURTH reading of searchPlaces' door
      * (the same record getPlace reads, one section further in), not the listugcposts route the
      * survey planned: that route needed a session token minted by a place-page bootstrap that was
      * never cracked, but the same reviews the token would have fetched are already sitting in the
@@ -16976,14 +16978,19 @@ interface GoogleNewsFullCoverage {
 
     /**
      * Everything Google News has indexed from one publisher — `publisher` is a domain like
-     * "reuters.com" or "apnews.com" — newest first, optionally narrowed with `query` the same way
-     * `searchNews` takes one. Built on the search door with a `site:` filter
+     * "reuters.com" or a name like "Reuters" — newest first, optionally narrowed with `query` the
+     * same way `searchNews` takes one. Built on the search door with a `site:` filter
      * (`/rss/search?q=site:<publisher> <query>`), NOT on the route that looks like its own:
      * `/rss/headlines/section/publication/<NAME>` answers 200 with the Top stories feed
      * byte-for-byte for a name it cannot resolve, so it would look like it worked and be wrong for
-     * every publisher. Measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which
-     * 100 carried a `<source>` domain on `reuters.com`. `locale` — `{ hl, gl, ceid }` — asks for
-     * another country/language edition; omitted, the US English one.
+     * every publisher. `site:` takes a DOMAIN, so a NAME is resolved to one through the search
+     * door first (the host dominating that name's own search results) rather than passed straight
+     * to `site:`, where it is mis-parsed as a TLD plus a keyword (measured 2026-09-17: "Al
+     * Jazeera" returned 100 rows, all from the .al ccTLD) — a name the door cannot resolve is
+     * refused rather than answered with the wrong newsroom. Measured 2026-09-15: `site:reuters.com
+     * tesla` returned 100 items of which 100 carried a `<source>` domain on `reuters.com`.
+     * `locale` — `{ hl, gl, ceid }` — asks for another country/language edition; omitted, the US
+     * English one.
      */
     listPublisherHeadlines(publisher: string, query?: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsPublisherHeadlines>;
 
@@ -19098,6 +19105,127 @@ interface HellotendService {
   }
 }
 
+declare namespace BowmarkProvider_higgsfield {
+  // ── Higgsfield — the unit's own declarations, verbatim ──
+interface higgsfieldModel {
+  id: string;
+  path: string;
+  kind: "image" | "video";
+  needsInputImage: boolean;
+  family: string;
+  measuredUsd: number;
+}
+
+interface higgsfieldEstimate {
+  model: string;
+  credits: number;
+  usd: number;
+  discountUsd: number | null;
+}
+
+interface higgsfieldRequest {
+  requestId: string;
+  status: "queued" | "in_progress" | "completed" | "failed" | "nsfw" | "canceled";
+  imageUrls: string[];
+  videoUrl: string | null;
+  error: string | null;
+  statusUrl: string | null;
+  cancelUrl: string | null;
+}
+
+interface higgsfieldGeneration extends higgsfieldRequest {
+  model: string;
+  estimate: higgsfieldEstimate;
+  settled: boolean;
+  files: higgsfieldSavedFile[];   // the same media, kept in YOUR account — Higgsfield's own links expire
+  warnings: string[];
+}
+
+// Bowmark's own saved-file handle (`SavedFile`), spelled out here because the
+// published surface has to stand alone. Manage these with `bowmark.files.*`;
+// `url` is presigned and `bowmark.files.url(id)` mints a fresh one.
+interface higgsfieldSavedFile {
+  id: string;
+  name: string;
+  contentType: string;
+  bytes: number;
+  url: string;
+  expiresAt: string;
+}
+
+  /**
+   * Higgsfield's own documented generation API — turns a text prompt (or a prompt plus an input
+   * image) into images or video across 25 models live on this account, including Kling 2.5
+   * Turbo, MiniMax Hailuo 02/2.3, WAN 2.5 and Higgsfield's own Soul and DoP. Every call is
+   * quoted by Higgsfield before it is submitted, and only a generation watched to completion is
+   * charged.
+   */
+  interface Unit {
+    /**
+     * Lists every generation model Bowmark's Higgsfield account can actually call, with what each
+     * one produces, whether it needs an input image, and what one call was measured to cost.
+     * Measured against the live API on 2026-09-16 by estimating all 48 endpoints Higgsfield's
+     * OpenAPI document publishes: 25 answered, and the rest refused as model_not_found,
+     * model_blocked or model_disabled — so this is the callable set, not the documented one. Takes
+     * no arguments and makes no request.
+     */
+    listModels(): Promise<higgsfieldModel[]>;
+
+    /**
+     * Asks Higgsfield what one generation will cost, for exactly the parameters you would submit,
+     * before submitting it — the vendor's own credit and US-dollar figure for this account, with
+     * any discount already applied. Generates nothing, produces no media and costs nothing.
+     * `model` defaults to `soul`. This is the same quote the generate functions take internally
+     * and charge from, so it is the honest answer to "what am I about to spend".
+     */
+    estimateCost(args: { prompt: string; model?: string; [param: string]: unknown }): Promise<higgsfieldEstimate>;
+
+    /**
+     * Generates one or more images from a text prompt and waits for them, returning the finished
+     * image URLs together with what Higgsfield quoted. `model` defaults to `soul` ($0.094
+     * measured); `listModels()` has the rest. Any other key — `aspect_ratio`, `num_images`,
+     * `input_images`, `output_format` — is passed to Higgsfield untouched, since each model takes
+     * its own. Waits up to `waitMs` (default 90000, and never longer than the run's own ceiling)
+     * for a terminal state. A wait always happens — a submit that never watches its own result is
+     * a generation Higgsfield bills us for and nobody is charged for — so the floor is 20000.
+     * **The finished images are copied into your Bowmark account automatically and come back on
+     * `files` — use those URLs, not `imageUrls`.** Higgsfield deletes its own copy after about
+     * seven days; a file in your account is yours until you delete it, and costs storage while you
+     * keep it. Pass `save: false` to skip the copy and take the expiring links. Uses Bowmark's
+     * Higgsfield key and charges the generation to your account; send your own key as the
+     * `x-bowmark-vendor-key-higgsfield` header instead.
+     */
+    generateImage(args: string | { prompt: string; model?: string; waitMs?: number; save?: boolean; [param: string]: unknown }): Promise<higgsfieldGeneration>;
+
+    /**
+     * Generates a video from a text prompt — or from a prompt plus an input image on the
+     * image-to-video models — and waits for it, returning the finished video URL together with
+     * what Higgsfield quoted. `model` defaults to `hailuo-02-standard` ($0.090 measured, the
+     * cheapest live video model); Kling 2.1 Master is $1.400, so check `listModels()` or
+     * `estimateCost` before reaching for a big one. Any other key (`duration`, `resolution`,
+     * `input_images`) is passed to Higgsfield untouched. Waits up to `waitMs` (default 90000,
+     * clamped to the run's own ceiling). Video usually renders past that, which is normal: you get
+     * `settled: false` and the handle, and collect it with `getRequestStatus`. **A call that waits
+     * copies the finished video into your Bowmark account and returns it on `files` — use that
+     * URL, not `videoUrl`**, because Higgsfield deletes its own copy after about seven days. Pass
+     * `save: false` to skip the copy. A call whose wait runs out saves nothing, since nothing has
+     * rendered yet — collect and download it yourself.
+     */
+    generateVideo(args: string | { prompt: string; model?: string; waitMs?: number; save?: boolean; [param: string]: unknown }): Promise<higgsfieldGeneration>;
+
+    /**
+     * Checks one submitted generation by its `requestId` and returns its current state plus any
+     * finished media. Use it after a generate call that returned `settled: false`, which means the
+     * wait ran out while the generation was still running. `status` is Higgsfield's own: `queued`,
+     * `in_progress`, `completed`, `failed`, `nsfw` (refused by moderation — reword the prompt) or
+     * `canceled`. This is a free read and it never charges you, even for a generation it finds
+     * completed — and for the same reason it never copies the media into your account either, so
+     * the URLs it returns are Higgsfield's own and expire after about seven days.
+     */
+    getRequestStatus(args: string | { requestId: string }): Promise<higgsfieldRequest>;
+  }
+}
+
 declare namespace BowmarkProvider_highlandhomes {
   // ── Highland Homes — the unit's own declarations, verbatim ──
 interface HighlandHomesSearchFilter {
@@ -26175,6 +26303,32 @@ interface OliverwineryShippingAvailability {
   }
 }
 
+declare namespace BowmarkProvider_onthemarket {
+  // ── OnTheMarket — the unit's own declarations, verbatim ──
+interface SearchArgs {
+  location: string;
+  type: "sale" | "rent";
+}
+
+interface OnTheMarketProperty {
+  id: string;
+  title: string;
+  price?: string;
+  location: string;
+  propertyType?: string; // the site's own labels — read the values off a result, never guess one from prose
+  bedrooms?: number;
+  bathrooms?: number;
+  description?: string;
+  url?: string;
+}
+
+  /** Search for residential property listings for sale or rent in the UK. */
+  interface Unit {
+    /** Search for residential properties by location and type (sale or rent) */
+    search(args: SearchArgs): Promise<OnTheMarketProperty[]>;
+  }
+}
+
 declare namespace BowmarkProvider_othership {
   // ── Othership — the unit's own declarations, verbatim ──
 // Othership's OWN shapes — not a capability contract.
@@ -34873,6 +35027,51 @@ interface YoutubeSearchVideo {
   thumbnail: string | null;
 }
 
+interface YoutubeChannelRef {
+  channelId: string;
+  url: string;
+  handle: string | null; // only set when the source we found it through carries one
+  title: string | null;  // only set coming off search; resolve_url gives no title
+  subscriberCountText: string | null;
+  thumbnail: string | null;
+}
+
+interface YoutubeVideo {
+  videoId: string;
+  title: string;
+  channel: string;
+  channelId: string;
+  description: string;       // the full watch-page description, not a truncated snippet
+  viewCount: number;
+  likeCount: number | null;  // null when the site itself hides it on this video
+  lengthSeconds: number;
+  publishDate: string | null; // ISO 8601
+  uploadDate: string | null;  // ISO 8601
+  category: string | null;
+  keywords: string[];
+  isLiveNow: boolean;         // live RIGHT NOW
+  isLiveContent: boolean;     // live now, or ever was (stays true for a finished stream's VOD)
+  isUnlisted: boolean;
+  thumbnails: { url: string; width: number; height: number }[];
+}
+
+interface YoutubeComment {
+  commentId: string;
+  author: string;
+  authorChannelId: string | null;
+  text: string;
+  likeCount: string;         // YouTube's own abbreviated text, e.g. "316K" — never an exact number
+  publishedTime: string;     // YouTube's own relative phrase, e.g. "1 year ago"
+  replyCount: number;
+  isPinned: boolean;
+  isHeartedByCreator: boolean;
+}
+
+interface YoutubeCommentPage {
+  comments: YoutubeComment[];
+  continuation: string | null; // pass back as { continuation } for the next page; null on the last
+}
+
   /**
    * A YouTube video's own caption transcript, read off the site's own Transcript panel —
    * timestamped lines plus the full text as one string. Language selection is not offered yet;
@@ -34894,6 +35093,36 @@ interface YoutubeSearchVideo {
      * the video has no caption track at all.
      */
     getTranscript(input: { video: string }): Promise<YoutubeTranscript>;
+
+    /**
+     * Resolves a channel `@handle`, a channel/handle URL, or a plain channel name to its canonical
+     * id — the door every other channel function here takes a channelId through. An `@handle` or
+     * URL goes through YouTube's own `navigation/resolve_url` and returns just the id and
+     * canonical URL (no title — that costs a second call, which `getChannel` makes). A plain name
+     * runs a channel-filtered search and returns the first, best-matching channel with its title,
+     * subscriber count and thumbnail. Returns null when nothing resolves — not a real answer to
+     * build a `getChannel` call on.
+     */
+    findChannel(input: { query: string }): Promise<YoutubeChannelRef | null>;
+
+    /**
+     * Everything the watch page says about one video without playing it: title, channel name and
+     * id, full description, view count, like count, length in seconds, publish and upload dates,
+     * category, the uploader's own keywords, every thumbnail size, and whether it is live now, was
+     * ever live, or is unlisted. `video` is a bare 11-character video id or any
+     * watch/shorts/embed/live/youtu.be URL, exactly as `getTranscript` takes it.
+     */
+    getVideo(input: { video: string }): Promise<YoutubeVideo>;
+
+    /**
+     * What people said under a video — each comment's author, text, like count (YouTube's own
+     * abbreviated text, e.g. "316K"), how long ago it was posted, its reply count, and whether the
+     * thread is pinned or was hearted by the creator. `sortBy` picks YouTube's own "Top" or
+     * "Newest" ordering (default Top) on the first call; pass back `continuation` alone — no
+     * `video` needed, it is self-contained — to read the next page. `continuation` is null once
+     * there are no more pages.
+     */
+    listComments(input: { video: string; sortBy?: "top" | "newest" } | { continuation: string }): Promise<YoutubeCommentPage>;
   }
 }
 
@@ -35863,7 +36092,6 @@ interface BowmarkProviders {
   boydsleep: BowmarkProvider_boydsleep.Unit;
   brius: BowmarkProvider_brius.Unit;
   brixton: BowmarkProvider_brixton.Unit;
-  browser_use: BowmarkProvider_browser_use.Unit;
   builder_strucsure_com: BowmarkProvider_builder_strucsure_com.Unit;
   bulletproof: BowmarkProvider_bulletproof.Unit;
   bungalow: BowmarkProvider_bungalow.Unit;
@@ -36004,6 +36232,7 @@ interface BowmarkProviders {
   heatherwood: BowmarkProvider_heatherwood.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
   hellotend: BowmarkProvider_hellotend.Unit;
+  higgsfield: BowmarkProvider_higgsfield.Unit;
   highlandhomes: BowmarkProvider_highlandhomes.Unit;
   hilton: BowmarkProvider_hilton.Unit;
   historymaker: BowmarkProvider_historymaker.Unit;
@@ -36090,6 +36319,7 @@ interface BowmarkProviders {
   nvisioncenters: BowmarkProvider_nvisioncenters.Unit;
   oanda: BowmarkProvider_oanda.Unit;
   oliverwinery: BowmarkProvider_oliverwinery.Unit;
+  onthemarket: BowmarkProvider_onthemarket.Unit;
   othership: BowmarkProvider_othership.Unit;
   otto: BowmarkProvider_otto.Unit;
   outdoorresearch: BowmarkProvider_outdoorresearch.Unit;
@@ -87970,6 +88200,7 @@ interface BowmarkLibrary {
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;
+  stream_channel: BowmarkCapability_stream_channel.Unit;
   stream_highlights: BowmarkCapability_stream_highlights.Unit;
   tariff: BowmarkCapability_tariff.Unit;
   text_to_speech: BowmarkCapability_text_to_speech.Unit;

package/dist/generated/validators.js

@@ -5,10 +5,10 @@
 // declares no readable argument shape — not an absent one, which is what the
 // guard fails closed on.
 //
-// Manifest version: 33a70781b68188bc68feb315e91e0c61cb56ecb49e10d82f223e4feb9d6b3399
-// 1103 checked, 20 unchecked.
+// Manifest version: 83b6073de78d83a7366cd17844242d5703320faa6ea88973baea85a98639f7d0
+// 1104 checked, 20 unchecked.
 export const VALIDATORS = {
-    "version": "33a70781b68188bc68feb315e91e0c61cb56ecb49e10d82f223e4feb9d6b3399",
+    "version": "83b6073de78d83a7366cd17844242d5703320faa6ea88973baea85a98639f7d0",
     "units": {
         "booking_links": {
             "defs": {
@@ -2895,6 +2895,57 @@ export const VALIDATORS = {
                 ]
             }
         },
+        "stream_channel": {
+            "defs": {
+                "SetChannelOptions": {
+                    "k": "object",
+                    "props": [
+                        {
+                            "name": "platform",
+                            "schema": {
+                                "k": "literal",
+                                "v": "twitch"
+                            },
+                            "optional": true
+                        },
+                        {
+                            "name": "title",
+                            "schema": {
+                                "k": "string"
+                            },
+                            "optional": true
+                        },
+                        {
+                            "name": "language",
+                            "schema": {
+                                "k": "string"
+                            },
+                            "optional": true
+                        },
+                        {
+                            "name": "game",
+                            "schema": {
+                                "k": "string"
+                            },
+                            "optional": true
+                        }
+                    ]
+                }
+            },
+            "functions": {
+                "get": [],
+                "set": [
+                    {
+                        "name": "options",
+                        "schema": {
+                            "k": "ref",
+                            "name": "SetChannelOptions"
+                        },
+                        "optional": false
+                    }
+                ]
+            }
+        },
         "stream_highlights": {
             "defs": {
                 "CreateHighlightOptions": {
@@ -5462,6 +5513,88 @@ export const VALIDATORS = {
                         "optional": false
                     }
                 ],
+                "listAccessories": [
+                    {
+                        "name": "category",
+                        "schema": {
+                            "k": "union",
+                            "of": [
+                                {
+                                    "k": "literal",
+                                    "v": "cases-protection"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "chargers-adapters"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "headphones-speakers"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "drives-storage"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "mice-keyboards"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "gaming"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "office"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "travel-essentials"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "college-essentials"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "software"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "homekit"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "content-creation"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "health-fitness"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "new-arrivals"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "made-by-apple"
+                                },
+                                {
+                                    "k": "literal",
+                                    "v": "accessibility"
+                                }
+                            ]
+                        },
+                        "optional": false
+                    },
+                    {
+                        "name": "page",
+                        "schema": {
+                            "k": "number"
+                        },
+                        "optional": true
+                    }
+                ],
                 "getTradeInEstimate": [
                     {
                         "name": "model",
@@ -7325,7 +7458,7 @@ export const VALIDATORS = {
                 "listInquiryServices": [],
                 "getInquiryServiceDetails": [
                     {
-                        "name": "serviceName",
+                        "name": "service",
                         "schema": {
                             "k": "string"
                         },
@@ -7944,206 +8077,6 @@ export const VALIDATORS = {
                 ]
             }
         },
-        "providers.browser_use": {
-            "defs": {
-                "BrowserUseCreateRunArgs": {
-                    "k": "object",
-                    "props": [
-                        {
-                            "name": "task",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": false
-                        },
-                        {
-                            "name": "model",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": true
-                        },
-                        {
-                            "name": "sessionId",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": true
-                        },
-                        {
-                            "name": "maxCostUsd",
-                            "schema": {
-                                "k": "number"
-                            },
-                            "optional": true
-                        },
-                        {
-                            "name": "proxyCountryCode",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": true
-                        }
-                    ]
-                },
-                "BrowserUseEventsArgs": {
-                    "k": "object",
-                    "props": [
-                        {
-                            "name": "runId",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": false
-                        },
-                        {
-                            "name": "after",
-                            "schema": {
-                                "k": "number"
-                            },
-                            "optional": true
-                        },
-                        {
-                            "name": "limit",
-                            "schema": {
-                                "k": "number"
-                            },
-                            "optional": true
-                        }
-                    ]
-                },
-                "BrowserUseQueueArgs": {
-                    "k": "object",
-                    "props": [
-                        {
-                            "name": "sessionId",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": false
-                        },
-                        {
-                            "name": "text",
-                            "schema": {
-                                "k": "string"
-                            },
-                            "optional": false
-                        },
-                        {
-                            "name": "interrupt",
-                            "schema": {
-                                "k": "boolean"
-                            },
-                            "optional": true
-                        }
-                    ]
-                }
-            },
-            "functions": {
-                "createRun": [
-                    {
-                        "name": "args",
-                        "schema": {
-                            "k": "ref",
-                            "name": "BrowserUseCreateRunArgs"
-                        },
-                        "optional": false
-                    }
-                ],
-                "getRun": [
-                    {
-                        "name": "runId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "getRunStatus": [
-                    {
-                        "name": "runId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "listRunEvents": [
-                    {
-                        "name": "args",
-                        "schema": {
-                            "k": "ref",
-                            "name": "BrowserUseEventsArgs"
-                        },
-                        "optional": false
-                    }
-                ],
-                "listSessionRuns": [
-                    {
-                        "name": "sessionId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "cancelRun": [
-                    {
-                        "name": "runId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "getSession": [
-                    {
-                        "name": "sessionId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "queueMessage": [
-                    {
-                        "name": "args",
-                        "schema": {
-                            "k": "ref",
-                            "name": "BrowserUseQueueArgs"
-                        },
-                        "optional": false
-                    }
-                ],
-                "findSessionBrowser": [
-                    {
-                        "name": "sessionId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "getBrowser": [
-                    {
-                        "name": "browserId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ],
-                "stopBrowser": [
-                    {
-                        "name": "browserId",
-                        "schema": {
-                            "k": "string"
-                        },
-                        "optional": false
-                    }
-                ]
-            }
-        },
         "providers.builder_strucsure_com": {
             "defs": {},
             "functions": {
@@ -16837,6 +16770,166 @@ export const VALIDATORS = {
                 ]
             }
         },
+        "providers.higgsfield": {
+            "defs": {},
+            "functions": {
+                "listModels": [],
+                "estimateCost": [
+                    {
+                        "name": "args",
+                        "schema": {
+                            "k": "object",
+                            "props": [
+                                {
+                                    "name": "prompt",
+                                    "schema": {
+                                        "k": "string"
+                                    },
+                                    "optional": false
+                                },
+                                {
+                                    "name": "model",
+                                    "schema": {
+                                        "k": "string"
+                                    },
+                                    "optional": true
+                                }
+                            ],
+                            "index": {
+                                "k": "any"
+                            }
+                        },
+                        "optional": false
+                    }
+                ],
+                "generateImage": [
+                    {
+                        "name": "args",
+                        "schema": {
+                            "k": "union",
+                            "of": [
+                                {
+                                    "k": "string"
+                                },
+                                {
+                                    "k": "object",
+                                    "props": [
+                                        {
+                                            "name": "prompt",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": false
+                                        },
+                                        {
+                                            "name": "model",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": true
+                                        },
+                                        {
+                                            "name": "waitMs",
+                                            "schema": {
+                                                "k": "number"
+                                            },
+                                            "optional": true
+                                        },
+                                        {
+                                            "name": "save",
+                                            "schema": {
+                                                "k": "boolean"
+                                            },
+                                            "optional": true
+                                        }
+                                    ],
+                                    "index": {
+                                        "k": "any"
+                                    }
+                                }
+                            ]
+                        },
+                        "optional": false
+                    }
+                ],
+                "generateVideo": [
+                    {
+                        "name": "args",
+                        "schema": {
+                            "k": "union",
+                            "of": [
+                                {
+                                    "k": "string"
+                                },
+                                {
+                                    "k": "object",
+                                    "props": [
+                                        {
+                                            "name": "prompt",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": false
+                                        },
+                                        {
+                                            "name": "model",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": true
+                                        },
+                                        {
+                                            "name": "waitMs",
+                                            "schema": {
+                                                "k": "number"
+                                            },
+                                            "optional": true
+                                        },
+                                        {
+                                            "name": "save",
+                                            "schema": {
+                                                "k": "boolean"
+                                            },
+                                            "optional": true
+                                        }
+                                    ],
+                                    "index": {
+                                        "k": "any"
+                                    }
+                                }
+                            ]
+                        },
+                        "optional": false
+                    }
+                ],
+                "getRequestStatus": [
+                    {
+                        "name": "args",
+                        "schema": {
+                            "k": "union",
+                            "of": [
+                                {
+                                    "k": "string"
+                                },
+                                {
+                                    "k": "object",
+                                    "props": [
+                                        {
+                                            "name": "requestId",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": false
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        "optional": false
+                    }
+                ]
+            }
+        },
         "providers.highlandhomes": {
             "defs": {
                 "HighlandHomesSearchFilter": {
@@ -22589,6 +22682,51 @@ export const VALIDATORS = {
                 ]
             }
         },
+        "providers.onthemarket": {
+            "defs": {
+                "SearchArgs": {
+                    "k": "object",
+                    "props": [
+                        {
+                            "name": "location",
+                            "schema": {
+                                "k": "string"
+                            },
+                            "optional": false
+                        },
+                        {
+                            "name": "type",
+                            "schema": {
+                                "k": "union",
+                                "of": [
+                                    {
+                                        "k": "literal",
+                                        "v": "sale"
+                                    },
+                                    {
+                                        "k": "literal",
+                                        "v": "rent"
+                                    }
+                                ]
+                            },
+                            "optional": false
+                        }
+                    ]
+                }
+            },
+            "functions": {
+                "search": [
+                    {
+                        "name": "args",
+                        "schema": {
+                            "k": "ref",
+                            "name": "SearchArgs"
+                        },
+                        "optional": false
+                    }
+                ]
+            }
+        },
         "providers.othership": {
             "defs": {},
             "functions": {
@@ -32994,6 +33132,94 @@ export const VALIDATORS = {
                         },
                         "optional": false
                     }
+                ],
+                "findChannel": [
+                    {
+                        "name": "input",
+                        "schema": {
+                            "k": "object",
+                            "props": [
+                                {
+                                    "name": "query",
+                                    "schema": {
+                                        "k": "string"
+                                    },
+                                    "optional": false
+                                }
+                            ]
+                        },
+                        "optional": false
+                    }
+                ],
+                "getVideo": [
+                    {
+                        "name": "input",
+                        "schema": {
+                            "k": "object",
+                            "props": [
+                                {
+                                    "name": "video",
+                                    "schema": {
+                                        "k": "string"
+                                    },
+                                    "optional": false
+                                }
+                            ]
+                        },
+                        "optional": false
+                    }
+                ],
+                "listComments": [
+                    {
+                        "name": "input",
+                        "schema": {
+                            "k": "union",
+                            "of": [
+                                {
+                                    "k": "object",
+                                    "props": [
+                                        {
+                                            "name": "video",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": false
+                                        },
+                                        {
+                                            "name": "sortBy",
+                                            "schema": {
+                                                "k": "union",
+                                                "of": [
+                                                    {
+                                                        "k": "literal",
+                                                        "v": "top"
+                                                    },
+                                                    {
+                                                        "k": "literal",
+                                                        "v": "newest"
+                                                    }
+                                                ]
+                                            },
+                                            "optional": true
+                                        }
+                                    ]
+                                },
+                                {
+                                    "k": "object",
+                                    "props": [
+                                        {
+                                            "name": "continuation",
+                                            "schema": {
+                                                "k": "string"
+                                            },
+                                            "optional": false
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        "optional": false
+                    }
                 ]
             }
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bowmark/web",
-  "version": "1.23.0",
+  "version": "1.24.1",
   "type": "module",
   "description": "The public client for the Bowmark capability library — real TypeScript for the whole bowmark.* surface, with no Bowmark source on the caller's disk. ZERO runtime dependencies, deliberately and permanently.",
   "license": "MIT",