@jay-framework/wix-stores 0.15.0

package/dist/index.js

@@ -0,0 +1,1140 @@
+import { getCurrentCartClient } from "@jay-framework/wix-cart";
+import { WIX_CART_CONTEXT, WIX_CART_SERVICE, cartIndicator, cartPage, provideWixCartContext, provideWixCartService } from "@jay-framework/wix-cart";
+import { createJayService, makeJayQuery, ActionError, makeJayStackComponent, RenderPipeline, makeJayInit } from "@jay-framework/fullstack-component";
+import { inventoryItemsV3, productsV3 } from "@wix/stores";
+import { categories } from "@wix/categories";
+import { registerService, getService } from "@jay-framework/stack-server-runtime";
+import { createJayContext } from "@jay-framework/runtime";
+import "@jay-framework/component";
+import { WIX_CLIENT_SERVICE } from "@jay-framework/wix-server-client";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var CurrentSort = /* @__PURE__ */ ((CurrentSort2) => {
+  CurrentSort2[CurrentSort2["relevance"] = 0] = "relevance";
+  CurrentSort2[CurrentSort2["priceAsc"] = 1] = "priceAsc";
+  CurrentSort2[CurrentSort2["priceDesc"] = 2] = "priceDesc";
+  CurrentSort2[CurrentSort2["newest"] = 3] = "newest";
+  CurrentSort2[CurrentSort2["nameAsc"] = 4] = "nameAsc";
+  CurrentSort2[CurrentSort2["nameDesc"] = 5] = "nameDesc";
+  return CurrentSort2;
+})(CurrentSort || {});
+const instances = {
+  productsV3ClientInstance: void 0,
+  categoriesClientInstance: void 0,
+  inventoryV3ClientInstance: void 0
+};
+function getProductsV3Client(wixClient) {
+  if (!instances.productsV3ClientInstance) {
+    instances.productsV3ClientInstance = wixClient.use(productsV3);
+  }
+  return instances.productsV3ClientInstance;
+}
+function getCategoriesClient(wixClient) {
+  if (!instances.categoriesClientInstance) {
+    instances.categoriesClientInstance = wixClient.use(categories);
+  }
+  return instances.categoriesClientInstance;
+}
+function getInventoryClient(wixClient) {
+  if (!instances.inventoryV3ClientInstance) {
+    instances.inventoryV3ClientInstance = wixClient.use(inventoryItemsV3);
+  }
+  return instances.inventoryV3ClientInstance;
+}
+const WIX_STORES_SERVICE_MARKER = createJayService("Wix Store Service");
+function provideWixStoresService(wixClient, options) {
+  const service = {
+    products: getProductsV3Client(wixClient),
+    categories: getCategoriesClient(wixClient),
+    inventory: getInventoryClient(wixClient),
+    // Keep cart for backward compatibility, but prefer WIX_CART_SERVICE
+    cart: getCurrentCartClient(wixClient),
+    categoryPrefixes: options?.categoryPrefixes ?? []
+  };
+  registerService(WIX_STORES_SERVICE_MARKER, service);
+  return service;
+}
+var MediaType$1 = /* @__PURE__ */ ((MediaType2) => {
+  MediaType2[MediaType2["IMAGE"] = 0] = "IMAGE";
+  MediaType2[MediaType2["VIDEO"] = 1] = "VIDEO";
+  return MediaType2;
+})(MediaType$1 || {});
+var AvailabilityStatus = /* @__PURE__ */ ((AvailabilityStatus2) => {
+  AvailabilityStatus2[AvailabilityStatus2["IN_STOCK"] = 0] = "IN_STOCK";
+  AvailabilityStatus2[AvailabilityStatus2["OUT_OF_STOCK"] = 1] = "OUT_OF_STOCK";
+  AvailabilityStatus2[AvailabilityStatus2["PARTIALLY_OUT_OF_STOCK"] = 2] = "PARTIALLY_OUT_OF_STOCK";
+  return AvailabilityStatus2;
+})(AvailabilityStatus || {});
+var PreorderStatus = /* @__PURE__ */ ((PreorderStatus2) => {
+  PreorderStatus2[PreorderStatus2["ENABLED"] = 0] = "ENABLED";
+  PreorderStatus2[PreorderStatus2["DISABLED"] = 1] = "DISABLED";
+  PreorderStatus2[PreorderStatus2["PARTIALLY_ENABLED"] = 2] = "PARTIALLY_ENABLED";
+  return PreorderStatus2;
+})(PreorderStatus || {});
+var ProductType$1 = /* @__PURE__ */ ((ProductType2) => {
+  ProductType2[ProductType2["PHYSICAL"] = 0] = "PHYSICAL";
+  ProductType2[ProductType2["DIGITAL"] = 1] = "DIGITAL";
+  return ProductType2;
+})(ProductType$1 || {});
+var QuickAddType = /* @__PURE__ */ ((QuickAddType2) => {
+  QuickAddType2[QuickAddType2["SIMPLE"] = 0] = "SIMPLE";
+  QuickAddType2[QuickAddType2["SINGLE_OPTION"] = 1] = "SINGLE_OPTION";
+  QuickAddType2[QuickAddType2["NEEDS_CONFIGURATION"] = 2] = "NEEDS_CONFIGURATION";
+  return QuickAddType2;
+})(QuickAddType || {});
+var OptionRenderType$1 = /* @__PURE__ */ ((OptionRenderType2) => {
+  OptionRenderType2[OptionRenderType2["TEXT_CHOICES"] = 0] = "TEXT_CHOICES";
+  OptionRenderType2[OptionRenderType2["COLOR_SWATCH_CHOICES"] = 1] = "COLOR_SWATCH_CHOICES";
+  return OptionRenderType2;
+})(OptionRenderType$1 || {});
+var ChoiceType$1 = /* @__PURE__ */ ((ChoiceType2) => {
+  ChoiceType2[ChoiceType2["CHOICE_TEXT"] = 0] = "CHOICE_TEXT";
+  ChoiceType2[ChoiceType2["ONE_COLOR"] = 1] = "ONE_COLOR";
+  return ChoiceType2;
+})(ChoiceType$1 || {});
+function parseWixMediaUrl(url) {
+  if (!url) return null;
+  const match = url.match(
+    /^wix:(image|video|document|audio):\/\/v1\/([^/]+)\/([^#]+)(?:#(.*))?$/
+  );
+  if (!match) return null;
+  const [, type, mediaId, fileName, hashParams] = match;
+  const result = {
+    type,
+    mediaId,
+    fileName: decodeURIComponent(fileName)
+  };
+  if (hashParams) {
+    const params = new URLSearchParams(hashParams);
+    const originWidth = params.get("originWidth");
+    const originHeight = params.get("originHeight");
+    if (originWidth) result.originWidth = parseInt(originWidth, 10);
+    if (originHeight) result.originHeight = parseInt(originHeight, 10);
+    const posterUri = params.get("posterUri");
+    const posterWidth = params.get("posterWidth");
+    const posterHeight = params.get("posterHeight");
+    if (posterUri) result.posterUri = decodeURIComponent(posterUri);
+    if (posterWidth) result.posterWidth = parseInt(posterWidth, 10);
+    if (posterHeight) result.posterHeight = parseInt(posterHeight, 10);
+  }
+  return result;
+}
+function formatWixMediaUrl(_id, url, resize) {
+  const resizeFragment = resize ? `/v1/fit/w_${resize.w},h_${resize.h},q_90/file.jpg` : "";
+  if (url == null ? void 0 : url.startsWith("wix:")) {
+    const parsed = parseWixMediaUrl(url);
+    if (parsed) {
+      return `https://static.wixstatic.com/media/${parsed.mediaId}${resizeFragment}`;
+    }
+  }
+  if ((url == null ? void 0 : url.startsWith("http://")) || (url == null ? void 0 : url.startsWith("https://"))) {
+    return url;
+  }
+  if (_id) {
+    return `https://static.wixstatic.com/media/${_id}${resizeFragment}`;
+  }
+  return "";
+}
+function resolveProductPrefix(product, prefixConfig) {
+  if (!prefixConfig?.length || !product.allCategoriesInfo?.categories) {
+    return null;
+  }
+  const productCategoryIds = new Set(
+    product.allCategoriesInfo.categories.map((c) => c._id).filter(Boolean)
+  );
+  for (const { categoryId, prefix } of prefixConfig) {
+    if (productCategoryIds.has(categoryId)) {
+      return prefix;
+    }
+  }
+  return null;
+}
+function resolveProductPrefixConfig(product, prefixConfig) {
+  if (!prefixConfig?.length || !product.allCategoriesInfo?.categories) {
+    return null;
+  }
+  const productCategoryIds = new Set(
+    product.allCategoriesInfo.categories.map((c) => c._id).filter(Boolean)
+  );
+  for (const config of prefixConfig) {
+    if (productCategoryIds.has(config.categoryId)) {
+      return config;
+    }
+  }
+  return null;
+}
+function mapAvailabilityStatus(status) {
+  switch (status) {
+    case "OUT_OF_STOCK":
+      return AvailabilityStatus.OUT_OF_STOCK;
+    case "PARTIALLY_OUT_OF_STOCK":
+      return AvailabilityStatus.PARTIALLY_OUT_OF_STOCK;
+    default:
+      return AvailabilityStatus.IN_STOCK;
+  }
+}
+function mapPreorderStatus(status) {
+  switch (status) {
+    case "ENABLED":
+      return PreorderStatus.ENABLED;
+    case "PARTIALLY_ENABLED":
+      return PreorderStatus.PARTIALLY_ENABLED;
+    default:
+      return PreorderStatus.DISABLED;
+  }
+}
+function mapMediaType$1(mediaType) {
+  return mediaType === "VIDEO" ? MediaType$1.VIDEO : MediaType$1.IMAGE;
+}
+function mapProductType$1(productType) {
+  return productType === "DIGITAL" ? ProductType$1.DIGITAL : ProductType$1.PHYSICAL;
+}
+function isValidPrice(amount) {
+  if (!amount) return false;
+  const numAmount = parseFloat(amount);
+  return !isNaN(numAmount) && numAmount > 0;
+}
+function getQuickAddType(product) {
+  const optionCount = product.options?.length ?? 0;
+  const hasModifiers = (product.modifiers?.length ?? 0) > 0;
+  if (hasModifiers || optionCount > 1) {
+    return QuickAddType.NEEDS_CONFIGURATION;
+  }
+  if (optionCount === 1) {
+    return QuickAddType.SINGLE_OPTION;
+  }
+  return QuickAddType.SIMPLE;
+}
+function mapOptionRenderType(renderType) {
+  return renderType === "COLOR_SWATCH_CHOICES" ? OptionRenderType$1.COLOR_SWATCH_CHOICES : OptionRenderType$1.TEXT_CHOICES;
+}
+function mapChoiceType(choiceType) {
+  return choiceType === "ONE_COLOR" ? ChoiceType$1.ONE_COLOR : ChoiceType$1.CHOICE_TEXT;
+}
+function mapQuickOption(option, variantsInfo) {
+  if (!option) return null;
+  const optionId = option._id;
+  const choices = option.choicesSettings?.choices || [];
+  return {
+    _id: optionId,
+    name: option.name || "",
+    optionRenderType: mapOptionRenderType(option.optionRenderType),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    choices: choices.map((choice) => {
+      return {
+        choiceId: choice.choiceId,
+        name: choice.name || "",
+        choiceType: mapChoiceType(choice.choiceType),
+        colorCode: choice.colorCode || "",
+        inStock: choice.inStock,
+        isSelected: false
+      };
+    })
+  };
+}
+const DEFAULT_PRODUCT_PAGE_PATH = "/products";
+function mapProductToCard(product, productPagePath = DEFAULT_PRODUCT_PAGE_PATH, prefixConfig) {
+  const mainMedia = product.media?.main;
+  const slug = product.slug || "";
+  const matchedPrefix = prefixConfig?.length ? resolveProductPrefixConfig(product, prefixConfig) : null;
+  const productUrl = slug ? matchedPrefix ? `${productPagePath}/${matchedPrefix.prefix}/${slug}` : `${productPagePath}/${slug}` : "";
+  const firstVariant = product.variantsInfo?.variants?.[0];
+  const variantPrice = firstVariant?.price;
+  const actualAmount = variantPrice?.actualPrice?.amount || product.actualPriceRange?.minValue?.amount || "0";
+  const actualFormattedAmount = variantPrice?.actualPrice?.formattedAmount || product.actualPriceRange?.minValue?.formattedAmount || "";
+  const compareAtAmount = variantPrice?.compareAtPrice?.amount || product.compareAtPriceRange?.minValue?.amount;
+  const compareAtFormattedAmount = variantPrice?.compareAtPrice?.formattedAmount || product.compareAtPriceRange?.minValue?.formattedAmount || "";
+  const hasDiscount = isValidPrice(compareAtAmount) && compareAtAmount !== actualAmount;
+  return {
+    _id: product._id || "",
+    name: product.name || "",
+    slug,
+    productUrl,
+    categoryPrefix: matchedPrefix?.name ?? "",
+    mainMedia: {
+      url: mainMedia ? formatWixMediaUrl(mainMedia._id, mainMedia.url) : "",
+      altText: mainMedia?.altText || product.name || "",
+      mediaType: mapMediaType$1(mainMedia?.mediaType)
+    },
+    thumbnail: {
+      url: mainMedia ? formatWixMediaUrl(mainMedia._id, mainMedia.url, { w: 300, h: 300 }) : "",
+      altText: mainMedia?.altText || product.name || "",
+      width: 300,
+      height: 300
+    },
+    // Simplified price fields
+    price: actualFormattedAmount,
+    strikethroughPrice: hasDiscount ? compareAtFormattedAmount : "",
+    hasDiscount,
+    inventory: {
+      availabilityStatus: mapAvailabilityStatus(product.inventory?.availabilityStatus),
+      preorderStatus: mapPreorderStatus(product.inventory?.preorderStatus)
+    },
+    ribbon: {
+      _id: product.ribbon?._id || "",
+      name: product.ribbon?.name || ""
+    },
+    hasRibbon: !!product.ribbon?.name,
+    brand: {
+      _id: product.brand?._id || "",
+      name: product.brand?.name || ""
+    },
+    productType: mapProductType$1(product.productType),
+    isAddingToCart: false,
+    // Quick add behavior
+    quickAddType: getQuickAddType(product),
+    quickOption: getQuickAddType(product) === QuickAddType.SINGLE_OPTION ? mapQuickOption(product.options?.[0], product.variantsInfo) : null
+  };
+}
+const PRICE_BUCKET_BOUNDARIES = [
+  0,
+  20,
+  40,
+  100,
+  200,
+  400,
+  1e3,
+  2e3,
+  4e3,
+  1e4,
+  2e4,
+  4e4,
+  1e5
+];
+const PRICE_BUCKETS = PRICE_BUCKET_BOUNDARIES.slice(0, -1).map((from, i) => ({
+  from,
+  to: PRICE_BUCKET_BOUNDARIES[i + 1]
+}));
+PRICE_BUCKETS.push({ from: PRICE_BUCKET_BOUNDARIES[PRICE_BUCKET_BOUNDARIES.length - 1] });
+const searchProducts = makeJayQuery("wixStores.searchProducts").withServices(WIX_STORES_SERVICE_MARKER).withHandler(
+  async (input, wixStores) => {
+    const { query, filters = {}, sortBy = "relevance", cursor, pageSize = 12 } = input;
+    try {
+      const filterConditions = [
+        // Only visible products
+        { visible: { $eq: true } }
+      ];
+      const hasMinPrice = filters.minPrice !== void 0 && filters.minPrice > 0;
+      const hasMaxPrice = filters.maxPrice !== void 0 && filters.maxPrice > 0;
+      if (hasMinPrice) {
+        filterConditions.push({
+          "actualPriceRange.minValue.amount": { $gte: String(filters.minPrice) }
+        });
+      }
+      if (hasMaxPrice) {
+        filterConditions.push({
+          "actualPriceRange.minValue.amount": { $lte: String(filters.maxPrice) }
+        });
+      }
+      if (filters.inStockOnly) {
+        filterConditions.push({
+          "inventory.availabilityStatus": { $eq: "IN_STOCK" }
+        });
+      }
+      if (filters.categoryIds && filters.categoryIds.length > 0) {
+        filterConditions.push({
+          "allCategoriesInfo.categories.id": {
+            $hasAll: filters.categoryIds
+          }
+        });
+      }
+      const filter = filterConditions.length === 1 ? filterConditions[0] : { $and: filterConditions };
+      const sort = [];
+      switch (sortBy) {
+        case "price_asc":
+          sort.push({ fieldName: "actualPriceRange.minValue.amount", order: "ASC" });
+          break;
+        case "price_desc":
+          sort.push({ fieldName: "actualPriceRange.minValue.amount", order: "DESC" });
+          break;
+        case "name_asc":
+          sort.push({ fieldName: "name", order: "ASC" });
+          break;
+        case "name_desc":
+          sort.push({ fieldName: "name", order: "DESC" });
+          break;
+        case "newest":
+          sort.push({ fieldName: "_createdDate", order: "DESC" });
+          break;
+      }
+      const cursorPaging = cursor ? { cursor, limit: pageSize } : { limit: pageSize };
+      const hasSearchQuery = query && query.trim().length > 0;
+      const search = hasSearchQuery ? {
+        expression: query.trim(),
+        fields: ["name", "description"]
+      } : void 0;
+      const aggregations = [
+        // Total count via COUNT_DISTINCT on slug
+        {
+          fieldPath: "slug",
+          name: "total-count",
+          type: "SCALAR",
+          scalar: { type: "COUNT_DISTINCT" }
+        },
+        // Price buckets with product counts
+        {
+          fieldPath: "actualPriceRange.minValue.amount",
+          name: "price-buckets",
+          type: "RANGE",
+          range: { buckets: PRICE_BUCKETS }
+        },
+        // Min price for slider bound
+        {
+          fieldPath: "actualPriceRange.minValue.amount",
+          name: "min-price",
+          type: "SCALAR",
+          scalar: { type: "MIN" }
+        },
+        // Max price for slider bound
+        {
+          fieldPath: "actualPriceRange.minValue.amount",
+          name: "max-price",
+          type: "SCALAR",
+          scalar: { type: "MAX" }
+        }
+      ];
+      const searchResult = await wixStores.products.searchProducts(
+        {
+          filter,
+          // @ts-expect-error - Wix SDK types don't match actual API
+          sort: sort.length > 0 ? sort : void 0,
+          cursorPaging,
+          search,
+          // @ts-expect-error - Wix SDK types don't include aggregations
+          aggregations
+        },
+        {
+          fields: [
+            "CURRENCY",
+            "VARIANT_OPTION_CHOICE_NAMES",
+            ...wixStores.categoryPrefixes.length > 0 ? ["ALL_CATEGORIES_INFO"] : []
+          ]
+        }
+      );
+      const products = searchResult.products || [];
+      const nextCursor = searchResult.pagingMetadata?.cursors?.next || null;
+      const aggResults = searchResult.aggregationData?.results || [];
+      const totalCountAgg = aggResults.find((a) => a.name === "total-count")?.scalar;
+      const minPriceAgg = aggResults.find((a) => a.name === "min-price")?.scalar;
+      const maxPriceAgg = aggResults.find((a) => a.name === "max-price")?.scalar;
+      const totalCount = totalCountAgg?.value ?? products.length;
+      const bucketsAgg = aggResults.find((a) => a.name === "price-buckets").ranges;
+      const minBound = minPriceAgg?.value;
+      const maxBound = maxPriceAgg?.value;
+      const buckets = bucketsAgg.results || [];
+      const currencySymbol = products[0]?.currency === "ILS" ? "₪" : products[0]?.currency === "USD" ? "$" : products[0]?.currency === "EUR" ? "€" : products[0]?.currency === "GBP" ? "£" : "$";
+      const priceRanges = [
+        {
+          rangeId: "all",
+          label: "Show all",
+          minValue: null,
+          maxValue: null,
+          productCount: totalCount,
+          isSelected: true
+        }
+      ];
+      const bucketRanges = buckets.filter((bucket) => (bucket.count ?? 0) > 0).map((bucket) => {
+        const from = bucket.from ?? 0;
+        const to = bucket.to;
+        const label = to ? `${currencySymbol}${from} - ${currencySymbol}${to}` : `${currencySymbol}${from}+`;
+        return {
+          rangeId: `${from}-${to ?? "plus"}`,
+          label,
+          minValue: from,
+          maxValue: to ?? null,
+          productCount: bucket.count ?? 0,
+          isSelected: false
+        };
+      });
+      priceRanges.push(...bucketRanges);
+      const prefixConfig = wixStores.categoryPrefixes;
+      const mappedProducts = products.map(
+        (p) => mapProductToCard(p, "/products", prefixConfig)
+      );
+      return {
+        products: mappedProducts,
+        totalCount,
+        nextCursor,
+        hasMore: nextCursor !== null,
+        priceAggregation: {
+          minBound,
+          maxBound,
+          ranges: priceRanges
+        }
+      };
+    } catch (error) {
+      console.error("[wixStores.searchProducts] Search failed:", error);
+      throw new ActionError("SEARCH_FAILED", "Failed to search products");
+    }
+  }
+);
+const getProductBySlug = makeJayQuery("wixStores.getProductBySlug").withServices(WIX_STORES_SERVICE_MARKER).withCaching({ maxAge: 300, staleWhileRevalidate: 600 }).withHandler(
+  async (input, wixStores) => {
+    const { slug } = input;
+    if (!slug) {
+      throw new ActionError("INVALID_INPUT", "Product slug is required");
+    }
+    try {
+      const prefixConfig = wixStores.categoryPrefixes;
+      const fields = [
+        "MEDIA_ITEMS_INFO",
+        "VARIANT_OPTION_CHOICE_NAMES",
+        ...prefixConfig.length > 0 ? ["ALL_CATEGORIES_INFO"] : []
+      ];
+      const result = await wixStores.products.getProductBySlug(slug, {
+        fields: [...fields]
+      });
+      const product = result.product;
+      if (!product) {
+        return null;
+      }
+      return mapProductToCard(product, "/products", prefixConfig);
+    } catch (error) {
+      console.error("[wixStores.getProductBySlug] Failed to get product:", error);
+      return null;
+    }
+  }
+);
+const getCategories = makeJayQuery("wixStores.getCategories").withServices(WIX_STORES_SERVICE_MARKER).withCaching({ maxAge: 3600 }).withHandler(
+  async (_input, wixStores) => {
+    try {
+      const result = await wixStores.categories.queryCategories({
+        treeReference: {
+          appNamespace: "@wix/stores"
+        }
+      }).eq("visible", true).find();
+      return (result.items || []).map((cat) => ({
+        categoryId: cat._id || "",
+        categoryName: cat.name || ""
+      }));
+    } catch (error) {
+      console.error("[wixStores.getCategories] Failed to load categories:", error);
+      throw new ActionError("LOAD_FAILED", "Failed to load categories");
+    }
+  }
+);
+const PAGE_SIZE = 12;
+async function renderSlowlyChanging$2(props, wixStores) {
+  const Pipeline = RenderPipeline.for();
+  const categoryPrefix = props.category;
+  const categoryConfig = categoryPrefix ? wixStores.categoryPrefixes.find((c) => c.prefix === categoryPrefix) : null;
+  const baseCategoryId = categoryConfig?.categoryId ?? null;
+  return Pipeline.try(async () => {
+    let query = wixStores.categories.queryCategories({
+      treeReference: { appNamespace: "@wix/stores" }
+    }).eq("visible", true);
+    if (baseCategoryId) {
+      query = query.eq("parentCategory.id", baseCategoryId);
+    }
+    const categoriesResult = await query.find();
+    return categoriesResult.items || [];
+  }).recover((error) => {
+    console.error("Failed to load categories:", error);
+    return Pipeline.ok([]);
+  }).toPhaseOutput((categories2) => {
+    const categoryInfos = categories2.map((cat) => ({
+      categoryId: cat._id || "",
+      categoryName: cat.name || "",
+      categorySlug: cat.slug || ""
+    }));
+    return {
+      viewState: {
+        searchFields: "name,description,sku",
+        fuzzySearch: true,
+        emptyStateMessage: "Enter a search term to find products",
+        filters: {
+          categoryFilter: {
+            categories: categoryInfos
+          }
+        }
+      },
+      carryForward: {
+        searchFields: "name,description,sku",
+        fuzzySearch: true,
+        categories: categoryInfos,
+        baseCategoryId
+      }
+    };
+  });
+}
+async function renderFastChanging$1(props, slowCarryForward, _wixStores) {
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.try(async () => {
+    const baseCategoryIds = slowCarryForward.baseCategoryId ? [slowCarryForward.baseCategoryId] : [];
+    const result = await searchProducts({
+      query: "",
+      filters: baseCategoryIds.length > 0 ? { categoryIds: baseCategoryIds } : void 0,
+      pageSize: PAGE_SIZE
+    });
+    return result;
+  }).recover((error) => {
+    console.error("Failed to load products:", error);
+    return Pipeline.ok({
+      products: [],
+      totalCount: 0,
+      nextCursor: null,
+      hasMore: false,
+      priceAggregation: {
+        minBound: 0,
+        maxBound: 1e3,
+        ranges: [
+          {
+            rangeId: "all",
+            label: "Show all",
+            minValue: null,
+            maxValue: null,
+            productCount: 0,
+            isSelected: true
+          }
+        ]
+      }
+    });
+  }).toPhaseOutput((result) => {
+    const priceAgg = result.priceAggregation || {
+      minBound: 0,
+      maxBound: 1e3,
+      ranges: [
+        {
+          rangeId: "all",
+          label: "Show all",
+          minValue: null,
+          maxValue: null,
+          productCount: result.totalCount,
+          isSelected: true
+        }
+      ]
+    };
+    return {
+      viewState: {
+        searchExpression: "",
+        isSearching: false,
+        hasSearched: false,
+        searchResults: result.products,
+        resultCount: result.products.length,
+        hasResults: result.products.length > 0,
+        hasSuggestions: false,
+        suggestions: [],
+        filters: {
+          inStockOnly: false,
+          priceRange: {
+            // Initialize sliders to full range (bounds)
+            minPrice: priceAgg.minBound,
+            maxPrice: priceAgg.maxBound,
+            minBound: priceAgg.minBound,
+            maxBound: priceAgg.maxBound,
+            ranges: priceAgg.ranges
+          },
+          categoryFilter: {
+            categories: slowCarryForward.categories.map((cat) => ({
+              categoryId: cat.categoryId,
+              isSelected: false
+            }))
+          }
+        },
+        sortBy: {
+          currentSort: CurrentSort.relevance
+        },
+        hasMore: result.hasMore,
+        loadedCount: result.products.length,
+        totalCount: result.totalCount
+      },
+      carryForward: {
+        searchFields: slowCarryForward.searchFields,
+        fuzzySearch: slowCarryForward.fuzzySearch,
+        categories: slowCarryForward.categories,
+        baseCategoryId: slowCarryForward.baseCategoryId
+      }
+    };
+  });
+}
+const productSearch = makeJayStackComponent().withProps().withServices(WIX_STORES_SERVICE_MARKER).withSlowlyRender(renderSlowlyChanging$2).withFastRender(renderFastChanging$1);
+var ProductType = /* @__PURE__ */ ((ProductType2) => {
+  ProductType2[ProductType2["PHYSICAL"] = 0] = "PHYSICAL";
+  ProductType2[ProductType2["DIGITAL"] = 1] = "DIGITAL";
+  return ProductType2;
+})(ProductType || {});
+var StockStatus = /* @__PURE__ */ ((StockStatus2) => {
+  StockStatus2[StockStatus2["OUT_OF_STOCK"] = 0] = "OUT_OF_STOCK";
+  StockStatus2[StockStatus2["IN_STOCK"] = 1] = "IN_STOCK";
+  return StockStatus2;
+})(StockStatus || {});
+var OptionRenderType = /* @__PURE__ */ ((OptionRenderType2) => {
+  OptionRenderType2[OptionRenderType2["TEXT_CHOICES"] = 0] = "TEXT_CHOICES";
+  OptionRenderType2[OptionRenderType2["COLOR_SWATCH_CHOICES"] = 1] = "COLOR_SWATCH_CHOICES";
+  return OptionRenderType2;
+})(OptionRenderType || {});
+var ChoiceType = /* @__PURE__ */ ((ChoiceType2) => {
+  ChoiceType2[ChoiceType2["CHOICE_TEXT"] = 0] = "CHOICE_TEXT";
+  ChoiceType2[ChoiceType2["ONE_COLOR"] = 1] = "ONE_COLOR";
+  return ChoiceType2;
+})(ChoiceType || {});
+var ModifierType = /* @__PURE__ */ ((ModifierType2) => {
+  ModifierType2[ModifierType2["TEXT_CHOICES"] = 0] = "TEXT_CHOICES";
+  ModifierType2[ModifierType2["COLOR_SWATCH_CHOICES"] = 1] = "COLOR_SWATCH_CHOICES";
+  ModifierType2[ModifierType2["FREE_TEXT"] = 2] = "FREE_TEXT";
+  return ModifierType2;
+})(ModifierType || {});
+var ChoiceType = /* @__PURE__ */ ((ChoiceType2) => {
+  ChoiceType2[ChoiceType2["CHOICE_TEXT"] = 0] = "CHOICE_TEXT";
+  ChoiceType2[ChoiceType2["ONE_COLOR"] = 1] = "ONE_COLOR";
+  return ChoiceType2;
+})(ChoiceType || {});
+var Selected = /* @__PURE__ */ ((Selected2) => {
+  Selected2[Selected2["selected"] = 0] = "selected";
+  Selected2[Selected2["notSelected"] = 1] = "notSelected";
+  return Selected2;
+})(Selected || {});
+var MediaType = /* @__PURE__ */ ((MediaType2) => {
+  MediaType2[MediaType2["IMAGE"] = 0] = "IMAGE";
+  MediaType2[MediaType2["VIDEO"] = 1] = "VIDEO";
+  return MediaType2;
+})(MediaType || {});
+async function* loadProductParams([wixStores]) {
+  const prefixConfig = wixStores.categoryPrefixes;
+  const hasPrefixes = prefixConfig.length > 0;
+  const fields = hasPrefixes ? ["ALL_CATEGORIES_INFO"] : [];
+  try {
+    let result = await wixStores.products.queryProducts({ fields: [...fields] }).find();
+    yield result.items.map((product) => mapProductToParams(product, prefixConfig));
+    while (result.hasNext()) {
+      result = await result.next();
+      yield result.items.map((product) => mapProductToParams(product, prefixConfig));
+    }
+  } catch (error) {
+    console.error("Failed to load product slugs:", error);
+    yield [];
+  }
+}
+function mapProductToParams(product, prefixConfig) {
+  const prefix = resolveProductPrefix(product, prefixConfig);
+  return {
+    slug: product.slug ?? "",
+    ...prefix ? { category: prefix } : {}
+  };
+}
+function mapProductType(productType) {
+  return productType === "DIGITAL" ? ProductType.DIGITAL : ProductType.PHYSICAL;
+}
+function mapInfoSections(infoSections) {
+  return infoSections.map((infoSection) => ({
+    _id: infoSection._id,
+    plainDescription: infoSection.plainDescription || "",
+    title: infoSection.title || "",
+    uniqueName: infoSection.uniqueName || ""
+  }));
+}
+function mapSeoData(seoData) {
+  return {
+    tags: seoData?.tags?.map((tag, index) => ({
+      position: index.toString().padStart(2, "0"),
+      type: tag.type,
+      props: Object.entries(tag.props || {}).map(([key, value]) => ({ key, value })),
+      meta: Object.entries(tag.meta || {}).map(([key, value]) => ({ key, value })),
+      children: tag.children
+    })),
+    settings: {
+      preventAutoRedirect: seoData?.settings?.preventAutoRedirect || false,
+      keywords: seoData?.settings?.keywords.map((keyword) => ({
+        isMain: keyword.isMain,
+        origin: keyword.origin,
+        term: keyword.term
+      }))
+    }
+  };
+}
+function mapMediaType(mediaType) {
+  if (mediaType === "VIDEO")
+    return MediaType.VIDEO;
+  else
+    return MediaType.IMAGE;
+}
+function mapMedia(media) {
+  const mainMediaType = mapMediaType(media.main.mediaType);
+  return {
+    selectedMedia: {
+      url: formatWixMediaUrl(media.main._id, media.main.url),
+      mediaType: mainMediaType,
+      thumbnail_50x50: formatWixMediaUrl(media.main._id, media.main.url, { w: 50, h: 50 })
+    },
+    availableMedia: media.itemsInfo?.items?.map((item) => ({
+      mediaId: item._id,
+      media: {
+        url: formatWixMediaUrl(item._id, item.url),
+        mediaType: item.mediaType === "IMAGE" ? MediaType.IMAGE : MediaType.VIDEO,
+        thumbnail_50x50: formatWixMediaUrl(item._id, item.url, { w: 50, h: 50 })
+      },
+      selected: item._id === media.main._id ? Selected.selected : Selected.notSelected
+    })) ?? []
+  };
+}
+function mapOptionsToSlowVS(options) {
+  return options?.map((option) => ({
+    name: option.name,
+    optionRenderType: option.optionRenderType === "TEXT_CHOICES" ? OptionRenderType.TEXT_CHOICES : OptionRenderType.COLOR_SWATCH_CHOICES,
+    _id: option._id,
+    choices: option.choicesSettings?.choices?.map((choice) => ({
+      name: choice.name,
+      choiceId: choice.choiceId,
+      choiceType: choice.choiceType === "CHOICE_TEXT" ? ChoiceType.CHOICE_TEXT : ChoiceType.ONE_COLOR,
+      inStock: choice.inStock,
+      colorCode: choice.colorCode
+    })) ?? []
+  })) ?? [];
+}
+function mapOptionsToFastVS(options) {
+  return options?.map((option) => ({
+    _id: option._id,
+    textChoiceSelection: void 0,
+    choices: option.choicesSettings?.choices?.map((choice) => ({
+      choiceId: choice.choiceId,
+      isSelected: false
+    })) ?? []
+  })) ?? [];
+}
+function mapModifierType(modifierRenderType) {
+  switch (modifierRenderType) {
+    case "FREE_TEXT":
+      return ModifierType.FREE_TEXT;
+    case "TEXT_CHOICES":
+      return ModifierType.TEXT_CHOICES;
+    case "SWATCH_CHOICES":
+      return ModifierType.COLOR_SWATCH_CHOICES;
+    default:
+      return ModifierType.FREE_TEXT;
+  }
+}
+function mapModifierChoiceType(choiceType) {
+  if (choiceType === "ONE_COLOR")
+    return ChoiceType.ONE_COLOR;
+  else
+    return ChoiceType.CHOICE_TEXT;
+}
+function mapModifiersToSlowVS(modifiers) {
+  return modifiers?.map((modifier) => ({
+    name: modifier.name || modifier.freeTextSettings?.title || "",
+    _id: modifier._id,
+    modifierType: mapModifierType(modifier.modifierRenderType),
+    textInputLength: modifier.freeTextSettings?.maxCharCount,
+    textInputRequired: modifier.mandatory,
+    choices: modifier.choicesSettings?.choices?.map((choice) => ({
+      name: choice.name,
+      choiceId: choice.choiceId,
+      colorCode: choice.colorCode,
+      choiceType: mapModifierChoiceType(choice.choiceType)
+    })) ?? []
+  })) ?? [];
+}
+function mapModifiersToFastVS(modifiers) {
+  return modifiers?.map((modifier) => ({
+    _id: modifier._id,
+    textModifierSelection: void 0,
+    choices: modifier.choicesSettings?.choices?.map((choice) => ({
+      choiceId: choice.choiceId,
+      isSelected: false
+    })) ?? []
+  })) ?? [];
+}
+function mapVariants(variantsInfo) {
+  return variantsInfo?.variants.map((variant) => ({
+    _id: variant._id,
+    choices: variant.choices,
+    sku: variant.sku,
+    price: variant.price.actualPrice.formattedAmount,
+    inventoryStatus: variant.inventoryStatus.inStock ? StockStatus.IN_STOCK : StockStatus.OUT_OF_STOCK,
+    mediaId: variant.media?._id,
+    strikethroughPrice: variant.price.compareAtPrice?.formattedAmount || ""
+  })) || [];
+}
+async function renderSlowlyChanging$1(props, wixStores) {
+  const Pipeline = RenderPipeline.for();
+  const prefixConfig = wixStores.categoryPrefixes;
+  const hasPrefixes = prefixConfig.length > 0;
+  return Pipeline.try(async () => {
+    const fields = [
+      "INFO_SECTION",
+      "INFO_SECTION_PLAIN_DESCRIPTION",
+      "MEDIA_ITEMS_INFO",
+      "PLAIN_DESCRIPTION",
+      "CURRENCY",
+      ...hasPrefixes ? ["ALL_CATEGORIES_INFO"] : []
+    ];
+    const response = await wixStores.products.getProductBySlug(props.slug, {
+      fields: [...fields]
+    });
+    if (props.category && hasPrefixes) {
+      const actualPrefix = resolveProductPrefix(response.product, prefixConfig);
+      if (actualPrefix !== props.category) {
+        throw new Error("Category prefix mismatch");
+      }
+    }
+    return response;
+  }).recover((error) => {
+    console.log("product page error", error);
+    return Pipeline.clientError(404, "not found");
+  }).toPhaseOutput((getProductResponse) => {
+    const product = getProductResponse.product;
+    const { _id, name, plainDescription, options, modifiers, actualPriceRange, compareAtPriceRange, media, productType, brand, ribbon, infoSections, seoData, physicalProperties, inventory, variantsInfo } = product;
+    return {
+      viewState: {
+        _id,
+        productName: name || "",
+        description: plainDescription,
+        brand: brand?.name || "",
+        ribbon: ribbon?.name || "",
+        productType: mapProductType(productType),
+        options: mapOptionsToSlowVS(options),
+        infoSections: mapInfoSections(infoSections),
+        modifiers: mapModifiersToSlowVS(modifiers),
+        seoData: mapSeoData(seoData)
+      },
+      carryForward: {
+        productId: _id,
+        mediaGallery: mapMedia(media),
+        options: mapOptionsToFastVS(options),
+        modifiers: mapModifiersToFastVS(modifiers),
+        sku: "N/A not in API",
+        price: actualPriceRange?.minValue?.formattedAmount || "",
+        strikethroughPrice: actualPriceRange?.minValue?.amount !== product.compareAtPriceRange?.minValue?.amount ? compareAtPriceRange?.minValue?.formattedAmount || "" : "",
+        pricePerUnit: physicalProperties?.pricePerUnitRange?.minValue?.description,
+        stockStatus: inventory?.availabilityStatus === "IN_STOCK" ? StockStatus.IN_STOCK : StockStatus.OUT_OF_STOCK,
+        variants: mapVariants(variantsInfo)
+      }
+    };
+  });
+}
+async function renderFastChanging(props, slowCarryForward, wixStores) {
+  const Pipeline = RenderPipeline.for();
+  const isInStock = slowCarryForward.stockStatus === StockStatus.IN_STOCK;
+  return Pipeline.ok({
+    actionsEnabled: isInStock,
+    options: slowCarryForward.options,
+    modifiers: slowCarryForward.modifiers,
+    mediaGallery: slowCarryForward.mediaGallery,
+    sku: slowCarryForward.variants[0].sku,
+    price: slowCarryForward.variants[0].price,
+    pricePerUnit: slowCarryForward.pricePerUnit || "",
+    stockStatus: slowCarryForward.stockStatus,
+    strikethroughPrice: slowCarryForward.variants[0].strikethroughPrice,
+    quantity: { quantity: 1 }
+  }).toPhaseOutput((viewState) => ({
+    viewState,
+    carryForward: {
+      productId: slowCarryForward.productId,
+      variants: slowCarryForward.variants
+    }
+  }));
+}
+const productPage = makeJayStackComponent().withProps().withServices(WIX_STORES_SERVICE_MARKER).withLoadParams(loadProductParams).withSlowlyRender(renderSlowlyChanging$1).withFastRender(renderFastChanging);
+async function renderSlowlyChanging(props, wixStores) {
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.try(async () => {
+    const result = await wixStores.categories.queryCategories({
+      treeReference: {
+        appNamespace: "@wix/stores"
+      }
+    }).eq("visible", true).find();
+    return result.items || [];
+  }).recover((error) => {
+    console.error("Failed to load categories:", error);
+    return Pipeline.ok([]);
+  }).toPhaseOutput((categories2) => {
+    const categoryItems = categories2.map((cat) => ({
+      _id: cat._id || "",
+      name: cat.name || "",
+      slug: cat.slug || "",
+      description: cat.description || "",
+      productCount: cat.itemCounter || 0,
+      imageUrl: cat.media?.mainMedia?.url || ""
+    }));
+    return {
+      viewState: {
+        categories: categoryItems,
+        hasCategories: categoryItems.length > 0
+      },
+      carryForward: {}
+    };
+  });
+}
+const categoryList = makeJayStackComponent().withProps().withServices(WIX_STORES_SERVICE_MARKER).withSlowlyRender(renderSlowlyChanging);
+const WIX_STORES_CONTEXT = createJayContext();
+function loadWixStoresConfig() {
+  const configPath = path.join(process.cwd(), "config", ".wix-stores.yaml");
+  if (!fs.existsSync(configPath)) {
+    return { categoryPrefixes: [] };
+  }
+  const fileContents = fs.readFileSync(configPath, "utf8");
+  const raw = yaml.load(fileContents);
+  if (!raw) {
+    return { categoryPrefixes: [] };
+  }
+  const prefixes = [];
+  if (Array.isArray(raw.categoryPrefixes)) {
+    for (const entry of raw.categoryPrefixes) {
+      if (typeof entry.categoryId === "string" && typeof entry.prefix === "string") {
+        prefixes.push({
+          categoryId: entry.categoryId.trim(),
+          prefix: entry.prefix.trim(),
+          name: typeof entry.name === "string" ? entry.name.trim() : entry.prefix.trim()
+        });
+      }
+    }
+  }
+  return { categoryPrefixes: prefixes };
+}
+const init = makeJayInit().withServer(async () => {
+  console.log("[wix-stores] Initializing Wix Stores service...");
+  const wixClient = getService(WIX_CLIENT_SERVICE);
+  const storesConfig = loadWixStoresConfig();
+  provideWixStoresService(wixClient, {
+    categoryPrefixes: storesConfig.categoryPrefixes
+  });
+  if (storesConfig.categoryPrefixes.length > 0) {
+    console.log(`[wix-stores] Category prefixes configured: ${storesConfig.categoryPrefixes.map((p) => p.prefix).join(", ")}`);
+  }
+  console.log("[wix-stores] Server initialization complete");
+  return {
+    enableClientCart: true,
+    enableClientSearch: true
+  };
+});
+const CONFIG_FILE_NAME = ".wix-stores.yaml";
+const CONFIG_TEMPLATE = `# Wix Stores Configuration
+#
+# Category Prefixes (optional):
+# Maps root Wix categories to URL prefix slugs.
+# Products under a root category get URLs like /products/{prefix}/{product-slug}
+# Each prefix gets its own search/listing page and product page templates.
+#
+# To find category IDs, use: jay-stack action wix-stores/getCategories
+#
+# categoryPrefixes:
+#   - categoryId: "<root-category-id>"
+#     prefix: "<url-prefix>"
+#     name: "<display-name>"
+#   - categoryId: "<another-root-category-id>"
+#     prefix: "<another-url-prefix>"
+#     name: "<another-display-name>"
+`;
+async function setupWixStores(ctx) {
+  if (ctx.initError) {
+    return {
+      status: "error",
+      message: `Service init failed (is wix-server-client configured?). ${ctx.initError.message}`
+    };
+  }
+  try {
+    getService(WIX_STORES_SERVICE_MARKER);
+  } catch {
+    return {
+      status: "error",
+      message: "WixStoresService not available. Run setup for wix-server-client first."
+    };
+  }
+  const configPath = path.join(ctx.configDir, CONFIG_FILE_NAME);
+  const configCreated = [];
+  if (!fs.existsSync(configPath)) {
+    if (!fs.existsSync(ctx.configDir)) {
+      fs.mkdirSync(ctx.configDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, CONFIG_TEMPLATE, "utf-8");
+    configCreated.push(`config/${CONFIG_FILE_NAME}`);
+  }
+  const service = getService(WIX_STORES_SERVICE_MARKER);
+  const prefixCount = service.categoryPrefixes.length;
+  const message = prefixCount > 0 ? `Wix Stores configured with ${prefixCount} category prefix(es): ${service.categoryPrefixes.map((p) => p.prefix).join(", ")}` : "Wix Stores service verified";
+  return {
+    status: "configured",
+    message,
+    ...configCreated.length > 0 ? { configCreated } : {}
+  };
+}
+async function generateWixStoresReferences(ctx) {
+  if (ctx.initError) {
+    throw new Error(`init failed: ${ctx.initError.message}`);
+  }
+  let storesService;
+  try {
+    storesService = getService(WIX_STORES_SERVICE_MARKER);
+  } catch {
+    throw new Error("WixStoresService not available. Run jay-stack setup first.");
+  }
+  fs.mkdirSync(ctx.referencesDir, { recursive: true });
+  const allCategories = [];
+  let result = await storesService.categories.queryCategories({
+    treeReference: { appNamespace: "@wix/stores" }
+  }).eq("visible", true).limit(100).find();
+  allCategories.push(...result.items || []);
+  while (result.hasNext()) {
+    result = await result.next();
+    allCategories.push(...result.items || []);
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const cat of allCategories) {
+    if (!cat._id) continue;
+    nodeMap.set(cat._id, {
+      _id: cat._id,
+      name: cat.name || "",
+      slug: cat.slug || "",
+      productCount: cat.itemCounter || 0,
+      children: []
+    });
+  }
+  const roots = [];
+  for (const cat of allCategories) {
+    if (!cat._id) continue;
+    const node = nodeMap.get(cat._id);
+    const parentId = cat.parentCategory?._id;
+    if (parentId && nodeMap.has(parentId)) {
+      nodeMap.get(parentId).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  const prefixConfig = storesService.categoryPrefixes;
+  const configuredPrefixes = prefixConfig.map((p) => ({
+    categoryId: p.categoryId,
+    prefix: p.prefix,
+    name: p.name,
+    categoryName: nodeMap.get(p.categoryId)?.name ?? "unknown"
+  }));
+  const categoriesPath = path.join(ctx.referencesDir, "categories.yaml");
+  fs.writeFileSync(
+    categoriesPath,
+    yaml.dump(
+      {
+        _generated: (/* @__PURE__ */ new Date()).toISOString(),
+        _description: "Wix Stores category tree for agent discovery. Shows category hierarchy, IDs, product counts, and configured URL prefixes.",
+        totalCategories: allCategories.length,
+        configuredPrefixes: configuredPrefixes.length > 0 ? configuredPrefixes : void 0,
+        categoryTree: roots
+      },
+      { indent: 2, lineWidth: 120, noRefs: true }
+    ),
+    "utf-8"
+  );
+  return {
+    referencesCreated: [`agent-kit/references/${ctx.pluginName}/categories.yaml`],
+    message: `${allCategories.length} categories (${roots.length} root)`
+  };
+}
+export {
+  WIX_CART_CONTEXT,
+  WIX_CART_SERVICE,
+  WIX_STORES_CONTEXT,
+  WIX_STORES_SERVICE_MARKER,
+  cartIndicator,
+  cartPage,
+  categoryList,
+  generateWixStoresReferences,
+  getCategories,
+  getProductBySlug,
+  init,
+  productPage,
+  productSearch,
+  provideWixCartContext,
+  provideWixCartService,
+  provideWixStoresService,
+  searchProducts,
+  setupWixStores
+};