@wix/ditto-codegen-public 1.0.55 → 1.0.56

package/dist/out.js

@@ -121273,7 +121273,7 @@ var require_planner = __commonJS({
 <WIXCLI_PLANNER_SYSTEM_PROMPT>
 ${(0, data_1.cmsPlannerPrompt)()}
 
-${hasBackendApiExtensions ? (0, apiSpec_1.apiSpecPrompt)() : "No backend API extensions in the blueprint, return an empty object: {}"}
+${hasBackendApiExtensions ? (0, apiSpec_1.apiSpecPrompt)() : "No backend API extensions in the blueprint, don't return anything for apiSpec"}
 
 ${hasEmbeddedScriptExtensions ? (0, dynamicParameters_1.dynamicParametersPrompt)() : 'No embeddedScriptParameters needed, no embedded scripts in the blueprint, return an empty array: "embeddedScriptParameters": []'}
 </WIXCLI_PLANNER_SYSTEM_PROMPT>
@@ -123279,7 +123279,7 @@ var require_PlannerAgent = __commonJS({
     exports2.PlannerOutputSchema = zod_1.z.object({
       collections: zod_1.z.array(CMSAgent_1.CmsCollectionSchema).default([]).describe("CMS collections to be created for the app"),
       embeddedScriptParameters: zod_1.z.array(EmbeddedScriptSchema_1.EmbeddedScriptParametersSchema).default([]).describe("Dynamic parameters for embedded script extensions (empty array if no embedded scripts)"),
-      apiSpec: ApiSpecSchema_1.ApiSpecSchema.optional().describe("API specification for the app")
+      apiSpec: ApiSpecSchema_1.ApiSpecSchema.optional().describe("API specification for the app, don't return anything if no backend API extensions")
     });
     var PlannerAgent = class {
       constructor(apiKey) {
@@ -128154,90 +128154,1142 @@ export default withDashboard(CollectionPage);
   }
 });
 
-// dist/system-prompts/embeddedScript/embededScript.js
-var require_embededScript = __commonJS({
-  "dist/system-prompts/embeddedScript/embededScript.js"(exports2) {
+// dist/system-prompts/SDK/ecom/cart.js
+var require_cart = __commonJS({
+  "dist/system-prompts/SDK/ecom/cart.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.embeddedScriptPrompt = void 0;
-    var embeddedScriptPrompt = (hasDynamicParameters) => {
-      return `
-<WIXCLI_EMBEDDED_SCRIPT_SYSTEM_PROMPT>
+    exports2.cartPrompt = void 0;
+    var cartPrompt = () => `
+<ecom_cart_docs>
+
+<description>
+This is a comprehensive reference guide for the Wix Ecom Current Cart SDK.
+The cart is the first phase of a purchase, followed by checkout, then order.
+The current cart is the cart that is currently being used by the site visitor or logged-in member.
+
+CRITICAL FOR EMBEDDED SCRIPTS:
+- Embedded scripts MUST use the @wix/ecom SDK directly - DO NOT create fetch() calls to arbitrary API endpoints
+- Import the currentCart module from '@wix/ecom' directly in your embedded script
+- NEVER create fetch() calls to /api/* endpoints for cart operations unless those endpoints are explicitly defined in the API spec
+- Use currentCart.getCurrentCart() and other cart methods directly in embedded script code
+</description>
+
+<introduction>
+# About the eCommerce Current Cart API
+
+A cart holds information about purchased items, prices, discounts, site details, buyer IDs (contact and member/visitor) and more.
+
+With the eCommerce Cart API you can:
+- Get the current cart
+- Add items to the current cart
+- Create a checkout from the current cart
+- Estimate the price totals for the current cart
+- Update the properties of the current cart
+- Update the quantity of line items in the current cart
+- Remove a coupon from the current cart
+- Remove line items from the current cart
+- Delete the current cart
+
+You can also listen for events when a cart is created, updated, and deleted.
+
+</introduction>
+
+<type_signatures>
+# Method Signatures & Types
+
+## getCurrentCart()
+\`\`\`typescript
+function getCurrentCart(): Promise<Cart>
+\`\`\`
+**Returns:** Promise<Cart> - The current visitor's cart object
+
+## addToCurrentCart(options)
+\`\`\`typescript
+function addToCurrentCart(options: AddToCurrentCartOptions): Promise<AddToCartResponse>
+
+interface AddToCurrentCartOptions {
+  lineItems?: Array<{
+    catalogReference: {
+      appId: string;           // Required
+      catalogItemId: string;   // Required
+      options?: Record<string, any>;
+    };
+    quantity: number;          // Required
+    catalogOverrideFields?: object;
+    extendedFields?: object;
+  }>;
+  customLineItems?: Array<CustomLineItem>;
+  businessLocationId?: string;
+}
+\`\`\`
+**Returns:** Promise<{cart: Cart}> - Response containing the updated cart
+
+## createCheckoutFromCurrentCart(options)
+\`\`\`typescript
+function createCheckoutFromCurrentCart(options: CreateCheckoutFromCurrentCartOptions): Promise<CreateCheckoutResponse>
+
+interface CreateCheckoutFromCurrentCartOptions {
+  channelType: ChannelType;  // Required: "WEB", "POS", "EBAY", etc.
+  email?: string;
+  shippingAddress?: Address;
+  billingAddress?: Address;
+  selectedShippingOption?: SelectedShippingOption;
+}
+\`\`\`
+**Returns:** Promise<{checkoutId: string}> - The created checkout ID
+
+## estimateCurrentCartTotals(options)
+\`\`\`typescript
+function estimateCurrentCartTotals(options?: EstimateCurrentCartTotalsOptions): Promise<EstimateTotalsResponse>
+
+interface EstimateCurrentCartTotalsOptions {
+  selectedShippingOption?: SelectedShippingOption;
+  shippingAddress?: Address;
+  billingAddress?: Address;
+  calculateShipping?: boolean;   // Default: true
+  calculateTax?: boolean;         // Default: true
+  selectedMemberships?: SelectedMemberships;
+}
+\`\`\`
+**Returns:** Promise<EstimateTotalsResponse> - Price totals, shipping info, tax summary
+
+## updateCurrentCart(options)
+\`\`\`typescript
+function updateCurrentCart(options: UpdateCurrentCartOptions): Promise<Cart>
+
+interface UpdateCurrentCartOptions {
+  cartInfo?: {
+    buyerNote?: string;
+    buyerInfo?: BuyerInfo;
+    contactInfo?: AddressWithContact;
+    selectedShippingOption?: SelectedShippingOption;
+    extendedFields?: ExtendedFields;
+    businessLocationId?: string;
+    overrideCheckoutUrl?: string;
+  };
+  lineItems?: Array<LineItem>;
+  customLineItems?: Array<CustomLineItem>;
+  couponCode?: string;
+}
+\`\`\`
+**Returns:** Promise<Cart> - The updated cart object
+
+## updateCurrentCartLineItemQuantity(lineItems)
+\`\`\`typescript
+function updateCurrentCartLineItemQuantity(lineItems: Array<LineItemQuantityUpdate>): Promise<UpdateLineItemsQuantityResponse>
+
+interface LineItemQuantityUpdate {
+  _id: string;      // Required: Line item ID
+  quantity: number; // Required: New quantity (min: 1)
+}
+\`\`\`
+**Returns:** Promise<{cart: Cart}> - Response containing the updated cart
+
+## removeCouponFromCurrentCart()
+\`\`\`typescript
+function removeCouponFromCurrentCart(): Promise<RemoveCouponResponse>
+\`\`\`
+**Returns:** Promise<{cart: Cart}> - Response containing the updated cart
+
+## removeLineItemsFromCurrentCart(lineItemIds)
+\`\`\`typescript
+function removeLineItemsFromCurrentCart(lineItemIds: Array<string>): Promise<RemoveLineItemsResponse>
+\`\`\`
+**Parameters:**
+- lineItemIds: Array<string> - Required. IDs of line items to remove
+
+**Returns:** Promise<{cart: Cart}> - Response containing the updated cart
+
+## deleteCurrentCart()
+\`\`\`typescript
+function deleteCurrentCart(): Promise<void>
+\`\`\`
+**Returns:** Promise<void> - No return value
+
+## Event Handlers
+
+### onCartCreated(handler)
+\`\`\`typescript
+function onCartCreated(handler: (event: CartEvent) => void): void
+
+interface CartEvent {
+  entity: Cart;
+  metadata: EventMetadata;
+}
+\`\`\`
+
+### onCartUpdated(handler)
+\`\`\`typescript
+function onCartUpdated(handler: (event: CartEvent) => void): void
+\`\`\`
+
+### onCartDeleted(handler)
+\`\`\`typescript
+function onCartDeleted(handler: (event: DeletedCartEvent) => void): void
+
+interface DeletedCartEvent {
+  metadata: {
+    entityId: string;
+    eventTime: string;
+  };
+}
+\`\`\`
+
+## Common Types
+
+### Cart Object
+\`\`\`typescript
+interface Cart {
+  _id: string;
+  _createdDate: Date;
+  _updatedDate: Date;
+  lineItems: Array<LineItem>;
+  buyerInfo?: BuyerInfo;
+  currency: string;
+  conversionCurrency: string;
+  paymentCurrency: string;
+  subtotal: MultiCurrencyPrice;
+  appliedDiscounts?: Array<CartDiscount>;
+  taxIncludedInPrices: boolean;
+  weightUnit: "KG" | "LB";
+  buyerLanguage: string;
+  siteLanguage: string;
+  checkoutId?: string;
+  purchaseFlowId: string;
+  // ... additional fields
+}
+\`\`\`
+
+### LineItem Object
+\`\`\`typescript
+interface LineItem {
+  _id: string;
+  quantity: number;
+  catalogReference: {
+    appId: string;
+    catalogItemId: string;
+    options?: Record<string, any>;
+  };
+  productName: {
+    original: string;
+    translated?: string;
+  };
+  price: MultiCurrencyPrice;
+  fullPrice: MultiCurrencyPrice;
+  priceBeforeDiscounts: MultiCurrencyPrice;
+  lineItemPrice: MultiCurrencyPrice;
+  image?: string;
+  url?: string;
+  availability?: ItemAvailabilityInfo;
+  physicalProperties?: PhysicalProperties;
+  itemType: ItemType;
+  // ... additional fields
+}
+\`\`\`
+
+### Address Object
+\`\`\`typescript
+interface Address {
+  addressLine1?: string;
+  addressLine2?: string;
+  city?: string;
+  country?: string;  // ISO-3166 alpha-2 format
+  subdivision?: string; // ISO 3166-2 format
+  postalCode?: string;
+  streetAddress?: {
+    name?: string;
+    number?: string;
+  };
+}
+\`\`\`
+
+### MultiCurrencyPrice Object
+\`\`\`typescript
+interface MultiCurrencyPrice {
+  amount: string;
+  convertedAmount: string;
+  formattedAmount: string;
+  formattedConvertedAmount: string;
+}
+\`\`\`
+
+### CartDiscount Object
+\`\`\`typescript
+interface CartDiscount {
+  coupon?: {
+    _id: string;
+    code: string;
+  };
+  merchantDiscount?: {
+    amount: MultiCurrencyPrice;
+  };
+}
+\`\`\`
+
+### BuyerInfo Object
+\`\`\`typescript
+interface BuyerInfo {
+  contactId?: string;
+  email?: string;
+  memberId?: string;    // If buyer is a site member
+  userId?: string;      // If buyer is a Wix user
+  visitorId?: string;   // If buyer is not a site member
+}
+\`\`\`
+
+**Getting User ID:**
+To get the user's ID, use \`getCurrentCart()\` and access the \`buyerInfo\` object. The user will have one of three ID types:
+- \`buyerInfo.memberId\` - Present when the buyer is a logged-in site member
+- \`buyerInfo.userId\` - Present when the buyer is a Wix user (cart owner)
+- \`buyerInfo.visitorId\` - Present when the buyer is an anonymous visitor (not logged in)
+
+Example:
+\`\`\`javascript
+const cart = await currentCart.getCurrentCart();
+const userId = cart.buyerInfo?.memberId || cart.buyerInfo?.userId || cart.buyerInfo?.visitorId;
+\`\`\`
+
+### ItemAvailabilityInfo Object
+\`\`\`typescript
+interface ItemAvailabilityInfo {
+  status: "AVAILABLE" | "NOT_AVAILABLE" | "NOT_FOUND" | "PARTIALLY_AVAILABLE";
+  quantityAvailable?: number;
+}
+\`\`\`
+
+### PhysicalProperties Object
+\`\`\`typescript
+interface PhysicalProperties {
+  sku?: string;
+  shippable?: boolean;
+  weight?: number;  // Measurement unit matches weightUnit in cart
+}
+\`\`\`
+
+### ItemType Object
+\`\`\`typescript
+interface ItemType {
+  preset?: "PHYSICAL" | "DIGITAL" | "GIFT_CARD" | "SERVICE" | "UNRECOGNISED";
+  custom?: string;  // Custom type when preset is not suitable
+}
+\`\`\`
+
+### ProductName Object
+\`\`\`typescript
+interface ProductName {
+  original: string;    // Required - in site's default language
+  translated?: string; // Translated into buyer's language
+}
+\`\`\`
+
+### DescriptionLine Object
+\`\`\`typescript
+interface DescriptionLine {
+  name: {
+    original: string;
+    translated?: string;
+  };
+  colorInfo?: {
+    original: string;
+    translated?: string;
+    code: string;  // HEX or RGB color code
+  };
+  plainText?: {
+    original: string;
+    translated?: string;
+  };
+  lineType?: string;
+}
+\`\`\`
+
+### SelectedShippingOption Object
+\`\`\`typescript
+interface SelectedShippingOption {
+  carrierId?: string;
+  code?: string;  // e.g., "usps_std_overnight"
+}
+\`\`\`
+
+### AddressWithContact Object
+\`\`\`typescript
+interface AddressWithContact {
+  address?: Address;
+  contactDetails?: {
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    company?: string;
+    vatId?: {
+      _id?: string;
+      type?: "CPF" | "CNPJ" | "UNSPECIFIED";  // For Brazil only
+    };
+  };
+}
+\`\`\`
+
+### ExtendedFields Object
+\`\`\`typescript
+interface ExtendedFields {
+  namespaces?: Record<string, any>;  // App-specific extended field data
+}
+\`\`\`
+
+### CustomLineItem Object
+\`\`\`typescript
+interface CustomLineItem {
+  _id?: string;  // Auto-generated if not provided
+  productName: ProductName;  // Required
+  price: string;             // Required - number or decimal without symbols
+  itemType: ItemType;        // Required
+  quantity?: number;         // Min: 1, Max: 100000
+  catalogReference?: CatalogReference;
+  descriptionLines?: Array<DescriptionLine>;
+  media?: string;  // Image from Wix media manager
+  url?: string;
+  fullPrice?: string;
+  quantityAvailable?: number;
+  physicalProperties?: PhysicalProperties;
+  deliveryProfileId?: string;
+  taxGroupId?: string;
+  membersOnly?: boolean;
+  paymentOption?: PaymentOptionType;
+  depositAmount?: string;
+  // ... additional fields
+}
+\`\`\`
+
+### CatalogReference Object
+\`\`\`typescript
+interface CatalogReference {
+  appId: string;         // Required
+  catalogItemId: string; // Required
+  options?: Record<string, any>;  // Additional item details
+}
+\`\`\`
+
+### PaymentOptionType
+\`\`\`typescript
+type PaymentOptionType =
+  | "FULL_PAYMENT_ONLINE"    // Entire payment during checkout
+  | "FULL_PAYMENT_OFFLINE"   // Payment after checkout (cash, check, etc.)
+  | "MEMBERSHIP"             // Charged to membership
+  | "MEMBERSHIP_OFFLINE"     // Membership, manually redeemed by admin
+  | "DEPOSIT_ONLINE"         // Partial payment upfront
+  | "MEMBERSHIP_ONLINE_WITH_OFFLINE_REMAINDER";  // Membership + offline remainder
+\`\`\`
+
+### ChannelType
+\`\`\`typescript
+type ChannelType =
+  | "WEB"                    // Web client
+  | "POS"                    // Point of sale
+  | "EBAY"                   // eBay shop
+  | "AMAZON"                 // Amazon shop
+  | "FACEBOOK"               // Facebook shop
+  | "WIX_APP_STORE"          // Wix Owner app
+  | "BACKOFFICE_MERCHANT"    // Wix merchant backoffice
+  | "OTHER_PLATFORM";        // Other platform
+\`\`\`
+
+### ModifierGroup Object
+\`\`\`typescript
+interface ModifierGroup {
+  _id?: string;
+  name?: {
+    original: string;
+    translated?: string;
+  };
+  modifiers?: Array<{
+    _id?: string;
+    label?: {
+      original: string;
+      translated?: string;
+    };
+    price?: MultiCurrencyPrice;
+    quantity?: number;
+    details?: {
+      original: string;
+      translated?: string;
+    };
+  }>;
+}
+\`\`\`
+
+### SelectedMembership Object
+\`\`\`typescript
+interface SelectedMembership {
+  _id: string;   // Required - Membership GUID
+  appId: string; // Required - App GUID providing this payment option
+}
+\`\`\`
+
+### ServiceProperties Object
+\`\`\`typescript
+interface ServiceProperties {
+  numberOfParticipants?: number;  // Number of people (class size, hotel room, etc.)
+  scheduledDate?: Date;           // ISO-8601 format - when service is provided
+}
+\`\`\`
+
+### EstimateTotalsResponse Object
+\`\`\`typescript
+interface EstimateTotalsResponse {
+  cart: Cart;
+  calculatedLineItems: Array<{
+    lineItemId: string;
+    pricesBreakdown: LineItemPricesData;
+    paymentOption?: PaymentOptionType;
+    taxableAddress?: TaxableAddress;
+  }>;
+  priceSummary: PriceSummary;
+  shippingInfo?: ShippingInformation;
+  taxSummary?: TaxSummary;
+  appliedDiscounts?: Array<AppliedDiscount>;
+  additionalFees?: Array<AdditionalFee>;
+  calculationErrors?: CalculationErrors;
+  membershipOptions?: MembershipOptions;
+  currency: string;
+  weightUnit: "KG" | "LB";
+  // ... additional fields
+}
+\`\`\`
+
+### PriceSummary Object
+\`\`\`typescript
+interface PriceSummary {
+  subtotal: MultiCurrencyPrice;
+  shipping?: MultiCurrencyPrice;
+  tax?: MultiCurrencyPrice;
+  discount?: MultiCurrencyPrice;
+  total: MultiCurrencyPrice;
+  additionalFees?: MultiCurrencyPrice;
+}
+\`\`\`
+
+### TaxSummary Object
+\`\`\`typescript
+interface TaxSummary {
+  taxableAmount?: MultiCurrencyPrice;
+  totalTax?: MultiCurrencyPrice;
+}
+\`\`\`
+
+### ShippingInformation Object
+\`\`\`typescript
+interface ShippingInformation {
+  region?: {
+    _id: string;
+    name: string;
+  };
+  selectedCarrierServiceOption?: {
+    carrierId: string;
+    code: string;
+    title: string;
+    cost: {
+      price: MultiCurrencyPrice;
+      totalPriceBeforeTax: MultiCurrencyPrice;
+      totalPriceAfterTax: MultiCurrencyPrice;
+      taxDetails?: ItemTaxFullDetails;
+      totalDiscount?: MultiCurrencyPrice;
+    };
+    logistics?: DeliveryLogistics;
+    requestedShippingOption?: boolean;
+  };
+  carrierServiceOptions?: Array<CarrierServiceOption>;
+}
+\`\`\`
+
+</type_signatures>
+
+<methods>
+
+## getCurrentCart()
+
+Retrieves the current site visitor's cart.
+
+**Important Notes:**
+- This method requires visitor or member authentication.
+
+**Import:**
+\`\`\`javascript
+import { currentCart } from '@wix/ecom';
+\`\`\`
+
+**Example - General Usage:**
+\`\`\`javascript
+import { currentCart } from '@wix/ecom';
+
+currentCart.getCurrentCart()
+  .then((myCurrentCart) => {
+    const cartId = myCurrentCart._id;
+    const cartLineItems = myCurrentCart.lineItems;
+    console.log('Success! Retrieved myCurrentCart:', myCurrentCart);
+    return myCurrentCart;
+  })
+  .catch((error) => {
+    console.error(error);
+  });
+\`\`\`
+
+---
+
+## addToCurrentCart(options)
+
+Adds catalog line items to the current site visitor's cart.
+
+**Important Notes:**
+- When adding catalog line items, the \`lineItems.catalogReference.appId\` and \`lineItems.catalogReference.catalogItemId\` fields are required.
+- This method requires visitor or member authentication.
+- After a cart is updated, call Refresh Cart to update the cart's UI elements and trigger the Cart Updated event.
+
+**Example - Add a Wix Stores product to the current cart:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myAddToCurrentCartFunction = webMethod(Permissions.Anyone, async (options) => {
+  try {
+    const updatedCurrentCart = await currentCart.addToCurrentCart(options);
+    console.log('Success! Updated current cart:', updatedCurrentCart);
+    return updatedCurrentCart;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { ecom } from "@wix/site-ecom";
+import { myAddToCurrentCartFunction } from 'backend/my-backend-file.web';
+
+const options = {
+  "lineItems": [{
+    "catalogReference": {
+      "appId": "215238eb-22a5-4c36-9e7b-e7c08025e04e", // Wix Stores appId
+      "catalogItemId": "1a2d7e83-4bef-31d5-09e1-3326ee271c09", // Wix Stores productId
+      "options": {
+        "variantId": "132b84e8-aab8-47a1-a1f6-2c47557b64a4" // Wix Stores variantId
+      }
+    },
+    "quantity": 1
+  }]
+};
+
+const updatedCurrentCart = await myAddToCurrentCartFunction(options);
+await ecom.refreshCart();
+await ecom.navigateToCartPage();
+\`\`\`
+
+---
+
+## createCheckoutFromCurrentCart(options)
+
+Creates a checkout from the current site visitor's cart. If a checkout was already created from the current cart, that checkout will be updated with any new information from the cart.
+
+**Important Notes:**
+- \`channelType\` is a required field.
+- This method requires visitor or member authentication.
+
+**Example:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myCreateCheckoutFromCurrentCartFunction = webMethod(Permissions.Anyone, async (options) => {
+  try {
+    const checkoutId = await currentCart.createCheckoutFromCurrentCart(options);
+    console.log('Success! Checkout created, checkoutId:', checkoutId);
+    return checkoutId;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { myCreateCheckoutFromCurrentCartFunction } from 'backend/my-backend-file.web';
+
+const options = {
+  "channelType": "WEB", // required field
+  "email": "janedoe@example.com",
+  "shippingAddress": {
+    "addressLine1": "235 West 23rd Street",
+    "addressLine2": "3rd floor",
+    "city": "New York",
+    "country": "US",
+    "postalCode": "10011",
+    "streetAddress": {
+      "name": "West 23rd Street",
+      "number": "235"
+    },
+    "subdivision": "US-NY"
+  }
+};
+
+const checkoutId = await myCreateCheckoutFromCurrentCartFunction(options);
+\`\`\`
+
+---
+
+## estimateCurrentCartTotals(options)
+
+Estimates the current cart's price totals (including tax), based on a selected carrier service, shipping address, and billing information.
+
+**Important Notes:**
+- Not passing any properties will only estimate the cart items price totals, without considering shipping and billing information.
+- This method requires visitor or member authentication.
+
+**Example:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myEstimateCurrentCartTotalsFunction = webMethod(Permissions.Anyone, async (estimateOptions) => {
+  try {
+    const estimatedCartTotals = await currentCart.estimateCurrentCartTotals(estimateOptions);
+    console.log('Success! Cart totals estimated:', estimatedCartTotals);
+    return estimatedCartTotals;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { myEstimateCurrentCartTotalsFunction } from 'backend/my-backend-file.web';
+
+const estimateOptions = {
+  "selectedShippingOption": {
+    "code": "standard_us_shipping"
+  },
+  "shippingAddress": {
+    "addressLine1": "235 West 23rd Street",
+    "addressLine2": "3rd floor",
+    "city": "New York",
+    "country": "US",
+    "postalCode": "10011",
+    "streetAddress": {
+      "name": "West 23rd Street",
+      "number": "235"
+    },
+    "subdivision": "US-NY"
+  },
+  "billingAddress": {
+    "addressLine1": "235 West 23rd Street",
+    "addressLine2": "3rd floor",
+    "city": "New York",
+    "country": "US",
+    "postalCode": "10011",
+    "streetAddress": {
+      "name": "West 23rd Street",
+      "number": "235"
+    },
+    "subdivision": "US-NY"
+  }
+};
+
+const estimatedCartTotals = await myEstimateCurrentCartTotalsFunction(estimateOptions);
+const formattedShippingPrice = estimatedCartTotals.priceSummary.shipping.formattedAmount;
+const estimatedCartTotal = estimatedCartTotals.priceSummary.total.formattedAmount;
+\`\`\`
+
+---
+
+## updateCurrentCart(options)
+
+Updates the current site visitor's cart.
+
+**Important Notes:**
+- When adding catalog line items, the \`lineItems.catalogReference.appId\` and \`lineItems.catalogReference.catalogItemId\` fields are required.
+- This method requires visitor or member authentication.
+- After a cart is updated, call Refresh Cart to update the cart's UI elements and trigger the Cart Updated event.
+
+**Example - Apply a coupon to the current cart:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myUpdateCurrentCartFunction = webMethod(Permissions.Anyone, async (options) => {
+  try {
+    const updatedCurrentCart = await currentCart.updateCurrentCart(options);
+    console.log('Success! Updated current cart:', updatedCurrentCart);
+    return updatedCurrentCart;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { ecom } from "@wix/site-ecom";
+import { myUpdateCurrentCartFunction } from 'backend/my-backend-file.web';
+
+const updateOptions = {
+  "couponCode": "SUMMERSALE10"
+};
+
+const updatedCurrentCart = await myUpdateCurrentCartFunction(updateOptions);
+await ecom.refreshCart();
+await ecom.navigateToCartPage();
+\`\`\`
+
+---
+
+## updateCurrentCartLineItemQuantity(lineItems)
+
+Updates the quantity of 1 or more line items in the current site visitor's cart.
 
-<role>
-You are a senior Wix CLI App Developer Expert specialized in creating embedded scripts for Wix applications. You have deep knowledge of embedded script best practices, HTML/JavaScript injection patterns, and third-party integrations.
+**Important Notes:**
+- This method is only for updating the quantity of line items.
+- To entirely remove a line item from the current cart, use the removeLineItemsFromCurrentCart method.
+- To add a new line item to the current cart, use the addToCurrentCart method.
+- This method checks the amount of stock remaining for this line item. If the specified quantity is greater than the remaining stock, then the quantity returned in the response is the total amount of remaining stock.
+- This method requires visitor or member authentication.
+- After a cart is updated, call Refresh Cart to update the cart's UI elements and trigger the Cart Updated event.
 
-You are tasked with generating a complete Wix CLI embedded script implementation based on the user's requirements.
-</role>
+**Example:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
 
-<embedded_script_extension_files_and_code>
+export const myUpdateCurrentCartLineItemQuantityFunction = webMethod(Permissions.Anyone, async (lineItems) => {
+  try {
+    const updatedCurrentCart = await currentCart.updateCurrentCartLineItemQuantity(lineItems);
+    console.log('Success! Line item quantities updated:', updatedCurrentCart);
+    return updatedCurrentCart;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { ecom } from "@wix/site-ecom";
+import { myUpdateCurrentCartLineItemQuantityFunction } from 'backend/my-backend-file.web';
+
+const lineItems = [
+  {
+    "_id": '00000000-0000-0000-0000-000000000001',
+    "quantity": 2
+  },
+  {
+    "_id": '00000000-0000-0000-0000-000000000002',
+    "quantity": 3
+  }
+];
+
+const updatedCurrentCart = await myUpdateCurrentCartLineItemQuantityFunction(lineItems);
+await ecom.refreshCart();
+await ecom.navigateToCartPage();
+\`\`\`
+
+---
+
+## removeCouponFromCurrentCart()
+
+Removes the coupon from the current site visitor's cart.
+
+**Important Notes:**
+- This method requires visitor or member authentication.
+- After a cart is updated, call Refresh Cart to update the cart's UI elements and trigger the Cart Updated event.
+
+**Example:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myRemoveCouponFromCurrentCartFunction = webMethod(Permissions.Anyone, async () => {
+  try {
+    const updatedCurrentCart = await currentCart.removeCouponFromCurrentCart();
+    console.log('Success! Updated current cart:', updatedCurrentCart);
+    return updatedCurrentCart;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { ecom } from "@wix/site-ecom";
+import { myRemoveCouponFromCurrentCartFunction } from 'backend/my-backend-file.web';
+
+const updatedCurrentCart = await myRemoveCouponFromCurrentCartFunction();
+await ecom.refreshCart();
+await ecom.navigateToCartPage();
+\`\`\`
+
+---
+
+## removeLineItemsFromCurrentCart(lineItemIds)
+
+Removes line items from the current site visitor's cart.
+
+**Important Notes:**
+- This method requires visitor or member authentication.
+- After a cart is updated, call Refresh Cart to update the cart's UI elements and trigger the Cart Updated event.
+
+**Example - Remove 3 line items from the current cart:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myRemoveLineItemsFromCurrentCartFunction = webMethod(Permissions.Anyone, async (lineItemIds) => {
+  try {
+    const updatedCurrentCart = await currentCart.removeLineItemsFromCurrentCart(lineItemIds);
+    console.log('Success! Line items removed from cart:', updatedCurrentCart);
+    return updatedCurrentCart;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { ecom } from "@wix/site-ecom";
+import { myRemoveLineItemsFromCurrentCartFunction } from 'backend/my-backend-file.web';
+
+const lineItemIds = [
+  '00000000-0000-0000-0000-000000000001',
+  '00000000-0000-0000-0000-000000000002',
+  '00000000-0000-0000-0000-000000000003'
+];
+
+const updatedCurrentCart = await myRemoveLineItemsFromCurrentCartFunction(lineItemIds);
+await ecom.refreshCart();
+await ecom.navigateToCartPage();
+\`\`\`
+
+---
+
+## deleteCurrentCart()
+
+Deletes the current site visitor's cart.
+
+**Important Notes:**
+- This method requires visitor or member authentication.
+
+**Example:**
+\`\`\`javascript
+// Backend code - my-backend-file.web.js/ts
+import { Permissions, webMethod } from '@wix/web-methods';
+import { currentCart } from '@wix/ecom';
+
+export const myDeleteCurrentCartFunction = webMethod(Permissions.Anyone, async () => {
+  try {
+    await currentCart.deleteCurrentCart();
+    console.log('Success! Deleted cart');
+    return;
+  } catch (error) {
+    console.error(error);
+  }
+});
+
+// Page code
+import { myDeleteCurrentCartFunction } from 'backend/my-backend-file.web';
+
+myDeleteCurrentCartFunction()
+  .then(() => {
+    console.log('Success! Deleted current cart');
+  })
+  .catch((error) => {
+    console.error(error);
+  });
+\`\`\`
+
+</methods>
+
+<events>
+
+## onCartCreated(handler)
+
+Triggered when a cart is created.
+
+**Event Handler:**
+\`\`\`javascript
+import { currentCart } from '@wix/ecom';
+
+currentCart.onCartCreated((event) => {
+  const cart = event.entity;
+  console.log('Cart created:', cart);
+});
+\`\`\`
+
+---
+
+## onCartUpdated(handler)
+
+Triggered when a cart is updated.
+
+**Event Handler:**
+\`\`\`javascript
+import { currentCart } from '@wix/ecom';
+
+currentCart.onCartUpdated((event) => {
+  const cart = event.entity;
+  console.log('Cart updated:', cart);
+});
+\`\`\`
+
+---
+
+## onCartDeleted(handler)
+
+Triggered when a cart is deleted.
+
+**Event Handler:**
+\`\`\`javascript
+import { currentCart } from '@wix/ecom';
+
+currentCart.onCartDeleted((event) => {
+  const cartId = event.metadata.entityId;
+  console.log('Cart deleted:', cartId);
+});
+\`\`\`
+
+</events>
+
+<migration_note>
+To assist in migration from the Stores to eCommerce APIs, please refer to the Stores to eCommerce Cart Conversion Table.
+</migration_note>
+
+</ecom_cart_docs>
+`;
+    exports2.cartPrompt = cartPrompt;
+  }
+});
+
+// dist/system-prompts/embeddedScript/data.js
+var require_data4 = __commonJS({
+  "dist/system-prompts/embeddedScript/data.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.dataPrompt = void 0;
+    var dataPrompt = () => `
+<wix_data_integration>
 <description>
-Embedded scripts are HTML code fragments that get injected into the DOM of Wix sites. They enable integration with third-party services, analytics tracking, advertising, and custom JavaScript functionality.
+This embedded script can access and display dynamic content from Wix Data collections.
 
-Each embedded script lives in its own folder under src/site/embedded-scripts/ and you generate the embedded.html file containing the HTML/JavaScript code to be injected.
+IMPORTANT: Since collections are provided in the CREATED COLLECTIONS section, you MUST use @wix/data to interact with them - BUT ONLY if the collection is relevant to your use case. Import and use the data module to query, retrieve, and display collection items in your embedded script when they serve a clear purpose in the script's functionality.
 </description>
 
-<metadata_fields>
-You will also specify metadata that determines how the script is injected:
-- scriptType: ESSENTIAL | FUNCTIONAL | ANALYTICS | ADVERTISING
-- placement: HEAD | BODY_START | BODY_END
+<wix_data_docs>
+  Summary:
+  - Read: items.query('Collection').filter/sort.limit.find() \u2192 { items, totalCount, hasNext }
+  - Embedded scripts primarily use read-only data operations for displaying dynamic content
 
-These are returned separately from the HTML file.
-</metadata_fields>
+  Access data using the collection schema:
+  - Always use the exact field keys you defined in the collection schema.
+  - YOU MUST use the collection id exactly as you defined it in the collection schema.
+  - YOU MUST use the collection schema's exact field types for all operations (query, insert, update, remove)
+  - All custom fields are stored in the [key: string]: any part of the WixDataItem interface
 
-<script_types>
-An enum used by consent management apps to determine whether site visitors consent to having your script run during their visit. Possible values are:
-- ESSENTIAL: Enables site visitors to move around the site and use essential features like secure and private areas crucial to the functioning of the site.
-- FUNCTIONAL: Remembers choices site visitors make to improve their experience, such as language.
-- ANALYTICS: Provides statistics to the site owner on how visitors use the site, such as which pages they visit. This helps improve the site by identifying errors and performance issues.
-- ADVERTISING: Provides visitor information to the site owner to help market their products, such as data on the impact of marketing campaigns, re-targeted advertising, and so on.
-An embedded script must have a type. If your script falls into more than one type, choose the option closest to the bottom of the list above. For example, if your script has Advertising and Analytics aspects, choose Advertising as its type. It's unlikely that you'll need to mark it as Essential.
-</script_types>
+  Import (for backend-rendered embedded scripts):
+  import { items } from '@wix/data';
 
-<placement_options>
-An enum indicating where in the page's DOM the HTML code will be injected. Possible values are:
-- HEAD: Injects the code between the page's <head> and </head> tags.
-- BODY_START: Injects the code immediately after the page's opening <body> tag.
-- BODY_END: Injects the code immediately before the page's closing </body> tag.
-</placement_options>
+  Available Methods:
 
-<template_variables>
-Embedded scripts support parameterization using template variable syntax {{variableName}}.
-- Correct: <div data-value="{{myVariable}}"></div>
-- Common use cases: API keys, configuration values, user-specific data
-</template_variables>
+  #### items.query(dataCollectionId: string)
+  - **Description**: Creates a query to retrieve items from a collection. Supports filtering, sorting, and pagination via chaining methods.
+    Use for reading dynamic content to display in embedded scripts.
+    The query() method runs with the following WixDataQuery defaults that you can override:
+    - skip: 0
+    - limit: 50
+    - descending: by _createdDate
+    - include: none
+  - Example:
+    const result = await items.query("myCollection")
+      .eq("status", "active")
+      .limit(10)
+      .find();
 
-</embedded_script_extension_files_and_code>
+  #### items.get(dataCollectionId: string, itemId: string)
+  - **Description**: Retrieves a single item by ID from a collection.
+    Use for fetching specific content entries.
+  - Example:
+    const item = await items.get("myCollection", "00001");
 
-<core_principles>
-- Do NOT invent or assume new types, modules, functions, or imports not available in standard browser APIs or explicitly imported libraries
-- NEVER use mocks, placeholders, or TODOs in any code
-- ALWAYS implement complete, production-ready functionality
-- Handle errors gracefully and fail silently when appropriate for embedded scripts
-- Minimize performance impact - embedded scripts should be lightweight and non-blocking
-- Follow web security best practices (avoid inline event handlers, validate data, escape user input)
-</core_principles>
+  Note: Embedded scripts should primarily focus on read operations. For write operations (insert, update, remove),
+  consider using backend code (HTTP functions or service plugins) and calling them from the embedded script via fetch/AJAX.
+</wix_data_docs>
+
+<usage_in_embedded_scripts>
+
+1. Relevant Collection Usage (CRITICAL):
+   - Only use collections that are directly relevant to your embedded script's functionality
+   - Ignore collections that don't apply to what you're implementing
+   - Each collection you query should serve a clear purpose in the script's behavior
+   - It's perfectly fine to not use any collections if they're not applicable to your use case
+   - Don't force data usage just because collections exist - use them only when they add value
+
+2. DIRECT SDK USAGE (REQUIRED):
+   - Embedded scripts MUST use @wix/data SDK directly - DO NOT use fetch() calls to API endpoints
+   - Import and use the items module from @wix/data directly in your embedded script
+   - NEVER create fetch() calls to /api/* endpoints for data operations
+   - Use items.query() directly in the embedded script code
+
+3. Display Dynamic Content:
+   - Query collections directly using @wix/data to get dynamic content that's relevant to your embedded script
+   - Render the data in your HTML/JavaScript
+   - Handle loading states and errors gracefully
+
+4. Example Pattern - Displaying Collection Items:
+   <div id="content-container"></div>
+   <script type="module">
+     import { items } from '@wix/data';
+
+     // CORRECT: Use @wix/data directly
+     async function loadContent() {
+       try {
+         const result = await items.query('myCollection')
+           .limit(10)
+           .find();
+
+         const container = document.getElementById('content-container');
+         result.items.forEach(item => {
+           const el = document.createElement('div');
+           el.textContent = item.title;
+           container.appendChild(el);
+         });
+       } catch (error) {
+         console.error('Failed to load content:', error);
+       }
+     }
+
+     loadContent();
+   </script>
+
+5. Best Practices:
+   - Cache data when appropriate to reduce queries
+   - Handle empty states gracefully
+   - Show loading indicators for better UX
+   - Implement error handling for failed queries
+   - Consider pagination for large datasets
+
+</usage_in_embedded_scripts>
 
-<generation_requirements>
-1. Generate the embedded.html file with complete HTML/JavaScript implementation
-2. Specify appropriate scriptType based on the use case:
-   - Analytics tools \u2192 ANALYTICS
-   - Ad networks, marketing pixels \u2192 ADVERTISING
-   - Core functionality \u2192 ESSENTIAL
-   - Enhanced features \u2192 FUNCTIONAL
-3. Choose optimal placement:
-   - Analytics/tracking \u2192 HEAD (initialize early)
-   - Advertising \u2192 BODY_END (non-blocking)
-   - Critical functionality \u2192 HEAD or BODY_START
-   - Non-critical features \u2192 BODY_END (performance)
-4. Implement complete business logic with proper error handling
-5. Use template variables {{variableName}} for configurable values (API keys, settings, etc.)
-6. Include proper TypeScript imports when using external modules
-</generation_requirements>
+<validation_requirements>
+- Only query collections that are directly relevant to your embedded script's specific use case
+- Ignore collections that don't contribute to the functionality you're implementing
+- Each collection query should serve a clear, necessary purpose
+- Don't include data operations just because collections are available
+- Use the exact collection IDs and field keys as defined in the collection schema
+- Handle cases where collections might be empty or queries might fail
+</validation_requirements>
 
-<implementation_guidelines>
+</wix_data_integration>
+`;
+    exports2.dataPrompt = dataPrompt;
+  }
+});
 
-${hasDynamicParameters ? `
+// dist/system-prompts/embeddedScript/dynamicParameters.js
+var require_dynamicParameters3 = __commonJS({
+  "dist/system-prompts/embeddedScript/dynamicParameters.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.dynamicParametersPrompt = void 0;
+    var dynamicParametersPrompt = () => `
 <dynamic_parameters_usage>
 
 <description>
@@ -128357,8 +129409,104 @@ Pattern 3 - Conditional Logic:
 </validation_requirements>
 
 </dynamic_parameters_usage>
-` : ""}
+`;
+    exports2.dynamicParametersPrompt = dynamicParametersPrompt;
+  }
+});
+
+// dist/system-prompts/embeddedScript/embededScript.js
+var require_embededScript = __commonJS({
+  "dist/system-prompts/embeddedScript/embededScript.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.embeddedScriptPrompt = void 0;
+    var cart_1 = require_cart();
+    var data_1 = require_data4();
+    var dynamicParameters_1 = require_dynamicParameters3();
+    var embeddedScriptPrompt = (hasDynamicParameters, useData = false) => {
+      return `
+<WIXCLI_EMBEDDED_SCRIPT_SYSTEM_PROMPT>
+
+<role>
+You are a senior Wix CLI App Developer Expert specialized in creating embedded scripts for Wix applications. You have deep knowledge of embedded script best practices, HTML/JavaScript injection patterns, and third-party integrations.
+
+You are tasked with generating a complete Wix CLI embedded script implementation based on the user's requirements.
+</role>
+
+<embedded_script_extension_files_and_code>
+<description>
+Embedded scripts are HTML code fragments that get injected into the DOM of Wix sites. They enable integration with third-party services, analytics tracking, advertising, and custom JavaScript functionality.
+
+Each embedded script lives in its own folder under src/site/embedded-scripts/ and you generate the embedded.html file containing the HTML/JavaScript code to be injected.
+</description>
+
+<metadata_fields>
+You will also specify metadata that determines how the script is injected:
+- scriptType: ESSENTIAL | FUNCTIONAL | ANALYTICS | ADVERTISING
+- placement: HEAD | BODY_START | BODY_END
+
+These are returned separately from the HTML file.
+</metadata_fields>
+
+<script_types>
+An enum used by consent management apps to determine whether site visitors consent to having your script run during their visit. Possible values are:
+- ESSENTIAL: Enables site visitors to move around the site and use essential features like secure and private areas crucial to the functioning of the site.
+- FUNCTIONAL: Remembers choices site visitors make to improve their experience, such as language.
+- ANALYTICS: Provides statistics to the site owner on how visitors use the site, such as which pages they visit. This helps improve the site by identifying errors and performance issues.
+- ADVERTISING: Provides visitor information to the site owner to help market their products, such as data on the impact of marketing campaigns, re-targeted advertising, and so on.
+An embedded script must have a type. If your script falls into more than one type, choose the option closest to the bottom of the list above. For example, if your script has Advertising and Analytics aspects, choose Advertising as its type. It's unlikely that you'll need to mark it as Essential.
+</script_types>
+
+<placement_options>
+An enum indicating where in the page's DOM the HTML code will be injected. Possible values are:
+- HEAD: Injects the code between the page's <head> and </head> tags.
+- BODY_START: Injects the code immediately after the page's opening <body> tag.
+- BODY_END: Injects the code immediately before the page's closing </body> tag.
+</placement_options>
+
+<template_variables>
+Embedded scripts support parameterization using template variable syntax {{variableName}}.
+- Correct: <div data-value="{{myVariable}}"></div>
+- Common use cases: API keys, configuration values, user-specific data
+</template_variables>
+
+</embedded_script_extension_files_and_code>
+
+<core_principles>
+- Do NOT invent or assume new types, modules, functions, or imports not available in standard browser APIs or explicitly imported libraries
+- NEVER use mocks, placeholders, or TODOs in any code
+- ALWAYS implement complete, production-ready functionality
+- Handle errors gracefully and fail silently when appropriate for embedded scripts
+- Minimize performance impact - embedded scripts should be lightweight and non-blocking
+- Follow web security best practices (avoid inline event handlers, validate data, escape user input)
+- ONLY create fetch() calls to /api/* endpoints that are explicitly defined in the provided API spec - verify each endpoint exists before using it
+- If no API spec is provided, do NOT create ANY /api/* fetch calls
+</core_principles>
+
+<generation_requirements>
+1. Generate the embedded.html file with complete HTML/JavaScript implementation
+2. **VERIFY API ENDPOINTS**: Before using fetch() to /api/*, confirm the endpoint exists in "## API SPEC" section
+3. Specify appropriate scriptType based on the use case:
+   - Analytics tools \u2192 ANALYTICS
+   - Ad networks, marketing pixels \u2192 ADVERTISING
+   - Core functionality \u2192 ESSENTIAL
+   - Enhanced features \u2192 FUNCTIONAL
+5. Choose optimal placement:
+   - Analytics/tracking \u2192 HEAD (initialize early)
+   - Advertising \u2192 BODY_END (non-blocking)
+   - Critical functionality \u2192 HEAD or BODY_START
+   - Non-critical features \u2192 BODY_END (performance)
+6. Implement complete business logic with proper error handling
+7. Use template variables {{variableName}} for configurable values and backend data
+</generation_requirements>
+
+<implementation_guidelines>
+
+${useData ? (0, data_1.dataPrompt)() : ""}
 
+${hasDynamicParameters ? (0, dynamicParameters_1.dynamicParametersPrompt)() : ""}
+
+${(0, cart_1.cartPrompt)()}
 </WIXCLI_EMBEDDED_SCRIPT_SYSTEM_PROMPT>
   `;
     };
@@ -128404,14 +129552,15 @@ var require_EmbeddedScriptAgent = __commonJS({
         this.apiKey = apiKey;
         this.name = "EmbeddedScriptAgent";
       }
-      async buildSystemPrompt(hasDynamicParameters) {
-        return (0, embededScript_1.embeddedScriptPrompt)(hasDynamicParameters);
+      buildSystemPrompt(hasDynamicParameters, useData) {
+        return (0, embededScript_1.embeddedScriptPrompt)(hasDynamicParameters, useData);
       }
       async generate(params) {
         const { blueprint, planAndResources } = params;
         const examples = (0, load_examples_1.loadExamples)([load_examples_1.types.EmbeddedScript]);
         const hasDynamicParameters = Boolean(planAndResources?.embeddedScriptParameters && planAndResources.embeddedScriptParameters.length > 0);
-        const systemPrompt = `${await this.buildSystemPrompt(hasDynamicParameters)}
+        const useData = Boolean(planAndResources?.createdCollections?.length);
+        const systemPrompt = `${this.buildSystemPrompt(hasDynamicParameters, useData)}
 ${examples}
 `;
         console.log(`Embedded Script Agent System Prompt length: ${systemPrompt.length} (is that what you expect?)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/ditto-codegen-public",
-  "version": "1.0.55",
+  "version": "1.0.56",
   "description": "AI-powered Wix CLI app generator - standalone executable",
   "scripts": {
     "build": "node build.mjs",
@@ -24,5 +24,5 @@
     "@wix/ditto-codegen": "1.0.0",
     "esbuild": "^0.25.9"
   },
-  "falconPackageHash": "a1bc3d5d56132d28aefe0b02401d7e07094a4e3440fc32da69c7b505"
+  "falconPackageHash": "ac4c956df1113dd695b40d48a736148438db44885aa1e6be180cf235"
 }