@bowmark/web 1.6.0 → 1.7.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: a400421498212bf60bfaab4808ff698bd8edb4febae1ba86fda5cb9ebc232c1b
+// 9 capabilities, 109 providers, 356 typed functions, 20 refused.
+// 51,714 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 {
@@ -2711,6 +2960,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 +4004,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 {
@@ -5113,6 +5461,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 +5614,132 @@ interface graingerStockRow {
   }
 }
 
+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 +5770,7 @@ interface HauslabsShadeMatch {
   variant: {
     number: number;
     family: string;
+    id: string;
     sku: string | null;
     price: string;
     available: boolean;
@@ -6181,6 +6703,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 +7991,47 @@ 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_joybird {
   // ── Joybird — the unit's own declarations, verbatim ──
 interface JoybirdConfigurator {
@@ -7633,6 +8268,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 {
@@ -8059,6 +8794,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 +9106,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 +9208,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 +11638,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 +11675,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[]>;
 
@@ -14384,6 +15236,57 @@ interface wellfoundCompanyDetail {
   }
 }
 
+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 +15334,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 +15364,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 +15387,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 +15402,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 +15458,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 +15551,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. */
@@ -14572,10 +15619,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 +15670,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 +15747,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 +15777,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 +15800,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 +15815,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 +15871,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 +15964,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. */
@@ -14795,10 +16032,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 +16083,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,7 +16106,10 @@ 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;
@@ -14837,6 +16123,7 @@ interface BowmarkProviders {
   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,6 +16132,7 @@ interface BowmarkProviders {
   dickssportinggoods: BowmarkProvider_dickssportinggoods.Unit;
   dillards: BowmarkProvider_dillards.Unit;
   discounttire: BowmarkProvider_discounttire.Unit;
+  embroker: BowmarkProvider_embroker.Unit;
   erieinsurance: BowmarkProvider_erieinsurance.Unit;
   extraspace: BowmarkProvider_extraspace.Unit;
   firstdibs: BowmarkProvider_firstdibs.Unit;
@@ -14854,22 +16142,30 @@ interface BowmarkProviders {
   fred: BowmarkProvider_fred.Unit;
   geico: BowmarkProvider_geico.Unit;
   google_flights: BowmarkProvider_google_flights.Unit;
+  gotchacovered: BowmarkProvider_gotchacovered.Unit;
   grainger: BowmarkProvider_grainger.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;
   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;
@@ -14916,6 +16212,7 @@ interface BowmarkProviders {
   visible: BowmarkProvider_visible.Unit;
   walmart: BowmarkProvider_walmart.Unit;
   wellfound: BowmarkProvider_wellfound.Unit;
+  yourarborhome: BowmarkProvider_yourarborhome.Unit;
   "000de82": BowmarkFamily_shopify_store.Unit;
   "001r3iv0": BowmarkFamily_shopify_store.Unit;
   "00246d8e": BowmarkFamily_shopify_store.Unit;
@@ -51946,6 +53243,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;
@@ -66645,5 +67943,6 @@ interface BowmarkLibrary {
   music: BowmarkCapability_music.Unit;
   pcparts: BowmarkCapability_pcparts.Unit;
   read: BowmarkCapability_read.Unit;
+  sheds: BowmarkCapability_sheds.Unit;
   providers: BowmarkProviders;
 }