@wix/agent-skills 1.16.3 → 1.18.0

package/skills/wix-vibe-headless/references/bookings/app/components/RentalDurationPicker.jsx

@@ -0,0 +1,67 @@
+// Rental length picker — pure UI. The options, the selection handler and the priced total all
+// come from useRentalDuration; no data wiring lives here.
+//
+// Renders the step an ordinary service doesn't have: the customer has already picked a START
+// (SlotPicker), and now picks HOW LONG. The running total sits beside the choices because a
+// rental's cost depends on the length — showing only a rate per hour leaves the customer
+// discovering the real number at checkout.
+//
+// Show this only when `rental.isRental` — an appointment or class has no length to choose.
+// Styled with base44 design tokens (shadcn Tailwind classes).
+const optionCls = "py-2.5 px-3 cursor-pointer text-sm font-body border rounded-sm transition-colors";
+const idle = "border-border bg-card text-foreground hover:border-foreground/40";
+const active = "border-primary bg-primary text-primary-foreground";
+
+/**
+ * @param {{
+ *   rental: object,        // the whole return of useRentalDuration
+ *   startLabel?: string,   // e.g. "Fri 4 Sep, 10:00" — what the customer already picked
+ * }} props
+ */
+export default function RentalDurationPicker({ rental, startLabel }) {
+  const { isRental, duration, options, selected, select, price, loading, error } = rental;
+  if (!isRental) return null;
+
+  const unitWord = duration?.unit === "DAY" ? "days" : "hours";
+
+  return (
+    <div className="mb-6">
+      <div className="mb-2 flex items-baseline justify-between gap-3">
+        <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+          How long{startLabel ? ` from ${startLabel}` : ""}
+        </p>
+        {price?.total ? (
+          <p className="text-sm font-semibold text-foreground">{price.total}</p>
+        ) : selected ? (
+          <p className="text-sm text-muted-foreground">Pricing…</p>
+        ) : null}
+      </div>
+
+      {loading ? (
+        <p className="text-sm text-muted-foreground">Loading available {unitWord}…</p>
+      ) : error ? (
+        <p className="text-sm text-destructive">{error}</p>
+      ) : !options.length ? (
+        // An empty list is a real answer: this start has no bookable length. Say so, and leave
+        // the start picker in place so the customer can choose another one.
+        <p className="text-sm text-muted-foreground">
+          Nothing available from that start — pick another time.
+        </p>
+      ) : (
+        <div className="grid grid-cols-3 gap-2 sm:grid-cols-4">
+          {options.map((option) => (
+            <button
+              key={option.localEndDate}
+              type="button"
+              aria-pressed={selected?.localEndDate === option.localEndDate}
+              className={`${optionCls} ${selected?.localEndDate === option.localEndDate ? active : idle}`}
+              onClick={() => select(option)}
+            >
+              {option.label}
+            </button>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

package/skills/wix-vibe-headless/references/bookings/app/hooks/useRentalDuration.js

@@ -0,0 +1,128 @@
+// useRentalDuration — the extra step a rental has and an ordinary service doesn't: once the
+// customer has picked a START, they pick how LONG, and the price follows the length.
+//
+// Compose it with useServiceDetail rather than replacing it. That hook already loads the
+// service, lists start times, holds the contact fields and runs bookAndCheckout — all of which
+// a rental uses unchanged. This adds only the second choice and its price:
+//
+//   const detail = useServiceDetail(serviceId);                       // service + start slots
+//   const rental = useRentalDuration(detail.service, detail.selectedSlot, detail.timeZone);
+//   // render detail.slots → customer picks a start → render rental.options → picks a length
+//   // book with rental.endDate as the slot's localEndDate
+//
+// Returns empty options for a non-rental service, so a page that renders both kinds needs no
+// branch of its own — `isRental(service)` decides whether to show the length step at all.
+import { useCallback, useEffect, useState } from "react";
+import {
+  dailyEndOptions,
+  isRental,
+  listEndOptions,
+  previewRentalPrice,
+  rentalDuration,
+} from "@/rest/wix-bookings-rentals";
+
+/** "1 hr 30 min" / "2 days" — the label for one length option. */
+function lengthLabel(startLocal, endLocal, unit) {
+  if (unit === "DAY") {
+    const days = Math.round((new Date(`${endLocal}Z`) - new Date(`${startLocal}Z`)) / 86400000);
+    return days === 1 ? "1 day" : `${days} days`;
+  }
+  const minutes = Math.round((new Date(`${endLocal}Z`) - new Date(`${startLocal}Z`)) / 60000);
+  const h = Math.floor(minutes / 60);
+  const m = minutes % 60;
+  return [h ? `${h} hr` : "", m ? `${m} min` : ""].filter(Boolean).join(" ") || "0 min";
+}
+
+/**
+ * @param {object|null} service   The service from useServiceDetail — may be null while loading.
+ * @param {object|null} startSlot The slot the customer picked (its localStartDate is the start).
+ * @param {string|null} timeZone  The zone the slot list came back in.
+ * @returns {{
+ *   isRental: boolean,
+ *   duration: { unit: "HOUR"|"DAY", min: number, max: number, step: number }|null,
+ *   options: { localEndDate: string, label: string }[],
+ *   selected: object|null,
+ *   select: (option: object) => void,
+ *   endDate: string|null,   // pass as the booking's localEndDate
+ *   price: { total: string, currency: string|null }|null,
+ *   loading: boolean,
+ *   error: string|null,
+ * }}
+ */
+export function useRentalDuration(service, startSlot, timeZone) {
+  const [options, setOptions] = useState([]);
+  const [selected, setSelected] = useState(null);
+  const [price, setPrice] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+
+  const rental = isRental(service);
+  const duration = rentalDuration(service);
+  const start = startSlot?.localStartDate ?? null;
+  // Forward the chosen slot's own location to end-options.
+  const location = startSlot?.location ?? null;
+  const serviceId = service?._id || service?.id || null;
+
+  // A new start invalidates the lengths that were valid for the previous one.
+  useEffect(() => {
+    setSelected(null);
+    setPrice(null);
+    if (!rental || !start || !serviceId) {
+      setOptions([]);
+      return;
+    }
+    let alive = true;
+    setLoading(true);
+    setError(null);
+    const load = duration.unit === "DAY"
+      ? dailyEndOptions(service, { localStartDate: start, timeZone })
+          .then((list) => list.map((o) => ({ localEndDate: o.localEndDate, label: lengthLabel(start, o.localEndDate, "DAY") })))
+      : listEndOptions(serviceId, { localStartDate: start, location, timeZone })
+          .then(({ endOptions }) =>
+            endOptions.map((o) => ({ localEndDate: o.localEndDate, label: lengthLabel(start, o.localEndDate, "HOUR") })),
+          );
+    load
+      .then((list) => {
+        if (!alive) return;
+        setOptions(list);
+        setLoading(false);
+      })
+      .catch((e) => {
+        if (!alive) return;
+        // Fail loudly — an empty length list and a failed call look identical on screen
+        // otherwise, and the second one is a bug the visitor should not absorb silently.
+        setError(e?.message || "Could not load available lengths.");
+        setOptions([]);
+        setLoading(false);
+      });
+    return () => {
+      alive = false;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [rental, serviceId, start, timeZone, duration?.unit]);
+
+  // The price comes from the server for the chosen length — never multiply the rate locally.
+  const select = useCallback(
+    (option) => {
+      setSelected(option);
+      setPrice(null);
+      if (!option || !serviceId || !start || !timeZone) return;
+      previewRentalPrice(serviceId, { localStartDate: start, localEndDate: option.localEndDate, timeZone })
+        .then((p) => setPrice({ total: p.total, currency: p.currency }))
+        .catch((e) => setError(e?.message || "Could not price that length."));
+    },
+    [serviceId, start, timeZone],
+  );
+
+  return {
+    isRental: rental,
+    duration,
+    options,
+    selected,
+    select,
+    endDate: selected?.localEndDate ?? null,
+    price,
+    loading,
+    error,
+  };
+}

package/skills/wix-vibe-headless/references/bookings/app/hooks/useServiceDetail.js

@@ -31,8 +31,9 @@ export function useServiceDetail(serviceId) {
   const [error, setError] = useState(null);
 
   useEffect(() => {
-    // getService returns null on a miss — show not-found, never invent a service.
-    getService(serviceId).then((s) => (s ? setService(s) : setNotFound(true)));
+    // getService returns null on a miss — show not-found, never invent a service. A rejected
+    // request (network, 4xx) must also resolve the page to not-found, never leave it loading forever.
+    getService(serviceId).then((s) => (s ? setService(s) : setNotFound(true))).catch(() => setNotFound(true));
   }, [serviceId]);
 
   useEffect(() => {
@@ -41,7 +42,8 @@ export function useServiceDetail(serviceId) {
     // returns { slots, nextCursor }. The LIST call takes fromLocalDate / toLocalDate — a different
     // arg naming than the single-slot re-validate call (getAvailableSlot: localStartDate/localEndDate).
     listSlotsForService(service, { fromLocalDate: localMidnight(0), toLocalDate: localMidnight(14) })
-      .then(({ slots, nextCursor, timeZone }) => { setSlots(slots); setCursor(nextCursor); setTimeZone(timeZone); });
+      .then(({ slots, nextCursor, timeZone }) => { setSlots(slots); setCursor(nextCursor); setTimeZone(timeZone); })
+      .catch(() => setSlots([]));
   }, [service]);
 
   const loadMoreSlots = useCallback(() => {

package/skills/wix-vibe-headless/references/bookings/app/rest/wix-bookings-checkout.js

@@ -3,7 +3,7 @@ import { wixApiRequest } from "./wix-client.js";
 // Data model reference: see INSTRUCTIONS.md
 // Service and TimeSlot shapes: see wix-bookings-services.js
 
-// Wix Bookings app id — required inside catalogReference for the eCommerce checkout.
+// Wix Bookings app id — required inside catalogReference when adding the booking to the eCom cart.
 const BOOKINGS_APP_ID = "13d21c63-b5ec-5912-8397-c3a5ddb27a97";
 
 /**
@@ -101,27 +101,28 @@ export async function createBooking(slot, contactDetails, { totalParticipants =
 }
 
 /**
- * Create an eCommerce checkout for a created booking and return the hosted checkout URL.
+ * Add a created booking to the current eCom cart and return the hosted checkout URL.
+ * In Cart V2 the cart id IS the checkout id — add the booking line to the current cart, then create
+ * the redirect session straight from that cart's id (there is no separate checkout-creation call).
  * Redirect the buyer there (window.location.href = ...). On return, the booking is confirmed.
  * Throws if no redirect URL is produced.
- * https://dev.wix.com/docs/api-reference/business-solutions/e-commerce/purchase-flow/checkout.md
+ * https://dev.wix.com/docs/api-reference/business-solutions/e-commerce/purchase-flow/cart-v2/add-line-items-to-current-cart.md
  * @param {string} bookingId  booking.id from createBooking().
  * @returns {Promise<string>} The hosted-checkout URL to redirect to.
  */
 export async function checkoutBooking(bookingId) {
   if (!bookingId) throw new Error("checkoutBooking requires a bookingId.");
 
-  const checkoutRes = await wixApiRequest("/ecom/v1/checkouts", {
+  const cartRes = await wixApiRequest("/ecom/v2/carts/current/add-line-items", {
     method: "POST",
     body: {
-      channelType: "WEB",
-      lineItems: [
+      catalogItems: [
         { quantity: 1, catalogReference: { appId: BOOKINGS_APP_ID, catalogItemId: bookingId } },
       ],
     },
   });
-  const checkoutId = checkoutRes?.checkout?.id;
-  if (!checkoutId) throw new Error("Failed to create a checkout for the booking.");
+  const checkoutId = cartRes?.cart?.id;
+  if (!checkoutId) throw new Error("Failed to add the booking to the cart for checkout.");
 
   const redirect = await wixApiRequest("/headless/v1/redirect-session", {
     method: "POST",

package/skills/wix-vibe-headless/references/bookings/app/rest/wix-bookings-rentals.js

@@ -0,0 +1,250 @@
+import { wixApiRequest } from "./wix-client.js";
+import { listAvailableSlots } from "./wix-bookings-services.js";
+
+/**
+ * Wix Rentals — a DELTA on `wix-bookings-services.js`, not a replacement.
+ *
+ * Wix Rentals has no APIs of its own. A rental is a Bookings **service** with rentals-specific
+ * field values, so the catalog read, the booking form, and the whole
+ * `createBooking → cart → checkout` chain in `wix-bookings-checkout.js` are UNCHANGED. Only
+ * three things differ, and they are all here:
+ *
+ *   1. every catalog read filters by the rentals `appId`, or rentals and appointments interleave
+ *   2. the customer picks the LENGTH, so availability is two calls: start times, then the valid
+ *      ends for the chosen start
+ *   3. price is a rate per unit, so the total for a chosen length comes from the server
+ *
+ * What makes a service a rental (from the docs' own mapping — nothing is inferred):
+ *   type      always "APPOINTMENT"
+ *   appId     always RENTALS_APP_ID
+ *   schedule.availabilityConstraints.durationRange   replaces `sessionDurations`
+ *                                                    — MUTUALLY EXCLUSIVE, one or the other
+ *   primaryResourceType   a resource type id, not staff — availability comes from its resources
+ *   payment.rateType      always "FIXED", charged per hour or per day
+ *
+ * ⚠️ Because the two constraint fields are mutually exclusive, `isRental()` below is a reliable
+ * test on the DATA. Never decide "this is a rental" from the brief, the service name, or a
+ * category — a 60-minute yoga class and a meeting room rented for 1–8 hours are told apart by
+ * which constraint the service carries, and nothing else.
+ *
+ * docs: https://dev.wix.com/docs/api-reference/business-solutions/rentals/wix-rentals-and-the-bookings-apis.md
+ * docs: https://dev.wix.com/docs/api-reference/business-solutions/rentals/about-wix-rentals-availability.md
+ */
+
+/** The Wix Rentals app. Used twice: to filter the catalog, and as the cart's catalogReference.appId. */
+export const RENTALS_APP_ID = "ff5d6eb1-65e4-4f9a-8b14-64d34c12cc2e";
+
+/** The Wix Bookings app — the other half of a mixed site. */
+export const BOOKINGS_APP_ID = "13d21c63-b5ec-5912-8397-c3a5ddb27a97";
+
+/**
+ * Is this service a rental? True when it carries a duration RANGE the customer picks within,
+ * rather than a fixed session length. This is the only correct test.
+ * @param {object} service
+ * @returns {boolean}
+ */
+export function isRental(service) {
+  return Boolean(service?.schedule?.availabilityConstraints?.durationRange);
+}
+
+/**
+ * The rental's unit and bounds, or null for an ordinary service.
+ * Hourly bounds are MINUTES (30–1440), daily bounds are DAYS (1–8).
+ * @param {object} service
+ * @returns {{ unit: "HOUR"|"DAY", min: number, max: number, step: number }|null}
+ */
+export function rentalDuration(service) {
+  const range = service?.schedule?.availabilityConstraints?.durationRange;
+  if (!range) return null;
+  if (range.unitType === "DAY") {
+    return {
+      unit: "DAY",
+      min: range.dayOptions?.minDurationInDays ?? 1,
+      max: range.dayOptions?.maxDurationInDays ?? 1,
+      step: 1,
+    };
+  }
+  return {
+    unit: "HOUR",
+    min: range.hourOptions?.minDurationInMinutes ?? 30,
+    max: range.hourOptions?.maxDurationInMinutes ?? 1440,
+    step: 30,
+  };
+}
+
+/**
+ * Query rentals only. On a site that has both apps an unfiltered `queryServices` returns
+ * haircuts next to meeting rooms, so this is not optional — it is the same query with the
+ * rentals `appId` on the filter.
+ *
+ * Pass `appId: BOOKINGS_APP_ID` to get the ordinary services instead, on a mixed site.
+ * @param {{ limit?: number, offset?: number, appId?: string }} [options]
+ * @returns {Promise<{ services: object[], total: number, nextOffset: number|null }>}
+ */
+export async function queryRentals({ limit = 100, offset = 0, appId = RENTALS_APP_ID } = {}) {
+  const res = await wixApiRequest("/bookings/v2/services/query", {
+    method: "POST",
+    body: { query: { filter: { hidden: false, appId }, paging: { limit, offset } } },
+  });
+  const services = res?.services ?? [];
+  const total = res?.pagingMetadata?.total ?? services.length;
+  const loaded = offset + services.length;
+  return { services, total, nextOffset: loaded < total ? loaded : null };
+}
+
+/**
+ * The resource type id(s) a rental's availability comes from — read off `serviceResources`.
+ * Every rental availability call must pass these as `includeResourceTypeIds`, or it returns zero slots.
+ * @param {object} service
+ * @returns {string[]}
+ */
+export function rentalResourceTypeIds(service) {
+  return (service?.serviceResources ?? [])
+    .map((sr) => sr.resourceType?._id ?? sr.resourceType?.id)
+    .filter(Boolean);
+}
+
+/**
+ * Start times for a rental — step 1 of 2.
+ *
+ * A rental is an APPOINTMENT-typed service, so this is the same availability call an appointment
+ * uses; what comes back are the times a rental may START. The customer then picks how long, which is
+ * `listEndOptions` below. Pass the whole `service` so its resource types ride along — the
+ * availability engine reads them to find a resource-driven service's slots.
+ * @param {object} service  A rental service from queryRentals.
+ * @param {{ fromLocalDate: string, toLocalDate: string, timeZone?: string, limit?: number, cursor?: string }} options
+ * @returns {Promise<{ slots: object[], nextCursor: string|null, timeZone: string|null }>}
+ */
+export function listRentalStartSlots(service, options = {}) {
+  const serviceId = service?._id || service?.id;
+  return listAvailableSlots(serviceId, { ...options, includeResourceTypeIds: rentalResourceTypeIds(service) });
+}
+
+/**
+ * The valid END times for a chosen start — step 2 of 2, HOURLY rentals only.
+ *
+ * Each entry is a TimeSlot sharing `localStartDate` with the request and varying only in
+ * `localEndDate`, sorted shortest first. The service's maximum duration always caps the list,
+ * so a `maxLocalEndDate` beyond it is ignored rather than rejected.
+ *
+ * ⚠️ Hourly only. A DAILY rental has no end options — its lengths are whole days, so walk
+ * consecutive days from the chosen start instead (`dailyEndOptions` below).
+ * https://dev.wix.com/docs/api-reference/business-solutions/bookings/time-slots/time-slots-v2/list-availability-time-slot-end-options.md
+ * Pass the chosen start slot's own `location`. It carries `locationType` (and an `id` on a
+ * multi-location site); `{ locationType: "BUSINESS" }` is enough on a single-location site.
+ * @param {string} serviceId
+ * @param {{ localStartDate: string, location: object, maxLocalEndDate?: string, timeZone?: string }} options
+ * @returns {Promise<{ endOptions: object[], timeZone: string|null }>}
+ */
+export async function listEndOptions(serviceId, { localStartDate, location, maxLocalEndDate, timeZone } = {}) {
+  if (!localStartDate) throw new Error("listEndOptions requires localStartDate (local 'YYYY-MM-DDThh:mm:ss').");
+  if (!location) throw new Error("listEndOptions requires the chosen slot's location.");
+  const res = await wixApiRequest("/_api/service-availability/v2/time-slots/end-options", {
+    method: "POST",
+    body: {
+      serviceId,
+      localStartDate,
+      location,
+      ...(maxLocalEndDate ? { maxLocalEndDate } : {}),
+      ...(timeZone ? { timeZone } : {}),
+    },
+  });
+  return { endOptions: res?.endOptions ?? [], timeZone: res?.timeZone ?? null };
+}
+
+/**
+ * The lengths a DAILY rental can run for from a chosen start day — the daily counterpart to
+ * `listEndOptions`. A day's slot list is the availability, so this walks forward from the start
+ * and stops at the first day that has none: a 3-day rental needs all 3 days free, and a gap
+ * means the longer options are not bookable however far out the calendar goes.
+ *
+ * Returns one entry per bookable length, `{ days, localEndDate }`, shortest first.
+ * `localEndDate` is midnight of the day AFTER the last rented day — the end boundary is
+ * exclusive, which is the same convention the catalog's availability window uses.
+ * @param {object} service  A rental service (daily).
+ * @param {{ localStartDate: string, timeZone?: string }} options
+ * @returns {Promise<{ days: number, localEndDate: string }[]>}
+ */
+export async function dailyEndOptions(service, { localStartDate, timeZone } = {}) {
+  const duration = rentalDuration(service);
+  if (!duration || duration.unit !== "DAY") {
+    throw new Error("dailyEndOptions expects a DAY-unit rental — use listEndOptions for hourly.");
+  }
+  const serviceId = service._id || service.id;
+  const includeResourceTypeIds = rentalResourceTypeIds(service);
+  const startDay = localStartDate.slice(0, 10);
+  const dayAfter = (isoDay, n) => {
+    const d = new Date(`${isoDay}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + n);
+    return d.toISOString().slice(0, 10);
+  };
+
+  const out = [];
+  for (let days = 1; days <= duration.max; days++) {
+    const dayToCheck = dayAfter(startDay, days - 1);
+    const { slots } = await listAvailableSlots(serviceId, {
+      fromLocalDate: `${dayToCheck}T00:00:00`,
+      toLocalDate: `${dayAfter(dayToCheck, 1)}T00:00:00`,
+      timeZone,
+      limit: 1,
+      includeResourceTypeIds,
+    });
+    if (!slots.length) break; // a gap — every longer option is unbookable too
+    if (days >= duration.min) out.push({ days, localEndDate: `${dayAfter(startDay, days)}T00:00:00` });
+  }
+  return out;
+}
+
+/**
+ * The price for a chosen length, from the server.
+ *
+ * ⚠️ Never compute this client-side. A rental is charged as a RATE — per hour or per day — and
+ * hourly is calculated at per-minute granularity, so a 90-minute rental of a $10/hour room is
+ * $15. Multiplying a displayed base price by a rounded number of hours quietly disagrees with
+ * what the customer is charged at checkout.
+ *
+ * ⚠️ Omitting the local dates or the time zone does NOT error — it returns a duration-blind
+ * price, which is the same trap in a quieter form.
+ * https://dev.wix.com/docs/api-reference/business-solutions/bookings/pricing/pricing-api/preview-price.md
+ * @param {string} serviceId
+ * @param {{ localStartDate: string, localEndDate: string, timeZone: string, numberOfParticipants?: number }} options
+ * @returns {Promise<{ total: string, currency: string|null, raw: object }>}
+ */
+export async function previewRentalPrice(serviceId, { localStartDate, localEndDate, timeZone, numberOfParticipants = 1 } = {}) {
+  if (!localStartDate || !localEndDate || !timeZone) {
+    throw new Error("previewRentalPrice requires localStartDate, localEndDate and timeZone — without them the price ignores the duration.");
+  }
+  const res = await wixApiRequest("/bookings/v2/pricing/v2/pricing/preview", {
+    method: "POST",
+    body: {
+      bookingLineItems: [{ serviceId, localStartDate, localEndDate, timeZone, numberOfParticipants }],
+    },
+  });
+  const info = res?.priceInfo ?? {};
+  const total = info.totalPrice ?? info.total ?? {};
+  return {
+    total: total.formattedValue ?? (total.value != null ? String(total.value) : ""),
+    currency: total.currency ?? null,
+    raw: info,
+  };
+}
+
+/**
+ * A rental's rate, ready to render — "$10 / hour" or "$120 / day".
+ * `servicePriceLabel` in `lib/serviceFacts.js` renders the same number as a flat price, which
+ * reads as the whole cost of the rental rather than its rate.
+ * @param {object} service
+ * @returns {string}
+ */
+export function rentalRateLabel(service) {
+  const duration = rentalDuration(service);
+  if (!duration) return "";
+  const price = service?.payment?.fixed?.price;
+  const money =
+    price?.formattedValue ||
+    (price?.currency && price?.value != null
+      ? new Intl.NumberFormat(undefined, { style: "currency", currency: price.currency }).format(Number(price.value))
+      : "");
+  if (!money) return "";
+  return `${money} / ${duration.unit === "DAY" ? "day" : "hour"}`;
+}

package/skills/wix-vibe-headless/references/bookings/app/rest/wix-bookings-services.js

@@ -183,11 +183,13 @@ export async function countServices() {
  * If you render a mixed catalog, route by `service.type` via `listSlotsForService`.
  * Dates are LOCAL ("YYYY-MM-DDThh:mm:ss") in timeZone.
  * https://dev.wix.com/docs/api-reference/business-solutions/bookings/time-slots/time-slots-v2/list-availability-time-slots.md
+ * For a rental (a resource-driven service), pass its resource type id(s) as `includeResourceTypeIds`
+ * so the slots come back with their bookable resources; a staff appointment can omit it.
  * @param {string} serviceId
- * @param {{ fromLocalDate: string, toLocalDate: string, timeZone?: string, limit?: number, cursor?: string }} options
+ * @param {{ fromLocalDate: string, toLocalDate: string, timeZone?: string, limit?: number, cursor?: string, includeResourceTypeIds?: string[] }} options
  * @returns {Promise<{ slots: object[], nextCursor: string|null, timeZone: string|null }>}
  */
-export async function listAvailableSlots(serviceId, { fromLocalDate, toLocalDate, timeZone, limit = 1000, cursor } = {}) {
+export async function listAvailableSlots(serviceId, { fromLocalDate, toLocalDate, timeZone, limit = 1000, cursor, includeResourceTypeIds } = {}) {
   if (!cursor && (!fromLocalDate || !toLocalDate)) {
     throw new Error("listAvailableSlots requires fromLocalDate and toLocalDate (local 'YYYY-MM-DDThh:mm:ss').");
   }
@@ -200,6 +202,7 @@ export async function listAvailableSlots(serviceId, { fromLocalDate, toLocalDate
         toLocalDate,
         timeZone: timeZone || defaultTimeZone(),
         cursorPaging: { limit },
+        ...(includeResourceTypeIds?.length ? { includeResourceTypeIds } : {}),
       };
   const res = await wixApiRequest("/_api/service-availability/v2/time-slots", { method: "POST", body });
   return {
@@ -287,7 +290,11 @@ export async function listEventTimeSlots(serviceIds, { fromLocalDate, toLocalDat
 export async function listSlotsForService(service, options = {}) {
   const serviceId = service?._id || service?.id;
   if (!serviceId) throw new Error("listSlotsForService requires a service with an id.");
-  return service?.type === "CLASS" || service?.type === "COURSE"
-    ? listEventTimeSlots(serviceId, options)
-    : listAvailableSlots(serviceId, options);
+  if (service?.type === "CLASS" || service?.type === "COURSE") return listEventTimeSlots(serviceId, options);
+  // For a rental, name its resource type(s) so the slots come back; reading them off the service
+  // keeps this call type-agnostic (a staff appointment just yields an empty list here).
+  const includeResourceTypeIds =
+    options.includeResourceTypeIds ??
+    (service?.serviceResources ?? []).map((sr) => sr.resourceType?._id ?? sr.resourceType?.id).filter(Boolean);
+  return listAvailableSlots(serviceId, { ...options, includeResourceTypeIds });
 }

package/skills/wix-vibe-headless/references/bookings/seed/SEED.md

@@ -101,6 +101,47 @@ await seed.attachServiceImage(ctx, { serviceId: services[0].id, revision: servic
 Both bulk calls report per-item `success`/`error` — retry only the failed items **once** with the
 same body; don't loop and don't re-create the ones that already succeeded.
 
+## Rentals
+
+`seed-rentals.js` is the rentals half — the same transport, a different create order and payload.
+Wix Rentals has no APIs of its own, so a rental is a Bookings service with rentals-specific
+field values.
+
+```js
+const seed = require("…/references/bookings/seed/seed-rentals.js");
+await seed.setupRentals(ctx, {
+  resourceTypeName: "Meeting rooms",
+  resources: ["Room A", "Room B"],              // parallel capacity = MORE RESOURCES
+  rentals: [
+    { name: "Meeting room, hourly", description: "…", price: 25, unit: "HOUR", min: 60, max: 480 },
+    { name: "Meeting room, daily",  description: "…", price: 180, unit: "DAY", min: 1, max: 5 },
+  ],
+});
+// → { resourceType, resources, services, ok, problems }
+```
+
+`price` is a RATE — per hour or per day — not the cost of a rental.
+Hourly `min`/`max` are MINUTES (30–1440); daily are DAYS (1–8).
+
+**`ok` must be true.** `problems` is the read-back check: a service created without `appId` or
+without `durationRange` still returns 200 and is simply a plain Bookings service from then on.
+
+### The four traps this seed handles
+
+- **Install Rentals ONLY.** It provisions the Bookings infrastructure it runs on; installing
+  Wix Bookings as well is redundant.
+- **`appId` is immutable after create.** A service created without it is a plain Bookings
+  service forever — there is no update that converts it.
+- **Order is load-bearing: resource type → resources → services.** A service whose resource
+  type holds no resources has permanently empty availability, and nothing errors.
+- **Rental services do not use categories.** Unlike bookings, do not create or assign one.
+- **`serviceResources` is required** and the docs' Create Service parameter list omits it.
+  Without it the create fails `MISSING_APPOINTMENT_RESOURCES`, whose message sends you to check
+  the resource type's contents — a dead end, since it fails even when the type is populated.
+
+Resources are seeded **24/7** (no working hours) so a multi-day rental stays one booking rather
+than a multi-service group. Pass `workingHours` only when the brief names opening hours.
+
 ## Reference
 If a call returns a shape you didn't expect, or you need an operation this module doesn't cover,
 use the **`wix-docs`** skill to search + read the live Wix API reference — never guess. The