@bowmark/web 1.22.0 → 1.23.0

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: 629f1aeb04463086ca99af95377a310bbd807733f6a06b36d16890fbc8e3314d
-// 48 capabilities, 410 providers, 1008 typed functions, 20 refused.
+// Manifest version: 33a70781b68188bc68feb315e91e0c61cb56ecb49e10d82f223e4feb9d6b3399
+// 50 capabilities, 418 providers, 1121 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
@@ -155,6 +155,118 @@ type CallOptions = {
   }
 }
 
+declare namespace BowmarkCapability_browser_agent {
+  // ── Browser agent — the unit's own declarations, verbatim ──
+type BrowserAgentStatus = "running" | "needs_input" | "idle" | "failed" | "stopped" | "closed";
+interface BrowserAgentQuestion {
+  kind: "question" | "takeover";   // takeover = a person must act in watchUrl (login, captcha)
+  question: string;
+}
+interface StartBrowserAgentOptions {
+  task: string;             // plain language, name the site
+  backend?: string;         // default "browser_use"
+  model?: string;           // e.g. "claude-sonnet-5"; default "gpt-5.6-luna"
+  maxCostUsd?: number;      // vendor spend ceiling per turn, default 2, max 25
+  proxyCountry?: string;    // e.g. "us"
+  timeoutMs?: number;
+}
+interface StartBrowserAgentResult {
+  id: string;               // keep this: status/send/stop take it
+  status: BrowserAgentStatus;
+  watchUrl: string;         // private link to WATCH AND CONTROL the live browser — show it to your user only
+  backend: string;
+  model: string;
+  warnings: string[];
+}
+interface BrowserAgentStep { at: string; kind: "thinking" | "action" | "message"; text: string }
+interface BrowserAgentStatusOptions {
+  cursor?: string;          // from the previous status() — only newer steps return
+  waitMs?: number;          // wait up to this long (max 60000) for the status to change
+  timeoutMs?: number;
+}
+interface BrowserAgentStatusResult {
+  id: string;
+  status: BrowserAgentStatus;
+  question: BrowserAgentQuestion | null;   // set when status is "needs_input"
+  result: string | null;                   // the agent's answer for its last finished turn
+  error: string | null;
+  steps: BrowserAgentStep[];
+  cursor: string;
+  task: string;
+  backend: string;
+  model: string;
+  closed: boolean;
+  warnings: string[];
+}
+interface SendBrowserAgentOptions { interrupt?: boolean; timeoutMs?: number }
+interface SendBrowserAgentResult { id: string; status: BrowserAgentStatus; warnings: string[] }
+interface StopBrowserAgentResult { id: string; status: BrowserAgentStatus; warnings: string[] }
+interface BrowserAgentSummary {
+  id: string; status: BrowserAgentStatus; task: string; backend: string; model: string;
+  question: BrowserAgentQuestion | null; createdAt: string; closedAt: string | null;
+}
+interface ListBrowserAgentsOptions { open?: boolean }   // default true
+interface ListBrowserAgentsResult { sessions: BrowserAgentSummary[]; warnings: string[] }
+interface WatchLinkResult { id: string; watchUrl: string; warnings: string[] }
+
+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
+}
+
+  /**
+   * LAST RESORT, and it costs money: hands a plain-language task to a hosted AI browser agent
+   * (Browser Use) when no Bowmark function covers the site or a script against one failed.
+   * Returns a session id and a private link your user can open to watch and take over the live
+   * browser; later scripts poll it, answer its questions and stop it.
+   */
+  interface Unit {
+    /**
+     * 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`.
+     */
+    start(options: StartBrowserAgentOptions): Promise<StartBrowserAgentResult>;
+
+    /**
+     * Reads a session: `running`, `needs_input` (relay `question` to your user, answer with
+     * `send`), `idle` (done — read `result`), `failed`, `stopped` or `closed`. Pass the previous
+     * `cursor` for only new steps, and `waitMs` (≤ 60000) to wait for a change instead of polling
+     * tightly.
+     */
+    status(id: string, options?: BrowserAgentStatusOptions): Promise<BrowserAgentStatusResult>;
+
+    /**
+     * Sends the agent a follow-up in the same browser: an answer to its question, the go-ahead
+     * after your user took over, or a new instruction. Runs when its current turn ends, or at once
+     * with `interrupt: true`. Each turn is billed.
+     */
+    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.
+     */
+    stop(id: string): Promise<StopBrowserAgentResult>;
+
+    /**
+     * Lists this account's browser agent sessions, open ones by default — how to recover an id you
+     * lost.
+     */
+    list(options?: ListBrowserAgentsOptions): Promise<ListBrowserAgentsResult>;
+
+    /**
+     * Makes a NEW watch link for an open session, for when the one from `start` was lost. The
+     * previous link stops working.
+     */
+    watchLink(id: string): Promise<WatchLinkResult>;
+  }
+}
+
 declare namespace BowmarkCapability_bundles {
   // ── Check whether a set of products can be built and bought right now — the unit's own declarations, verbatim ──
 interface BundleItemAvailability {
@@ -571,31 +683,21 @@ type CallOptions = {
 }
 
   /**
-   * Actually RUNS a developer dashboard's signup flow and hands back a real, usable API key — no
-   * email verification, no CAPTCHA, for the dashboards this covers. Today: Alpha Vantage's free
-   * stock-data API. Call it directly; don't just describe the steps. If the caller gave no
-   * organization/email of their own, invent a placeholder — this is an instant, unverified
-   * free-tier signup, not an account tied to a real identity, so there is nothing to ask
-   * permission for. MAKE THE EMAIL UNIQUE PER CALL (see the worked example) — the dashboard
-   * dedupes by address, so a copied literal example email gets "Redundant origin" on the second
-   * and every later run.
+   * Actually RUNS a developer dashboard's signup flow and hands back a real, usable API key.
+   * Supports: Alpha Vantage (instant, no verification). Call it directly; don't just describe
+   * the steps. For Alpha Vantage with a placeholder identity: MAKE THE EMAIL UNIQUE PER CALL
+   * (see the worked example) — the dashboard dedupes by address, so a copied literal example
+   * email gets "Redundant origin" on the second and every later run.
    */
   interface Unit {
     /**
-     * Signs up for a real API key on a developer dashboard — RUN this, don't just explain how —
-     * `bowmark.developer_api_key_signup.signUp("alphavantage", { organization: "Acme Corp", email:
-     * `qa-${Date.now()}@example.com` })`. `service` selects which dashboard (today: "alphavantage"
-     * only — THROWS naming the supported list otherwise, a caller-fixable error).
-     * `details.organization` and `details.email` are required; when the caller did not supply
-     * their own, invent placeholder-shaped ones like the example's — the signup is instant and
-     * unverified, so nothing is lost by not stopping to ask first. MAKE THE EMAIL UNIQUE EVERY
-     * CALL (e.g. embed `Date.now()`, as the example does) — the dashboard rejects a repeated
-     * address with "Redundant origin", so a literal copied example email fails on the second and
-     * every later run. `details.occupation` is optional and dashboard-specific. Returns the real
-     * key plus the dashboard's own confirmation sentence. `options.timeoutMs` sets the call budget
-     * (default 30000).
+     * Signs up for a real developer API key on a dashboard. `service` selects which dashboard:
+     * "alphavantage" for stock data. For alphavantage: `details.organization` and `details.email`
+     * required (MAKE EMAIL UNIQUE PER CALL, e.g. `qa-${Date.now()}@example.com`);
+     * `details.occupation` optional. Returns real key plus confirmation. `options.timeoutMs` sets
+     * call budget (default 30000).
      */
-    signUp(service: string, details: { organization: string, email: string, occupation?: string }, options?: CallOptions): Promise<DeveloperApiKeySignupResult>;
+    signUp(service: string, details: object, options?: CallOptions): Promise<DeveloperApiKeySignupResult>;
   }
 }
 
@@ -730,6 +832,27 @@ type CallOptions = {
 
 declare namespace BowmarkCapability_flights {
   // ── Flights — the unit's own declarations, verbatim ──
+// ── "Which day is cheapest?" ── NOT a flights.* function: it is ONE provider call,
+// bowmark.providers.google_flights.getPriceGraph(query: FlightQuery): Promise<PriceGraph>,
+// typed here so no second lookup is needed. Only from/to/depart/return are read.
+// The window is Google's own: about depart-7 days to depart+52 days, not selectable,
+// so to cover a whole month from its 1st pass depart = the 8th.
+type PricePoint = {
+  date: string             // departure date, "2026-11-08"
+  returnDate: string | null // the return priced with it; null for one-way
+  price: number | null     // cheapest total that day; null where none was priced
+  currency: string
+}
+type PriceGraph = {
+  from: string
+  to: string
+  tripType: "round trip" | "one way"
+  rangeStart: string       // the window Google actually returned
+  rangeEnd: string
+  points: PricePoint[]     // ascending by date
+  cheapest: PricePoint | null // ties go to the earliest date
+  url: string
+}
 type FlightQuery = {
   from: string          // IATA ("SFO") — best for cross-provider matching
   to: string
@@ -882,7 +1005,10 @@ type FlightStatusResult = {
      * returning `flights: []`, since an empty list would otherwise be indistinguishable from a
      * route nobody flies. `options.timeoutMs` sets the per-site budget (default 30000) — a site
      * slower than that is dropped and named, so the answer arrives inside the calling client's own
-     * tool-call limit rather than not at all.
+     * tool-call limit rather than not at all. **For 'which day is cheapest' over a range of dates,
+     * do not call this once per date**: `bowmark.providers.google_flights.getPriceGraph(query:
+     * FlightQuery): Promise<PriceGraph>` (both typed above) prices every departure date from about
+     * depart-7 to depart+52 in one call.
      */
     search(query: FlightQuery, options?: CallOptions): Promise<FlightSearchResult>;
 
@@ -2597,11 +2723,12 @@ type ShippingQuery = {
 // One normalized shipping-rate quote. Same shape no matter which carrier
 // quoted it.
 type ShippingRate = {
-  source: string                              // "usps" | "ups"
+  source: string                              // "usps" | "ups" | "pirateship"
   serviceCode: string                         // the carrier's own code, verbatim
   serviceName: string                         // the carrier's own name, e.g. "UPS Ground"
   price: { amount: number; currency: string } // integer minor units (cents)
   transitDays: number | null                  // null when the carrier didn't state one
+  deliveryEstimate?: string | null            // the carrier's own delivery-date text, when stated
 }
 
 type ShippingEstimateResult = {
@@ -2619,25 +2746,82 @@ type CallOptions = {
    * Prices a domestic package across USPS and UPS for a ZIP-to-ZIP move, weight and optional
    * dimensions, and returns normalized quotes cheapest first — service name, price and transit
    * days where the carrier states one. Direct JSON, no browser. USPS needs no key and always
-   * quotes; UPS is BYOK, and a caller without a UPS developer key gets the USPS quotes plus a
-   * `warnings` line naming what was dropped rather than a silent skip.
+   * quotes. Pirate Ship (source `pirateship`) also quotes USPS AND UPS with no key, at its
+   * discounted label prices, with a delivery date. UPS direct is BYOK; without a UPS developer
+   * key that one leg is dropped and named in `warnings`.
    */
   interface Unit {
     /**
      * Prices a domestic package — `{ fromZip: "20024", toZip: "10001", weightOz: 16 }` — across
      * every USPS and UPS service that quotes it, and returns `rates` cheapest first.
      * `length`/`width`/`height` (inches) must be given together or omitted entirely. USPS needs no
-     * API key. UPS is BYOK: bring your own UPS developer key or that leg is dropped and named in
-     * `warnings` (it is never served off a fleet credential). `warnings` also names any carrier
-     * dropped for a timeout or an error. THROWS `AllProvidersFailedError` when NEITHER carrier
-     * answered, because that is a different fact from "no service quotes this shipment" and only
-     * one of them means there truly is no rate. `options.timeoutMs` sets the per-carrier budget
-     * (default 30000).
+     * API key. Pirate Ship (`source: "pirateship"`) needs none either and quotes BOTH USPS and UPS
+     * at its discounted label prices, with the carrier named in `serviceName` and a
+     * `deliveryEstimate` date; given no dimensions, it prices a 10x8x4 inch box. UPS direct is
+     * BYOK: bring your own UPS developer key or that leg is dropped and named in `warnings` (it is
+     * never served off a fleet credential). `warnings` also names any carrier dropped for a
+     * timeout or an error. THROWS `AllProvidersFailedError` when NEITHER carrier answered, because
+     * that is a different fact from "no service quotes this shipment" and only one of them means
+     * there truly is no rate. `options.timeoutMs` sets the per-carrier budget (default 30000).
      */
     estimate(query: ShippingQuery, options?: CallOptions): Promise<ShippingEstimateResult>;
   }
 }
 
+declare namespace BowmarkCapability_stream_highlights {
+  // ── Stream highlights — cut a highlight of your own live broadcast — the unit's own declarations, verbatim ──
+interface CreateHighlightOptions {
+  platform?: "twitch"      // the default, and the only one today
+  videoId?: string         // id or video link; omit for the newest broadcast (the live one, while live)
+  startSeconds: number     // seconds into that broadcast
+  endSeconds: number
+  title: string
+  description?: string
+  language?: string        // default "en"
+  tags?: string[]
+  game?: string            // category name, e.g. "Wetrix"
+}
+interface StreamHighlight {
+  // "created" by this call; "existing" = a highlight with this exact title was
+  // already on the channel, nothing new made; "unknown" = no answer came back —
+  // check dashboardUrl. Calling again with the same title is always safe.
+  status: "created" | "existing" | "unknown"
+  platform: "twitch"
+  highlightId: string | null   // null only when status is "unknown"
+  url: string | null
+  title: string
+  videoId: string
+  startSeconds: number
+  endSeconds: number
+  channel: string
+  dashboardUrl: string
+  warnings: string[]
+}
+
+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
+}
+
+  /**
+   * Cuts a permanent Highlight out of a streamer's own broadcast on Twitch — including the one
+   * still live — between two offsets in seconds, with a title. 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 {
+    /**
+     * Cuts a highlight from [startSeconds, endSeconds] of the signed-in streamer's broadcast
+     * (`videoId`, or the newest one — the live one while streaming) and titles it. Safe to call
+     * again with the same title: an existing highlight of that title is returned with status
+     * "existing" instead of being cut twice. THROWS with "Retry shortly" when the live broadcast's
+     * archive has not recorded up to endSeconds yet (it trails real time by a minute or two).
+     * Needs a Twitch sign-in.
+     */
+    create(options: CreateHighlightOptions): Promise<StreamHighlight>;
+  }
+}
+
 declare namespace BowmarkCapability_tariff {
   // ── HS/HTS tariff code lookup — the unit's own declarations, verbatim ──
 
@@ -3855,6 +4039,291 @@ interface AlphavantageSignUpResult {
   }
 }
 
+declare namespace BowmarkProvider_amazon {
+  // ── Amazon — the unit's own declarations, verbatim ──
+interface AmazonProduct {
+  asin: string;
+  title: string;
+  url: string;
+  price: number | null;
+  listPrice: number | null;
+  rating: number | null;
+  ratingCount: number | null;
+  sponsored: boolean;
+}
+interface SearchProductsArgs {
+  keywords: string;
+  department?: string;
+  sort?: string;
+  priceMin?: number;
+  priceMax?: number;
+  brand?: string;
+}
+interface AmazonKeywordSuggestion {
+  value: string;
+}
+interface AmazonBestSellerCategory {
+  name: string;
+  slug: string;
+}
+interface AmazonBestSellerEntry {
+  asin: string;
+  rank: number;
+  title: string;
+  url: string;
+  price: number | null;
+  rating: number | null;
+  ratingCount: number | null;
+}
+interface AmazonBestSellerRankEntry {
+  category: string;
+  rank: number;
+}
+interface AmazonProductDetail {
+  asin: string;
+  title: string;
+  url: string;
+  brand: string | null;
+  price: number | null;
+  listPrice: number | null;
+  inStock: boolean;
+  availabilityText: string | null;
+  rating: number | null;
+  ratingCount: number | null;
+  features: string[]; // the site's own free-text bullet points — read them off a result, never guess one from prose
+  specifications: Record<string, string>;
+  breadcrumbs: string[];
+  bestSellersRank: AmazonBestSellerRankEntry[];
+  images: string[];
+  soldBy: string | null;
+  sellerId: string | null;
+}
+interface AmazonVariation {
+  asin: string;
+  dimensions: Record<string, string>; // e.g. { style_name: "Skillet", size_name: "12-inch" } — the site's own dimension names
+  isCurrent: boolean;
+}
+interface AmazonReview {
+  reviewId: string;
+  author: string;
+  rating: number;
+  title: string;
+  date: string; // the site's own sentence, e.g. "Reviewed in the United States on August 9, 2026"
+  variant: string | null; // e.g. "Style: Skillet, Size: 15-inch"
+  verifiedPurchase: boolean;
+  body: string; // paragraphs joined with a blank line, in the site's own order
+  helpfulCount: number;
+}
+interface AmazonRelatedProduct {
+  asin: string;
+  title: string;
+  url: string;
+  price: number | null;
+  rating: number | null; // null on a "Frequently bought together" row — that rail never shows one
+  ratingCount: number | null;
+}
+interface AmazonRelatedProducts {
+  boughtTogether: AmazonRelatedProduct[]; // complements, never the current ASIN
+  related: AmazonRelatedProduct[]; // "Customers who viewed this item also viewed" — substitutes
+  unavailableRails: string[]; // sims-consolidated-N_feature_div ids Amazon lazy-loads rather than serving inline
+}
+interface AmazonDeal {
+  asin: string;
+  title: string;
+  url: string;
+  dealPrice: number;
+  listPrice: number | null;
+  percentOff: number | null;
+  limitedTimeText: string | null; // e.g. "Limited time deal", or "Ends in 2026-09-16T06:59:59.000Z" for a countdown deal
+}
+interface AmazonSellerRatingPeriod {
+  averageRating: number | null;
+  ratingCount: number | null;
+}
+interface AmazonSeller {
+  sellerId: string;
+  name: string;
+  positivePercentageLast12Months: number | null; // Amazon's own headline figure; no lifetime equivalent is published
+  ratings: {
+    last30Days: AmazonSellerRatingPeriod;
+    last90Days: AmazonSellerRatingPeriod;
+    last12Months: AmazonSellerRatingPeriod;
+    lifetime: AmazonSellerRatingPeriod;
+  };
+  businessName: string | null;
+  businessAddress: string[];
+  aboutSeller: string | null;
+}
+interface GetDeliveryEstimateArgs {
+  product: string;
+  zip: string;
+}
+interface AmazonDeliveryEstimate {
+  asin: string;
+  zip: string;
+  zipResolved: boolean; // false = the fields below are Amazon's default location, not this zip
+  deliveryDate: string | null;
+  priceLabel: string | null;
+  condition: string | null;  // the site's own labels — read the values off a result, never guess one from prose
+}
+interface AmazonSellerOffer {
+  condition: string; // e.g. "New", "Used - Good", "Used - Acceptable" — read the values off a result, never guess one from prose
+  price: number | null;
+  shippingCost: number | null; // derived from shippingLabel ("FREE" -> 0)
+  shippingLabel: string | null; // the site's own delivery-price label, e.g. "FREE" or "$3.99"
+  deliveryEstimate: string | null; // e.g. "September 24 - 29"
+  sellerName: string; // "Amazon.com" when Amazon itself is the seller
+  sellerId: string | null; // null when sold by Amazon.com itself — getSeller's argument otherwise
+  sellerRating: number | null; // 0-5
+  sellerRatingCount: number | null;
+}
+interface AmazonSellerOffersResult {
+  asin: string;
+  totalOfferCount: number | null; // Amazon's own count, including offers this page did not render
+  offers: AmazonSellerOffer[]; // page one only, up to 10 — see the note on listSellerOffers
+}
+
+  /**
+   * Search Amazon's catalogue and read a product the way a shopper does — price, stock, rating,
+   * the customer reviews, the other products it recommends, every size and colour the listing
+   * sells, when it would arrive at a given ZIP — plus the rankings (best sellers, new releases,
+   * movers and shakers, most wished for), today's deals and a marketplace seller's feedback.
+   * searchProducts, suggestKeywords, listBestSellerCategories, getProduct, listVariations,
+   * listReviews, listRelatedProducts, listBestSellers, listNewReleases, listMostWishedFor,
+   * listDeals, getSeller, getDeliveryEstimate and listSellerOffers are built; everything else is
+   * still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Search Amazon's catalogue for what a person would type — "cast iron skillet", "usb c hub" —
+     * and get back the result cards as the site ranks them: ASIN, title, price, list price, star
+     * rating, review count, whether the row is a paid placement, and its product URL. Optionally
+     * narrowed to a department, a brand, a price range and a sort order. THE provider's door:
+     * every function below that takes an ASIN is fed by this one.
+     */
+    searchProducts(args: SearchProductsArgs): Promise<AmazonProduct[]>;
+
+    /**
+     * Ask Amazon's own search box what it would autocomplete a prefix to — "cast iron" comes back
+     * as "cast iron skillets", "cast iron", "cast iron dutch oven". What an agent holding a vague
+     * noun calls before it commits to a search, and the cheapest call in the provider.
+     */
+    suggestKeywords(prefix: string): Promise<AmazonKeywordSuggestion[]>;
+
+    /**
+     * List the departments Amazon publishes Best Sellers rankings for — Electronics, Kitchen &
+     * Dining, Books, roughly forty of them — each with the slug ("electronics", "kitchen",
+     * "books") that listBestSellers, listNewReleases, listMostWishedFor and listMoversAndShakers
+     * take. The door for all four ranking functions: a caller holding the word "kitchen" cannot
+     * reach a ranking without this.
+     */
+    listBestSellerCategories(): Promise<AmazonBestSellerCategory[]>;
+
+    /**
+     * Read one product page the way a shopper reads it: title, brand, ASIN, current price and list
+     * price, whether it is in stock, the star rating and how many ratings it has, the bullet-point
+     * features, the specification table, the images, its category breadcrumb, its Best Sellers
+     * Rank, and who it is sold by. The single most-wanted read on the whole site.
+     */
+    getProduct(asinOrUrl: string): Promise<AmazonProductDetail>;
+
+    /**
+     * List every version of a product that is really the same listing — the 8-inch, 10.25-inch,
+     * 12-inch and 15-inch skillet; the colours; the pack sizes — each with the ASIN that buys it.
+     * What an agent needs when the person said "the 12 inch one" and the search returned whichever
+     * size Amazon ranked first. Empty when the listing has no variations — a real answer, not a
+     * parse failure.
+     */
+    listVariations(asinOrUrl: string): Promise<AmazonVariation[]>;
+
+    /**
+     * Read what customers actually wrote about a product — reviewer name, star rating, headline,
+     * date, the variant they bought, whether the purchase was Verified, the review body, and how
+     * many people found it helpful. Amazon shows a logged-out visitor its top eight reviews on the
+     * product page itself; sorting, filtering and paging past them needs a signed-in account,
+     * which sign-up has not shipped for yet. The read an agent needs to answer "is this any good"
+     * rather than "what does it cost".
+     */
+    listReviews(asinOrUrl: string): Promise<AmazonReview[]>;
+
+    /**
+     * The other products Amazon puts next to this one — "Frequently bought together" and
+     * "Customers who viewed this item also viewed" — each with its ASIN, title, price and rating,
+     * kept in separate arrays so a caller can tell a complement from a substitute. Names any
+     * further rail Amazon lazy-loads rather than serving inline rather than silently dropping it.
+     * How an agent moves from one product to the alternatives without inventing a new search
+     * query.
+     */
+    listRelatedProducts(asinOrUrl: string): Promise<AmazonRelatedProducts>;
+
+    /**
+     * Amazon's hourly-updated top sellers in one department (the slug listBestSellerCategories
+     * returns, e.g. "kitchen") — each row's ASIN, rank, title, price and rating, in rank order.
+     * What is actually selling right now, as opposed to searchProducts' relevance ranking. Page
+     * one only (up to 30 rows) — Amazon publishes more per department across a paging control this
+     * pass did not find.
+     */
+    listBestSellers(department: string): Promise<AmazonBestSellerEntry[]>;
+
+    /**
+     * What is newly out in a department (the slug listBestSellerCategories returns, e.g.
+     * "kitchen"), in Amazon's own hot-new-releases order — each row's ASIN, rank, title, price and
+     * rating. The ranking a caller wants when "best seller" would only ever return the same
+     * entrenched products. Page one only (up to 30 rows), the same limit listBestSellers carries
+     * and for the same reason.
+     */
+    listNewReleases(department: string): Promise<AmazonBestSellerEntry[]>;
+
+    /**
+     * What people in a department (the slug listBestSellerCategories returns, e.g. "kitchen") are
+     * adding to wish lists and registries most — each row's ASIN, rank, title, price and rating.
+     * Demand that has not turned into a purchase yet, which is a different signal from
+     * listBestSellers' sales rank. Page one only (up to 30 rows), the same limit the other
+     * rankings carry.
+     */
+    listMostWishedFor(department: string): Promise<AmazonBestSellerEntry[]>;
+
+    /**
+     * Today's Deals — what is discounted right now: ASIN, title, the deal price, the price it was,
+     * the percentage off, and any "limited time" wording (a plain label, or, for a countdown deal,
+     * the fragment plus its ISO deadline). Read off the page's own widget JSON rather than scraped
+     * from a card, so the discount is a published field rather than something to compute. Page one
+     * only (30 deals) — the site's own paging control was not found this pass.
+     */
+    listDeals(): Promise<AmazonDeal[]>;
+
+    /**
+     * Read a marketplace seller's storefront — their name, feedback across four windows (30 days,
+     * 90 days, the last 12 months and lifetime), the one positive-percentage figure Amazon
+     * publishes (last 12 months only), their registered business name and address, and their
+     * free-text "About Seller" text. What tells an agent whether the cheap third-party offer is
+     * from a shop with 86,000 ratings or one with thirty. The door is getProduct's sellerId field
+     * — a listing Amazon sells itself has none.
+     */
+    getSeller(sellerId: string): Promise<AmazonSeller>;
+
+    /**
+     * When a product would actually arrive at a given US ZIP, and what it costs to get it there —
+     * sets the ZIP for one session (Amazon's own "glow" location picker, no account needed) and
+     * reads the delivery block the product page then re-renders for it: the site's own delivery
+     * sentence, the price label and the condition it attaches. `zipResolved` is false, and the
+     * three fields are Amazon's DEFAULT location rather than the caller's ZIP, on an invalid ZIP.
+     */
+    getDeliveryEstimate(args: GetDeliveryEstimateArgs): Promise<AmazonDeliveryEstimate>;
+
+    /**
+     * Every seller offering the same listing side by side — condition (new, used, its grade),
+     * price, shipping cost and estimate, and the seller's own name, id and star rating — read off
+     * the site's "All Offers Display" modal rather than the buy-box winner alone. What tells an
+     * agent who has it cheapest, and whether the cheap one is Amazon itself or a thirty-rating
+     * marketplace seller. Page one only (up to 10 offers, `totalOfferCount` reports the site's own
+     * full count) — no paging control was found in the modal's static markup this pass. Empty
+     * `offers` on a listing with no other sellers is a real answer, not a parse failure.
+     */
+    listSellerOffers(asinOrUrl: string): Promise<AmazonSellerOffersResult>;
+  }
+}
+
 declare namespace BowmarkProvider_americandreamvacations {
   // ── American Dream Vacations — the unit's own declarations, verbatim ──
 interface AdvLocation {
@@ -4317,6 +4786,329 @@ interface AosomProduct {
   }
 }
 
+declare namespace BowmarkProvider_app_store {
+  // ── Apple App Store — the unit's own declarations, verbatim ──
+interface AppStoreApp {
+  id: string;
+  name: string;
+  bundleId: string;
+  developer: { id: string; name: string };
+  price: { amount: number; currency: string; formatted: string } | null;
+  rating: { average: number; count: number } | null;
+  category: string;
+  url: string;
+}
+type AppStorePlatform = "iphone" | "ipad" | "mac";
+interface SearchAppsArgs {
+  term: string;
+  platform?: AppStorePlatform;
+  genreId?: string | number;
+  country?: string;
+  limit?: number;
+}
+interface AppStoreSearchResult {
+  term: string;
+  platform: AppStorePlatform;
+  country: string;
+  total: number;
+  apps: AppStoreApp[];
+}
+interface GetAppArgs {
+  app: string | number;
+  country?: string;
+}
+interface GetAppsArgs {
+  apps: (string | number)[];
+  country?: string;
+}
+interface GetAppsResult {
+  apps: AppStoreApp[];
+  warnings: string[];
+}
+interface GetAppDetailsArgs {
+  app: string | number;
+  country?: string;
+}
+interface AppStoreRatingHistogram {
+  average: number;
+  total: number;
+  counts: number[];
+}
+interface AppStoreChartPosition {
+  category: string;
+  position: number;
+}
+interface AppStoreInAppPurchase {
+  name: string;
+  price: string;
+}
+interface AppStorePrivacyCategory {
+  type: string;
+  title: string;
+  categories: string[];
+}
+interface AppStoreVersionInfo {
+  version: string | null;
+  releaseDate: string | null;
+  notes: string;
+}
+interface AppStoreLink {
+  label: string;
+  url: string;
+}
+interface AppStoreFeaturedStory {
+  title: string;
+  url: string;
+}
+interface AppStoreAppDetails {
+  id: string;
+  country: string;
+  url: string;
+  ratings: AppStoreRatingHistogram | null;
+  chartPosition: AppStoreChartPosition | null;
+  editorsChoice: boolean;
+  information: Record<string, string>;
+  inAppPurchases: AppStoreInAppPurchase[];
+  privacy: AppStorePrivacyCategory[];
+  mostRecentVersion: AppStoreVersionInfo | null;
+  accessibilityFeatures: string[];
+  links: AppStoreLink[];
+  featuredIn: AppStoreFeaturedStory[];
+}
+interface AppStoreCategory {
+  id: string;
+  name: string;
+  parentId: string | null;
+}
+interface ListCategoriesResult {
+  categories: AppStoreCategory[];
+}
+type AppStoreChartDevice = "iphone" | "ipad" | "mac";
+type AppStoreChartKind = "free" | "paid";
+interface ListTopChartsArgs {
+  device?: AppStoreChartDevice;
+  chart?: AppStoreChartKind;
+  genreId?: string | number;
+  country?: string;
+  limit?: number;
+}
+interface AppStoreChartApp {
+  position: number;
+  id: string;
+  bundleId: string;
+  name: string;
+  subtitle: string;
+  developer: string;
+  ageRating: string;
+  price: string;
+  rating: { average: number; countLabel: string } | null;
+  url: string;
+}
+interface ListTopChartsResult {
+  device: AppStoreChartDevice;
+  chart: AppStoreChartKind;
+  genreId: string;
+  country: string;
+  source: "page" | "feed";
+  apps: AppStoreChartApp[];
+}
+interface ListDeveloperAppsArgs {
+  developer?: string | number;
+  app?: string | number;
+  country?: string;
+  limit?: number;
+}
+interface ListDeveloperAppsResult {
+  developer: { id: string; name: string };
+  apps: AppStoreApp[];
+}
+interface ListSimilarAppsArgs {
+  app: string | number;
+  country?: string;
+}
+interface AppStoreSimilarApp {
+  id: string;
+  bundleId: string;
+  name: string;
+  subtitle: string;
+  ageRating: string;
+  price: string;
+  rating: { average: number; countLabel: string } | null;
+  url: string;
+}
+interface AppStoreSimilarAppsResult {
+  id: string;
+  country: string;
+  apps: AppStoreSimilarApp[];
+}
+interface GetStoryArgs {
+  story: string | number;
+  platform?: AppStoreChartDevice;
+  country?: string;
+}
+interface AppStoreStoryApp {
+  id: string;
+  bundleId: string;
+  name: string;
+  subtitle: string;
+  developer: string;
+  ageRating: string;
+  rating: { average: number; countLabel: string } | null;
+  price: string;
+  url: string;
+}
+interface AppStoreStory {
+  id: string;
+  country: string;
+  url: string;
+  heading: string;
+  title: string;
+  subtitle: string;
+  body: string;
+  apps: AppStoreStoryApp[];
+}
+interface ListTodayStoriesArgs {
+  device?: AppStoreChartDevice;
+  country?: string;
+}
+interface AppStoreTodayStory {
+  id: string;
+  title: string;
+  url: string;
+}
+interface ListTodayStoriesResult {
+  device: AppStoreChartDevice;
+  country: string;
+  stories: AppStoreTodayStory[];
+}
+type AppStoreReviewSort = "mostRecent" | "mostHelpful";
+interface ListReviewsArgs {
+  app: string | number;
+  page?: number;
+  sortBy?: AppStoreReviewSort;
+  country?: string;
+}
+interface AppStoreReview {
+  id: string;
+  author: string;
+  title: string;
+  body: string;
+  rating: number | null;
+  version: string;
+  helpfulVotes: number;
+  totalVotes: number;
+  updated: string;
+}
+interface ListReviewsResult {
+  app: string;
+  page: number;
+  sortBy: AppStoreReviewSort;
+  country: string;
+  hasMore: boolean;
+  reviews: AppStoreReview[];
+}
+
+  /**
+   * Search every iPhone, iPad and Mac app Apple lists, read one app's price, rating, reviews,
+   * in-app purchases and privacy labels, and see what is charting right now — off Apple's own
+   * keyless public API and its server-rendered store pages.
+   */
+  interface Unit {
+    /**
+     * Search the App Store for what a person would actually type — "budget tracker", "slack",
+     * "photo editor" — and get back the apps Apple's own store search ranks, narrowable by
+     * platform (iPhone/iPad/Mac), category and store country. THE door: every id-taking function
+     * in this provider is fed by an id this returns.
+     */
+    searchApps(args: SearchAppsArgs): Promise<AppStoreSearchResult>;
+
+    /**
+     * Read one app the way its store listing reads: name, developer, price, average rating and
+     * rating count, category, and the id every other function here takes — from a numeric app id,
+     * its bundle id, or an apps.apple.com URL a person pasted. The core read of the provider, and
+     * the cheapest call in it.
+     */
+    getApp(args: GetAppArgs): Promise<AppStoreApp>;
+
+    /**
+     * Read up to fifty apps in ONE request, for when an agent already holds a list of ids — the
+     * ranks past the top of a chart, the ids in a "you might also like" shelf, a comparison a
+     * person asked for. Same record as getApp, one round trip instead of fifty; an id that does
+     * not resolve is named in warnings rather than silently dropped.
+     */
+    getApps(args: GetAppsArgs): Promise<GetAppsResult>;
+
+    /**
+     * Everything the store page shows that the API does not: the five-star rating histogram, the
+     * app's live chart position, every in-app purchase by name and price, Apple's privacy
+     * nutrition labels, the Editors' Choice citation, the latest version's notes, size, seller,
+     * compatibility, languages, copyright, accessibility features, developer-website and
+     * privacy-policy links, and the editorial stories it has been featured in. Every field is
+     * optional — a missing shelf on the app's own page is an absent field here, never a throw.
+     */
+    getAppDetails(args: GetAppDetailsArgs): Promise<AppStoreAppDetails>;
+
+    /**
+     * Answer "what else is like this one" with the App Store's own You Might Also Like shelf — the
+     * apps Apple itself puts next to this one, each with its name, tagline, developer, age rating,
+     * price and the id every function here takes. What an agent reaches for when the app a person
+     * named is wrong, too expensive, or not on their device. Shares getAppDetails' page cache, so
+     * calling both for one app costs one fetch.
+     */
+    listSimilarApps(args: ListSimilarAppsArgs): Promise<AppStoreSimilarAppsResult>;
+
+    /**
+     * List every app one developer has on the store — from the developer's numeric artist id,
+     * their apps.apple.com developer URL, or just one of their apps (resolved to its developer
+     * first). The read behind "what else did the people who made this write" and behind checking
+     * whether an app is from who it claims to be.
+     */
+    listDeveloperApps(args: ListDeveloperAppsArgs): Promise<ListDeveloperAppsResult>;
+
+    /**
+     * List every category and subcategory the App Store sorts apps into — Business, Education,
+     * Games and its nineteen sub-genres, and the rest — each with the numeric id that narrows
+     * searchApps and listTopCharts. The finder that lets an agent holding the word "puzzle" reach
+     * a real listing without being told an id.
+     */
+    listCategories(): Promise<ListCategoriesResult>;
+
+    /**
+     * What is charting on the App Store right now — top free or top paid, on iPhone, iPad or Mac,
+     * for the whole store or narrowed to any genre id listCategories returns — in rank order, each
+     * entry with its position, name, tagline, developer, age rating, price and the id every other
+     * function here takes. The question this provider exists to answer that no search engine
+     * answers, because the answer changes every day.
+     */
+    listTopCharts(args?: ListTopChartsArgs): Promise<ListTopChartsResult>;
+
+    /**
+     * Read an App Store editorial story — the Today-tab piece Apple's editors wrote ("Master Your
+     * Major", "About In-App Purchases") — its heading, title, body and the apps it recommends,
+     * each with the id every other function here takes. Takes the story URL
+     * getAppDetails().featuredIn[].url returns, or a bare story id plus the platform it was
+     * featured under. How an agent answers "what does Apple say about this" and finds apps nobody
+     * searches for by name.
+     */
+    getStory(args: GetStoryArgs): Promise<AppStoreStory>;
+
+    /**
+     * Read what people actually wrote about an app — the review body, its title, the star rating,
+     * the reviewer's name, which app version they were on, and how many others found it helpful —
+     * fifty at a time, newest first or most helpful first. The one read that turns "4.1 stars"
+     * into a reason.
+     */
+    listReviews(args: ListReviewsArgs): Promise<ListReviewsResult>;
+
+    /**
+     * List the editorial stories Apple is featuring on the Today tab right now — the page a person
+     * actually sees when they open the App Store — each with the id and URL getStory takes. The
+     * door into getStory for an agent that holds no app yet, rather than one that already does.
+     */
+    listTodayStories(args?: ListTodayStoriesArgs): Promise<ListTodayStoriesResult>;
+  }
+}
+
 declare namespace BowmarkProvider_apple {
   // ── Apple — the unit's own declarations, verbatim ──
 interface AppleSearchResult {
@@ -4330,6 +5122,15 @@ interface AppleSearchResponse {
   query: string;
   results: AppleSearchResult[];
 }
+interface AppleSuggestionRow {
+  label: string;
+  url: string;
+}
+interface AppleSuggestResponse {
+  query: string;
+  suggestions: AppleSuggestionRow[];
+  quickLinks: AppleSuggestionRow[];
+}
 interface AppleProduct {
   name: string;
   lowPrice: number | null;
@@ -4342,11 +5143,204 @@ interface AppleProductPage {
   url: string;
   products: AppleProduct[];
 }
+interface AppleConfigChoice {
+  key: string;
+  label: string;
+}
+interface AppleConfigDimension {
+  key: string;
+  label: string;
+  choices: AppleConfigChoice[];
+}
+interface AppleConfiguration {
+  dimensions: Record<string, string>;
+  partNumber: string | null;
+  buildToOrder: boolean;
+  price: number | null;
+  priceCurrency: string | null;
+}
+interface AppleConfigurationOptions {
+  url: string;
+  dimensions: AppleConfigDimension[];
+  configDimensions: AppleConfigDimension[];
+  configurations: AppleConfiguration[];
+}
+interface ApplePurchaseOptionTerm {
+  id: string;
+  name: string;
+  sectionHeader: string;
+  sectionFooter: string;
+}
+interface ApplePurchaseOption {
+  id: string;
+  formValue: string;
+  sectionHeader: string;
+  sectionFooter: string;
+  hideCarrier: boolean;
+  terms: ApplePurchaseOptionTerm[];
+}
+interface ApplePurchaseOptions {
+  url: string;
+  options: ApplePurchaseOption[];
+}
+interface AppleFamilyModel {
+  name: string;
+  startingPrice: number | null;
+  url: string;
+}
+interface AppleFamilyModelList {
+  family: "mac" | "iphone" | "ipad" | "watch";
+  models: AppleFamilyModel[];
+}
+interface AppleRefurbishedListing {
+  partNumber: string;
+  name: string;
+  price: number | null;
+  priceCurrency: string | null;
+  url: string;
+  image: string | null;
+}
+interface AppleRefurbishedCatalog {
+  category: "mac" | "ipad" | "iphone" | "watch" | "appletv" | "homepod" | "airpods" | "accessories";
+  listings: AppleRefurbishedListing[];
+}
 interface AppleTradeInEstimate {
   device: string;
   upToUsd: number;
   sourceUrl: string;
 }
+interface AppleTradeInDeviceValue {
+  modelId: string | null;
+  modelName: string;
+  maxValueUsd: number;
+}
+interface AppleTradeInCatalog {
+  category: "smartphone" | "computer" | "watch";
+  devices: AppleTradeInDeviceValue[];
+}
+interface AppleSupportResult {
+  docid: string;
+  title: string;
+  url: string;
+  snippet: string;
+}
+interface AppleSupportSearchResponse {
+  query: string;
+  results: AppleSupportResult[];
+  totalResults: number;
+}
+interface AppleSupportArticle {
+  docid: string;
+  title: string;
+  description: string;
+  url: string;
+  body: string;
+}
+interface AppleLocationSuggestion {
+  displayValue: string;
+  city: string;
+  state: string;
+}
+interface AppleResolvedLocation {
+  place: string;
+  location: string;
+  city: string;
+  state: string;
+  alternates: AppleLocationSuggestion[];
+}
+interface AppleNearbyStore {
+  storeNumber: string;
+  storeName: string;
+  city: string;
+  state: string;
+  address: string;
+  phoneNumber: string;
+  distanceMiles: number | null;
+}
+interface AppleStoresNear {
+  location: string;
+  stores: AppleNearbyStore[];
+}
+interface ApplePickupStore {
+  storeNumber: string;
+  storeName: string;
+  city: string;
+  state: string;
+  address: string;
+  phoneNumber: string;
+  distanceMiles: number | null;
+  available: boolean;
+  pickupQuote: string | null;
+}
+interface ApplePickupAvailability {
+  partNumber: string;
+  location: string;
+  stores: ApplePickupStore[];
+}
+interface AppleDeliveryOption {
+  displayName: string;
+  date: string;
+  shippingCost: string;
+}
+interface AppleDeliveryEstimate {
+  partNumber: string;
+  postalCode: string;
+  options: AppleDeliveryOption[];
+}
+interface AppleStoreListing {
+  storeNumber: string;
+  name: string;
+  url: string;
+}
+interface AppleStoreList {
+  stores: AppleStoreListing[];
+}
+interface AppleStoreHours {
+  days: string[];
+  opens: string;
+  closes: string;
+}
+interface AppleStore {
+  storeNumber: string;
+  name: string;
+  url: string;
+  phoneNumber: string;
+  address: string;
+  city: string;
+  state: string;
+  postalCode: string;
+  latitude: number | null;
+  longitude: number | null;
+  hours: AppleStoreHours[];
+}
+interface AppleNewsroomPost {
+  title: string;
+  category: string;
+  date: string;
+  url: string;
+  summary: string;
+}
+interface AppleNewsroomPostList {
+  posts: AppleNewsroomPost[];
+}
+interface AppleNewsroomArticle {
+  title: string;
+  summary: string;
+  date: string;
+  url: string;
+  body: string;
+}
+interface AppleCompareSpec {
+  label: string;
+  value: string;
+}
+interface AppleCompareModel {
+  name: string;
+  specs: AppleCompareSpec[];
+}
+interface AppleCompareModels {
+  models: AppleCompareModel[];
+}
 
   /** apple.com's own site search and product pages — no API, no login, no browser. */
   interface Unit {
@@ -4356,12 +5350,85 @@ interface AppleTradeInEstimate {
      */
     search(query: string): Promise<AppleSearchResponse>;
 
+    /**
+     * Types a partial query into apple.com's own search box and returns what it suggests:
+     * completed search phrases ("AirPods Pro 3") and quick links straight to a product page
+     * ("AirPods" → apple.com/airpods/). A caller holding only the words somebody said gets a real
+     * product URL with no id to know first.
+     */
+    suggestSearches(query: string): Promise<AppleSuggestResponse>;
+
     /**
      * Reads one apple.com product/buy page (a URL or path, e.g. search()'s own rows) and returns
      * every schema.org Product block it publishes.
      */
     getProduct(urlOrPath: string): Promise<AppleProductPage>;
 
+    /**
+     * Turns an Apple part number — the "MYAP3LL/A"-shaped code printed on every buy page and
+     * returned by getPickupAvailability/getDeliveryEstimate — into the product it names: real
+     * name, price and currency, straight off the configured buy page apple.com redirects a part
+     * number to. Also accepts a /shop/ path or apple.com URL, resolved the same way getProduct's
+     * argument is.
+     */
+    getProductByPartNumber(partNumber: string): Promise<AppleProductPage>;
+
+    /**
+     * Reads every choice a Mac/iPhone/iPad buy page actually offers — screen size, colour, chip,
+     * memory, storage, keyboard layout, connectivity — straight off the page's own configurator
+     * data, with the part number and price each fixed combination already resolves to. "Configure
+     * and price it" as one read instead of clicking through the on-page configurator: every part
+     * number this returns is directly usable by getProductByPartNumber, getPickupAvailability and
+     * getDeliveryEstimate. A combination apple.com has not fixed a single part number for yet
+     * (memory/storage still open) comes back with `buildToOrder: true` and a null part number,
+     * listing the further choices rather than guessing a price for combinations apple.com computes
+     * client-side.
+     */
+    getConfigurationOptions(urlOrPath: string): Promise<AppleConfigurationOptions>;
+
+    /**
+     * Reads the ways apple.com will let you pay for the product a buy page has settled on — buy
+     * outright, Apple Card Monthly Installments, or the Apple Upgrade Program lease (with its 24-
+     * vs 36-month term choice) — with apple.com's own copy for each, straight off the buy page's
+     * own window.PURCHASE_OPTIONS_BOOTSTRAP. Only a page that has resolved to ONE product exposes
+     * this: every Mac family buy page has (e.g. "/shop/buy-mac/macbook-air"), an iPhone/iPad
+     * chooser page has not even at one specific part number, and this throws a caller-fixable
+     * error naming that rather than guessing. Carries no dollar figure — apple.com computes a
+     * monthly amount only after a term and trade-in are picked on the buy page itself; read a
+     * configuration's own price off getConfigurationOptions.
+     */
+    getPurchaseOptions(urlOrPath: string): Promise<ApplePurchaseOptions>;
+
+    /**
+     * Puts two or more iPhone models side by side on the specs apple.com itself compares them on —
+     * screen size, chip, camera system, battery, capacity, finish, durability rating, connectivity
+     * — straight off apple.com's own /iphone/compare/ grid. Model names must match the page's own
+     * naming exactly (e.g. "iPhone 17 Pro", not "17 Pro" or "iphone17pro"); an unmatched name
+     * throws naming the page's own list. Carries no price: apple.com's own compare page renders
+     * its Price row as an unfilled client-side template with no number in the static HTML, so this
+     * omits it rather than guess — read a price off getConfigurationOptions or getPurchaseOptions
+     * instead. A spec absent for one model (an older phone with no Dynamic Island) is simply
+     * missing from that model's own list, never a false "no".
+     */
+    compareModels(models: string[]): Promise<AppleCompareModels>;
+
+    /**
+     * Lists every model apple.com currently sells in one product family — the chooser page's own
+     * cards (e.g. "MacBook Air", "iPad mini"), each with its starting price and the buy page that
+     * configures it. Takes "mac", "iphone", "ipad" or "watch" — apple.com publishes no equivalent
+     * chooser page for AirPods or Vision Pro, each sold as a single named model with no lineup to
+     * list.
+     */
+    listFamilyModels(family: "mac" | "iphone" | "ipad" | "watch"): Promise<AppleFamilyModelList>;
+
+    /**
+     * Apple's own certified refurbished store, read as data: every listing currently in stock in
+     * one category, each with its real name, its current price and the part number that resolves
+     * it straight through getProductByPartNumber. Stock turns over daily and a category can
+     * legitimately be empty when Apple has nothing left in it.
+     */
+    listRefurbished(category: "mac" | "ipad" | "iphone" | "watch" | "appletv" | "homepod" | "airpods" | "accessories"): Promise<AppleRefurbishedCatalog>;
+
     /**
      * 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
@@ -4370,6 +5437,95 @@ interface AppleTradeInEstimate {
      * best-case figure, not a quote for a specific unit's actual condition.
      */
     getTradeInEstimate(model: string): Promise<AppleTradeInEstimate>;
+
+    /**
+     * The whole Apple Trade In price list in one call. "smartphone" is the RICH catalog behind the
+     * estimator — every individual phone model apple.com will take, INCLUDING non-Apple ones
+     * (Samsung, Google, …), each with its own ceiling. "computer" and "watch" are coarser: a
+     * ceiling per product LINE ("MacBook Pro", "Apple Watch Ultra 3"), the same table
+     * getTradeInEstimate reads for iPhone. apple.com has no measured trade-in catalog for "tablet"
+     * at all — neither surface this function uses covers it.
+     */
+    listTradeInValues(category: "smartphone" | "computer" | "watch"): Promise<AppleTradeInCatalog>;
+
+    /**
+     * Searches Apple's own support library the way a person describes a problem ("iphone battery
+     * draining") and returns the articles Apple ranks for it — HelpKB pages, User Guide pages and
+     * Apple Support Community threads mixed in one list, each with its document id, title, URL and
+     * a plain-text snippet. A DOOR: the way into the support half of this provider before
+     * getSupportArticle reads one page in full.
+     */
+    searchSupport(query: string): Promise<AppleSupportSearchResponse>;
+
+    /**
+     * Reads one Apple support article end to end — the real instructions under its headline, not a
+     * search snippet — from the docid or URL one of searchSupport()'s own rows carries. The read
+     * an agent reaches for once searchSupport has narrowed the problem to one page.
+     */
+    getSupportArticle(docidOrUrl: string): Promise<AppleSupportArticle>;
+
+    /**
+     * Turns the place a person said — "cupertino", "san francisco" — into the exact "<city>,
+     * <state>" string apple.com's own store and delivery lookups accept, off apple.com's own
+     * location typeahead. A DOOR HOP: the small step that makes findStoresNear,
+     * getPickupAvailability and getDeliveryEstimate callable from words alone instead of a
+     * pre-resolved location string.
+     */
+    resolveLocation(place: string): Promise<AppleResolvedLocation>;
+
+    /**
+     * Finds the Apple Stores near a place a person named — "Cupertino", "94108", "San Francisco" —
+     * with each store's name, number, city, state, address, phone and distance, nearest first. The
+     * finder that turns a place into the store records every other retail function here takes, for
+     * a caller who holds no part number and must not have to invent one.
+     */
+    findStoresNear(place: string): Promise<AppleStoresNear>;
+
+    /**
+     * Answers the one question apple.com is uniquely able to answer: can I walk into a store today
+     * and pick this up. Give it a part number (or a /shop/ path or apple.com URL — resolved the
+     * same way getProduct's argument is) and a place, and it returns every nearby Apple Store with
+     * whether that exact configuration is in stock, the pickup window, and the store's name,
+     * number, address, phone and distance.
+     */
+    getPickupAvailability(partNumber: string, place: string): Promise<ApplePickupAvailability>;
+
+    /**
+     * When would this actually arrive if ordered now, to a ZIP code — the shipping options and
+     * delivery dates apple.com quotes on the buy page for one exact configuration, without
+     * starting a checkout. Takes a bare 5-digit ZIP, NOT the resolved place string
+     * getPickupAvailability takes: apple.com's own delivery-message endpoint reads a different
+     * parameter and ignores a "<city>, <state>" value entirely.
+     */
+    getDeliveryEstimate(partNumber: string, postalCode: string): Promise<AppleDeliveryEstimate>;
+
+    /**
+     * Every Apple Store in the US on one call — its name, its store number and its page — off
+     * apple.com's own store-locator directory, so a caller can browse or filter them rather than
+     * guess a slug. The store number is the SAME id findStoresNear and getPickupAvailability's
+     * rows carry, so a listing here joins straight to either.
+     */
+    listStores(): Promise<AppleStoreList>;
+
+    /**
+     * Read one Apple Store: its full address, phone number, map coordinates, store number and the
+     * hours it is open each day of the week — everything a person needs before driving there.
+     * Takes a URL or /retail/ path, e.g. one of listStores()'s own rows.
+     */
+    getStore(urlOrPath: string): Promise<AppleStore>;
+
+    /**
+     * Apple's official announcements, newest first, off its own published RSS feed — every product
+     * launch, financial result and press release, with its headline, category, publish date and
+     * link. The primary source for "what did Apple just announce", with no publisher in between.
+     */
+    listNewsroomPosts(): Promise<AppleNewsroomPostList>;
+
+    /**
+     * Read one Apple press release or announcement in full from its URL — the article text itself,
+     * not the feed's one-line summary. Takes a URL straight off listNewsroomPosts()'s own rows.
+     */
+    getNewsroomPost(url: string): Promise<AppleNewsroomArticle>;
   }
 }
 
@@ -6073,18 +7229,18 @@ interface bestbuyProduct {
 }
 
   /**
-   * Best Buy's own documented Products API (api.bestbuy.com) — searches the live bestbuy.com
-   * catalog by query and returns price, availability and review data, and looks up one product
-   * by Best Buy's own SKU, without scraping bestbuy.com's search page.
+   * Searches the live bestbuy.com catalog by query and returns price, availability and review
+   * data — off bestbuy.com's own search page with no key, or Best Buy's documented Products API
+   * when a key is available — and looks up one product by Best Buy's own SKU (key required).
    */
   interface Unit {
     /**
-     * Runs a Best Buy product search the way bestbuy.com's own search box does, via Best Buy's
-     * documented Products API, and returns the matching products — name, sale/regular price,
-     * online and in-store availability, manufacturer, model number, UPC and review stats.
-     * `pageSize` caps the row count (default 10, Best Buy's own ceiling 100). Uses Bowmark's Best
-     * Buy key and charges each request to your account; send your own key as the
-     * `x-bowmark-vendor-key-bestbuy` header instead.
+     * Runs a Best Buy product search the way bestbuy.com's own search box does and returns the
+     * matching products — name, sale/regular price, online and in-store availability and review
+     * stats. With a Best Buy developer key (Bowmark's, charged to your account, or your own on the
+     * `x-bowmark-vendor-key-bestbuy` header) it reads the documented Products API and also fills
+     * manufacturer, model number and UPC. With no key it reads bestbuy.com's own search results
+     * page, where those three fields are null. `pageSize` caps the row count (default 10).
      */
     search(args: string | { query: string; pageSize?: number }): Promise<bestbuyProduct[]>;
 
@@ -7345,6 +8501,107 @@ 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 {
@@ -8132,7 +9389,10 @@ interface CamelPriceHistory {
     /**
      * Runs camelcamelcamel's own Amazon-product search and returns each hit's ASIN, title and
      * current price — the locator this provider was missing: `getPriceHistory` takes an ASIN, and
-     * this is how a caller holding only a shopper's words finds one.
+     * this is how a caller holding only a shopper's words finds one. Pass the product's name; if
+     * the full wording matches nothing it retries on its own with measurements ("24000mAh",
+     * "140W") dropped, so there is no need to re-run it with shorter queries, and no need to
+     * search Amazon as well to find the ASIN.
      */
     search(query: string): Promise<CamelSearchResult[]>;
 
@@ -8140,6 +9400,11 @@ interface CamelPriceHistory {
      * Reads camelcamelcamel's independently-tracked Amazon price history for one ASIN — the site's
      * own lowest-ever/highest-ever/current/average figures, each dated, for the Amazon,
      * 3rd-party-new and 3rd-party-used price types, plus the full-history chart image URL.
+     * `amazon.current.price` is Amazon's own price today and is null when Amazon itself is not
+     * selling it, which is an answer rather than a gap. These summary figures are ALL the history
+     * the library has: there is no month-by-month series anywhere (the chart is an image), so
+     * answer 'how has the price moved' from lowest/highest/average/current and do not look for
+     * another source.
      */
     getPriceHistory(asinOrUrl: string): Promise<CamelPriceHistory>;
   }
@@ -15363,10 +16628,6 @@ interface GooglePriceGraph {
 
 declare namespace BowmarkProvider_google_maps {
   // ── Google Maps — the unit's own declarations, verbatim ──
-interface GoogleMapsPlace {
-  featureId: string;
-  name: string;
-}
 interface SuggestPlacesArgs {
   query: string;
 }
@@ -15391,6 +16652,17 @@ interface GeocodeAddressResult {
   formattedAddress: string;
   coordinates: { lat: number; lng: number } | null;
 }
+interface ReverseGeocodeArgs {
+  lat: number;
+  lng: number;
+}
+interface ReverseGeocodeResult {
+  formatted: string;
+  plusCode: string;
+  locality: string;
+  dms: string;
+  coordinates: { lat: number; lng: number };
+}
 interface GetPlaceArgs {
   query: string;
 }
@@ -15417,12 +16689,58 @@ interface Review {
   text: string;
   relativeDate?: string;
 }
+interface ListRelatedPlacesArgs {
+  query: string;
+}
+interface RelatedPlace {
+  featureId: string;
+  name: string;
+  coordinates: { lat: number; lng: number } | null;
+  categories: string[];
+  rating?: number;
+  reviewCount?: number;
+}
+interface GetDirectionsArgs {
+  origin: string;
+  destination: string;
+  mode?: "driving" | "walking" | "transit";
+}
+interface DirectionsStep {
+  instruction: string;
+  distance: string;
+  duration: string;
+}
+interface GetDirectionsResult {
+  distance: string;
+  duration: string;
+  distanceMeters: number;
+  durationSeconds: number;
+  steps: DirectionsStep[];
+}
+interface ResolvePlaceUrlArgs {
+  url: string;
+}
+interface GoogleMapsPlace {
+  featureId: string;
+  name?: string;
+}
+interface ListPhotosArgs {
+  featureId: string;
+}
+interface Photo {
+  url: string;
+  width: number;
+  height: number;
+  takenAt?: string;
+  source?: string;
+}
 
   /**
    * Local business search on Google Maps — find places by what a person would say, then read the
-   * address, hours, rating, reviews and route. suggestPlaces (autocomplete), searchPlaces (the
-   * door), geocodeAddress, getPlace and listReviews are built; everything else is still a
-   * declared stub.
+   * address, hours, rating, reviews, photos, co-located tenants and route. suggestPlaces
+   * (autocomplete), searchPlaces (the door), geocodeAddress, getPlace, listReviews, listPhotos,
+   * listRelatedPlaces, getDirections, resolvePlaceUrl and reverseGeocode are built; everything
+   * else is still a declared stub.
    */
   interface Unit {
     /**
@@ -15448,6 +16766,17 @@ interface Review {
      */
     geocodeAddress(args: GeocodeAddressArgs): Promise<GeocodeAddressResult>;
 
+    /**
+     * A point in — the Plus Code and locality Google Maps shows for it out, the same string a
+     * person sees when they drop a pin ("JMC2+57W Seattle, Washington"), never a street address:
+     * that is what the site itself answers for a bare point, verified live against the White
+     * House's own coordinates. Rides the same tbm=map door searchPlaces and geocodeAddress use,
+     * with a different field mask — not the browser rung the survey queued this for; the browser
+     * pass that found the field mask was how the shape was discovered, not what the shipped
+     * function needs.
+     */
+    reverseGeocode(args: ReverseGeocodeArgs): Promise<ReverseGeocodeResult>;
+
     /**
      * Everything Google Maps shows on one business's panel — name, full address, coordinates,
      * category, neighborhood, phone, website, rating, review count and weekly hours, each present
@@ -15469,11 +16798,67 @@ interface Review {
      * place.
      */
     listReviews(args: ListReviewsArgs): Promise<Review[]>;
+
+    /**
+     * Other businesses Google Maps lists "At this place" — the site's own label for a shared
+     * address, not the "people also search for" competitor set the survey planned. A FIFTH reading
+     * of searchPlaces' door (the same record getPlace reads, at [204]). Verified 2026-09-15:
+     * `null` for an ordinary standalone business (confirmed against four, including Analog Coffee
+     * and Pike Place Market), populated only for a multi-tenant venue — Space Needle's own gift
+     * shop, café and lounge; a 61-store list for Westlake Center mall. Returns [] for a
+     * single-business query rather than throwing; throws only when the query itself does not
+     * resolve to one place.
+     */
+    listRelatedPlaces(args: ListRelatedPlacesArgs): Promise<RelatedPlace[]>;
+
+    /**
+     * A DIFFERENT door from searchPlaces' — www.google.com/maps/preview/directions, its own
+     * reusable pb= template (BUILD_QUEUE.md), one per mode. Takes origin and destination as text,
+     * exactly what a person would type ("Space Needle, Seattle, WA") or a
+     * searchPlaces/geocodeAddress result's name plus address — not a feature id, measured live the
+     * same way getPlace measured it. mode defaults to "driving"; "walking" and "transit" are also
+     * built. "bicycling" is not: its response shape diverges enough that a route total cannot be
+     * read off it safely yet. Returns the site's own trip total (distance, duration, traffic-aware
+     * for driving) plus the turn-by-turn instructions, each carrying the site's own distance and
+     * duration text. Throws when either place does not resolve to a route.
+     */
+    getDirections(args: GetDirectionsArgs): Promise<GetDirectionsResult>;
+
+    /**
+     * A Google Maps link somebody pasted — a maps.app.goo.gl short link, a full /maps/place/ link,
+     * or the older ?ftid=/?cid= link — turned into the feature id and name it points at. Two of
+     * the three shapes need no network call at all: everything returned is already sitting in the
+     * URL string, since fetching a resolved link live only echoes the request back rather than
+     * adding data (measured 2026-09-15). Only a short link costs a request — one redirect-follow,
+     * reading the destination out of the "location" header rather than the (contentless) body. A
+     * bare ?cid= link resolves only the LOW half of the feature id and carries no name, reported
+     * as "0x0:0x<lo>" the same way the site's own echo does. Throws when the link resolves to
+     * something that is not a place — a dropped-pin share or a review share, both measured live.
+     */
+    resolvePlaceUrl(args: ResolvePlaceUrlArgs): Promise<GoogleMapsPlace>;
+
+    /**
+     * The photos Google Maps shows in a place's gallery panel — up to 20, each with a url, its
+     * real dimensions and the site's own upload-source tag ("photos:gmm_ios_review_post" and
+     * similar — which app and flow it came in through, not a caption; none was found at any
+     * position tried), plus a date when the response carried one. A THIRD door, not searchPlaces'
+     * field mask: opening the place page's own photo panel fires its own batchexecute RPC, which
+     * is not a bootstrap-derived static template the way searchPlaces' and reverseGeocode's are —
+     * a browser genuinely has to run to get the real gallery back, measured 2026-09-16. Takes a
+     * featureId (searchPlaces/geocodeAddress/getPlace/resolvePlaceUrl all hand one back), not a
+     * resolving query.
+     */
+    listPhotos(args: ListPhotosArgs): Promise<Photo[]>;
   }
 }
 
 declare namespace BowmarkProvider_google_news {
   // ── Google News — the unit's own declarations, verbatim ──
+interface GoogleNewsLocaleArg {
+  hl?: string;
+  gl?: string;
+  ceid?: string;
+}
 interface GoogleNewsClusterEntry {
   title: string;
   link: string;
@@ -15501,12 +16886,55 @@ interface GoogleNewsTopicHeadlines {
   title: string;
   articles: GoogleNewsArticle[];
 }
+interface GoogleNewsPublisherHeadlines {
+  publisher: string;
+  query: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsLocalHeadlines {
+  place: string;
+  title: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsArticleResolution {
+  articleId: string;
+  url: string;
+}
+interface GoogleNewsTopic {
+  topicId: string;
+  name: string;
+}
+interface GoogleNewsTopicFeed {
+  topicId: string;
+  title: string;
+  articles: GoogleNewsArticle[];
+}
+interface GoogleNewsStory {
+  storyId: string;
+  title: string;
+}
+interface GoogleNewsCoverageArticle {
+  articleId: string;
+  title: string;
+  snippet: string | null;
+  publisher: string;
+  publisherUrl: string | null;
+  url: string;
+  publishedAt: string | null;
+}
+interface GoogleNewsFullCoverage {
+  storyId: string;
+  articles: GoogleNewsCoverageArticle[];
+}
 
   /**
    * Headlines from every publisher at once — today's top stories as clusters, a section or a
-   * city's local news, and everything indexed about a subject with Google's own when: and site:
-   * operators. searchNews (the door) and topStories are built; everything else is still a
-   * declared stub.
+   * city's local news, one outlet's own coverage, and everything indexed about a subject with
+   * Google's own when: and site: operators. searchNews (the door), topStories,
+   * listTopicHeadlines, listLocalHeadlines, listPublisherHeadlines, resolveArticleUrl (the
+   * redirector-to-publisher resolver every other function's links need), listTopics (the finder
+   * for getTopicHeadlines), listStories (the finder for getFullCoverage) and getFullCoverage
+   * (every outlet reporting one story) are built; everything else is still a declared stub.
    */
   interface Unit {
     /**
@@ -15518,18 +16946,21 @@ interface GoogleNewsTopicHeadlines {
      * subjects — measured 2026-09-15: `site:reuters.com tesla` returned 100 items of which 100
      * carried `<source>Reuters</source>`. This is the provider's main door: a caller holding only
      * words gets in here. A query that matches nothing returns an empty `articles` array rather
-     * than throwing.
+     * than throwing. `locale` — `{ hl, gl, ceid }` — asks for another country/language edition,
+     * e.g. `{ hl: "es-419", gl: "MX", ceid: "MX:es" }` for Mexico; omitted, every field defaults
+     * to the US English edition.
      */
-    searchNews(query: string): Promise<GoogleNewsSearchResult>;
+    searchNews(query: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsSearchResult>;
 
     /**
      * What Google News is leading with right now — the front page, as ranked story CLUSTERS rather
      * than a flat list. Each entry carries the lead headline and publisher plus every other outlet
      * covering the same story, which is the one thing a single publisher's own feed can never give
-     * a caller asking "what is everyone saying about this today". No arguments: the front page is
-     * the whole ask.
+     * a caller asking "what is everyone saying about this today". `locale` — `{ hl, gl, ceid }` —
+     * asks for another country/language edition, e.g. `{ hl: "es-419", gl: "MX", ceid: "MX:es" }`
+     * for Mexico; omitted, the US English front page.
      */
-    topStories(): Promise<GoogleNewsTopStories>;
+    topStories(locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopStories>;
 
     /**
      * The latest headlines in one of Google News' own eight sections — World, Nation, Business,
@@ -15538,9 +16969,447 @@ interface GoogleNewsTopicHeadlines {
      * case-insensitively against the closed list of eight; anything else throws before any request
      * is made, because an unrecognized section answers 200 with Google News' own app-shell HTML
      * rather than a 404 (measured 2026-09-15) — reading that as an empty section would be silently
-     * wrong rather than refused.
+     * wrong rather than refused. `locale` — `{ hl, gl, ceid }` — asks for another country/language
+     * edition; omitted, the US English one.
+     */
+    listTopicHeadlines(section: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopicHeadlines>;
+
+    /**
+     * 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
+     * (`/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.
+     */
+    listPublisherHeadlines(publisher: string, query?: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsPublisherHeadlines>;
+
+    /**
+     * What is being reported in one place — the local-news edition for a city or region, by NAME
+     * ("Seattle", "San Francisco"), not a place id. There is no closed list of valid places, so a
+     * place Google News has no edition for is refused only after the request comes back: it
+     * answers 200 with an in-protocol "This feed is not available." sentinel item and a bare
+     * "Google News" channel title rather than the place's own name (measured 2026-09-15 on a
+     * nonsense place; the same sentinel `_client` already drops out of every other feed by guid) —
+     * reading that as an empty result would be silently wrong, so this throws instead. A
+     * recognized place's own channel title is echoed back in `place`, in the site's own spelling,
+     * so `"seattle"` and `"Seattle"` both resolve to `"Seattle"`. `locale` — `{ hl, gl, ceid }` —
+     * asks for another country/language edition; omitted, the US English one.
+     */
+    listLocalHeadlines(place: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsLocalHeadlines>;
+
+    /**
+     * The publisher's real article URL behind a Google News link — every `link` in every feed
+     * above is a `news.google.com/rss/articles/<id>` redirector that does NOT redirect (it 302s to
+     * itself, then serves an interstitial with no publisher URL anywhere in its bytes), so this is
+     * what turns a headline into something a caller can actually read. Takes either the bare
+     * `articleId` (a feed item's own `<guid>`) or a full redirector link someone pasted. Two hops,
+     * both browserless: GET the interstitial for a `data-n-a-id`/`-ts`/`-sg` signature minted for
+     * that article page, then POST it to the site's `batchexecute` RPC for the real URL — the
+     * signature cannot be skipped or reused across articles, so this is always two requests.
+     */
+    resolveArticleUrl(articleIdOrLink: string): Promise<GoogleNewsArticleResolution>;
+
+    /**
+     * The topics Google News' own home-page nav rail is offering today — the eight standing
+     * sections plus "Your local news" (measured 2026-09-15: nine entries, geo-scoped to whichever
+     * exit made the request) — each with the opaque topic id `getTopicHeadlines` takes. Read off
+     * the home page's own embedded `AF_initDataCallback({key: 'ds:2'…})` state rather than scraped
+     * from the rendered nav, so it needs no browser. The finder that makes a topic id reachable by
+     * somebody who only holds words. `locale` — `{ hl, gl, ceid }` — asks for another
+     * country/language edition's own nav rail; omitted, the US English one.
+     */
+    listTopics(locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopic[]>;
+
+    /**
+     * The headlines under any Google News topic id — the opaque key `/rss/topics/<id>` takes,
+     * which the eight named sections `listTopicHeadlines` takes by word are only a subset of.
+     * Identical fetch and parse to `listTopicHeadlines` (`/rss/topics/<topicId>` rather than
+     * `/rss/headlines/section/topic/<NAME>`) — the only difference is the key, since a topic id
+     * has no canonical spelling for the site to correct it to. Measured 2026-09-15: the Technology
+     * section's own topic id answers the identical feed shape as its section-name door, 70 items,
+     * titled "Technology - Latest - Google News". THE ONLY IDS REACHABLE WITHOUT AN ACCOUNT ARE
+     * THE NINE `listTopics` RETURNS. Google News also runs entity and interest topics (a company,
+     * a person, a sports league), but measured 2026-09-16 nothing logged-out hands their ids out —
+     * a topic page, a story page, `/home` and `/publications` each carry only the nav rail's own
+     * nine, and the HTML `/search` page that renders the entity's Follow chip answers 429 through
+     * the proxy. To follow a company or a person today, use `searchNews`. `locale` — `{ hl, gl,
+     * ceid }` — asks for another country/language edition; omitted, the US English one.
+     */
+    getTopicHeadlines(topicId: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsTopicFeed>;
+
+    /**
+     * The story CLUSTERS Google News is running right now, as ids — the finder for
+     * `getFullCoverage`. Pass a `topicId` (from `listTopics`, or one of the eight section names'
+     * own topic id) to read a topic page — measured 2026-09-15: 43 distinct stories on the
+     * Technology topic page, the richer of the two doors — or omit it to read the front page
+     * instead, which surfaces far fewer (2 measured) since most front-page items are
+     * single-outlet. Reads the "Full Coverage" anchor Google News renders on every multi-outlet
+     * story directly off the page's HTML, rather than the page's own embedded state — no RSS feed
+     * on this site emits a story id at all, so this is the only door. `locale` — `{ hl, gl, ceid
+     * }` — asks for another country/language edition of whichever page is read; omitted, the US
+     * English one.
+     */
+    listStories(topicId?: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsStory[]>;
+
+    /**
+     * Every outlet reporting one story — Google News' own Full Coverage, chained off a `storyId`
+     * from `listStories`. Reads the story page's own `AF_initDataCallback({key: 'ds:0'…})` state:
+     * a mix of named groups ("Top news", "Personal perspective", an occasional "Posts on X" of
+     * social posts rather than articles, which are excluded) and ungrouped rows, folded into one
+     * flat list. Unlike every other function here, each article's `url` is the PUBLISHER's own
+     * page directly — no `news.google.com` redirector, so no `resolveArticleUrl` hop is needed. A
+     * story id is as short-lived as a headline; hold one only as long as the `listStories` call
+     * that produced it — a stale id throws, naming that as the likely cause, rather than answering
+     * with 0 articles. `locale` — `{ hl, gl, ceid }` — matters here even though every article
+     * already carries its own publisher URL: the STORY PAGE ITSELF is read in whichever edition is
+     * asked for, and reading it in the wrong one silently truncates or empties the coverage
+     * (measured 2026-09-16: the same story id answered 0 articles under the US default and 53
+     * under `{ hl: "es-419", gl: "MX", ceid: "MX:es" }`). Pass the SAME locale the `listStories`
+     * call that produced this id used; omitted, the US English edition.
+     */
+    getFullCoverage(storyId: string, locale?: GoogleNewsLocaleArg): Promise<GoogleNewsFullCoverage>;
+  }
+}
+
+declare namespace BowmarkProvider_google_translate {
+  // ── Google Translate — the unit's own declarations, verbatim ──
+interface TranslateArgs {
+  text: string | readonly string[];
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateResult {
+  source: string;
+  translated: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  detected: boolean;
+}
+interface DetectLanguageArgs {
+  text: string;
+}
+interface GoogleTranslateLanguageCandidate {
+  language: string;
+  confidence: number;
+}
+interface GoogleTranslateLanguageDetection {
+  language: string;
+  confidence: number;
+  candidates: GoogleTranslateLanguageCandidate[];
+}
+interface ListLanguagesArgs {
+  hl?: string;
+}
+interface GoogleTranslateLanguage {
+  code: string;
+  name: string;
+  sourceSupported: boolean;
+  targetSupported: boolean;
+}
+interface LookupWordArgs {
+  word: string;
+  to: string;
+  from: string;
+  hl?: string;
+}
+interface GoogleTranslateWordCandidate {
+  word: string;
+  reverseTranslations: string[];
+  score: number;
+}
+interface GoogleTranslateWordSense {
+  partOfSpeech: string;
+  candidates: GoogleTranslateWordCandidate[];
+}
+interface GoogleTranslateWordLookup {
+  word: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  senses: GoogleTranslateWordSense[];
+}
+interface GetDefinitionsArgs {
+  word: string;
+  language: string;
+}
+interface GoogleTranslateDefinitionExample {
+  text: string;
+}
+interface GoogleTranslateDefinition {
+  definitionId: string;
+  gloss: string;
+  examples: GoogleTranslateDefinitionExample[];
+  subject?: string[];
+  register?: string[];
+}
+interface GoogleTranslateDefinitionSense {
+  partOfSpeech: string;
+  definitions: GoogleTranslateDefinition[];
+}
+interface GoogleTranslateWordDefinitions {
+  word: string;
+  language: string;
+  senses: GoogleTranslateDefinitionSense[];
+}
+interface GetSynonymsArgs {
+  word: string;
+  language: string;
+}
+interface GoogleTranslateSynonymGroup {
+  definitionId: string;
+  synonyms: string[];
+  register?: string[];
+}
+interface GoogleTranslateSynonymSense {
+  partOfSpeech: string;
+  groups: GoogleTranslateSynonymGroup[];
+}
+interface GoogleTranslateWordSynonyms {
+  word: string;
+  language: string;
+  senses: GoogleTranslateSynonymSense[];
+}
+interface GetAlternativeTranslationsArgs {
+  text: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateAlternative {
+  text: string;
+  backends: number[];
+}
+interface GoogleTranslateAlternativeSegment {
+  sourceSegment: string;
+  offsets: { begin: number; end: number };
+  alternatives: GoogleTranslateAlternative[];
+}
+interface GoogleTranslateAlternativeTranslations {
+  text: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  segments: GoogleTranslateAlternativeSegment[];
+}
+interface CheckSpellingArgs {
+  text: string;
+  language: string;
+}
+interface GoogleTranslateSpellCheck {
+  text: string;
+  language: string;
+  correct: boolean;
+  corrected?: string;
+  correctedHtml?: string;
+  correctionType?: number[];
+  confident?: boolean;
+}
+interface RomanizeArgs {
+  text: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateRomanization {
+  text: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  detected: boolean;
+  targetRomanization?: string;
+  sourceRomanization?: string;
+}
+interface SpeakArgs {
+  text: string;
+  language: string;
+}
+interface GoogleTranslateSpeech {
+  audioBase64: string;
+  contentType: string;
+  chunkCount: number;
+}
+interface TranslateWebPageArgs {
+  url: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateWebPageSegment {
+  original: string;
+  translated: string;
+}
+interface GoogleTranslateWebPage {
+  url: string;
+  title: string;
+  translatedTitle: string;
+  targetLanguage: string;
+  sourceLanguage: string;
+  detected: boolean;
+  segments: GoogleTranslateWebPageSegment[];
+}
+interface TranslateDocumentArgs {
+  fileBase64: string;
+  mimeType: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateDocumentResult {
+  translatedBase64: string;
+  mimeType: string;
+}
+interface TranslateImageArgs {
+  imageBase64: string;
+  mimeType: string;
+  to: string;
+  from?: string;
+}
+interface GoogleTranslateImageResult {
+  translatedImageBase64: string;
+  mimeType: string;
+  sourceText: string;
+  translatedText: string;
+}
+
+  /**
+   * Translate text into any of 249 languages, in a batch if you have a list, and find out what
+   * language something already is — plus the dictionary underneath: senses, definitions,
+   * synonyms, alternative wordings, the romanization and the spoken audio. Thirteen functions
+   * are built; the four account-gated ones (saved phrases, history) are still declared stubs.
+   */
+  interface Unit {
+    /**
+     * Turn text into another language. `args.text` is one string or a list translated together in
+     * one request, in order; `args.to` names the target language by name ("Spanish") or code
+     * ("es", "pt-BR"); `args.from` is optional and, left out, the source is detected per string,
+     * with `detected: true` and the detected code coming back on each result. Returns one
+     * `GoogleTranslateResult` per input string, aligned by position.
+     */
+    translate(args: TranslateArgs): Promise<GoogleTranslateResult[]>;
+
+    /**
+     * Work out what language a string is written in. Returns `language` (Google's own code) and
+     * `confidence` (0-1) rather than swallowing it — a single word can come back confidently wrong
+     * (measured 2026-09-15: "Bonjour" alone detects as "en"), so a caller reading only `language`
+     * cannot tell a guess from a sure thing. `candidates` carries every language Google's detector
+     * considered, most confident first.
+     */
+    detectLanguage(args: DetectLanguageArgs): Promise<GoogleTranslateLanguageDetection>;
+
+    /**
+     * Every language this site supports — the table that turns a caller's "Portuguese" into the
+     * `pt`/`pt-BR` code the rest of this provider takes, and the honest answer to "can Google
+     * Translate do Cherokee". `args.hl` optionally localizes the returned `name`s (`{ hl: "es" }`
+     * returns "abjasio" for `ab`); left out, names come back in English.
+     * `sourceSupported`/`targetSupported` are not both always true — `sl` alone carries `"auto"`
+     * ("Detect language") and `tl` alone carries `"zh-TW"`, measured 2026-09-15.
+     */
+    listLanguages(args?: ListLanguagesArgs): Promise<GoogleTranslateLanguage[]>;
+
+    /**
+     * The full "translations of <word>" dictionary panel: every part of speech Google has for
+     * `args.word`, the candidate translations under each (ordered by Google's own frequency
+     * `score`), and for each candidate the words it itself translates back to — the difference
+     * between "run means correr" and knowing `ejecutar` is the software sense and `huir` is the
+     * fleeing sense. `args.from` is required, unlike `translate` — there is no "detect it" reading
+     * of a dictionary lookup. `senses` comes back empty when Google has no per-sense breakdown for
+     * the term (a longer phrase, or a string its dictionary does not recognize); the plain
+     * `translate` function still works on those.
+     */
+    lookupWord(args: LookupWordArgs): Promise<GoogleTranslateWordLookup>;
+
+    /**
+     * What `args.word` MEANS, IN `args.language` — monolingual, unlike `lookupWord`, which
+     * translates between two. Groups every sense by part of speech, each carrying a plain-English
+     * gloss and, where Google has one, a real usage example (its own `<b>`-highlight markup
+     * stripped). `senses` comes back empty when Google's dictionary has nothing for the term.
+     */
+    getDefinitions(args: GetDefinitionsArgs): Promise<GoogleTranslateWordDefinitions>;
+
+    /**
+     * Other words that mean the same thing as `args.word`, IN `args.language` — grouped by sense
+     * (`definitionId` matches a `GoogleTranslateDefinition.definitionId` from `getDefinitions`)
+     * rather than thrown into one list, and labelled where Google knows the register: "informal"
+     * synonyms for "run" (belt, zip, leg it, hotfoot it) come back in a separate group from the
+     * neutral ones (sprint, race, dart, dash), and a group with no `register` is the neutral case.
+     * `senses` comes back empty when Google has no synonyms for the term.
+     */
+    getSynonyms(args: GetSynonymsArgs): Promise<GoogleTranslateWordSynonyms>;
+
+    /**
+     * The other ways Google would have translated `args.text` — the list that appears when a
+     * person clicks a translated phrase to see what else it could have said. Works on a whole
+     * sentence, not just a word: `args.text` splits into `segments`, one per sentence Google
+     * recognizes, each carrying its own `alternatives` — the unit of the answer is the SEGMENT,
+     * never the whole input. `args.from` is optional and, left out, the source is detected, same
+     * as `translate`.
+     */
+    getAlternativeTranslations(args: GetAlternativeTranslationsArgs): Promise<GoogleTranslateAlternativeTranslations>;
+
+    /**
+     * Google Translate's own "Did you mean …" line for `args.text`, written in `args.language` —
+     * `correct: true` when nothing needed fixing, otherwise the corrected text plain and
+     * HTML-marked-up. What a caller runs before trusting a translation of something a human typed
+     * in a hurry.
+     */
+    checkSpelling(args: CheckSpellingArgs): Promise<GoogleTranslateSpellCheck>;
+
+    /**
+     * A Latin-alphabet (or phonetic) rendering of `args.text` or its translation —
+     * "Ohayōgozaimasu, ogenkidesuka?" under a Japanese translation, "rən" under the English word
+     * "run". `targetRomanization` comes back when the TARGET script is non-Latin,
+     * `sourceRomanization` when the SOURCE is — measured 2026-09-16, that includes a short
+     * Latin-script dictionary lookup, which still carries an English pronunciation guide. Both are
+     * absent on an ordinary sentence between two Latin-script languages, which is a normal answer,
+     * not a failure. `args.from` is optional and, left out, the source is detected, same as
+     * `translate`.
+     */
+    romanize(args: RomanizeArgs): Promise<GoogleTranslateRomanization>;
+
+    /**
+     * Hear `args.text` spoken in `args.language`, as the MP3 the site's own speaker button plays.
+     * Google's `/translate_tts` refuses anything over 200 characters with a hard 400, so this
+     * function chunks longer text on SENTENCE boundaries (never mid-sentence) and stitches the
+     * resulting MP3s into one file — confirmed 2026-09-16 that concatenating raw `/translate_tts`
+     * bytes decodes as one continuous, correctly-timed clip, since the door answers a bare MPEG
+     * stream with no container. `chunkCount` says how many `/translate_tts` calls the answer is
+     * built from. Throws when a single SENTENCE in `args.text` is itself over 200 characters —
+     * there is no boundary left to chunk on, and truncating it silently is the one thing this
+     * function must not do.
      */
-    listTopicHeadlines(section: string): Promise<GoogleNewsTopicHeadlines>;
+    speak(args: SpeakArgs): Promise<GoogleTranslateSpeech>;
+
+    /**
+     * Read `args.url` in `args.to` — fetches the page with a plain GET (no browser; a page that
+     * renders its text client-side is out of reach), walks its rendered text nodes in reading
+     * order, and translates them through this provider's own `translate` door. Measured 2026-09-16
+     * that `<host>.translate.goog` (the site's own page-translation product) serves the ORIGINAL
+     * page plus a client-side translator script and never returns translated text browserless,
+     * which is why this fetches the caller's url directly instead. `args.from` is optional and,
+     * left out, the source is detected off the page's title. `segments` preserves the page's own
+     * reading order.
+     */
+    translateWebPage(args: TranslateWebPageArgs): Promise<GoogleTranslateWebPage>;
+
+    /**
+     * Translate a whole PDF, Word or PowerPoint file — the Documents tab. Takes `fileBase64` (the
+     * document, base64-encoded), `mimeType`, `to`, and optional `from` (left out, auto-detects),
+     * and returns `translatedBase64` + `mimeType` for the SAME document translated. Built on a
+     * real browser (rung 15): the RPC answers 200 to a bare browserless replay too, but silently
+     * returns the document UNTRANSLATED without a BotGuard token (`x-goog-batchexecute-bgr`) only
+     * a real browser produces — measured 2026-09-16, two earlier browserless-adjacent attempts
+     * read that 200 as success.
+     */
+    translateDocument(args: TranslateDocumentArgs): Promise<GoogleTranslateDocumentResult>;
+
+    /**
+     * Read the text in a picture and translate it — the Images tab. Takes `imageBase64` (the
+     * image, base64-encoded), `mimeType`, `to`, and optional `from` (left out, auto-detects), and
+     * returns `translatedImageBase64` + `mimeType` (a copy of the image with the detected text
+     * replaced in place) plus the plain `sourceText`/`translatedText` strings Google's OCR found.
+     * Shares `translateDocument`'s RPC channel and BotGuard gate (rung 15, real browser) but its
+     * own rpcid (`WqWDPb`) and upload shape — measured 2026-09-16 uploading a real PNG with
+     * rendered glyphs, verified "Hola mundo" → "Bonjour le monde" (tl=fr) and → "Hello world"
+     * (tl=en).
+     */
+    translateImage(args: TranslateImageArgs): Promise<GoogleTranslateImageResult>;
   }
 }
 
@@ -21199,7 +23068,7 @@ interface LululemonColorway {
   imageAssets: ProductImage[];
   sale: SaleEvidence;
   coordination: CoordinationMetadata;
-  /** ISO 4217, or null. Always null — see SaleEvidence.currency. */
+  /** ISO 4217 from the colourway url's own locale, or null for an unknown one. */
   currency: string | null;
   inStock: boolean;
   optionGroups: LululemonOptionGroup[];
@@ -21246,7 +23115,7 @@ interface LululemonProductAttributes {
   /** The site's own ProductGroup category, e.g. "Leggings". */
   category: string | null;
   description: string | null;
-  /** Trademarked fabric names off the detail accordion, e.g. ["Nulu"]. */
+  /** Trademarked fabric names off the product-detail region, e.g. ["Nulu"]. */
   fabrics: string[];
   fit: string | null;
   /** "High-Rise" / "Mid-Rise" / "Low-Rise", as the title spells it. */
@@ -25514,6 +27383,435 @@ interface PremierbuildingsDealer {
   }
 }
 
+declare namespace BowmarkProvider_prime_video {
+  // ── Prime Video — the unit's own declarations, verbatim ──
+interface PrimeVideoTitle {
+  titleId: string;
+  catalogId: string | null;
+  title: string;
+  url: string;
+  entityType: string | null;
+  releaseYear: number | null;
+  maturityRating: string | null;
+  entitled: boolean;
+  watchMessage: string | null;
+}
+interface PrimeVideoTitleSuggestion {
+  value: string;
+}
+interface PrimeVideoWatchOffer {
+  kind: "rent" | "buy" | "subscribe";
+  label: string;
+  price: { currency: string; value: string } | null;
+  quality: "SD" | "HD" | "UHD" | null;
+  channel: { benefitId: string; link: string } | null;
+}
+interface PrimeVideoWatchOptions {
+  titleId: string;
+  entitlementType: "Entitled" | "Unentitled";
+  entitled: boolean;
+  message: string;
+  channel: { name: string; link: string } | null;
+  offers: PrimeVideoWatchOffer[];
+}
+interface PrimeVideoSeason {
+  seasonId: string;
+  seasonLink: string;
+  displayName: string;
+  sequenceNumber: number;
+  seasonSelectorIcon: string | null;
+}
+interface PrimeVideoCredit {
+  name: string;
+  searchLink: string | null;
+}
+interface PrimeVideoRatingBucket {
+  stars: 1 | 2 | 3 | 4 | 5;
+  percentage: number;
+}
+interface PrimeVideoTitleDetail {
+  titleId: string;
+  catalogId: string | null;
+  title: string;
+  seriesTitle: string | null;
+  seasonNumber: number | null;
+  titleType: string | null;
+  synopsis: string | null;
+  releaseYear: number | null;
+  releaseDate: string | null;
+  runtime: string | null;
+  durationSeconds: number | null;
+  genres: string[];
+  maturityRating: string | null;
+  cast: PrimeVideoCredit[];
+  directors: PrimeVideoCredit[];
+  studios: string[];
+  amazonRating: { value: number; count: number } | null;
+  ratingsHistogram: PrimeVideoRatingBucket[];
+  imdbScore: number | null;
+  audioTracks: string[];
+  subtitles: string[];
+  isUhd: boolean;
+  isHdr: boolean;
+  isDolbyVision: boolean;
+  isDolbyAtmos: boolean;
+  isXRay: boolean;
+  isClosedCaption: boolean;
+  isPrime: boolean;
+  isAd: boolean;
+}
+interface PrimeVideoEpisode {
+  titleId: string | null;
+  episodeNumber: number;
+  title: string;
+  synopsis: string | null;
+  runtime: string | null;
+  durationSeconds: number | null;
+  releaseDate: string | null;
+  releaseYear: number | null;
+  images: { packshot: string | null; covershot: string | null };
+  audioTracks: string[];
+  subtitles: string[];
+  isUhd: boolean;
+  isHdr: boolean;
+  isDolbyVision: boolean;
+  isDolbyAtmos: boolean;
+  isXRay: boolean;
+  isClosedCaption: boolean;
+  isPrime: boolean;
+  isAd: boolean;
+}
+interface PrimeVideoPersonCredit {
+  titleId: string | null;
+  catalogId: string;
+  title: string;
+  releaseYear: number | null;
+  runtime: string | null;
+  synopsis: string | null;
+  maturityRating: string | null;
+}
+interface PrimeVideoPerson {
+  personId: string;
+  name: string;
+  roles: string[];
+  birthPlace: string | null;
+  dateOfBirth: string | null;
+  bio: string | null;
+  imdbUrl: string | null;
+  filmography: PrimeVideoPersonCredit[];
+}
+interface PrimeVideoCategory {
+  name: string;
+  slug: string;
+  kind: "genre" | "collection" | "storefront";
+  path: string;
+}
+interface PrimeVideoCategoryRow {
+  heading: string;
+  titles: PrimeVideoTitle[];
+}
+interface PrimeVideoTop10Entry extends PrimeVideoTitle {
+  position: number;
+  list: "tv" | "movies" | "channel";
+}
+interface PrimeVideoChannel {
+  name: string;
+  channelId: string | null;
+  benefitId: string | null;
+  synopsis: string | null;
+  offerMessage: string | null;
+}
+interface PrimeVideoChannelDetail {
+  name: string;
+  rows: PrimeVideoCategoryRow[];
+}
+interface PrimeVideoLiveProgram {
+  title: string;
+  seriesTitle: string | null;
+  start: number;
+  end: number;
+}
+interface PrimeVideoLiveStation {
+  id: string;
+  name: string;
+  logo: string | null;
+  group: string;
+  nowPlaying: PrimeVideoLiveProgram | null;
+}
+interface PrimeVideoLiveScheduleEntry {
+  title: string;
+  seriesTitle: string | null;
+  seasonNumber: number | null;
+  episodeNumber: number | null;
+  synopsis: string | null;
+  maturityRating: string | null;
+  start: number;
+  end: number;
+}
+interface PrimeVideoLiveSportsEvent {
+  titleId: string;
+  title: string;
+  group: string;
+  status: "LIVE" | "UPCOMING" | null;
+  timeBadge: string | null;
+  venue: string | null;
+  entitled: boolean;
+  watchMessage: string | null;
+}
+
+  /**
+   * Search Prime Video's catalogue and read a film or series the way a viewer does — synopsis,
+   * cast, rating, seasons and episodes — and above all say how it can actually be watched:
+   * included with Prime, free with ads, on a named add-on channel, or rentable and buyable with
+   * the real price. Plus the browse surfaces (genres, collections, the top ten, this week's
+   * deals), the add-on channels, and the free live TV, news and sports schedules. searchTitles,
+   * suggestTitles, getTitle, getWatchOptions, listSeasons, listEpisodes, getPerson and
+   * listCategories are built; everything else is still a declared stub.
+   */
+  interface Unit {
+    /**
+     * Search Prime Video's whole catalogue for what a person would type — "matrix", "the boys" —
+     * and get back the title cards the site itself ranks: display title, the titleId every other
+     * function here takes, whether it is a film or a series, the year, the maturity rating, and
+     * the site's own sentence for how to watch it. THE provider's door: every titleId-taking
+     * function below is fed by this one. Returns the FIRST page only — Prime Video's search page
+     * carries no pagination markers at all (measured 2026-09-15). `options.waysToWatch` narrows by
+     * how you can watch it — "prime" (included with a Prime membership), "channels" (an add-on
+     * subscription) or "rentOrBuy" — the commonest thing a viewer does after typing a query and
+     * the one refinement built so far. The site's other five refinement dimensions (which channel,
+     * HD/UHD, theme, subtitle language, film-or-series) are still not built here: every one of
+     * them rides the same opaque per-page `serviceToken` mechanism (rung 11 — an undocumented
+     * endpoint reached by harvesting the token off the page a search already returned), never a
+     * query parameter, and a hand-constructed query parameter silently returns the unfiltered set
+     * rather than erroring. A query that matches nothing returns an empty array rather than
+     * throwing. A filtered call whose real matches are too few can carry the site's own generic
+     * recommendations under a heading still labelled "Top results" — measured 2026-09-16, not a
+     * defect in this parser: the site does this identically on the unfiltered page's own "More to
+     * explore" row.
+     */
+    searchTitles(query: string, options?: { waysToWatch?: "prime" | "channels" | "rentOrBuy" }): Promise<PrimeVideoTitle[]>;
+
+    /**
+     * Ask Prime Video's own search box what it would autocomplete a prefix to — "the boy" comes
+     * back as "the boys", "the boy", "the boy and the heron". What an agent holding a
+     * half-remembered title calls before it commits to a search, and the cheapest call in the
+     * provider.
+     */
+    suggestTitles(prefix: string): Promise<PrimeVideoTitleSuggestion[]>;
+
+    /**
+     * Read one film, series-season or episode the way a viewer reads its page: title, synopsis,
+     * year, release date, runtime (both the display string and durationSeconds), genres, maturity
+     * rating, cast, directors, studio, the Amazon customer rating and its five-star histogram, the
+     * IMDb score, which audio languages and subtitles it ships, and whether it is in UHD, HDR,
+     * Dolby Atmos or X-Ray. The core read of the whole provider. Takes a titleId or a title URL,
+     * e.g. one read off searchTitles(). THE REVIEW TEXT IS NOT HERE — the aggregate rating and
+     * histogram are real and logged out, but review bodies are amazon.com's own surface behind
+     * amazon.com's sign-in wall.
+     */
+    getTitle(titleId: string): Promise<PrimeVideoTitleDetail>;
+
+    /**
+     * Say how you would actually watch a title: included with your Prime membership, free with
+     * ads, on an add-on channel you would have to subscribe to (and which one), or available to
+     * rent or buy — and when it is rent-or-buy, every offer with its real price and quality. THE
+     * question this provider exists to answer, and the one no general search result answers about
+     * Amazon's catalogue. Takes a titleId or a title URL, e.g. one read off searchTitles() or
+     * getTitle(). Reads the SAME page as getTitle, never fetches it twice. Placing any of these
+     * orders is never a function of this provider — a flow that costs money stops before the
+     * payment step, always.
+     */
+    getWatchOptions(titleId: string): Promise<PrimeVideoWatchOptions>;
+
+    /**
+     * List every season of a series with the titleId that opens each one, its number, its display
+     * name, and whether it needs paying for beyond what the current season needs. What an agent
+     * needs when the person said "season 4" and the search returned whichever season Prime Video
+     * ranked first. Takes a titleId or a title URL, e.g. one read off searchTitles() or
+     * getTitle(). Reads the SAME cached page as getTitle and getWatchOptions, never fetches it
+     * twice. A film returns an empty array — a real, measured answer, since a film's own /detail/
+     * page carries no seasons at all.
+     */
+    listSeasons(titleId: string): Promise<PrimeVideoSeason[]>;
+
+    /**
+     * List a season's episodes with number, title, synopsis, runtime, release date, artwork, and
+     * the audio and subtitle languages each one ships. The read behind "what happens in episode 3"
+     * and "how long is the finale". Takes the SEASON's titleId — one read off listSeasons() or
+     * getTitle() — or a title URL. Reads the SAME cached page as getTitle, getWatchOptions and
+     * listSeasons, never fetches it twice; episodes come with whichever season is selected, so
+     * reading another season means calling this on THAT season's own titleId, off listSeasons(). A
+     * film returns an empty array — a real, measured answer, matching listSeasons() on the same
+     * title.
+     */
+    listEpisodes(titleId: string): Promise<PrimeVideoEpisode[]>;
+
+    /**
+     * Read a cast member's own Prime Video page: their name, what they are credited as, when and
+     * where they were born, their biography, and the titles of theirs the catalogue carries — with
+     * each credit's own synopsis, runtime and maturity rating, not just its title. How an agent
+     * answers "what else is she in" without leaving the site. Takes a personId or a person URL —
+     * read one off getTitle().cast[].searchLink, never .directors[].searchLink, which points at a
+     * search instead: a director gets no page of their own here, only a searchTitles() fallback.
+     */
+    getPerson(personId: string): Promise<PrimeVideoPerson>;
+
+    /**
+     * List the ways Prime Video lets you browse — its genres (action, comedy, horror, anime,
+     * documentary and more, plus kids), its editorial collections (new and upcoming, award
+     * winners, free to watch) and its storefronts (movies, TV, store, sports, news, live TV,
+     * subscriptions) — each with the token the browse function below this one in the queue takes.
+     * The door for every browse read here: an agent holding the word "horror" can reach a real
+     * listing without being told a URL. Every row carries `name` (the site's own display text),
+     * `slug` (the literal, inconsistently-cased path token — "science-fiction", "mgForYou" — never
+     * guess its casing) and `kind`. Resolve a caller's typed word against `name`, never `slug`.
+     */
+    listCategories(): Promise<PrimeVideoCategory[]>;
+
+    /**
+     * Browse one genre, collection or storefront and get its rows of titles back — "what horror is
+     * on Prime Video", "what is in the free-with-ads collection" — each row carrying the site's
+     * own heading ("Popular movies", "Free comedy movies") and every title under it in the site's
+     * own order, with the same fields searchTitles() returns. Takes a `path` off listCategories(),
+     * e.g. "/genre/comedy", "/collection/streamfree", "/movie", "/tv" or "/store" — those five are
+     * the only shapes this pass measured. Drops the leading, unheaded hero carousel every
+     * storefront page opens with; every other row is real. Returns the FIRST page only, exactly
+     * like searchTitles() — these pages carry no pagination markers either.
+     */
+    listCategoryTitles(path: string): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * What has just arrived on Prime Video and what is coming — the read behind "anything new
+     * worth watching", which a genre browse can never answer because a genre ranks by popularity
+     * and this ranks by recency. Same row shape as listCategoryTitles(): a heading ("Premium New
+     * Releases", "Recently added to Prime – Movies") and every title under it. No arguments — this
+     * is a named call over listCategoryTitles' own parser, pointed at the site's own newness
+     * surfaces (`/collection/newandupcoming` plus `/tv`'s "Explore: Latest TV" row) rather than a
+     * caller-supplied path. Prime Video publishes no logged-out "leaving soon" surface — none of
+     * "leaving", "expires", "available until" or "last chance" appear anywhere the survey read —
+     * so there is no sibling function for that half of the question.
+     */
+    listNewReleases(): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * What you can watch on Prime Video without paying anything at all — the free-with-ads
+     * catalogue, a different answer from "included with Prime" and the honest one for a caller
+     * with no Amazon subscription. No arguments — `GET /collection/streamfree`, filtered
+     * card-by-card to the site's own `freewithads` entitlement marker rather than trusted by row
+     * heading: a "Free popular TV" row on that page mixes titles a visitor with no subscription
+     * can watch with titles that need Prime, and both carry the identical "Watch for free" message
+     * and "Entitled" verdict, so the row heading alone cannot tell them apart (measured
+     * 2026-09-16: 8 of 20 cards on that row are Prime-included, not free-with-ads). A row whose
+     * cards are all Prime-included, not free-with-ads, is dropped rather than returned empty.
+     */
+    listFreeToWatch(): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * Prime Video's own top ten right now — the most-watched TV shows in the US ("tv", off `/tv`),
+     * the top films to rent or buy ("movies", off `/store`), or the top ten on one add-on channel
+     * ("channel", off that channel's own page — pass its uuid as `channelId`, e.g. one read off
+     * listChannels() or a channel URL). The read behind "what is everyone watching", and one
+     * search can never give you, because search ranks by relevance and this ranks by what is
+     * actually being played. Every row carries `position` (the card's own 1-based rank within that
+     * list — Prime Video never prints a rank number, so this is the card's own order) and `list`
+     * (which of the three it came from) alongside the same fields searchTitles() returns; a merged
+     * top ten that does not say whether it means streaming or renting is a wrong answer wearing a
+     * right one. **The row is intermittent** — measured this build pass, three spaced captures of
+     * `/tv` in one minute carried it on only one — so a request that lands without it returns
+     * `[]`, a real and honest answer, never an error.
+     */
+    listTop10(list: "tv" | "movies" | "channel", channelId?: string): Promise<PrimeVideoTop10Entry[]>;
+
+    /**
+     * What is discounted to rent or buy on Prime Video this week — "Prime deals this week", "New
+     * release deals", time-boxed sales and film bundles — the read behind "how do I watch this"
+     * when the answer turns out to be "buy it" and the follow-up is "is it cheaper right now". No
+     * arguments — `GET /store/deals`, read with the same listCategoryTitles() parser: same row
+     * shape (a heading and every title under it), same dropped leading hero carousel. **Carries no
+     * price.** Exactly three dollar strings exist on the whole page and all three are a row
+     * heading ("$15.99 or less TV deals"), never a per-title price, so a caller who wants the
+     * number calls getWatchOptions() on a titleId from one of these rows, where the price comes
+     * off a decoded offerToken rather than a scraped string.
+     */
+    listDeals(): Promise<PrimeVideoCategoryRow[]>;
+
+    /**
+     * List the add-on subscriptions Prime Video sells inside itself — HBO Max, Paramount+,
+     * Britbox, ViX Premium and seventy-odd more — with the two ids each one is addressed by:
+     * `channelId`, which opens the channel's own page (getChannel(), listTop10("channel",
+     * channelId)), and `benefitId`, which `GET /offers?benefitId=<benefitId>` takes to start a
+     * subscription. The door for getChannel() and the thing that turns getWatchOptions' "get an
+     * add-on subscription" into a named service a person can decide about. No arguments — `GET
+     * /addons`, read off the "Subscriptions you might like" row with the shared hydration parser.
+     * **Carries no price.** The two dollar strings on the whole page are a card's own compact
+     * offer wording, never a clean number, so `offerMessage` carries the site's own sentence
+     * instead. Most cards carry both ids; a card with no channel page of its own (CNN All Access)
+     * carries only `benefitId`, and one further outlier (NBA League Pass, a subscription pass
+     * rather than a channel) carries neither — both real, measured gaps, never a guess.
+     */
+    listChannels(): Promise<PrimeVideoChannel[]>;
+
+    /**
+     * Read one add-on channel: what it is called, its top ten, its originals and series, and the
+     * live events it is carrying — the rest of a channel's catalogue, for answering "is it worth
+     * subscribing to this to watch that" rather than one title. Takes the channel's uuid off
+     * listChannels(), e.g. one read off `channelId` there — NOT the same card's `benefitId`, which
+     * opens a different route. `GET /channel/<uuid>`, read off the same carousel parser
+     * listCategoryTitles() uses: a heading and every title under it, per row, in the site's own
+     * order. `rows` never includes the channel's own hero banner, which carries no title list of
+     * its own.
+     */
+    getChannel(channelId: string): Promise<PrimeVideoChannelDetail>;
+
+    /**
+     * List the free live TV ("livetv", off `/livetv`) or news ("news", off `/news`) stations Prime
+     * Video streams — their name, their logo, the id that addresses them, which row they are
+     * grouped under (on `/livetv` the channel selling them, "Prime" or "AMC+"; on `/news` a topic
+     * like "National news"), and what is on each one right now. The half of this site that has
+     * nothing to do with the on-demand catalogue. `nowPlaying` is derived by walking the station's
+     * own schedule for the entry covering this moment, never read off a per-entry badge — measured
+     * 2026-09-16, every schedule entry on both pages carries the identical `linearBadge: {label:
+     * "ON NOW"}` whether or not it is actually airing, so that field cannot say which slot is
+     * current. `nowPlaying` is `null`, a real answer, when no entry covers this instant. A station
+     * whose card appears on more than one row on the same page (an unheaded hero container
+     * duplicating a station a headed row below it already carries) is returned once, off the
+     * headed row — an unheaded container is dropped whole.
+     */
+    listLiveChannels(section: "livetv" | "news"): Promise<PrimeVideoLiveStation[]>;
+
+    /**
+     * Read one live TV or news station's FULL schedule — every program the page carries for it, in
+     * order, never filtered to what is on now (that single entry is `listLiveChannels()`'s own
+     * `nowPlaying`). `start` and `end` are EPOCH MILLISECONDS, never the page's
+     * `localizedTimeRange` ("9 - 9:30 AM EDT"), which is rendered for Amazon's assumed timezone
+     * and useless to a caller in another one. Takes the SAME `section` `listLiveChannels(section)`
+     * was called with and a `stationId` read off one of its rows — `/livetv` and `/news` carry
+     * different stations, so a `livetv` id will not resolve on `/news`. Refuses (caller-fixable)
+     * when the page carries no station with that id.
+     */
+    getLiveSchedule(section: "livetv" | "news", stationId: string): Promise<PrimeVideoLiveProgram[]>;
+
+    /**
+     * What sport is on Prime Video now and what is coming — live and upcoming EVENTS, off
+     * `/sports`, never a station (that is `listLiveChannels`'s own shape, a `LinearStationCard`,
+     * which this function ignores) and never an on-demand documentary sharing the same page. No
+     * arguments. `group` names the row the event is listed under: "Sports with a subscription" is
+     * entitlement a Prime member already carries some of, "Apple TV: Live and upcoming events" is
+     * a different provider's events entirely, and `entitled`/`watchMessage` carry the site's own
+     * per-event verdict — measured 2026-09-16, a Prime-entitled poker event on the "Sports with a
+     * subscription" row reads `entitled: true, watchMessage: "Watch for free"` beside an
+     * Unentitled squash event on the SAME row reading `entitled: false, watchMessage: "Free trial
+     * of SquashTV"`, so the row heading alone never says whether a given event is free. `status`
+     * and `timeBadge` are the site's own words ("LIVE", "Live at 7 PM EDT", "Fri, Sep 18 6:30 PM
+     * EDT") — no epoch timestamp exists on an event card the way one does on a station's
+     * `schedule[]`, so none is invented. `venue` is `null` for an event with no physical location
+     * (an online poker series, a studio broadcast) — a real and common answer, never a parse
+     * failure.
+     */
+    listLiveSports(): Promise<PrimeVideoLiveSportsEvent[]>;
+  }
+}
+
 declare namespace BowmarkProvider_progressive {
   // ── Progressive — the unit's own declarations, verbatim ──
 // Progressive's OWN shapes — not a capability contract.
@@ -28359,6 +30657,88 @@ interface ScPlaylist {
   }
 }
 
+declare namespace BowmarkProvider_speedrun {
+  // ── speedrun.com — the unit's own declarations, verbatim ──
+interface FindGameArgs {
+  name: string;
+}
+
+interface CategoriesArgs {
+  gameId: string;
+}
+
+interface PlatformsArgs {
+  gameId?: string;
+}
+
+interface Game {
+  id: string;
+  names: { international: string; japanese?: string };
+  abbreviation: string;
+  weblink: string;
+  released: number;
+  "release-date": string;
+  platforms?: string[];
+  ruleset?: { "require-video": boolean; "require-verification": boolean; "show-milliseconds": boolean };
+}
+
+interface Category {
+  id: string;
+  name: string;
+  weblink: string;
+  type: string;            // "per-game" | "per-level"
+  rules?: string;
+  players?: { type: string; value?: number }
+  miscellaneous?: boolean; // hidden from the default leaderboard view
+  variables?: { data: CategoryVariable[] }
+}
+
+interface CategoryVariable {
+  id: string;
+  name: string;
+  mandatory: boolean;
+  "user-defined": boolean;
+  // submitRun takes the KEY of a choice, never its label
+  values?: { choices?: Record<string, { label: string }>; default?: string }
+}
+
+interface Platform {
+  id: string;
+  name: string;
+  released?: number;
+}
+
+  /** Submit speedruns and search game metadata on speedrun.com */
+  interface Unit {
+    /**
+     * Searches games by name and returns the matches with the metadata every other call here needs
+     * — the opaque `id`, the abbreviation, the weblink, the platform ids, and the `ruleset` that
+     * says whether a video is required and whether milliseconds are shown. Start here:
+     * speedrun.com addresses everything by id and nothing by title. The search is fuzzy and
+     * ranked, so read the first row rather than assuming one match, and an unknown title returns
+     * an empty array rather than an error.
+     */
+    findGame(args: FindGameArgs): Promise<Game[]>;
+
+    /**
+     * Lists every category for one game, with the variables each one carries. The `variables`
+     * block is the part that matters before a submit: a category with a `mandatory` variable
+     * rejects a run that omits it, and the accepted values are the keys of `values.choices`, not
+     * their labels. `type` separates a per-game category from a per-level one, and
+     * `is-miscellaneous` marks the ones the leaderboard hides by default.
+     */
+    categories(args: CategoriesArgs): Promise<Category[]>;
+
+    /**
+     * Lists platforms as `{ id, name, released }` — called with no argument it returns the whole
+     * speedrun.com platform table, and with a `gameId` only the platforms that game accepts.
+     * Prefer the `gameId` form when you need the platform a specific game accepts — the whole
+     * table is ~140 rows and most of them are not playable for any one game.
+     */
+    platforms(args?: PlatformsArgs): Promise<Platform[]>;
+  }
+}
+
 declare namespace BowmarkProvider_spirithalloween {
   // ── Spirit Halloween — the unit's own declarations, verbatim ──
 interface SpiritHalloweenSearchResult {
@@ -30812,6 +33192,133 @@ type TwiddyQuote =
   }
 }
 
+declare namespace BowmarkProvider_twitch {
+  // ── Twitch — the unit's own declarations, verbatim ──
+interface TwitchVideo {
+  id: string;
+  title: string;
+  /** Seconds. For a live archive this GROWS, trailing real time by a minute or two. */
+  lengthSeconds: number;
+  /** "RECORDING" while the broadcast is live, "RECORDED" after. */
+  status: string;
+  /** "ARCHIVE" (a past broadcast), "HIGHLIGHT" or "UPLOAD". */
+  type: string;
+  createdAt: string;
+  ownerLogin: string;
+  url: string;
+}
+interface GetVideoArgs {
+  /** A Twitch video id, or a twitch.tv/videos/<id> link. */
+  vodId: string;
+}
+interface CreateHighlightArgs {
+  /** The broadcast to cut from — an id or a twitch.tv/videos/<id> link. Omit it
+   * for the signed-in channel's NEWEST archive, which during a broadcast is the
+   * live one. */
+  vodId?: string;
+  /** Seconds into that video. Rounded outward to whole seconds. */
+  startSeconds: number;
+  endSeconds: number;
+  title: string;
+  description?: string;
+  /** Default "en". */
+  language?: string;
+  tags?: string[];
+  /** Category name, e.g. "Wetrix". */
+  game?: string;
+}
+interface TwitchHighlight {
+  /** "created" by this call; "existing" when a highlight with this exact title
+   * was already on the channel (nothing new made); "unknown" when the request
+   * went out and no answer came back — check dashboardUrl before retrying. */
+  status: "created" | "existing" | "unknown";
+  highlightId: string | null;
+  url: string | null;
+  title: string;
+  vodId: string;
+  startSeconds: number;
+  endSeconds: number;
+  channel: string;
+  dashboardUrl: string;
+}
+interface SetChannelArgs {
+  /** The channel title shown on the stream page. Twitch's own input field for
+   * this is called "status"; this provider takes the name the UI shows. */
+  title?: string;
+  /** ISO 639-1 language code, e.g. "en". */
+  language?: string;
+  /** Category NAME, e.g. "Wetrix" — not a category id. */
+  game?: string;
+}
+interface TwitchChannelSettings {
+  id: string;
+  /** The channel title shown on the stream page. */
+  title: string;
+  /** ISO 639-1 language code, e.g. "en". */
+  language: string;
+  /** The category. Empty strings when the channel has never set one. */
+  gameId: string;
+  gameName: string;
+}
+interface RegisterDeveloperAppArgs {
+  /** Application name */
+  name: string;
+  /** OAuth redirect URI(s), comma-separated if multiple */
+  redirectUri: string;
+  /** "Application Integration" or "Website Integration" */
+  category: string;
+  /** "Public" or "Confidential" */
+  clientType?: string;
+}
+interface TwitchDeveloperApp {
+  clientId: string;
+  clientSecret?: string;
+  name: string;
+  redirectUri: string;
+  dashboardUrl: string;
+}
+
+  /**
+   * Twitch — cut a Highlight of your own broadcast, including the one still live, and read any
+   * public video's length and status.
+   */
+  interface Unit {
+    /**
+     * Reads one public Twitch video by id or twitch.tv/videos link — title, length in seconds,
+     * whether it is still RECORDING (a live broadcast's archive) or RECORDED, its type (ARCHIVE,
+     * HIGHLIGHT, UPLOAD) and its channel. No sign-in. THROWS naming the id when Twitch has no such
+     * video.
+     */
+    getVideo(args: GetVideoArgs): Promise<TwitchVideo>;
+
+    /**
+     * Cuts a permanent Highlight from the signed-in streamer's own broadcast — including the one
+     * still live — between two offsets in seconds, with a title. Omit vodId to cut from the newest
+     * archive. NEEDS the streamer's Twitch sign-in, which only a capability can hold: call it as
+     * bowmark.stream_highlights.create. Idempotent on the title: a highlight whose title already
+     * exists on the channel is returned with status "existing" rather than made twice. Refuses,
+     * without asking for a sign-in, a vod id Twitch does not have or an end offset past what the
+     * live archive has recorded so far (retry shortly in that case).
+     */
+    createHighlight(args: CreateHighlightArgs): Promise<TwitchHighlight>;
+
+    /**
+     * Reads the signed-in streamer's channel settings: title, language and current game/category.
+     * Takes no arguments. NEEDS the streamer's Twitch sign-in, which only a capability can hold:
+     * call it as bowmark.stream_channel.get.
+     */
+    getChannel(): Promise<TwitchChannelSettings>;
+
+    /**
+     * Updates the signed-in streamer's channel settings: title, language and game/category.
+     * Returns the updated settings. It cannot set tags — `tags` is not a field of Twitch's own
+     * UpdateBroadcastSettingsInput. NEEDS the streamer's Twitch sign-in, which only a capability
+     * can hold: call it as bowmark.stream_channel.set.
+     */
+    setChannel(args: SetChannelArgs): Promise<TwitchChannelSettings>;
+  }
+}
+
 declare namespace BowmarkProvider_uhc_smallbusiness {
   // ── UnitedHealthcare Small Business — the unit's own declarations, verbatim ──
 interface UhcSmallbusinessPlan {
@@ -31600,6 +34107,41 @@ interface VisibleGetPlansResult {
   }
 }
 
+declare namespace BowmarkProvider_vistaprint {
+  // ── Vistaprint — the unit's own declarations, verbatim ──
+type ShippingBoxSize = "11x8.5x5.5" | "12x12x5.5" | "13x13x10";
+type ShippingBoxPrintArea = "inside-and-outside" | "outside-only";
+
+interface GetShippingBoxPriceArgs {
+  size: ShippingBoxSize;
+  printArea: ShippingBoxPrintArea;
+  quantity: number;
+}
+
+interface ShippingBoxPrice {
+  size: ShippingBoxSize;
+  printArea: ShippingBoxPrintArea;
+  quantity: number;
+  price: { amount: number; currency: string };      // real total for `quantity` units
+  unitPrice: { amount: number; currency: string };
+}
+
+  /**
+   * Prices Vistaprint's Full-Print Shipping Boxes for a real size, print area and quantity — the
+   * live, quantity-tiered price the site's own PDP configurator computes, with no browser,
+   * account or cart. Custom printed boxes, mailer boxes and packaging boxes.
+   */
+  interface Unit {
+    /**
+     * Reads Vistaprint's own live pricing service for its Full-Print Shipping Boxes — the real,
+     * quantity-tiered total and per-unit price for a chosen box size, print area and quantity, the
+     * same figure the site's PDP configurator computes as a buyer changes those inputs. THROWS a
+     * caller-fixable error for a size/printArea/quantity combination Vistaprint has no price for.
+     */
+    getShippingBoxPrice(args: GetShippingBoxPriceArgs): Promise<ShippingBoxPrice>;
+  }
+}
+
 declare namespace BowmarkProvider_voluspa {
   // ── Voluspa — the unit's own declarations, verbatim ──
 interface VoluspaQuizButton {
@@ -32318,12 +34860,34 @@ interface YoutubeTranscript {
   fullText: string;
 }
 
+interface YoutubeSearchVideo {
+  videoId: string;
+  url: string;
+  title: string;
+  channel: string | null;
+  channelId: string | null;
+  published: string | null;          // YouTube's own phrase, e.g. "4 weeks ago"
+  publishedAgeSeconds: number | null; // that phrase in seconds, to order newest-first
+  length: string | null;             // e.g. "22:28"; null for a live stream
+  views: number | null;
+  thumbnail: string | null;
+}
+
   /**
    * 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;
    * this reads whichever track the panel shows by default.
    */
   interface Unit {
+    /**
+     * Searches YouTube the way its search box does and returns the videos on the results page —
+     * id, url, title, channel, upload age, length and views. `uploadedWithin` applies YouTube's
+     * own upload-date filter. Rows come back in YouTube's own order either way, which is NOT
+     * newest first, so sort on `publishedAgeSeconds` (smaller is newer) to find the most recent.
+     * Pass a video's `url` or `videoId` straight to `getTranscript`.
+     */
+    search(input: { query: string; uploadedWithin?: "today" | "week" | "month" | "year" }): Promise<YoutubeSearchVideo[]>;
+
     /**
      * Returns a YouTube video's own caption transcript. `video` is a bare 11-character video id or
      * any watch/shorts/embed/live/youtu.be URL. `segments` is [] — a real, honest answer — when
@@ -33236,6 +35800,7 @@ interface BowmarkProviders {
   ajmadison: BowmarkProvider_ajmadison.Unit;
   allied: BowmarkProvider_allied.Unit;
   alphavantage: BowmarkProvider_alphavantage.Unit;
+  amazon: BowmarkProvider_amazon.Unit;
   americandreamvacations: BowmarkProvider_americandreamvacations.Unit;
   americanstandard: BowmarkProvider_americanstandard.Unit;
   americanvisionwindows: BowmarkProvider_americanvisionwindows.Unit;
@@ -33246,6 +35811,7 @@ interface BowmarkProviders {
   anthropic_com: BowmarkProvider_anthropic_com.Unit;
   antunes: BowmarkProvider_antunes.Unit;
   aosom: BowmarkProvider_aosom.Unit;
+  app_store: BowmarkProvider_app_store.Unit;
   apple: BowmarkProvider_apple.Unit;
   aquaphoenixsci: BowmarkProvider_aquaphoenixsci.Unit;
   arajet: BowmarkProvider_arajet.Unit;
@@ -33297,6 +35863,7 @@ 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;
@@ -33418,6 +35985,7 @@ interface BowmarkProviders {
   google_flights: BowmarkProvider_google_flights.Unit;
   google_maps: BowmarkProvider_google_maps.Unit;
   google_news: BowmarkProvider_google_news.Unit;
+  google_translate: BowmarkProvider_google_translate.Unit;
   gostoreit: BowmarkProvider_gostoreit.Unit;
   gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
@@ -33540,6 +36108,7 @@ interface BowmarkProviders {
   positivegrid: BowmarkProvider_positivegrid.Unit;
   postiz: BowmarkProvider_postiz.Unit;
   premierbuildings: BowmarkProvider_premierbuildings.Unit;
+  prime_video: BowmarkProvider_prime_video.Unit;
   progressive: BowmarkProvider_progressive.Unit;
   prolook: BowmarkProvider_prolook.Unit;
   prose: BowmarkProvider_prose.Unit;
@@ -33576,6 +36145,7 @@ interface BowmarkProviders {
   smithery: BowmarkProvider_smithery.Unit;
   solostove: BowmarkProvider_solostove.Unit;
   soundcloud: BowmarkProvider_soundcloud.Unit;
+  speedrun: BowmarkProvider_speedrun.Unit;
   spirithalloween: BowmarkProvider_spirithalloween.Unit;
   starlighthomes: BowmarkProvider_starlighthomes.Unit;
   statefarm: BowmarkProvider_statefarm.Unit;
@@ -33607,6 +36177,7 @@ interface BowmarkProviders {
   tryalma_com: BowmarkProvider_tryalma_com.Unit;
   tweethunter: BowmarkProvider_tweethunter.Unit;
   twiddy: BowmarkProvider_twiddy.Unit;
+  twitch: BowmarkProvider_twitch.Unit;
   uhc_smallbusiness: BowmarkProvider_uhc_smallbusiness.Unit;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
   upkeepstl_com: BowmarkProvider_upkeepstl_com.Unit;
@@ -33618,6 +36189,7 @@ interface BowmarkProviders {
   viewrail: BowmarkProvider_viewrail.Unit;
   villagerealtyobx: BowmarkProvider_villagerealtyobx.Unit;
   visible: BowmarkProvider_visible.Unit;
+  vistaprint: BowmarkProvider_vistaprint.Unit;
   voluspa: BowmarkProvider_voluspa.Unit;
   vscode: BowmarkProvider_vscode.Unit;
   walkerhughes: BowmarkProvider_walkerhughes.Unit;
@@ -85357,6 +87929,7 @@ interface BowmarkProviders {
  * generated once precisely so those two cannot drift. */
 interface BowmarkLibrary {
   booking_links: BowmarkCapability_booking_links.Unit;
+  browser_agent: BowmarkCapability_browser_agent.Unit;
   bundles: BowmarkCapability_bundles.Unit;
   cable_railing_quote: BowmarkCapability_cable_railing_quote.Unit;
   cars: BowmarkCapability_cars.Unit;
@@ -85397,6 +87970,7 @@ interface BowmarkLibrary {
   search: BowmarkCapability_search.Unit;
   sheds: BowmarkCapability_sheds.Unit;
   shipping: BowmarkCapability_shipping.Unit;
+  stream_highlights: BowmarkCapability_stream_highlights.Unit;
   tariff: BowmarkCapability_tariff.Unit;
   text_to_speech: BowmarkCapability_text_to_speech.Unit;
   theme_park_tickets: BowmarkCapability_theme_park_tickets.Unit;