@bowmark/web 1.6.0 → 1.8.0

package/src/generated/library.d.ts

@@ -5,9 +5,9 @@
 // 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: 5426792a92faf41fd663aa77ef068ec2f38bcc28d33426a6a565458c7a3b4c42
-// 8 capabilities, 95 providers, 316 typed functions, 20 refused.
-// 51,713 family members, sharing 2 interface(s) — declared once and pointed at, never repeated per member.
+// Manifest version: b71c060db620c119ab92eac724aab2d9670d3d22f342f754075e353929634db2
+// 9 capabilities, 121 providers, 380 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
 // carry no types, so no honest signature exists. Each one is commented in place
@@ -861,6 +861,126 @@ type ReadResult = {
   }
 }
 
+declare namespace BowmarkCapability_sheds {
+  // ── Sheds and portable buildings (configure and price) — the unit's own declarations, verbatim ──
+type ShedSize = {
+  sizeKey: string             // the maker's own key; opaque, meaningful only to source
+  widthFt: number             // FEET, always — the maker's own units are converted away
+  lengthFt: number
+}
+type ShedStyle = {
+  source: string              // which maker — a provider id
+  brand: string               // the maker's brand name, for an answer that names who builds it
+  key: string                 // the maker's own style key
+  label: string               // the style as a customer sees it ("Lofted Barn")
+  sidingOptions: string[]     // siding keys; the first is the maker's standard
+  sizes: ShedSize[]
+  imageUrl: string | null     // a real product image from the maker's own catalogue
+  roofStyle: string | null    // "gable", "gambrel", ...
+  roofing: string | null      // "metal", ...
+  wallHeight: string | null   // the maker's own spec, verbatim, e.g. "left-78-right-78-eave-72"
+}
+type ShedStylesResult = {
+  styles: ShedStyle[]
+  warnings: string[]          // always present; a maker named here returned NOTHING
+}
+
+type ShedQuoteRequest = {
+  widthFt: number             // in feet, as a person says it — "a 12 by 20"
+  lengthFt: number
+  zip: string                 // required; every maker prices regionally
+  style?: string              // style key OR its customer-facing name, matched loosely.
+                              // Omit to price EVERY style that builds the size
+  siding?: string             // omit for the maker's standard siding
+}
+type ShedQuote = {
+  source: string
+  brand: string
+  styleKey: string
+  style: string               // "Lofted Barn"
+  model: string | null        // the maker's model name, where it has one
+  widthFt: number
+  lengthFt: number
+  siding: string              // the siding key this was priced in
+  zip: string
+  region: string              // the maker's own pricing region that zip fell under
+  basePrice: number
+  sidingSurcharge: number     // what the siding added, by the maker's rules; 0 for standard
+  total: number               // basePrice + sidingSurcharge, the maker's own arithmetic
+  currency: string
+  imageUrl: string | null     // what the building looks like, from the maker's catalogue
+  roofStyle: string | null    // "gable", "gambrel", ...
+  roofing: string | null      // "metal", ...
+  wallHeight: string | null   // the maker's own spec, verbatim
+  orderUrl: string            // where to go order THIS build, always present
+}
+type ShedQuoteResult = {
+  quotes: ShedQuote[]         // cheapest first, across every maker that builds the size
+  warnings: string[]          // always present; names a dropped maker, a style that does
+                              // not build the size, and a capped fan
+}
+
+type ShedDealer = {
+  source: string
+  brand: string
+  name: string
+  city: string
+  state: string
+  zip: string
+  phone: string | null        // null when the directory lists none (never "")
+  url: string
+}
+type ShedDealerResult = {
+  dealers: ShedDealer[]
+  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
+}
+
+  /**
+   * Price a portable building the way its maker's own 3D configurator does — give a size in feet
+   * and a zip and get the real regional price for every style that builds it, the exact siding
+   * surcharge rather than a guessed range, a real product image and spec for each one, and the
+   * link to go order it. Plus the maker's real dealer locations by state.
+   */
+  interface Unit {
+    /**
+     * Prices a building at a real size for a real zip, exactly the way the maker's own
+     * configurator does — the regional base price plus the EXACT siding surcharge its rules apply
+     * at that width and region, never a national range or a guessed upcharge. Sizes are in FEET ({
+     * widthFt: 12, lengthFt: 20 }), and both orientations count. Omit `style` to price every style
+     * that builds the size, cheapest first; name it loosely ("lofted barn") when you want one.
+     * `zip` is required because every maker prices regionally. Each quote DESCRIBES the building
+     * as well as costing it — a real product image, the roof line and roofing material, the
+     * maker's own wall-height spec — and carries `orderUrl`, their own page to go order that
+     * build. `warnings` is always present and names a maker that failed, styles that do not build
+     * the size, and a capped fan. `options.timeoutMs` sets the per-maker budget (default 30000).
+     */
+    quote(request: ShedQuoteRequest, options?: CallOptions): Promise<ShedQuoteResult>;
+
+    /**
+     * Lists every building style each maker actually offers — its customer-facing name, the siding
+     * it can be built in, every real buildable size in FEET, and what the building IS (a real
+     * product image, the roof line and roofing material, the maker's own wall-height spec). Use it
+     * to see what exists before pricing, or to answer "what sizes do they even make". `warnings`
+     * names any maker that returned nothing, which is not the same as a maker with no styles.
+     */
+    listStyles(options?: CallOptions): Promise<ShedStylesResult>;
+
+    /**
+     * Looks up the real places that sell a maker's buildings in one US state or Canadian province
+     * — full name ("Tennessee") or abbreviation ("TN") — with name, city, phone and the dealer's
+     * own page, for handing a priced configuration to somebody who can actually build it. `phone`
+     * is null when the directory lists none, never an empty string.
+     */
+    findDealers(state: string, options?: CallOptions): Promise<ShedDealerResult>;
+  }
+}
+
 declare namespace BowmarkProvider_aa {
   // ── American Airlines — the unit's own declarations, verbatim ──
 interface aaFlight {
@@ -1318,6 +1438,94 @@ interface abercrombieStockQuery {
   }
 }
 
+declare namespace BowmarkProvider_aiper {
+  // ── Aiper — the unit's own declarations, verbatim ──
+interface AiperPoolOption {
+  id: string;
+  label: string;
+}
+interface AiperPoolQuestion {
+  id: string;
+  problemName: string;
+  multiSelect: boolean;
+  options: AiperPoolOption[];
+}
+interface AiperPoolAnswerInput {
+  question: string;
+  choice: string | string[];
+}
+interface AiperRecommendedProduct {
+  productId: string;
+  slug: string;
+  name: string;
+  sku: string;
+  price: number;
+  regularPrice: number;
+  url: string;
+  image: string | null;
+}
+interface AiperPoolRecommendation {
+  products: AiperRecommendedProduct[];
+  answers: AiperPoolAnswerInput[];
+  warnings: string[];
+}
+
+  /**
+   * Aiper's Help Me Choose robotic-pool-cleaner finder, run for real — the quiz's own computed
+   * recommendation (model, SKU, real current price, PDP link) for a buyer's pool answers, off
+   * the site's own undocumented API.
+   */
+  interface Unit {
+    /**
+     * Reads the Help Me Choose quiz's live question list — every question in order, with its
+     * option ids and labels. The entry point: recommendPoolCleaner takes answers keyed off these
+     * labels, so a caller normally reads this first (or already knows the labels from a prior
+     * call).
+     */
+    listPoolChooserQuestions(): Promise<AiperPoolQuestion[]>;
+
+    /**
+     * Runs the Help Me Choose quiz's real backend computation for a buyer's answers (given as
+     * question/choice LABELS, matched case-insensitively against listPoolChooserQuestions) and
+     * returns the same computed recommendation the quiz's own terminal page renders: model name,
+     * SKU, real current price, list price, and a PDP URL. THROWS if a question or choice label
+     * doesn't match, or if the site's computed result carries no product list.
+     */
+    recommendPoolCleaner(answers: AiperPoolAnswerInput[]): Promise<AiperPoolRecommendation>;
+  }
+}
+
+declare namespace BowmarkProvider_ajmadison {
+  // ── AJ Madison — the unit's own declarations, verbatim ──
+interface AjmadisonSearchArgs {
+  category: string;              // the site's own category slug, e.g. "refrigerators"
+  filters?: Record<string, string>; // the site's own facet query params, verbatim
+  limit?: number;                 // default 25, clamped to [1, 60]
+}
+
+interface AjmadisonSearchResult {
+  sku: string;
+  name: string;
+  price: number;             // real, current selling price
+  wasPrice: number | null;   // the crossed-out "was" price, when shown
+  url: string;                // this product's own AJ Madison URL
+}
+
+  /**
+   * AJ Madison's real appliance catalog — search runs the site's own category + facet filter
+   * (brand, size/capacity, price band, style, availability) and returns real, currently-listed
+   * products with their live selling price and the product's own AJ Madison URL.
+   */
+  interface Unit {
+    /**
+     * Runs AJ Madison's own category + facet filter and returns real, currently-listed products
+     * (name, real current price, the crossed-out 'was' price when shown, the product's own AJ
+     * Madison URL). Read-only — never adds to cart or checks out.
+     */
+    search(args: AjmadisonSearchArgs): Promise<AjmadisonSearchResult[]>;
+  }
+}
+
 declare namespace BowmarkProvider_ashleyfurniture {
   // ── Ashley Furniture — the unit's own declarations, verbatim ──
 interface AshleyFurnitureSearchArgs {
@@ -1438,6 +1646,47 @@ interface AshleyFurnitureStore {
   }
 }
 
+declare namespace BowmarkProvider_atlasseniorliving {
+  // ── Atlas Senior Living — the unit's own declarations, verbatim ──
+type AtlasCareType = "assisted_living" | "independent_living" | "memory_care" | "respite_care";
+
+interface AtlasCommunity {
+  id: string;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phone: string;
+  distanceMiles: number;
+  lat: number;
+  lng: number;
+  url: string;
+}
+
+interface AtlasSearchCommunitiesResult {
+  location: string;
+  geocodedLat: number;
+  geocodedLng: number;
+  careTypes: AtlasCareType[];
+  radiusMiles: number;
+  communities: AtlasCommunity[];
+}
+
+  /**
+   * Atlas Senior Living's own community search (atlasseniorliving.com/our-communities/) — given
+   * a US city/state or ZIP, plus optional care type(s) and radius, returns the real,
+   * distance-sorted set of matching Atlas communities.
+   */
+  interface Unit {
+    /**
+     * Runs the site's own community search: a US location + optional care type(s) and radius,
+     * returns the real, distance-sorted matching Atlas communities.
+     */
+    searchCommunities(arg: { location: string, careTypes?: AtlasCareType[], radiusMiles?: number, maxResults?: number }): Promise<AtlasSearchCommunitiesResult>;
+  }
+}
+
 declare namespace BowmarkProvider_avis {
   // ── Avis — the unit's own declarations, verbatim ──
 interface avisRow {
@@ -1780,6 +2029,58 @@ interface StoreStock {
   }
 }
 
+declare namespace BowmarkProvider_bigrentz {
+  // ── BigRentz — the unit's own declarations, verbatim ──
+interface BigrentzEquipmentRow {
+  id: number;
+  name: string;
+  slug: string;
+  permalink: string;
+  categories: { id: number; name: string; slug: string }[];
+  images: { src: string; alt: string }[];
+  inStock: boolean;
+  priced: false;
+  priceNote: string;
+}
+interface BigrentzEquipmentDetail extends BigrentzEquipmentRow {
+  description: string;
+  specSheetUrls: string[];
+}
+interface BigrentzCategoryRow {
+  id: number;
+  name: string;
+  slug: string;
+  count: number;
+  permalink: string;
+}
+
+  /**
+   * BigRentz's own equipment catalog — search, category browse and per-item detail, real data
+   * from their WooCommerce Store API. Live rental pricing is not yet built (site gates it behind
+   * a location + date picker); see getRentalPricing.
+   */
+  interface Unit {
+    /**
+     * Searches BigRentz's equipment catalog by free text (e.g. "boom lift", "40 ft boom lift") and
+     * returns matching rows. Real catalog data — id, name, slug, permalink, category, stock flag,
+     * images — but NOT a real price (see `priceNote` on each row).
+     */
+    search(query: string): Promise<BigrentzEquipmentRow[]>;
+
+    /**
+     * Reads one piece of equipment in full by the slug `search` or `listCategories` returned —
+     * description, spec-sheet PDF links, category and stock flag.
+     */
+    getEquipment(slug: string): Promise<BigrentzEquipmentDetail>;
+
+    /**
+     * Lists BigRentz's equipment categories — id, name, slug, live listing count, category page
+     * URL. Pass `parentSlug` to list a category's children.
+     */
+    listCategories(options?: { parentSlug?: string }): Promise<BigrentzCategoryRow[]>;
+  }
+}
+
 declare namespace BowmarkProvider_blenderseyewear {
   // ── Blenders Eyewear — the unit's own declarations, verbatim ──
 // Blenders Eyewear's OWN shapes — not a capability contract.
@@ -2103,6 +2404,62 @@ interface BmwusaModelListing {
   }
 }
 
+declare namespace BowmarkProvider_boydsleep {
+  // ── Boyd Sleep — the unit's own declarations, verbatim ──
+// Boyd Sleep's OWN shapes — not a capability contract.
+
+type BoydsleepGender = "Male" | "Female" | "Non Binary";
+type BoydsleepSleepPosition = "Side" | "Back" | "Stomach" | "Multi";
+
+interface BoydsleepCalibrationInput {
+  gender: BoydsleepGender;
+  heightInches: number;   // snapped to the site's own height band
+  weightLbs: number;      // snapped to the site's own weight band
+  sleepPosition: BoydsleepSleepPosition;
+}
+
+interface Boydsleep2ZoneResult {
+  supportIndex: number;       // 0-100
+  heightBandInches: number;
+  weightBandLbs: number;
+  setupGuideUrl: string;      // the real next step — no checkout exists on this domain
+  calibratorUrl: string;
+}
+
+interface Boydsleep6ZoneResult {
+  headFoot: number;
+  center: number;
+  heightBandInches: number;
+  weightBandLbs: number;
+  setupGuideUrl: string;
+  calibratorUrl: string;
+}
+
+  /**
+   * Boyd Sleep's own 'Smart Support Number' calibrator for a Nautica Home Smart Zone air bed —
+   * the real personalized 0-100 Support Index (2-zone) or Head/Foot + Center numbers (6-zone),
+   * computed exactly as the site computes them, plus the site's own setup guide as the real next
+   * step (Boyd sells through retail/franchise partners, so there is no DTC checkout on this
+   * domain to route to).
+   */
+  interface Unit {
+    /**
+     * Runs Boyd's own 2-zone Smart Support Number calculation for a Nautica Home Smart Zone air
+     * bed — a real, personalized 0-100 Support Index computed exactly as the site's own calculator
+     * computes it, no estimate. `setupGuideUrl` is the real next step; Boyd sells through
+     * retail/franchise partners, so there is no cart to route to on this domain.
+     */
+    calibrateSupportNumber(input: BoydsleepCalibrationInput): Promise<Boydsleep2ZoneResult>;
+
+    /**
+     * Runs Boyd's own 6-zone Smart Support Number calculation — same inputs as the 2-zone tool,
+     * returns a separate Head/Foot number and a Center (lumbar) number for the 6-zone Nautica Home
+     * Smart Zone bed.
+     */
+    calibrateSixZoneSupportNumber(input: BoydsleepCalibrationInput): Promise<Boydsleep6ZoneResult>;
+  }
+}
+
 declare namespace BowmarkProvider_bykoket {
   // ── KOKET — the unit's own declarations, verbatim ──
 interface KoketProductSummary {
@@ -2711,6 +3068,75 @@ interface ChriscraftPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_classichome {
+  // ── Classic Home — the unit's own declarations, verbatim ──
+// Classic Home's OWN shapes — not a capability contract.
+
+interface ClassicHomeProduct {
+  handle: string;        // the key getProduct/addToCart take
+  title: string;
+  url: string;
+  priceMin: number;      // dollars — the cheapest real fabric/leather choice
+  priceMax: number;      // dollars — the most expensive (usually top-grain leather)
+  variantCount: number;  // >1 means a real fabric/leather choice exists
+}
+
+interface ClassicHomeVariant {
+  optionValue: string;   // e.g. "Soft Olive", "Dawn-Flax", "ElPaso-Saddle"
+  sku: string;
+  price: number;         // dollars — this exact fabric/leather's own real price
+  available: boolean;
+}
+
+interface ClassicHomeProductDetail {
+  handle: string;
+  title: string;
+  url: string;
+  optionName: string;      // usually "Color" (fabric/leather); "Title" if no real picker
+  variants: ClassicHomeVariant[];
+}
+
+interface ClassicHomeCartHandoff {
+  handle: string;
+  optionValue: string;
+  sku: string;
+  price: number;         // dollars — the real price for this exact fabric/leather
+  available: boolean;
+  productUrl: string;    // finish add-to-cart/checkout on the real product page
+}
+
+  /**
+   * Classic Home's real Made-to-Order fabric/leather catalog and its real, material-specific
+   * Shopify pricing — search real MTO products (sofas, chairs, ottomans), read one product's
+   * real fabric/leather picker, and resolve one exact fabric or leather choice to its real SKU,
+   * price and availability.
+   */
+  interface Unit {
+    /**
+     * Searches Classic Home's real Made-to-Order catalog (sofas, chairs, ottomans) via the site's
+     * own Shopify collection JSON, optionally filtered by a free-text query against the product
+     * title. Returns real products with a real price range read off their own fabric/leather
+     * variants.
+     */
+    searchProducts(query?: string): Promise<ClassicHomeProduct[]>;
+
+    /**
+     * Reads one product's real live fabric/leather picker: every real color/material choice with
+     * its own real price and availability, keyed by the site's own option name. THROWS on an
+     * unknown handle, naming searchProducts() as the way to find current ones.
+     */
+    getProduct(handle: string): Promise<ClassicHomeProductDetail>;
+
+    /**
+     * Resolves ONE exact fabric/leather choice (optionValue from getProduct's own variant list,
+     * e.g. "Soft Olive") to Classic Home's own real price, availability and SKU, plus the product
+     * page to finish add-to-cart/checkout on the site itself. Writes nothing — classichome.com's
+     * robots.txt disallows automated /cart access.
+     */
+    addToCart(handle: string, optionValue: string): Promise<ClassicHomeCartHandoff>;
+  }
+}
+
 declare namespace BowmarkProvider_classpass {
   // ── ClassPass — the unit's own declarations, verbatim ──
 /** Everything /v2/venues publishes about one studio — a superset of
@@ -3686,6 +4112,36 @@ interface DiscounttireTireSizeSearch {
   }
 }
 
+declare namespace BowmarkProvider_embroker {
+  // ── Embroker — the unit's own declarations, verbatim ──
+interface EmbrokerCoverageCatalog {
+  coverageLines: string[];
+  productTypes: string[];
+}
+
+interface EmbrokerQuoteEntryPoint {
+  product: string;
+  productLabel: string;
+  url: string;
+  reachable: boolean;
+}
+
+  /**
+   * Embroker's own coverage catalog and live self-serve quote-wizard entry points for
+   * tech/startup, law firm, cyber, BOP, crime and professional-liability business insurance.
+   */
+  interface Unit {
+    /** Returns Embroker's real coverage-line and policy-product-type catalog. */
+    listCoverageLines(): Promise<EmbrokerCoverageCatalog>;
+
+    /**
+     * Returns the live, confirmed-reachable entry URL for one of Embroker's self-serve
+     * quote-wizard products.
+     */
+    getQuoteEntryPoint(args: { product: string }): Promise<EmbrokerQuoteEntryPoint>;
+  }
+}
+
 declare namespace BowmarkProvider_erieinsurance {
   // ── ERIE Insurance — the unit's own declarations, verbatim ──
 interface ErieAgentQuery {
@@ -3774,6 +4230,64 @@ interface ErieAgent {
   }
 }
 
+declare namespace BowmarkProvider_eventsource {
+  // ── Event Source — the unit's own declarations, verbatim ──
+interface EventSourceDesign {
+  designId: number;
+  visionBoardId: number;
+  roomId: number;
+  designName: string;
+  roomName: string;
+  venueName: string;
+  hasLayouts: boolean;
+  hasTemplates: boolean;
+}
+interface EventSourceShowroom {
+  accessCode: string;
+  showroomName: string;
+  ownerName: string;
+  branded: boolean;
+  underConstruction: boolean;
+  logoUrl: string;
+  eventId: number;
+  venueIds: number[];
+  designs: EventSourceDesign[];
+}
+interface EventSourceVenue {
+  venueId: number;
+  businessName: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  market: string;
+  primaryImageUrl: string;
+  rooms: Array<{ roomId: number; roomName: string; primaryImageUrl: string; active: boolean }>;
+}
+interface EventSourceInquiryContact {
+  inquiryRequestEmail: string;
+  ownerName: string;
+  ownerLogoUrl: string;
+}
+
+  /**
+   * Reads a public Event Source Virtual Design Center showroom (design, venue, inquiry contact)
+   * by its access code — no login.
+   */
+  interface Unit {
+    /**
+     * Reads a public Virtual Design Center showroom by its access code — its design(s), venue and
+     * branding.
+     */
+    getShowroom(code: string): Promise<EventSourceShowroom>;
+
+    /** Reads the real venue/room a showroom's design is staged in. */
+    getShowroomVenue(eventId: number, venueId: number, code: string): Promise<EventSourceVenue>;
+
+    /** Reads who a showroom's Send Inquiry button emails, without submitting anything. */
+    getShowroomInquiryContact(code: string): Promise<EventSourceInquiryContact>;
+  }
+}
+
 declare namespace BowmarkProvider_extraspace {
   // ── Extra Space Storage — the unit's own declarations, verbatim ──
 interface ExtraspaceSearchResult {
@@ -5113,6 +5627,53 @@ interface GooglePriceGraph {
   }
 }
 
+declare namespace BowmarkProvider_gotchacovered {
+  // ── Gotcha Covered — the unit's own declarations, verbatim ──
+interface GotchaCoveredQuizOption {
+  label: string;
+  imageUrl: string | null;
+}
+interface GotchaCoveredQuizQuestion {
+  step: number;
+  prompt: string;
+  options: GotchaCoveredQuizOption[];
+}
+interface GotchaCoveredQuizQuestions {
+  questions: GotchaCoveredQuizQuestion[];
+}
+interface GotchaCoveredQuizAnswers {
+  colorScheme: string;
+  pattern: string;
+  imageChoice: number | string;
+  destination: string;
+  material: string;
+  item: string;
+}
+interface GotchaCoveredQuizResult {
+  styleName: string;
+  description: string;
+  recommendedProducts: string | null;
+  url: string;
+}
+
+  /**
+   * Reads and answers Gotcha Covered's own 'What Design Style Am I?' window-treatment style
+   * quiz, returning the site's real computed match.
+   */
+  interface Unit {
+    /** Reads the live 'What Design Style Am I?' quiz's real 6 questions and option lists. */
+    getDesignStyleQuizQuestions(): Promise<GotchaCoveredQuizQuestions>;
+
+    /**
+     * Answers all 6 questions of Gotcha Covered's Design Style Quiz (e.g. { colorScheme:
+     * "Metallics Color Scheme", pattern: "Eclectic Pattern", imageChoice: 1, destination: "Spain
+     * Destination", material: "Wood Material", item: "Graphic Rug Item" }) and returns the site's
+     * real computed style match.
+     */
+    takeDesignStyleQuiz(answers: GotchaCoveredQuizAnswers): Promise<GotchaCoveredQuizResult>;
+  }
+}
+
 declare namespace BowmarkProvider_grainger {
   // ── Grainger — the unit's own declarations, verbatim ──
 interface graingerRow {
@@ -5219,6 +5780,198 @@ interface graingerStockRow {
   }
 }
 
+declare namespace BowmarkProvider_grandwelcome {
+  // ── Grand Welcome — the unit's own declarations, verbatim ──
+interface GrandwelcomeRentalRow {
+  rentalId: string;
+  name: string;
+  url: string;
+  location: string;
+  propertyType: string;
+  petFriendly: boolean;
+  priceFromUsd: number | null;
+  priceFromFormatted: string | null;
+  bedrooms: number | null;
+  bathrooms: number | null;
+  guests: number | null;
+  ratingValue: number | null;
+  ratingCount: number | null;
+}
+interface GrandwelcomeRentalDetail {
+  rentalId: string;
+  propertyId: string;
+  name: string;
+  description: string;
+  images: string[];
+  url: string;
+}
+interface GrandwelcomeQuoteFee {
+  label: string;
+  amountUsd: number;
+}
+type GrandwelcomeQuote =
+  | { available: true; propertyId: string; checkin: string; checkout: string; currency: "USD";
+      rentUsd: number; fees: GrandwelcomeQuoteFee[]; feesTotalUsd: number; taxUsd: number;
+      totalUsd: number; bookNowUrl: string }
+  | { available: false; propertyId: string; checkin: string; checkout: string };
+
+  /**
+   * Grand Welcome's own vacation rental search, listing detail, and real-time dated
+   * pricing/booking-link engine — a national franchise's own inventory, live availability and
+   * price, not a stale catalog.
+   */
+  interface Unit {
+    /**
+     * Runs Grand Welcome's own destination search (a market slug like "california-sea-ranch", from
+     * a rental's own page or the destination directory), optionally filtered to a bedroom count,
+     * and returns the live matching listings — name, url, location, type, pet-friendly flag,
+     * advertised "as low as" price, bed/bath/guest counts, rating.
+     */
+    searchRentals(destinationSlug: string, options?: { bedrooms?: number }): Promise<GrandwelcomeRentalRow[]>;
+
+    /**
+     * Reads one rental in full — name, description, photos, and the internal numeric propertyId
+     * getRentalQuote needs — from the rentalId a search result or a grandwelcome.com/rentals/<id>
+     * URL carries.
+     */
+    getRentalDetail(rentalId: string): Promise<GrandwelcomeRentalDetail>;
+
+    /**
+     * Runs the site's own real-time pricing engine for one property and a date range
+     * ("YYYY-MM-DD") — rent, fees, tax, total — and returns the exact Book Now checkout URL for
+     * those dates. `available: false` means the site checked and the property is not free for
+     * those dates, an ordinary answer.
+     */
+    getRentalQuote(propertyId: string, options: { checkin: string; checkout: string }): Promise<GrandwelcomeQuote>;
+  }
+}
+
+declare namespace BowmarkProvider_handypro {
+  // ── HandyPro — the unit's own declarations, verbatim ──
+// HandyPro's OWN shapes — not a capability contract.
+
+interface HandyproHourlyRate { fromHours: number; toHours: number; pricePerHour: number }
+
+interface HandyproServiceArea {
+  covered: boolean;
+  message?: string;         // present only when covered is false
+  franchiseeName?: string;
+  phone?: string;
+  city?: string;
+  state?: string;
+  formattedAddress?: string;
+  hourlyRates?: HandyproHourlyRate[];
+}
+
+interface HandyproCategoryPrice {
+  categoryId: string;
+  categoryName: string;
+  parentCategoryName: string;
+  pricingKind: "estimate" | "fixedJob" | "unpriced";
+  price: number | null;     // dollars
+  whatsIncluded: string;
+}
+
+interface HandyproCategorySearch {
+  zipcode: string;
+  covered: boolean;
+  message?: string;         // present only when covered is false
+  categories: HandyproCategoryPrice[];
+}
+
+  /**
+   * HandyPro's real service-area coverage and per-category job pricing — checks whether a ZIP is
+   * served by a real local franchisee (with its own live hourly rate table) and prices
+   * HandyPro's actual handyman/home-modification categories (grab bars, appliance install, TV
+   * mounting, painting, and more) for that ZIP, rather than a researched nationwide estimate.
+   */
+  interface Unit {
+    /**
+     * Checks whether a ZIP is served by a real local HandyPro franchisee and returns that
+     * franchisee's own real hourly rate table. covered is false with a message for a ZIP outside
+     * HandyPro's online booking area — an honest, ordinary answer, not an error.
+     */
+    checkServiceArea(zipcode: string): Promise<HandyproServiceArea>;
+
+    /**
+     * Lists HandyPro's real service categories priced for one ZIP's franchisee (a free estimate or
+     * a real fixed job price, and what's included), optionally narrowed by a free-text query (e.g.
+     * "grab bar"). covered is false with a message for a ZIP outside the service area.
+     */
+    searchServiceCategories(zipcode: string, query?: string): Promise<HandyproCategorySearch>;
+  }
+}
+
+declare namespace BowmarkProvider_harmar {
+  // ── Harmar Mobility — the unit's own declarations, verbatim ──
+interface HarmarVehicleModel {
+  make: string;
+  modelId: string;
+  model: string;
+}
+
+interface HarmarChairModel {
+  chairId: string;
+  model: string;
+}
+
+interface HarmarLiftOption {
+  code: string;
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+interface HarmarCompatibleLift {
+  liftId: string;
+  productCode: string;
+  name: string;
+  requiredAccessories: HarmarLiftOption[];
+  optionalAccessories: HarmarLiftOption[];
+}
+
+interface HarmarCompatibleLiftsResult {
+  year: string;
+  vehicleId: string;
+  chairId: string;
+  lifts: HarmarCompatibleLift[];
+}
+
+interface HarmarFindCompatibleLiftsResult extends HarmarCompatibleLiftsResult {
+  vehicleMake: string;
+  vehicleModel: string;
+  chairMake: string;
+  chairModel: string;
+}
+
+  /**
+   * Harmar's Vehicle Compatibility Calculator (calculator.harmar.com) — given a vehicle and a
+   * wheelchair/scooter, returns the real Harmar vehicle lifts that fit that combination.
+   */
+  interface Unit {
+    /**
+     * Every vehicle (make + calculator's own model id) the compatibility calculator has data for
+     * in a given model year.
+     */
+    searchVehicleModels(arg: { year: string }): Promise<HarmarVehicleModel[]>;
+
+    /** Every wheelchair/scooter model the calculator has data for under a given manufacturer make. */
+    searchChairModels(arg: { make: string }): Promise<HarmarChairModel[]>;
+
+    /**
+     * Runs the calculator's own 'Lift Lookup' against its internal vehicle/chair ids and returns
+     * the compatible Harmar lifts.
+     */
+    getCompatibleLifts(arg: { year: string, vehicleId: string, chairId: string }): Promise<HarmarCompatibleLiftsResult>;
+
+    /**
+     * The whole goal-flow in one call: plain vehicle year/make/model + chair make/model, resolved
+     * to the calculator's own ids and run through the real Lift Lookup.
+     */
+    findCompatibleLifts(arg: { year: string, vehicleMake: string, vehicleModel: string, chairMake: string, chairModel: string }): Promise<HarmarFindCompatibleLiftsResult>;
+  }
+}
+
 declare namespace BowmarkProvider_hauslabs {
   // ── Haus Labs by Lady Gaga — the unit's own declarations, verbatim ──
 interface HauslabsVariant {
@@ -5249,6 +6002,7 @@ interface HauslabsShadeMatch {
   variant: {
     number: number;
     family: string;
+    id: string;
     sku: string | null;
     price: string;
     available: boolean;
@@ -6181,6 +6935,78 @@ interface hiltonRoomOffer {
   }
 }
 
+declare namespace BowmarkProvider_hobie {
+  // ── Hobie Cat Company — the unit's own declarations, verbatim ──
+interface HobieModelSummary {
+  slug: string;
+  name: string;
+  url: string;
+}
+interface HobieModelColor {
+  color: string;
+  upc: string;
+}
+interface HobieModelColors {
+  slug: string;
+  name: string;
+  defaultColor: string;
+  colors: HobieModelColor[];
+}
+interface HobieDealer {
+  storeId: number;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phoneNumber: string;
+  latitude: number;
+  longitude: number;
+  distanceMiles: number;
+  carriesExactColor: boolean;
+  carriesModel: boolean;
+  carriesBrand: boolean;
+  stockStatus: string;
+  stockDisclaimer: string;
+}
+interface HobieLocalAvailability {
+  slug: string;
+  modelName: string;
+  color: string;
+  upc: string;
+  zip: string;
+  dealers: HobieDealer[];
+  dealersCarryingExactColor: number;
+  dealersCarryingModel: number;
+}
+
+  /**
+   * Reads Hobie Cat Company's own real-time 'Find it Locally' dealer-inventory widget directly —
+   * which real dealer near a zip has a specific kayak model, IN A SPECIFIC COLOR, in stock right
+   * now. Kayaks are dealer-distribution only; there is no first-party checkout.
+   */
+  interface Unit {
+    /**
+     * Lists every real kayak model Hobie currently sells (slug, display name, its own hobie.com
+     * URL), read straight from the live /kayaks/ index.
+     */
+    listModels(): Promise<HobieModelSummary[]>;
+
+    /**
+     * Reads one model's real buildable colors, each paired with the exact UPC the local-inventory
+     * widget is keyed on, plus the site's own default color.
+     */
+    listModelColors(slug: string): Promise<HobieModelColors>;
+
+    /**
+     * Runs Hobie's own real-time 'Find it Locally' widget for one model + color near a US zip and
+     * returns real nearby dealers with Hobie's own exact-color / model / brand carrying flags.
+     * `color` defaults to the site's own default color when omitted.
+     */
+    checkLocalAvailability(slug: string, color: string | undefined, zip: string): Promise<HobieLocalAvailability>;
+  }
+}
+
 declare namespace BowmarkProvider_hunter {
   // ── Hunter — the unit's own declarations, verbatim ──
 interface hunterDomainCandidate {
@@ -7397,6 +8223,105 @@ interface InteriorDefineCartHandoff {
   }
 }
 
+declare namespace BowmarkProvider_islllc {
+  // ── Integral Senior Living — the unit's own declarations, verbatim ──
+type IsllcCareType = "assisted_living" | "independent_living" | "memory_care" | "respite_care";
+
+interface IsllcCommunity {
+  id: string;
+  name: string;
+  address: string;
+  city: string;
+  state: string;
+  zip: string;
+  phone: string;
+  careTypes: string;
+  lat: number;
+  lng: number;
+  url: string;
+}
+
+interface IsllcSearchCommunitiesResult {
+  location: string;
+  geocodedLat: number;
+  geocodedLng: number;
+  careTypes: IsllcCareType[];
+  radiusMiles: number;
+  communities: IsllcCommunity[];
+}
+
+  /**
+   * Integral Senior Living's own community locator (islllc.com/communities/) — given a US
+   * city/state or ZIP, plus optional care type(s) and radius, returns the real, nearest-first
+   * set of matching ISL communities.
+   */
+  interface Unit {
+    /**
+     * Runs the site's own community locator: a US location + optional care type(s) and radius,
+     * returns the real, nearest-first matching ISL communities.
+     */
+    searchCommunities(arg: { location: string, careTypes?: IsllcCareType[], radiusMiles?: number, maxResults?: number }): Promise<IsllcSearchCommunitiesResult>;
+  }
+}
+
+declare namespace BowmarkProvider_jennikayne {
+  // ── Jenni Kayne — the unit's own declarations, verbatim ──
+interface GiftCardDenomination {
+  variantId: string;
+  amount: string;
+  available: boolean;
+}
+interface GiftCardOptions {
+  productUrl: string;
+  denominations: GiftCardDenomination[];
+  timezones: string[];
+}
+interface GiftCardConfig {
+  amount: string;
+  recipientName: string;
+  recipientEmail: string;
+  giftMessage?: string;
+  deliveryDate: string;
+  deliveryTimezone: string;
+}
+interface GiftCardLink {
+  amount: string;
+  variantId: string;
+  recipientName: string;
+  recipientEmail: string;
+  giftMessage: string | null;
+  deliveryDate: string;
+  deliveryTimezone: string;
+  available: boolean;
+  cartUrl: string;
+  checkoutUrl: string;
+  deliveryTimeLeftToShopper: true;
+}
+
+  /**
+   * Jenni Kayne's live gift-card product: read the real denominations and hand the shopper a
+   * checkout link pre-filled with the recipient, message and scheduled delivery date/timezone.
+   */
+  interface Unit {
+    /**
+     * Reads the live Jenni Kayne digital gift-card product — every denomination from $50 to $1,000
+     * with its real variant id and current stock, plus the exact timezone strings the checkout
+     * form accepts. Call this first to know what buildGiftCardLink will accept.
+     */
+    getGiftCardOptions(): Promise<GiftCardOptions>;
+
+    /**
+     * Configures a Jenni Kayne digital gift card — amount, recipient name/email, an optional
+     * message, and a scheduled delivery date + timezone — and returns a checkout link with every
+     * one of those fields already filled in, so the shopper only has to pick a delivery TIME and
+     * pay. THROWS on an unknown amount, an invalid email, a malformed date, or a timezone the
+     * store does not offer — call getGiftCardOptions first to see the live choices. Builds the
+     * link only; nothing is purchased or charged here.
+     */
+    buildGiftCardLink(config: GiftCardConfig): Promise<GiftCardLink>;
+  }
+}
+
 declare namespace BowmarkProvider_joybird {
   // ── Joybird — the unit's own declarations, verbatim ──
 interface JoybirdConfigurator {
@@ -7633,6 +8558,106 @@ interface KayakCar {
   }
 }
 
+declare namespace BowmarkProvider_kitchentuneup {
+  // ── Kitchen Tune-Up — the unit's own declarations, verbatim ──
+interface KitchentuneupCabinetStyle {
+  featureDefinitionId: number;
+  name: string;
+  group: string | null;
+  thumbnailUrl: string | null;
+}
+
+interface KitchentuneupVisualization {
+  resultImageUrl: string;
+  appliedFeatureIds: number[];
+}
+
+  /**
+   * Kitchen Tune-Up's own AI Design Tool — the live cabinet door/color/finish catalog, and
+   * photo-in/AI-visualization-out generation, run the way kitchentuneup.com/design-tool/ does.
+   */
+  interface Unit {
+    /**
+     * Reads Kitchen Tune-Up's own AI Design Tool catalog off its visualizer vendor's API — every
+     * cabinet door style / color / finish feature currently enabled for the kitchen visualizer,
+     * with the featureDefinitionId visualizeKitchen needs to apply it. Real catalog data, not a
+     * marketing page scrape.
+     */
+    listCabinetStyles(): Promise<KitchentuneupCabinetStyle[]>;
+
+    /**
+     * Runs a photo through Kitchen Tune-Up's own AI Design Tool the way
+     * kitchentuneup.com/design-tool/ does — uploads the photo plus one or more chosen cabinet
+     * features (from listCabinetStyles) to their visualizer vendor's AI image pipeline and returns
+     * the generated visualization image URL. This is the exact functional gap this packet's ANGLE
+     * fit-check recorded: ChatGPT knows the AI Design Tool exists but explicitly refuses to
+     * operate it ('I can't operate Kitchen Tune-Up's website on your behalf') and bounces the user
+     * back to the site.
+     */
+    visualizeKitchen(args: { photoBase64: string, photoFileName?: string, featureDefinitionIds: number[] }): Promise<KitchentuneupVisualization>;
+  }
+}
+
+declare namespace BowmarkProvider_kompan {
+  // ── KOMPAN Master — the unit's own declarations, verbatim ──
+// KOMPAN Master's OWN shapes — not a capability contract.
+
+type KompanRegion = "region_america" | "region_europe_middleeast" | "region_asia_newzealand" | "region_australia";
+
+interface KompanVariant {
+  id: string;         // pass to getSparePartsDocuments()
+  title: string;       // e.g. "PCM157-0205 | UNIVERSAL CAROUSEL"
+}
+
+interface KompanSearchResult {
+  productNo: string;
+  region: KompanRegion;
+  found: boolean;       // false is a real "no such product number in this region" answer
+  image: string | null;
+  variants: KompanVariant[];
+}
+
+interface KompanDocument {
+  section: string;      // the site's own heading, e.g. "Layout Drawing", "Installation Instruction"
+  label: string;
+  url: string;
+}
+
+interface KompanSparePartsDocuments {
+  variantId: string;
+  purchaseDate: string;
+  title: string | null;
+  documents: KompanDocument[];
+  fullPackageUrl: string | null;   // generated on fetch by the site — the URL to fetch, not a static file
+}
+
+  /**
+   * KOMPAN's own spare-parts / TÜV-certificate / maintenance-manual lookup (KOMPAN Master) —
+   * search a KOMPAN playground product number for its real installed variants, then read the
+   * exact layout drawing, installation instruction, general instruction, on-demand full-package
+   * PDF and language-specific inspection checklists / maintenance manuals for one variant +
+   * purchase date, off the site's own live tool rather than a researched guess.
+   */
+  interface Unit {
+    /**
+     * Searches KOMPAN Master for a product number (e.g. "PCM157") in one region (default
+     * "region_america") and lists every real installed variant of it — each with the internal item
+     * id getSparePartsDocuments() takes. `found: false` is a real, expected answer for a product
+     * number with no record in that region, not an error.
+     */
+    searchProduct(productNo: string, region?: KompanRegion): Promise<KompanSearchResult>;
+
+    /**
+     * Reads the real spare-parts / TÜV-certificate / maintenance-manual documents KOMPAN Master
+     * publishes for one variant (an id from searchProduct()) at one purchase date ("YYYY-MM-DD",
+     * since the site keys the applicable document revision off it) — layout drawing, installation
+     * instruction, general instruction, additional checklists/manuals, and the on-demand "full
+     * package" PDF URL.
+     */
+    getSparePartsDocuments(variantId: string, purchaseDate: string): Promise<KompanSparePartsDocuments>;
+  }
+}
+
 declare namespace BowmarkProvider_labcorp {
   // ── Labcorp — the unit's own declarations, verbatim ──
 interface LabcorpTestSummary {
@@ -7967,9 +8992,9 @@ interface LiquiddeathCart {
 interface LiquiddeathLiveCartLine {
   lineId: string;
   variantId: string;
-  variantTitle: string | null;
-  productTitle: string;
+  title: string;
   quantity: number;
+  unitPrice: string;
   lineTotal: string;
 }
 interface LiquiddeathLiveCart {
@@ -7980,9 +9005,7 @@ interface LiquiddeathLiveCart {
   total: string;
   currency: string;
   checkoutUrl: string;
-  countryCode: string | null;
-  createdAt: string | null;
-  updatedAt: string | null;
+  expiresAt: string | null;
 }
 
   /**
@@ -8018,15 +9041,19 @@ interface LiquiddeathLiveCart {
     addToCart(items: LiquiddeathCartItem[]): Promise<LiquiddeathCart>;
 
     /**
-     * Reads a cart the shopper already has, by its id — line items, quantities, per-line and order
-     * totals, and the real checkout URL to hand back. The id is a bearer credential the SHOPPER
-     * holds, and it is the one their cart or checkout LINK carries
-     * (liquiddeath.com/cart/c/<token>?key=<key>), NOT the store's `cart` cookie or /cart.js token
-     * — those are a separate Ajax id space this endpoint answers 'Cart does not exist' for. There
-     * is no way to list or search carts, so a caller without an id cannot get one. Accepts the id
-     * with or without the `?key=` suffix. THROWS when the cart does not exist or has expired —
-     * Shopify drops an unused cart within 30 days and deletes it at checkout — because an empty
-     * cart and a dead link are opposite answers. Does not return shipping options or discounts:
+     * Reads a cart the shopper already has, by its id — line items, quantities, per-unit and
+     * per-line prices, order subtotal and total, the cart's currency and expiry, and the real
+     * checkout URL to hand back. The id is a bearer credential the SHOPPER holds, and it is the
+     * one their cart or checkout LINK carries (liquiddeath.com/cart/c/<token>?key=<key>), NOT the
+     * store's `cart` cookie or /cart.js token — those are a separate Ajax id space this endpoint
+     * answers 'The requested cart does not exist' for. There is no way to list or search carts, so
+     * a caller without an id cannot get one. THE WHOLE id IS REQUIRED, `?key=` included: the store
+     * checks the key's value, so a bare token comes back as a cart that does not exist rather than
+     * as a missing credential, and this refuses it here instead. THROWS when the cart does not
+     * exist or has expired — Shopify drops an unused cart within 30 days and deletes it at
+     * checkout — because an empty cart and a dead link are opposite answers. Each line carries the
+     * store's own joined product-and-variant `title` ("Death Western Hat - Cream/Green"); this
+     * door publishes no separate product title. Does not return shipping options or discounts:
      * both require setting an address on the cart, which is a write this provider does not
      * perform.
      */
@@ -8059,6 +9086,61 @@ interface LonelyPlanetSearchResult {
   }
 }
 
+declare namespace BowmarkProvider_louvershop {
+  // ── Louver Shop Shutters — the unit's own declarations, verbatim ──
+interface LouvershopBranch {
+  id: number;
+  name: string;
+  link: string;
+  tel: string;
+}
+
+interface LouvershopLocalArea {
+  zip: string;
+  city: string;
+  state: string;
+  stateCode: string;
+}
+
+interface LouvershopConsultant {
+  id: number;
+  name: string;
+  link: string;
+}
+
+interface LouvershopAvailability {
+  exteriorDecorative: boolean;
+  exteriorSecurity: boolean;
+}
+
+interface FindLocalDealerResult {
+  zip: string;
+  inServiceArea: boolean;
+  branch: LouvershopBranch | null;
+  area: LouvershopLocalArea | null;
+  consultants: LouvershopConsultant[];
+  availability: LouvershopAvailability | null;
+}
+
+  /**
+   * Window treatments (interior/exterior shutters, blinds, shades) dealer network.
+   * findLocalDealer is live — the same lookup the site's own free-quote/consultant-locator forms
+   * run before showing a booking path, given a ZIP. requestConsultation (submitting the actual
+   * in-home consultation request) is a stub — see its notImplemented reason.
+   */
+  interface Unit {
+    /**
+     * Looks up the Louver Shop dealer/branch that covers a US ZIP (`zip`, a 4-5 digit string, e.g.
+     * "30301") — the same lookup the site's own "Free In-Home Design Consultation" form and "Find
+     * a Consultant" locator both run before offering a booking path. Returns whether the ZIP is in
+     * the dealer network, the matched branch (name, phone, page slug), the normalized local area,
+     * the branch's assigned consultants (deduplicated), and per-branch exterior-shutter
+     * availability flags. Recovered from the locator widget's own backend, not guessed at.
+     */
+    findLocalDealer(args: object): Promise<FindLocalDealerResult>;
+  }
+}
+
 declare namespace BowmarkProvider_lufthansa {
   // ── Lufthansa — the unit's own declarations, verbatim ──
 interface LufthansaFlightLeg {
@@ -8316,9 +9398,54 @@ interface LululemonProductAttributes {
    * reviews on products whose live page shows 22,748. */
   ratingValue: number | null;
   reviewCount: number | null;
+  /** Per-FIELD origin for the eight facts above, keyed by the same names. THIS
+   * is how a refused read is told apart from a garment with nothing published:
+   * fabrics [] beside status "absent" is lululemon saying it names no fabric,
+   * and fabrics [] beside status "unreachable" is the page refusing us. Ranking
+   * that treats the two alike silently prefers whichever candidates loaded. */
+  provenance: Record<string, FieldProvenance>;
+  /** The roll-up. On a refused page ratio is 0 and unreachableFields names all
+   * eight — the machine-readable form of the sentence in warnings. */
+  completeness: Completeness;
   /** What could not be reached. Non-empty means the page refused. */
   warnings: string[];
 }
+/** Where one field's value came from, and the retailer text behind it. */
+interface FieldProvenance {
+  /** "published" — lululemon stated it. "absent" — the page rendered and said
+   * nothing about this field. "unreachable" — the page refused, so UNKNOWN. */
+  status: "published" | "absent" | "unreachable";
+  /** Which door: "lululemon_pdp_ldjson", "lululemon_pdp_accordion" or
+   * "lululemon_pdp_title". Null when nothing filled it. */
+  source: string | null;
+  /** The retailer's own words the value rests on, for a field derived from
+   * prose. Null for a field the site published as a typed value. */
+  evidence: string | null;
+  /** On "unreachable" only: what was refused. */
+  detail?: string;
+}
+interface Completeness {
+  fields: number;
+  published: number;
+  absent: number;
+  unreachable: number;
+  /** published / fields, to 3dp. */
+  ratio: number;
+  /** The fields that are UNKNOWN rather than known-empty. */
+  unreachableFields: string[];
+  sourcesUsed: string[];
+}
+/** What getProducts returns. PARTIAL by construction — the pricing catalogue
+ * holds ~39% of the ids in lululemon's own sitemap, so ids it does not carry are
+ * NAMED rather than silently dropped or thrown over. */
+interface LululemonProductBatch {
+  /** In the order the ids were passed, not the order they finished. */
+  products: LululemonProduct[];
+  /** Every id that did not read, with the catalogue's own sentence. */
+  missing: Array<{ productId: string; detail: string }>;
+  requested: number;
+  warnings: string[];
+}
 interface LululemonRow {
   id: string;
   title: string;
@@ -8373,6 +9500,17 @@ interface LululemonSimilarProducts {
      */
     getProduct(query: { productId: string }): Promise<LululemonProduct>;
 
+    /**
+     * Reads the full configurator for MANY products in one call — the shape to use when ranking a
+     * candidate set, because a `search` row carries a price range and a colour count but not the
+     * per-colourway sizes, markdown evidence or images a ranking turns on. Returns `products` in
+     * the order the ids were passed. PARTIAL is the normal answer: the pricing catalogue holds
+     * roughly 39% of the ids in lululemon's own sitemap, so ids it does not carry come back in
+     * `missing` with the catalogue's own sentence, and one of them never costs the other rows. At
+     * most 24 ids — the same cap `search` returns — so one full search page is always one batch.
+     */
+    getProducts(query: { productIds: string[] }): Promise<LululemonProductBatch>;
+
     /**
      * Reads what lululemon's OWN product page publishes about a garment and the third-party
      * pricing door does not carry at all: the category the site files it under, the collection
@@ -10792,6 +11930,10 @@ interface PremierbuildingsStyle {
   label: string;
   sidingOptions: string[];
   sizes: { sizeKey: string; width: number; length: number }[];
+  imageUrl: string | null;   // a real product image from Premier's own catalogue
+  roofStyle: string | null;  // "gable", "gambrel", ...
+  roofing: string | null;    // "metal", ...
+  wallHeight: string | null; // Premier's own encoding in inches, e.g. "left-78-right-78-eave-72"
 }
 interface PremierbuildingsPrice {
   styleKey: string;
@@ -10825,8 +11967,10 @@ interface PremierbuildingsDealer {
   interface Unit {
     /**
      * Lists every real building style Premier's ShedView configurator offers (Lofted Barn,
-     * Utility, Cabin, Garage, ...) with its real siding options and every real buildable size
-     * (width x length), read straight from the configurator's own live catalogue.
+     * Utility, Cabin, Garage, ...) with its real siding options, every real buildable size (width
+     * x length), and what the building actually IS — a real product image, the roof line and
+     * roofing material, and Premier's own wall-height spec — read straight from the configurator's
+     * own live catalogue.
      */
     listBuildingStyles(): Promise<PremierbuildingsStyle[]>;
 
@@ -11853,6 +12997,47 @@ interface RitaniPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_roofmaxx {
+  // ── Roof Maxx — the unit's own declarations, verbatim ──
+interface RoofmaxxCalculatorSettings {
+  title: string;
+  description: string;
+}
+
+interface RoofmaxxCostEstimateArgs {
+  squareFootage: number;
+  region: "new-england" | "middle-atlantic" | "east-north-central" | "west-north-central" |
+    "south-atlantic" | "east-south-central" | "west-south-central" | "mountain" | "pacific";
+  roofType: "asphalt" | "metal" | "clay" | "wood";
+  roofSlope: "walkable" | "semiWalkable" | "nonWalkable";
+  numOfLevels: "1" | "2" | "3";
+  garageType: "nogarage" | "1car" | "2car";
+}
+
+interface RoofmaxxCostEstimate {
+  low: number;
+  mid: number;
+  high: number;
+}
+
+  /**
+   * Roof Maxx's own Roof Replacement Cost Calculator (roofmaxx.com/learning-hub) — given a
+   * home's size, location and roof details, returns the site's real server-computed low/mid/high
+   * full-replacement-cost estimate.
+   */
+  interface Unit {
+    /** The Roof Replacement Cost Calculator's own admin-configured title and description. */
+    getCalculatorSettings(): Promise<RoofmaxxCalculatorSettings>;
+
+    /**
+     * Runs the real calculator: given square footage, region, roof type, roof slope, garage size
+     * and building levels, returns Roof Maxx's own server-computed low/mid/high
+     * full-replacement-cost tiers.
+     */
+    estimateRoofReplacementCost(arg: RoofmaxxCostEstimateArgs): Promise<RoofmaxxCostEstimate>;
+  }
+}
+
 declare namespace BowmarkProvider_samsclub {
   // ── Sam's Club — the unit's own declarations, verbatim ──
 interface SamsclubInstantSavingsItem {
@@ -12940,6 +14125,52 @@ interface SunHomeSaunasCartResult {
   }
 }
 
+declare namespace BowmarkProvider_tamarackidaho {
+  // ── Tamarack Resort — the unit's own declarations, verbatim ──
+interface tamarackidahoSearchArgs {
+  arrivalDate: string;
+  departureDate: string;
+  adultCount: number;
+  childCount?: number;
+}
+
+interface tamarackidahoSearchResult {
+  arrivalDate: string;
+  departureDate: string;
+  adultCount: number;
+  childCount: number;
+  units: tamarackidahoUnit[];
+}
+
+interface tamarackidahoUnit {
+  supplierId: string;
+  supplierName: string;
+  productId: string;
+  unitName: string;
+  totalPrice: number;
+}
+
+  /**
+   * Tamarack Resort's own direct-managed lodging booking engine (Inntopia RTP) — real
+   * availability and price per unit type for a date range and party size, straight from the
+   * site's own search widget, browserless.
+   */
+  interface Unit {
+    /**
+     * Searches Tamarack Resort's own direct-managed lodging (the Lodge at Osprey Meadows, the
+     * Village at Tamarack Resort, and Tamarack Homes and Cottages — not the golf tee-time flow, a
+     * different vendor) for a stay and party size. `arrivalDate`/`departureDate` are "MM/DD/YYYY"
+     * strings (the widget's own format), `adultCount` is required and positive, `childCount`
+     * defaults to 0. Returns every unit type Tamarack's own booking engine (Inntopia RTP)
+     * currently prices as AVAILABLE for that exact query — each with its supplier (property), unit
+     * name, and `totalPrice` in USD for the whole queried stay (not nightly) — genuinely computed
+     * per call, not a cached listing. An empty `units` array is a real answer: Tamarack has
+     * nothing available for that stay, not a failure.
+     */
+    searchLodging(args: tamarackidahoSearchArgs): Promise<tamarackidahoSearchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_target {
   // ── Target — the unit's own declarations, verbatim ──
 interface targetRow {
@@ -12994,6 +14225,55 @@ interface TargetStoreSearch {
   }
 }
 
+declare namespace BowmarkProvider_tatcha {
+  // ── Tatcha — the unit's own declarations, verbatim ──
+interface TatchaQuizOption {
+  value: string;
+  label: string;
+}
+
+interface TatchaRitualQuizOptions {
+  skinTypes: TatchaQuizOption[];
+  benefits: TatchaQuizOption[];
+  eyeConcerns: TatchaQuizOption[];
+}
+
+interface TatchaRitualProduct {
+  step: string;
+  sku: string;
+  name: string;
+  secondaryName: string;
+  price: string;
+  handle: string;
+  url: string;
+  image: string;
+  usageTime: "AM" | "PM" | "both";
+  description: string;
+  inStock: boolean;
+}
+
+interface TatchaRitual {
+  summary: string;
+  products: TatchaRitualProduct[];
+  handoffUrl: string;
+}
+
+  /**
+   * Runs Tatcha's real "Ritual Finder" skincare quiz — the site's own product-matching backend,
+   * not a generic routine.
+   */
+  interface Unit {
+    /** Reads the live Ritual Finder quiz's real skin-type, benefit and eye-concern menus. */
+    getRitualQuizOptions(): Promise<TatchaRitualQuizOptions>;
+
+    /**
+     * Runs real quiz answers through Tatcha's own personalization backend and returns the real
+     * AM/PM product ritual it recommends.
+     */
+    getPersonalizedRitual(skinType: string, benefits: string[], eyeConcerns?: string[], sensitive?: boolean, owned?: string[]): Promise<TatchaRitual>;
+  }
+}
+
 declare namespace BowmarkProvider_teladoc {
   // ── Teladoc Health — the unit's own declarations, verbatim ──
 interface teladocRow {
@@ -13048,98 +14328,6 @@ interface teladocInsuranceCoverage {
   }
 }
 
-declare namespace BowmarkProvider_tentree {
-  // ── tentree — the unit's own declarations, verbatim ──
-interface TentreeVariant {
-  /** Shopify's numeric variant id as a string. What addToCart takes. */
-  id: string;
-  /** The variant's own label, e.g. "ASHWOOD METEORITE BLACK / ONE". */
-  title: string;
-  /** Decimal string exactly as the store publishes it, e.g. "45.00". */
-  price: string;
-  compareAtPrice: string | null;
-  sku: string | null;
-  /** The store's own per-variant stock flag. */
-  available: boolean;
-  options: string[];
-}
-interface TentreeProduct {
-  handle: string;
-  title: string;
-  productType: string;
-  vendor: string;
-  url: string;
-  optionNames: string[];
-  variants: TentreeVariant[];
-  priceRange: { min: string; max: string } | null;
-  inStock: boolean;
-  tags: string[];
-  descriptionHtml: string | null;
-}
-interface TentreeCartLine {
-  /** Shopify's own line key, which its cart-change endpoints address a line by. */
-  lineKey: string;
-  variantId: string;
-  productTitle: string;
-  /** Null on a single-variant product. */
-  variantTitle: string | null;
-  quantity: number;
-  price: string;
-  lineTotal: string;
-  url: string;
-}
-interface TentreeCart {
-  /** The store's own cart token — a bearer credential, so treat it like one. */
-  token: string;
-  lines: TentreeCartLine[];
-  /** Units, NOT lines: two of one variant is one line and two items. */
-  itemCount: number;
-  subtotal: string;
-  currency: string;
-  cartUrl: string;
-  checkoutUrl: string;
-}
-
-  /**
-   * Sustainable apparel storefront — hats, tees, hoodies and outerwear — with a real guest cart
-   * a caller can fill across several calls.
-   */
-  interface Unit {
-    /**
-     * Searches tentree's live catalogue and returns matching products with their real variants,
-     * current prices and per-variant stock. Matches whole words, so 'tee' finds tees and not
-     * 'steel'. Returns [] when nothing matches, which is an ordinary answer rather than an error.
-     */
-    searchProducts(query: string, opts?: { productType?: string; inStockOnly?: boolean; limit?: number }): Promise<TentreeProduct[]>;
-
-    /**
-     * Reads one product by its handle — every variant, its exact price and whether that specific
-     * size or colour is purchasable right now. Takes the handle searchProducts returns, and its
-     * variants[].id is what addToCart takes. THROWS on an unknown handle (the store answers a real
-     * 404).
-     */
-    getProduct(handle: string): Promise<TentreeProduct>;
-
-    /**
-     * Puts variants into THIS run's own cart on the store and returns the cart as the store
-     * reports it. Really writes — the cart exists on tentree.com from the first call, and it
-     * belongs to this run's cookie jar. Call it several times inside one bowmark.session() and the
-     * lines accumulate; call it across two separate runs and the second cart does not contain the
-     * first's lines. Takes VARIANT ids (getProduct().variants[].id), never handles. Nothing is
-     * bought: checkoutUrl is where a shopper would pay.
-     */
-    addToCart(items: Array<{ variantId: string; quantity?: number }>): Promise<TentreeCart>;
-
-    /**
-     * Reads THIS run's cart back from the store — lines, quantities, per-line and order totals,
-     * and the real cart and checkout URLs. Takes no id: the cart is the one this run's cookie jar
-     * holds, so a fresh run reads an empty cart rather than somebody else's. An empty cart is an
-     * ordinary answer (itemCount 0), not an error.
-     */
-    getCart(): Promise<TentreeCart>;
-  }
-}
-
 declare namespace BowmarkProvider_therabody {
   // ── Therabody — the unit's own declarations, verbatim ──
 interface TherabodyVariant {
@@ -13835,6 +15023,72 @@ interface TrekTravelSearchFilters {
   }
 }
 
+declare namespace BowmarkProvider_twiddy {
+  // ── Twiddy & Company Realtors — the unit's own declarations, verbatim ──
+interface TwiddyRentalRow {
+  propertyId: number;
+  propertyNumber: string;
+  name: string;
+  url: string;
+  town: string;
+  distanceToBeach: string;
+  bedrooms: number | null;
+  priceFromUsd: number | null;
+  priceFromFormatted: string | null;
+  ratingValue: number | null;
+  isAvailable: boolean;
+}
+interface TwiddyRentalDetail {
+  propertyId: number;
+  name: string;
+  identifier: string;
+  description: string;
+  streetAddress: string;
+  town: string;
+  petsAllowed: boolean;
+  amenities: string[];
+  numberOfBedrooms: number | null;
+  numberOfBathrooms: number | null;
+  images: string[];
+  url: string;
+}
+type TwiddyQuote =
+  | { available: true; propertyId: number; checkin: string; nights: number; currency: "USD";
+      rentalFeeUsd: number; discountUsd: number; taxUsd: number; totalUsd: number; checkoutUrl: string }
+  | { available: false; propertyId: number; checkin: string; nights: number };
+
+  /**
+   * Twiddy & Company's own Outer Banks vacation rental search and real-time weekly
+   * pricing/booking-handoff engine — a regional owner-operator's own 1,000+ property inventory,
+   * live availability and price, not a stale catalog.
+   */
+  interface Unit {
+    /**
+     * Runs Twiddy's own portfolio-wide search (all 1,000+ managed Outer Banks properties in one
+     * call), optionally filtered to one of the six towns ("Corolla", "Duck", "4x4", "Southern
+     * Shores", "Kitty Hawk", "Kill Devil Hills", "Nags Head") and/or a minimum bedroom count, and
+     * returns the live matching listings — name, url, town, distance to beach, bed count, an "as
+     * low as" headline price, rating.
+     */
+    searchRentals(options?: { town?: string; minBedrooms?: number }): Promise<TwiddyRentalRow[]>;
+
+    /**
+     * Reads one rental in full — description, address, pets-allowed flag, amenities, bed/bath
+     * counts, photos, and the internal numeric propertyId getRentalQuote needs — from the
+     * propertyUrl a search result carries (a twiddy.com/outer-banks/... path or full URL).
+     */
+    getRentalDetail(propertyUrl: string): Promise<TwiddyRentalDetail>;
+
+    /**
+     * Runs the site's own real-time weekly pricing engine for one property and a check-in date
+     * ("YYYY-MM-DD", default 7 nights) — rental fee, discount, tax, total — and returns the exact
+     * booking/checkout URL for that week. `available: false` means the site checked and the
+     * property has no live rate for that week, an ordinary answer.
+     */
+    getRentalQuote(propertyId: number, options: { checkin: string; nights?: number }): Promise<TwiddyQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_ulrichlifestyle {
   // ── Ulrich Lifestyle Structures — the unit's own declarations, verbatim ──
 // Ulrich Lifestyle Structures' OWN shapes — not a capability contract.
@@ -13906,6 +15160,58 @@ interface UlrichPriceResult {
   }
 }
 
+declare namespace BowmarkProvider_vervecoffee {
+  // ── Verve Coffee Roasters — the unit's own declarations, verbatim ──
+interface VervecoffeeSubscription {
+  id: string;
+  handle: string;
+  title: string;
+  priceFormatted: string;
+  url: string;
+}
+interface VervecoffeeCoffeeMatch {
+  id: string;
+  title: string;
+  descriptionHtml: string;
+  startingPriceFormatted: string;
+  url: string;
+  subscriptionPlans: Array<{ name: string; deliveryInterval: string; priceWithDiscount: string }>;
+}
+interface VervecoffeeCoffeeMatchResult {
+  recommendedProducts: VervecoffeeCoffeeMatch[];
+}
+interface CoffeeQuizAnswers {
+  journeyStage: "coffee_curious" | "casual_coffee_lover" | "coffee_connoisseur" | "barista";
+  brewMethod: "pourover" | "coffee_maker" | "espresso" | "french_press" | "aeropress";
+  coffeeStyle: "black" | "milk_or_cream" | "sugar_or_sweetener";
+  roastPreference: "light" | "medium" | "dark" | "not_sure";
+  tastingNote: "chocolate" | "citrus" | "fruits" | "sweet" | "floral" | "nuts";
+}
+
+  /**
+   * Verve Coffee Roasters' Roaster's Choice subscription catalog and its real 'Find Your Coffee
+   * Match' quiz (Octane AI-powered) — drives the same 5 questions the live site asks and returns
+   * the actual subscription it recommends, priced, with a buy link.
+   */
+  interface Unit {
+    /**
+     * Lists Verve's five real Roaster's Choice coffee subscription products (single origin, blend,
+     * espresso, Africa, Latin America) with their live USD price, read off the storefront's own
+     * /products.json catalog.
+     */
+    listRoastersChoiceSubscriptions(): Promise<VervecoffeeSubscription[]>;
+
+    /**
+     * Runs Verve's real 'Find Your Coffee Match' quiz end to end — the same 5 questions the live
+     * Octane AI-powered quiz at /pages/quiz asks every visitor — and returns the actual Roaster's
+     * Choice subscription(s) it recommends, with real USD price and a buy-page link. THROWS if
+     * Verve's quiz has been reconfigured and one of the 5 answer labels no longer matches (see the
+     * error for the live option set).
+     */
+    matchCoffeeSubscription(answers: CoffeeQuizAnswers): Promise<VervecoffeeCoffeeMatchResult>;
+  }
+}
+
 declare namespace BowmarkProvider_viewrail {
   // ── Viewrail — the unit's own declarations, verbatim ──
 interface ViewrailMaterial {
@@ -13946,6 +15252,62 @@ interface ViewrailMountingStyle {
   }
 }
 
+declare namespace BowmarkProvider_villagerealtyobx {
+  // ── Village Realty — the unit's own declarations, verbatim ──
+interface VillagerealtyobxListing {
+  propertyID: string;
+  seoName: string;
+  name: string;
+  town: string;
+  address: string | null;
+  bedrooms: number | null;
+  maxGuests: number | null;
+  photoUrl: string | null;
+  url: string;
+}
+
+interface VillagerealtyobxQuote {
+  propertyID: string;
+  checkin: string;
+  checkout: string;
+  available: boolean;
+  rent: number | null;
+  taxes: number | null;
+  total: number | null;
+  currency: string;
+  bookNowURL: string | null;
+  message: string | null;
+}
+
+  /**
+   * Village Realty's own Outer Banks vacation-rental search and real-time property quote (rent,
+   * taxes, total, book-now link) — the same live pricing their own site computes, no login
+   * required.
+   */
+  interface Unit {
+    /**
+     * Searches Village Realty's own 900+ Outer Banks rental listings the way
+     * villagerealtyobx.com/outer-banks-vacation-rentals does — filter by town (e.g. "Corolla",
+     * "Nags Head"), exact bedroom count, amenities (e.g. "Private Pool", "Elevator"), and
+     * optionally a date range — returning each matching property's id, name, town, address,
+     * bedroom count, max guests and detail-page URL. Call getQuote with a result's propertyID for
+     * a real priced quote.
+     */
+    searchRentals(args?: { town?: string, bedrooms?: number, amenities?: string[], checkin?: string, checkout?: string, page?: number }): Promise<VillagerealtyobxListing[]>;
+
+    /**
+     * Gets a real-time price quote for one Village Realty property and date range — the exact
+     * server-computed rent, taxes and total the rental detail page shows after picking dates, plus
+     * the book-now URL. `checkin`/`checkout` are `MM/DD/YYYY`. `available: false` is a genuine
+     * site answer (e.g. the dates fail the property's minimum-night-stay rule), not an error —
+     * this is the flow ChatGPT itself cannot operate today: asked to price a Village Realty stay
+     * it answers "I can't complete the booking or take payment for you" and recommends competitor
+     * sites instead of quoting Village Realty's own live price.
+     */
+    getQuote(args: { propertyID: string, checkin: string, checkout: string }): Promise<VillagerealtyobxQuote>;
+  }
+}
+
 declare namespace BowmarkProvider_visible {
   // ── Visible — the unit's own declarations, verbatim ──
 interface VisibleDealOffer {
@@ -14205,6 +15567,33 @@ interface VisibleGetPlansResult {
   }
 }
 
+declare namespace BowmarkProvider_voluspa {
+  // ── Voluspa — the unit's own declarations, verbatim ──
+interface VoluspaQuizButton {
+  text: string;
+  action: string;
+  url?: string;
+  selectedValue?: string;
+}
+interface VoluspaQuizIntro {
+  paths: VoluspaQuizButton[];
+  firstQuestionOptions: VoluspaQuizButton[];
+}
+
+  /**
+   * Voluspa's own "Find Your Fragrance" quiz suite — reads the branching quiz's entry paths and
+   * first-question scent-family options straight from the quiz vendor's config.
+   */
+  interface Unit {
+    /**
+     * Reads the fragrance quiz's entry screen — its two branching paths and the FIRST question's
+     * scent-family options for one of them (0 = home fragrance, 1 = personal fragrance/EDP, as the
+     * splash screen lists them; default 0) — decoded from Digioh's own campaign config.
+     */
+    getFragranceQuizIntro(pathIndex?: number): Promise<VoluspaQuizIntro>;
+  }
+}
+
 declare namespace BowmarkProvider_walmart {
   // ── Walmart — the unit's own declarations, verbatim ──
 interface walmartStore {
@@ -14384,6 +15773,103 @@ interface wellfoundCompanyDetail {
   }
 }
 
+declare namespace BowmarkProvider_xpresswellnessurgentcare {
+  // ── Xpress Wellness Urgent Care — the unit's own declarations, verbatim ──
+interface XpressFacility {
+  facilityId: string;       // healow facility_id — what checkWaitTime takes
+  name: string;              // e.g. "Manhattan, KS"
+  address: string | null;
+  phone: string | null;
+  detailsUrl: string | null; // the clinic's own page on the marketing site
+  checkinUrl: string;        // the healow openaccess widget URL
+}
+interface XpressWaitTime {
+  facilityId: string;
+  facilityName: string;      // confirmed by the widget's own dataLayer, not assumed
+  address: string | null;
+  phone: string | null;
+  waitTimeText: string;      // the site's own bucketed phrase, e.g. "Under 30 mins"
+  hoursText: string | null;  // e.g. "OPEN - Until 8 PM"
+  url: string;
+}
+
+  /**
+   * Reads Xpress Wellness Urgent Care's clinic roster and each clinic's live healow wait-time /
+   * check-in widget — no key, no browser.
+   */
+  interface Unit {
+    /**
+     * Lists every Xpress Wellness Urgent Care clinic — 40 locations across Oklahoma, Kansas and
+     * one Texas site — with name, address, phone, the clinic's own detail page and the healow
+     * check-in widget URL + facility_id. Takes nothing. The facilityId it returns is what
+     * checkWaitTime takes. THROWS rather than returning [] when the roster page answers with no
+     * clinics — the roster is never honestly empty.
+     */
+    listFacilities(): Promise<XpressFacility[]>;
+
+    /**
+     * Reads one clinic's live estimated wait time, hours-today status and confirmed identity
+     * straight off its healow openaccess widget. facilityId is the numeric id listFacilities
+     * returns (e.g. "10"). Confirms the facility resolved by cross-checking the widget's own
+     * embedded facility name before returning a reading; THROWS with the caller-facing facility_id
+     * named if the widget carries no name (an unknown id) or no wait-time reading (the widget's
+     * markup changed).
+     */
+    checkWaitTime(facilityId: string): Promise<XpressWaitTime>;
+  }
+}
+
+declare namespace BowmarkProvider_yourarborhome {
+  // ── Arbor Homes — the unit's own declarations, verbatim ──
+interface ArborHome {
+  uniqueName: string;
+  headline: string;
+  status: string;
+  price: number | null;
+  beds: number | null;
+  bathsFull: number | null;
+  bathsHalf: number | null;
+  sqft: number | null;
+  stories: number | null;
+  moveInDate: string | null;
+  address: { street: string; city: string; state: string; postalCode: string };
+  detailUrl: string | null;
+  selfTourUrl: string | null;
+}
+interface SearchHomesFilters {
+  city?: string;
+  minPrice?: number;
+  maxPrice?: number;
+  minBeds?: number;
+  minBaths?: number;
+  minSqft?: number;
+  status?: string;
+}
+
+  /**
+   * Arbor Homes — Indiana/Ohio/Kentucky new-construction homebuilder (Clayton Properties Group).
+   * searchHomes reads its live quick-move-in inventory (price, beds/baths/sqft, status,
+   * availability); getHome reads one listing by id. Both return the site's own NterNow
+   * self-guided-tour booking link where the listing has it enabled.
+   */
+  interface Unit {
+    /**
+     * Reads Arbor Homes' live quick move-in inventory off yourarborhome.com/homes and returns rows
+     * matching the optional filters (city, price range, min beds/baths/sqft, status) — real price,
+     * beds/baths, square footage, an availability date and, where the listing has it enabled,
+     * Arbor's own NterNow self-guided-tour booking link.
+     */
+    searchHomes(filters?: SearchHomesFilters): Promise<ArborHome[]>;
+
+    /**
+     * Reads one Arbor Homes listing by the `uniqueName` id `searchHomes` returns — the same row,
+     * for a caller that already picked a home and wants its detail-page URL and self-tour link
+     * without re-filtering the whole search.
+     */
+    getHome(uniqueName: string): Promise<ArborHome>;
+  }
+}
+
 declare namespace BowmarkFamily_shopify_store {
   // ── Shopify storefronts — the unit's own declarations, verbatim ──
 interface ShopifyVariant {
@@ -14431,8 +15917,8 @@ interface SaleEvidence {
   /** The published "was" price. Strictly greater than currentPrice when
    * evidenceType is "compare_at_price". Null when nothing published one. */
   originalPrice: string | null;
-  /** ISO 4217, or null. Null on the REST catalogue door, which publishes no
-   * currency — reported honestly rather than assumed to be USD. */
+  /** ISO 4217, from the storefront's own /meta.json. Null only when that read
+   * failed — never defaulted to "USD", which is wrong on every non-US store. */
   currency: string | null;
   promotionMessage: string | null;
   /** How it was decided. "compare_at_price" is a struck-through price;
@@ -14461,6 +15947,11 @@ interface PublishedProductAttributes {
   sleeveLength: string | null;
   rise: string | null;
   waistband: string | null;
+  /** How long the GARMENT is — "Cropped", "Midi". What every store's own
+   * `length::` tag fills, on a top exactly as on a bottom. */
+  garmentLength: string | null;
+  /** The inside leg seam and only that. NULL on a top — a tank has no inseam,
+   * and its length is `garmentLength`. */
   inseam: string | null;
   legShape: string | null;
   fit: string | null;
@@ -14479,8 +15970,14 @@ interface CoordinationMetadata {
   productFamily: string | null;
 }
 /** An EXPLICIT retailer-published relationship. Shared colour, fabric,
- * collection or family is NOT this — that is CoordinationMetadata. Usually [];
- * the catalogue door carries no set tags on any store measured. */
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [].
+ *
+ * Two doors fill it. On a PRODUCT row it comes from the store's tags, and no
+ * store measured publishes a set tag, so it is [] there. getSetEvidence() reads
+ * the other one: the complementary products a MERCHANDISER pinned by hand,
+ * admitted only for rows the store marks pr_prod_strat=pinned. The algorithmic
+ * "related products" feed is never read into this — that is a recommendation
+ * engine's output, not the retailer stating a pairing. */
 interface RetailerSetEvidence {
   evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
   evidenceText: string | null;
@@ -14488,6 +15985,48 @@ interface RetailerSetEvidence {
   setId: string | null;
   relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
+/** What getSetEvidence returns. An OBJECT rather than a bare array so the
+ * healthy EMPTY answer is still probeable: productId and sourceUrl exist only
+ * when BOTH hops answered, where an empty evidence list is the ordinary case. */
+interface ShopifySetEvidence {
+  handle: string;
+  /** Shopify's numeric PRODUCT id — the only key the recommendations door takes,
+   * and published by no other function here. */
+  productId: string;
+  /** The product page the pairing is published on. */
+  sourceUrl: string;
+  /** ONLY the rows a merchandiser pinned by hand. [] when they pinned nothing,
+   * which is the common case and is the STORE's answer. At most one entry — one
+   * statement, N related products. Read this for "what did the retailer SAY". */
+  evidence: RetailerSetEvidence[];
+  /** EVERY row the store recommends, pinned AND algorithmic, deduplicated, each
+   * labelled. Read source.by before treating one as the retailer's decision —
+   * the algorithmic rows are usually SUBSTITUTES rather than companions, since
+   * similarity returns the nearest product and the nearest thing to a baby
+   * monitor is another baby monitor. [] when includeAlgorithmic was false. */
+  recommendations: RecommendedProduct[];
+  /** Non-empty when the store returned a FULL page for an intent, which cannot be
+   * told apart from a longer list cut off at the cap. A merchandiser's pairing is
+   * a statement, so a partial one must not read as the whole. */
+  warnings: string[];
+}
+/** One recommended product, with the store's own label for who chose it. */
+interface RecommendedProduct {
+  productId: string | null;
+  handle: string | null;
+  title: string | null;
+  url: string | null;
+  source: RecommendationSource;
+}
+interface RecommendationSource {
+  /** "retailer" when a merchandiser pinned it; "algorithm" otherwise, INCLUDING
+   * a row the store labelled with nothing — an unknown provenance must never
+   * read as a person's decision. */
+  by: "retailer" | "algorithm";
+  /** The store's own token, verbatim and unmapped — "pinned", "jac" (Jaccard),
+   * "e" (embedding), "collection_fallback". Null when the row carried none. */
+  strategy: string | null;
+}
 interface ShopifyProduct {
   handle: string;
   title: string;
@@ -14502,13 +16041,64 @@ interface ShopifyProduct {
   descriptionHtml: string | null;
   /** The same copy with its markup removed. */
   descriptionText: string | null;
+  /** ISO 4217, read once per store from its own /meta.json. */
   currency: string | null;
+  /** When the store's door ANSWERED this row, ISO 8601 UTC. Every field here is
+   * a live fact with a shelf life — the price, the markdown, the per-variant
+   * stock flag — so read it before treating a cached row as current. Stamped per
+   * REQUEST: a getProducts batch carries one stamp per handle, not one per call. */
+  fetchedAt: string;
   /** Every image the door published, deduplicated, in the store's own order. */
   images: ProductImage[];
   attributes: PublishedProductAttributes;
+  /** Per-FIELD origin for `attributes` — keyed by the same field names. Read it
+   * before ranking on a null: "absent" is the store publishing nothing, and is
+   * the store's own answer; "unreachable" is a door we could not read, and means
+   * UNKNOWN. On this store both doors are one request that either answered or
+   * threw, so nothing here is ever "unreachable" — the status exists because the
+   * same vocabulary is used by providers whose page can refuse mid-answer. */
+  attributeProvenance: Record<string, FieldProvenance>;
+  attributeCompleteness: Completeness;
   coordination: CoordinationMetadata;
   retailerSetEvidence: RetailerSetEvidence[];
 }
+/** Where one attribute value came from, and the retailer text behind it. */
+interface FieldProvenance {
+  /** "published" — the retailer stated it. "absent" — every door was silent.
+   * "unreachable" — a door that would carry it was refused, so it is UNKNOWN. */
+  status: "published" | "absent" | "unreachable";
+  /** Which door: "shopify_tags", "shopify_product_type", "shopify_color_option"
+   * or "shopify_product_copy". Null when nothing filled it. */
+  source: string | null;
+  /** The retailer's own words the value rests on, verbatim — the tag, or the
+   * sentence out of the description. Null when nothing filled it. */
+  evidence: string | null;
+  /** On "unreachable" only: what was refused. */
+  detail?: string;
+}
+/** The roll-up over one product's attributeProvenance. */
+interface Completeness {
+  fields: number;
+  published: number;
+  absent: number;
+  unreachable: number;
+  /** published / fields, to 3dp. */
+  ratio: number;
+  /** The fields whose value is UNKNOWN rather than known-empty. Read this before
+   * comparing two rows: a row with entries here was not fully looked at. */
+  unreachableFields: string[];
+  sourcesUsed: string[];
+}
+/** What getProducts returns. PARTIAL by design: one handle the store will not
+ * serve costs that row and nothing else, where getProduct throws. */
+interface ShopifyProductBatch {
+  /** In the order the handles were passed, not the order they finished. */
+  products: ShopifyProduct[];
+  /** Every handle the store did not serve, with what it said. */
+  missing: Array<{ handle: string; detail: string }>;
+  requested: number;
+  warnings: string[];
+}
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
   lineKey: string;
@@ -14544,6 +16134,46 @@ interface ShopifyCollectionProducts {
    * top-then-bottom; reading a pairing out of that order is the caller's
    * inference, never this provider's claim. [] is an ordinary answer. */
   products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page, or NULL when this is the last
+   * one. A collection bigger than one page is reachable only through this. */
+  cursor: string | null;
+  /** Empty on an ordinary page. One entry when the walk hit the store platform's
+   * 25,000-row ceiling with the collection unfinished — a TRUNCATION, which a
+   * null cursor on its own would read as the end of the list. */
+  warnings: string[];
+}
+/** One page of a whole-catalogue walk. Advance it with the cursor; there is
+ * deliberately no "fetch everything" call, because every row is a request
+ * against the store and only the caller knows how many candidates it needs. */
+interface ShopifyProductPage {
+  /** In the store's own MERCHANDISED order — not id, not date. The store may
+   * re-merchandise mid-walk, so key on handle rather than assuming pages are
+   * disjoint. */
+  products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page. NULL when the store answered a
+   * short page, which is what the end of the catalogue looks like. */
+  cursor: string | null;
+  /** How many rows this page asked the store for. */
+  limit: number;
+  /** Empty on an ordinary page. One entry when the walk stopped at the 25,000-row
+   * ceiling with the catalogue unfinished. */
+  warnings: string[];
+}
+/** What resolveProductUrl hands back — the product a url names, and the variant
+ * its own ?variant= selected. */
+interface ShopifyProductFromUrl {
+  product: ShopifyProduct;
+  /** The variant ?variant= named, or NULL when the url named none — the ordinary
+   * case for a link off a collection page. Also null when it named one the store
+   * no longer publishes, which warnings says. NEVER the first variant instead:
+   * that answers "is my size in stock" about a different size. */
+  variant: ShopifyVariant | null;
+  /** The ?variant= value exactly as the url carried it, kept even when it
+   * matched nothing — a stale link is a fact about the link. */
+  variantIdInUrl: string | null;
+  /** Empty on a clean resolve. One entry when the url named a variant the store
+   * no longer publishes. */
+  warnings: string[];
 }
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
@@ -14559,8 +16189,8 @@ interface ShopifyCart {
 
   /**
    * OSMUND OLSEN — Every Shopify storefront, reached by its own name. One engine over the
-   * platform's two published surfaces — the store's own MCP server at /api/mcp for search, and
-   * the keyless Ajax storefront JSON for products and the cart.
+   * platform's two published surfaces — the store's own UCP MCP server at /api/ucp/mcp for
+   * search, and the keyless Ajax storefront JSON for products and the cart.
    */
   interface Unit {
     /**
@@ -14572,10 +16202,45 @@ interface ShopifyCart {
 
     /**
      * Reads one product by handle — every variant, its exact price, its SKU and whether that
-     * specific size or colour is purchasable right now.
+     * specific size or colour is purchasable right now. Pass { withReviews: true } to ALSO get the
+     * star rating and review count from whichever review app the merchant installed; it is off by
+     * default because it costs a second origin and usually the rendered product page too.
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
 
+    /**
+     * Turns a product URL into the product, which is the address a caller actually holds when a
+     * link arrives from a search result, a page or a person. Takes the whole url — origin, market
+     * prefix, ?variant= and #fragment — so nothing has to be stripped down to a bare handle first,
+     * and the variant the url named comes back beside the product instead of being lost. THROWS,
+     * naming the domain, on a url belonging to another storefront. Takes the same { withReviews:
+     * true } option as getProduct, on the same default: a url is another way of naming one
+     * product, so holding a link rather than a handle must not cost a caller the rating.
+     */
+    resolveProductUrl(url: string): Promise<ShopifyProductFromUrl>;
+
+    /**
+     * Reads FULL detail for many products in one call — the shape for ranking a candidate set,
+     * since a search row carries neither the description copy nor the per-variant stock a ranking
+     * turns on. PARTIAL by construction: a search row's handle may 404 on the Ajax product door
+     * (measured 2026-08-05, 2 of 10 sampled members), so one bad handle is named in `missing` and
+     * costs that row alone, where `getProduct` throws and takes the whole set with it. Capped at
+     * 50 handles because each one is a request to the store. Takes the same { withReviews: true }
+     * option, and is the shape to use for it: the review app's key is learned from the first pages
+     * and reused, so ratings for twenty handles cost a handful of page fetches rather than twenty.
+     */
+    getProducts(handles: string[]): Promise<ShopifyProductBatch>;
+
+    /**
+     * Walks the store's WHOLE catalogue a page at a time, in its own merchandised order — the
+     * shape that makes a realistic candidate set reachable at all, since search ranks against a
+     * query and returns one slice. The caller advances a cursor and stops on its own budget or on
+     * a null cursor. There is deliberately no fetch-everything call: every row is a request
+     * against a stranger's storefront, and how many candidates a ranking needs is the caller's
+     * decision rather than one taken once, inside the library, on behalf of every member.
+     */
+    listProducts(opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyProductPage>;
+
     /**
      * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
      * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
@@ -14588,7 +16253,18 @@ interface ShopifyCart {
      * rows. An empty list is an ordinary answer — several named 'look' collections publish no
      * products through this door.
      */
-    getCollection(handle: string, opts?: { limit?: number }): Promise<ShopifyCollectionProducts>;
+    getCollection(handle: string, opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyCollectionProducts>;
+
+    /**
+     * Two answers in one call. `evidence` is ONLY what a MERCHANDISER pinned by hand, in the order
+     * they typed it — an explicit retailer statement, and [] on most products, which is the
+     * retailer's own answer. `recommendations` is EVERY row the store returns including the
+     * algorithmic ones, each carrying source.by (retailer | algorithm) and the store's own
+     * strategy token, so a caller can use them without either field lying. The algorithmic rows
+     * are usually SUBSTITUTES rather than companions. Pass includeAlgorithmic: false to skip the
+     * second request.
+     */
+    getSetEvidence(handle: string, opts?: { includeAlgorithmic?: boolean }): Promise<ShopifySetEvidence>;
 
     /**
      * Puts variants into THIS run's own cart on the store and returns the cart the store reports
@@ -14654,8 +16330,8 @@ interface SaleEvidence {
   /** The published "was" price. Strictly greater than currentPrice when
    * evidenceType is "compare_at_price". Null when nothing published one. */
   originalPrice: string | null;
-  /** ISO 4217, or null. Null on the REST catalogue door, which publishes no
-   * currency — reported honestly rather than assumed to be USD. */
+  /** ISO 4217, from the storefront's own /meta.json. Null only when that read
+   * failed — never defaulted to "USD", which is wrong on every non-US store. */
   currency: string | null;
   promotionMessage: string | null;
   /** How it was decided. "compare_at_price" is a struck-through price;
@@ -14684,6 +16360,11 @@ interface PublishedProductAttributes {
   sleeveLength: string | null;
   rise: string | null;
   waistband: string | null;
+  /** How long the GARMENT is — "Cropped", "Midi". What every store's own
+   * `length::` tag fills, on a top exactly as on a bottom. */
+  garmentLength: string | null;
+  /** The inside leg seam and only that. NULL on a top — a tank has no inseam,
+   * and its length is `garmentLength`. */
   inseam: string | null;
   legShape: string | null;
   fit: string | null;
@@ -14702,8 +16383,14 @@ interface CoordinationMetadata {
   productFamily: string | null;
 }
 /** An EXPLICIT retailer-published relationship. Shared colour, fabric,
- * collection or family is NOT this — that is CoordinationMetadata. Usually [];
- * the catalogue door carries no set tags on any store measured. */
+ * collection or family is NOT this — that is CoordinationMetadata. Usually [].
+ *
+ * Two doors fill it. On a PRODUCT row it comes from the store's tags, and no
+ * store measured publishes a set tag, so it is [] there. getSetEvidence() reads
+ * the other one: the complementary products a MERCHANDISER pinned by hand,
+ * admitted only for rows the store marks pr_prod_strat=pinned. The algorithmic
+ * "related products" feed is never read into this — that is a recommendation
+ * engine's output, not the retailer stating a pairing. */
 interface RetailerSetEvidence {
   evidenceType: "official_set" | "shop_the_set" | "complete_the_look" | "matching_piece";
   evidenceText: string | null;
@@ -14711,6 +16398,48 @@ interface RetailerSetEvidence {
   setId: string | null;
   relatedProducts: Array<{ productId: string | null; handle: string | null; title: string | null; url: string | null }>;
 }
+/** What getSetEvidence returns. An OBJECT rather than a bare array so the
+ * healthy EMPTY answer is still probeable: productId and sourceUrl exist only
+ * when BOTH hops answered, where an empty evidence list is the ordinary case. */
+interface ShopifySetEvidence {
+  handle: string;
+  /** Shopify's numeric PRODUCT id — the only key the recommendations door takes,
+   * and published by no other function here. */
+  productId: string;
+  /** The product page the pairing is published on. */
+  sourceUrl: string;
+  /** ONLY the rows a merchandiser pinned by hand. [] when they pinned nothing,
+   * which is the common case and is the STORE's answer. At most one entry — one
+   * statement, N related products. Read this for "what did the retailer SAY". */
+  evidence: RetailerSetEvidence[];
+  /** EVERY row the store recommends, pinned AND algorithmic, deduplicated, each
+   * labelled. Read source.by before treating one as the retailer's decision —
+   * the algorithmic rows are usually SUBSTITUTES rather than companions, since
+   * similarity returns the nearest product and the nearest thing to a baby
+   * monitor is another baby monitor. [] when includeAlgorithmic was false. */
+  recommendations: RecommendedProduct[];
+  /** Non-empty when the store returned a FULL page for an intent, which cannot be
+   * told apart from a longer list cut off at the cap. A merchandiser's pairing is
+   * a statement, so a partial one must not read as the whole. */
+  warnings: string[];
+}
+/** One recommended product, with the store's own label for who chose it. */
+interface RecommendedProduct {
+  productId: string | null;
+  handle: string | null;
+  title: string | null;
+  url: string | null;
+  source: RecommendationSource;
+}
+interface RecommendationSource {
+  /** "retailer" when a merchandiser pinned it; "algorithm" otherwise, INCLUDING
+   * a row the store labelled with nothing — an unknown provenance must never
+   * read as a person's decision. */
+  by: "retailer" | "algorithm";
+  /** The store's own token, verbatim and unmapped — "pinned", "jac" (Jaccard),
+   * "e" (embedding), "collection_fallback". Null when the row carried none. */
+  strategy: string | null;
+}
 interface ShopifyProduct {
   handle: string;
   title: string;
@@ -14725,13 +16454,64 @@ interface ShopifyProduct {
   descriptionHtml: string | null;
   /** The same copy with its markup removed. */
   descriptionText: string | null;
+  /** ISO 4217, read once per store from its own /meta.json. */
   currency: string | null;
+  /** When the store's door ANSWERED this row, ISO 8601 UTC. Every field here is
+   * a live fact with a shelf life — the price, the markdown, the per-variant
+   * stock flag — so read it before treating a cached row as current. Stamped per
+   * REQUEST: a getProducts batch carries one stamp per handle, not one per call. */
+  fetchedAt: string;
   /** Every image the door published, deduplicated, in the store's own order. */
   images: ProductImage[];
   attributes: PublishedProductAttributes;
+  /** Per-FIELD origin for `attributes` — keyed by the same field names. Read it
+   * before ranking on a null: "absent" is the store publishing nothing, and is
+   * the store's own answer; "unreachable" is a door we could not read, and means
+   * UNKNOWN. On this store both doors are one request that either answered or
+   * threw, so nothing here is ever "unreachable" — the status exists because the
+   * same vocabulary is used by providers whose page can refuse mid-answer. */
+  attributeProvenance: Record<string, FieldProvenance>;
+  attributeCompleteness: Completeness;
   coordination: CoordinationMetadata;
   retailerSetEvidence: RetailerSetEvidence[];
 }
+/** Where one attribute value came from, and the retailer text behind it. */
+interface FieldProvenance {
+  /** "published" — the retailer stated it. "absent" — every door was silent.
+   * "unreachable" — a door that would carry it was refused, so it is UNKNOWN. */
+  status: "published" | "absent" | "unreachable";
+  /** Which door: "shopify_tags", "shopify_product_type", "shopify_color_option"
+   * or "shopify_product_copy". Null when nothing filled it. */
+  source: string | null;
+  /** The retailer's own words the value rests on, verbatim — the tag, or the
+   * sentence out of the description. Null when nothing filled it. */
+  evidence: string | null;
+  /** On "unreachable" only: what was refused. */
+  detail?: string;
+}
+/** The roll-up over one product's attributeProvenance. */
+interface Completeness {
+  fields: number;
+  published: number;
+  absent: number;
+  unreachable: number;
+  /** published / fields, to 3dp. */
+  ratio: number;
+  /** The fields whose value is UNKNOWN rather than known-empty. Read this before
+   * comparing two rows: a row with entries here was not fully looked at. */
+  unreachableFields: string[];
+  sourcesUsed: string[];
+}
+/** What getProducts returns. PARTIAL by design: one handle the store will not
+ * serve costs that row and nothing else, where getProduct throws. */
+interface ShopifyProductBatch {
+  /** In the order the handles were passed, not the order they finished. */
+  products: ShopifyProduct[];
+  /** Every handle the store did not serve, with what it said. */
+  missing: Array<{ handle: string; detail: string }>;
+  requested: number;
+  warnings: string[];
+}
 interface ShopifyCartLine {
   /** Shopify's own line key, which its cart-change endpoints address a line by. */
   lineKey: string;
@@ -14767,6 +16547,46 @@ interface ShopifyCollectionProducts {
    * top-then-bottom; reading a pairing out of that order is the caller's
    * inference, never this provider's claim. [] is an ordinary answer. */
   products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page, or NULL when this is the last
+   * one. A collection bigger than one page is reachable only through this. */
+  cursor: string | null;
+  /** Empty on an ordinary page. One entry when the walk hit the store platform's
+   * 25,000-row ceiling with the collection unfinished — a TRUNCATION, which a
+   * null cursor on its own would read as the end of the list. */
+  warnings: string[];
+}
+/** One page of a whole-catalogue walk. Advance it with the cursor; there is
+ * deliberately no "fetch everything" call, because every row is a request
+ * against the store and only the caller knows how many candidates it needs. */
+interface ShopifyProductPage {
+  /** In the store's own MERCHANDISED order — not id, not date. The store may
+   * re-merchandise mid-walk, so key on handle rather than assuming pages are
+   * disjoint. */
+  products: ShopifyProduct[];
+  /** Pass back as opts.cursor for the next page. NULL when the store answered a
+   * short page, which is what the end of the catalogue looks like. */
+  cursor: string | null;
+  /** How many rows this page asked the store for. */
+  limit: number;
+  /** Empty on an ordinary page. One entry when the walk stopped at the 25,000-row
+   * ceiling with the catalogue unfinished. */
+  warnings: string[];
+}
+/** What resolveProductUrl hands back — the product a url names, and the variant
+ * its own ?variant= selected. */
+interface ShopifyProductFromUrl {
+  product: ShopifyProduct;
+  /** The variant ?variant= named, or NULL when the url named none — the ordinary
+   * case for a link off a collection page. Also null when it named one the store
+   * no longer publishes, which warnings says. NEVER the first variant instead:
+   * that answers "is my size in stock" about a different size. */
+  variant: ShopifyVariant | null;
+  /** The ?variant= value exactly as the url carried it, kept even when it
+   * matched nothing — a stale link is a fact about the link. */
+  variantIdInUrl: string | null;
+  /** Empty on a clean resolve. One entry when the url named a variant the store
+   * no longer publishes. */
+  warnings: string[];
 }
 interface ShopifyCart {
   /** The store's own cart token — a bearer credential, so treat it like one. */
@@ -14782,8 +16602,8 @@ interface ShopifyCart {
 
   /**
    * friedrikdev — Every Shopify storefront, reached by its own name. One engine over the
-   * platform's two published surfaces — the store's own MCP server at /api/mcp for search, and
-   * the keyless Ajax storefront JSON for products and the cart.
+   * platform's two published surfaces — the store's own UCP MCP server at /api/ucp/mcp for
+   * search, and the keyless Ajax storefront JSON for products and the cart.
    */
   interface Unit {
     /**
@@ -14795,10 +16615,45 @@ interface ShopifyCart {
 
     /**
      * Reads one product by handle — every variant, its exact price, its SKU and whether that
-     * specific size or colour is purchasable right now.
+     * specific size or colour is purchasable right now. Pass { withReviews: true } to ALSO get the
+     * star rating and review count from whichever review app the merchant installed; it is off by
+     * default because it costs a second origin and usually the rendered product page too.
      */
     getProduct(handle: string): Promise<ShopifyProduct>;
 
+    /**
+     * Turns a product URL into the product, which is the address a caller actually holds when a
+     * link arrives from a search result, a page or a person. Takes the whole url — origin, market
+     * prefix, ?variant= and #fragment — so nothing has to be stripped down to a bare handle first,
+     * and the variant the url named comes back beside the product instead of being lost. THROWS,
+     * naming the domain, on a url belonging to another storefront. Takes the same { withReviews:
+     * true } option as getProduct, on the same default: a url is another way of naming one
+     * product, so holding a link rather than a handle must not cost a caller the rating.
+     */
+    resolveProductUrl(url: string): Promise<ShopifyProductFromUrl>;
+
+    /**
+     * Reads FULL detail for many products in one call — the shape for ranking a candidate set,
+     * since a search row carries neither the description copy nor the per-variant stock a ranking
+     * turns on. PARTIAL by construction: a search row's handle may 404 on the Ajax product door
+     * (measured 2026-08-05, 2 of 10 sampled members), so one bad handle is named in `missing` and
+     * costs that row alone, where `getProduct` throws and takes the whole set with it. Capped at
+     * 50 handles because each one is a request to the store. Takes the same { withReviews: true }
+     * option, and is the shape to use for it: the review app's key is learned from the first pages
+     * and reused, so ratings for twenty handles cost a handful of page fetches rather than twenty.
+     */
+    getProducts(handles: string[]): Promise<ShopifyProductBatch>;
+
+    /**
+     * Walks the store's WHOLE catalogue a page at a time, in its own merchandised order — the
+     * shape that makes a realistic candidate set reachable at all, since search ranks against a
+     * query and returns one slice. The caller advances a cursor and stops on its own budget or on
+     * a null cursor. There is deliberately no fetch-everything call: every row is a request
+     * against a stranger's storefront, and how many candidates a ranking needs is the caller's
+     * decision rather than one taken once, inside the library, on behalf of every member.
+     */
+    listProducts(opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyProductPage>;
+
     /**
      * Lists the store's own merchandised collections. THIS is where a retailer states a SET: a
      * collection the store itself named "Matching Sets" or "Activewear Sets" carries setLike:
@@ -14811,7 +16666,18 @@ interface ShopifyCart {
      * rows. An empty list is an ordinary answer — several named 'look' collections publish no
      * products through this door.
      */
-    getCollection(handle: string, opts?: { limit?: number }): Promise<ShopifyCollectionProducts>;
+    getCollection(handle: string, opts?: { limit?: number; cursor?: string | null }): Promise<ShopifyCollectionProducts>;
+
+    /**
+     * Two answers in one call. `evidence` is ONLY what a MERCHANDISER pinned by hand, in the order
+     * they typed it — an explicit retailer statement, and [] on most products, which is the
+     * retailer's own answer. `recommendations` is EVERY row the store returns including the
+     * algorithmic ones, each carrying source.by (retailer | algorithm) and the store's own
+     * strategy token, so a caller can use them without either field lying. The algorithmic rows
+     * are usually SUBSTITUTES rather than companions. Pass includeAlgorithmic: false to skip the
+     * second request.
+     */
+    getSetEvidence(handle: string, opts?: { includeAlgorithmic?: boolean }): Promise<ShopifySetEvidence>;
   }
 }
 
@@ -14823,20 +16689,26 @@ interface ShopifyCart {
 interface BowmarkProviders {
   aa: BowmarkProvider_aa.Unit;
   abercrombie: BowmarkProvider_abercrombie.Unit;
+  aiper: BowmarkProvider_aiper.Unit;
+  ajmadison: BowmarkProvider_ajmadison.Unit;
   ashleyfurniture: BowmarkProvider_ashleyfurniture.Unit;
+  atlasseniorliving: BowmarkProvider_atlasseniorliving.Unit;
   avis: BowmarkProvider_avis.Unit;
   azure: BowmarkProvider_azure.Unit;
   barletta: BowmarkProvider_barletta.Unit;
   bhphoto: BowmarkProvider_bhphoto.Unit;
+  bigrentz: BowmarkProvider_bigrentz.Unit;
   blenderseyewear: BowmarkProvider_blenderseyewear.Unit;
   bluehaven: BowmarkProvider_bluehaven.Unit;
   bmwusa: BowmarkProvider_bmwusa.Unit;
+  boydsleep: BowmarkProvider_boydsleep.Unit;
   bykoket: BowmarkProvider_bykoket.Unit;
   cancer: BowmarkProvider_cancer.Unit;
   caraway: BowmarkProvider_caraway.Unit;
   cars: BowmarkProvider_cars.Unit;
   cheapflights: BowmarkProvider_cheapflights.Unit;
   chriscraft: BowmarkProvider_chriscraft.Unit;
+  classichome: BowmarkProvider_classichome.Unit;
   classpass: BowmarkProvider_classpass.Unit;
   cloudflare: BowmarkProvider_cloudflare.Unit;
   cyberpowerpc: BowmarkProvider_cyberpowerpc.Unit;
@@ -14845,7 +16717,9 @@ interface BowmarkProviders {
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
   dillards: BowmarkProvider_dillards.Unit;
   discounttire: BowmarkProvider_discounttire.Unit;
+  embroker: BowmarkProvider_embroker.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
+  eventsource: BowmarkProvider_eventsource.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
   firstdibs: BowmarkProvider_firstdibs.Unit;
   flightradar24: BowmarkProvider_flightradar24.Unit;
@@ -14854,22 +16728,32 @@ interface BowmarkProviders {
   fred: BowmarkProvider_fred.Unit;
   geico: BowmarkProvider_geico.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
+  gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.Unit;
+  grandwelcome: BowmarkProvider_grandwelcome.Unit;
+  handypro: BowmarkProvider_handypro.Unit;
+  harmar: BowmarkProvider_harmar.Unit;
   hauslabs: BowmarkProvider_hauslabs.Unit;
   healthcare_gov: BowmarkProvider_healthcare_gov.Unit;
   hellofresh: BowmarkProvider_hellofresh.Unit;
   hellotend: BowmarkProvider_hellotend.Unit;
   hilton: BowmarkProvider_hilton.Unit;
+  hobie: BowmarkProvider_hobie.Unit;
   hunter: BowmarkProvider_hunter.Unit;
   ibuypower: BowmarkProvider_ibuypower.Unit;
   insurify: BowmarkProvider_insurify.Unit;
   interiordefine: BowmarkProvider_interiordefine.Unit;
+  islllc: BowmarkProvider_islllc.Unit;
+  jennikayne: BowmarkProvider_jennikayne.Unit;
   joybird: BowmarkProvider_joybird.Unit;
   kayak: BowmarkProvider_kayak.Unit;
+  kitchentuneup: BowmarkProvider_kitchentuneup.Unit;
+  kompan: BowmarkProvider_kompan.Unit;
   labcorp: BowmarkProvider_labcorp.Unit;
   linkedin: BowmarkProvider_linkedin.Unit;
   liquiddeath: BowmarkProvider_liquiddeath.Unit;
   lonelyplanet: BowmarkProvider_lonelyplanet.Unit;
+  louvershop: BowmarkProvider_louvershop.Unit;
   lufthansa: BowmarkProvider_lufthansa.Unit;
   lululemon: BowmarkProvider_lululemon.Unit;
   maidenhome: BowmarkProvider_maidenhome.Unit;
@@ -14895,6 +16779,7 @@ interface BowmarkProviders {
   prose: BowmarkProvider_prose.Unit;
   reddit: BowmarkProvider_reddit.Unit;
   ritani: BowmarkProvider_ritani.Unit;
+  roofmaxx: BowmarkProvider_roofmaxx.Unit;
   samsclub: BowmarkProvider_samsclub.Unit;
   sears: BowmarkProvider_sears.Unit;
   seegarsfence: BowmarkProvider_seegarsfence.Unit;
@@ -14904,18 +16789,25 @@ interface BowmarkProviders {
   statefarm: BowmarkProvider_statefarm.Unit;
   stickergiant: BowmarkProvider_stickergiant.Unit;
   sunhomesaunas: BowmarkProvider_sunhomesaunas.Unit;
+  tamarackidaho: BowmarkProvider_tamarackidaho.Unit;
   target: BowmarkProvider_target.Unit;
+  tatcha: BowmarkProvider_tatcha.Unit;
   teladoc: BowmarkProvider_teladoc.Unit;
-  tentree: BowmarkProvider_tentree.Unit;
   therabody: BowmarkProvider_therabody.Unit;
   thezebra: BowmarkProvider_thezebra.Unit;
   topviewtix: BowmarkProvider_topviewtix.Unit;
   trektravel: BowmarkProvider_trektravel.Unit;
+  twiddy: BowmarkProvider_twiddy.Unit;
   ulrichlifestyle: BowmarkProvider_ulrichlifestyle.Unit;
+  vervecoffee: BowmarkProvider_vervecoffee.Unit;
   viewrail: BowmarkProvider_viewrail.Unit;
+  villagerealtyobx: BowmarkProvider_villagerealtyobx.Unit;
   visible: BowmarkProvider_visible.Unit;
+  voluspa: BowmarkProvider_voluspa.Unit;
   walmart: BowmarkProvider_walmart.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
+  xpresswellnessurgentcare: BowmarkProvider_xpresswellnessurgentcare.Unit;
+  yourarborhome: BowmarkProvider_yourarborhome.Unit;
   "000de82": BowmarkFamily_shopify_store.Unit;
   "001r3iv0": BowmarkFamily_shopify_store.Unit;
   "00246d8e": BowmarkFamily_shopify_store.Unit;
@@ -51946,6 +53838,7 @@ interface BowmarkProviders {
   santabarbaraforgeandiron: BowmarkFamily_shopify_store.Unit;
   santabarbaranutrients: BowmarkFamily_shopify_store.Unit;
   santaclararealtorstore: BowmarkFamily_shopify_store.Unit;
+  santacruzbicycles: BowmarkFamily_shopify_store.Unit;
   santacruzmountainsclothing: BowmarkFamily_shopify_store.Unit;
   santafesoapranch: BowmarkFamily_shopify_store.Unit;
   santafewineandchilefiesta: BowmarkFamily_shopify_store.Unit;
@@ -56835,6 +58728,7 @@ interface BowmarkProviders {
   tentarte: BowmarkFamily_shopify_store.Unit;
   tenthavenuenorthshop: BowmarkFamily_shopify_store.Unit;
   tenthpine: BowmarkFamily_shopify_store.Unit;
+  tentree: BowmarkFamily_shopify_store.Unit;
   teoapparel: BowmarkFamily_shopify_store.Unit;
   teopanzolcobarcelonnette: BowmarkFamily_shopify_store.Unit;
   tepawines: BowmarkFamily_shopify_store.Unit;
@@ -66645,5 +68539,6 @@ interface BowmarkLibrary {
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
   read: BowmarkCapability_read.Unit;
+  sheds: BowmarkCapability_sheds.Unit;
   providers: BowmarkProviders;
 }