@mercurjs/core 2.2.0-canary.1 → 2.2.0-canary.11

package/.medusa/server/src/workflows/product-edit/steps/update-product-change-actions.d.ts

@@ -0,0 +1,49 @@
+export declare const updateProductChangeActionsStepId = "pc-update-product-change-actions";
+type UpdateProductChangeActionsStepInput = Array<{
+    id: string;
+    applied?: boolean;
+    details?: Record<string, unknown>;
+    internal_note?: string | null;
+}>;
+/**
+ * Pattern-match
+ * `medusa/packages/core/core-flows/src/order/steps/update-order-change-actions.ts:21-60`:
+ * list-before, update, revert updates with before-state.
+ */
+export declare const updateProductChangeActionsStep: import("@medusajs/framework/workflows-sdk").StepFunction<UpdateProductChangeActionsStepInput, {
+    id: string;
+    product_id: string;
+    ordering: number;
+    action: string;
+    details: Record<string, unknown>;
+    internal_note: string | null;
+    applied: boolean;
+    product_change: {
+        id: string;
+        product_id: string;
+        status: import("@mercurjs/types").ProductChangeStatus;
+        internal_note: string | null;
+        external_note: string | null;
+        created_by: string | null;
+        confirmed_by: string | null;
+        confirmed_at: Date | null;
+        declined_by: string | null;
+        declined_at: Date | null;
+        declined_reason: string | null;
+        canceled_by: string | null;
+        canceled_at: Date | null;
+        requires_action_by: string | null;
+        requires_action_at: Date | null;
+        requires_action_reason: string | null;
+        metadata: Record<string, unknown> | null;
+        actions: /*elided*/ any[];
+        created_at: Date;
+        updated_at: Date;
+        deleted_at: Date | null;
+    };
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+    product_change_id: string | null;
+}[]>;
+export {};

package/.medusa/server/src/workflows/product-edit/steps/update-product-change-actions.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateProductChangeActionsStep = exports.updateProductChangeActionsStepId = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+exports.updateProductChangeActionsStepId = "pc-update-product-change-actions";
+const pickPrev = (a) => ({
+    id: a.id,
+    applied: a.applied ?? false,
+    details: a.details ?? {},
+    internal_note: a.internal_note ?? null,
+});
+/**
+ * Pattern-match
+ * `medusa/packages/core/core-flows/src/order/steps/update-order-change-actions.ts:21-60`:
+ * list-before, update, revert updates with before-state.
+ */
+exports.updateProductChangeActionsStep = (0, workflows_sdk_1.createStep)(exports.updateProductChangeActionsStepId, async (input, { container }) => {
+    const service = container.resolve(types_1.MercurModules.PRODUCT_EDIT);
+    const ids = input.map((i) => i.id);
+    const prev = (await service.listProductChangeActions({
+        id: ids,
+    }));
+    const prevScalars = prev.map(pickPrev);
+    const result = await service.updateProductChangeActions(input);
+    return new workflows_sdk_1.StepResponse(result, prevScalars);
+}, async (prevScalars, { container }) => {
+    if (!prevScalars?.length) {
+        return;
+    }
+    const service = container.resolve(types_1.MercurModules.PRODUCT_EDIT);
+    await service.updateProductChangeActions(prevScalars);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLXByb2R1Y3QtY2hhbmdlLWFjdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3Byb2R1Y3QtZWRpdC9zdGVwcy91cGRhdGUtcHJvZHVjdC1jaGFuZ2UtYWN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxRUFBNEU7QUFDNUUsMkNBQStDO0FBSWxDLFFBQUEsZ0NBQWdDLEdBQzNDLGtDQUFrQyxDQUFBO0FBZ0JwQyxNQUFNLFFBQVEsR0FBRyxDQUNmLENBQTJDLEVBQ3pCLEVBQUUsQ0FBQyxDQUFDO0lBQ3RCLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRTtJQUNSLE9BQU8sRUFBRyxDQUFDLENBQUMsT0FBbUIsSUFBSSxLQUFLO0lBQ3hDLE9BQU8sRUFBRyxDQUFDLENBQUMsT0FBbUMsSUFBSSxFQUFFO0lBQ3JELGFBQWEsRUFBRyxDQUFDLENBQUMsYUFBK0IsSUFBSSxJQUFJO0NBQzFELENBQUMsQ0FBQTtBQUVGOzs7O0dBSUc7QUFDVSxRQUFBLDhCQUE4QixHQUFHLElBQUEsMEJBQVUsRUFDdEQsd0NBQWdDLEVBQ2hDLEtBQUssRUFBRSxLQUEwQyxFQUFFLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRTtJQUNsRSxNQUFNLE9BQU8sR0FBRyxTQUFTLENBQUMsT0FBTyxDQUMvQixxQkFBYSxDQUFDLFlBQVksQ0FDM0IsQ0FBQTtJQUVELE1BQU0sR0FBRyxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUNsQyxNQUFNLElBQUksR0FBRyxDQUFDLE1BQU0sT0FBTyxDQUFDLHdCQUF3QixDQUFDO1FBQ25ELEVBQUUsRUFBRSxHQUFHO0tBQ1IsQ0FBQyxDQUFvRCxDQUFBO0lBQ3RELE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLENBQUE7SUFFdEMsTUFBTSxNQUFNLEdBQUcsTUFBTSxPQUFPLENBQUMsMEJBQTBCLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDOUQsT0FBTyxJQUFJLDRCQUFZLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQyxDQUFBO0FBQzlDLENBQUMsRUFDRCxLQUFLLEVBQUUsV0FBMkMsRUFBRSxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUU7SUFDbkUsSUFBSSxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsQ0FBQztRQUN6QixPQUFNO0lBQ1IsQ0FBQztJQUNELE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQy9CLHFCQUFhLENBQUMsWUFBWSxDQUMzQixDQUFBO0lBQ0QsTUFBTSxPQUFPLENBQUMsMEJBQTBCLENBQUMsV0FBVyxDQUFDLENBQUE7QUFDdkQsQ0FBQyxDQUNGLENBQUEifQ==

package/.medusa/server/src/workflows/product-edit/steps/validate-no-pending-product-change.d.ts

@@ -1,12 +1,12 @@
+export declare const validateNoPendingProductChangeStepId = "pc-validate-no-pending-product-change";
 type ValidateNoPendingProductChangeStepInput = {
-    product: any;
+    product_ids: string[];
 };
 /**
- * Guards every action-staging workflow: a product can carry only one
- * pending `ProductChange` at a time. The flow is sequential — each edit
- * (`product-edit-update-fields`, `product-edit-add-variant`, etc.) opens
- * its own change, and the next edit must wait until the current one is
- * confirmed, declined, or canceled.
+ * Enforces "one pending change per product". Filters the
+ * `product_change` entity by `product_id` (denormalised column on the
+ * change row) and `status = PENDING`. Throws if any input product
+ * already has a pending change.
  */
-export declare const validateNoPendingProductChangeStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateNoPendingProductChangeStepInput, unknown>;
+export declare const validateNoPendingProductChangeStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateNoPendingProductChangeStepInput, undefined>;
 export {};

package/.medusa/server/src/workflows/product-edit/steps/validate-no-pending-product-change.js

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateNoPendingProductChangeStep = void 0;
-const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+exports.validateNoPendingProductChangeStep = exports.validateNoPendingProductChangeStepId = void 0;
 const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+exports.validateNoPendingProductChangeStepId = "pc-validate-no-pending-product-change";
 /**
- * Guards every action-staging workflow: a product can carry only one
- * pending `ProductChange` at a time. The flow is sequential — each edit
- * (`product-edit-update-fields`, `product-edit-add-variant`, etc.) opens
- * its own change, and the next edit must wait until the current one is
- * confirmed, declined, or canceled.
+ * Enforces "one pending change per product". Filters the
+ * `product_change` entity by `product_id` (denormalised column on the
+ * change row) and `status = PENDING`. Throws if any input product
+ * already has a pending change.
  */
-exports.validateNoPendingProductChangeStep = (0, workflows_sdk_1.createStep)("validate-no-pending-product-change", async ({ product }) => {
-    if (!product) {
-        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Product not found");
+exports.validateNoPendingProductChangeStep = (0, workflows_sdk_1.createStep)(exports.validateNoPendingProductChangeStepId, async ({ product_ids }, { container }) => {
+    if (!product_ids.length) {
+        return new workflows_sdk_1.StepResponse(void 0);
+    }
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: changes } = await query.graph({
+        entity: "product_change",
+        fields: ["id", "product_id", "status"],
+        filters: {},
+    });
+    const conflicts = new Set();
+    for (const change of changes) {
+        if (change.status === types_1.ProductChangeStatus.PENDING &&
+            change.product_id &&
+            product_ids.includes(change.product_id)) {
+            conflicts.add(change.product_id);
+        }
     }
-    if (product.product_change) {
-        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Product '${product.title}' already has a pending request.`);
+    if (conflicts.size) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Product(s) [${[...conflicts].join(", ")}] already have a pending product change. Resolve it before opening a new one.`);
     }
+    return new workflows_sdk_1.StepResponse(void 0);
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtbm8tcGVuZGluZy1wcm9kdWN0LWNoYW5nZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcHJvZHVjdC1lZGl0L3N0ZXBzL3ZhbGlkYXRlLW5vLXBlbmRpbmctcHJvZHVjdC1jaGFuZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUVBQThEO0FBQzlELHFEQUF1RDtBQU12RDs7Ozs7O0dBTUc7QUFDVSxRQUFBLGtDQUFrQyxHQUFHLElBQUEsMEJBQVUsRUFDMUQsb0NBQW9DLEVBQ3BDLEtBQUssRUFBRSxFQUFFLE9BQU8sRUFBMkMsRUFBRSxFQUFFO0lBQzdELElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNiLE1BQU0sSUFBSSxtQkFBVyxDQUNuQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQzNCLG1CQUFtQixDQUNwQixDQUFBO0lBQ0gsQ0FBQztJQUVELElBQUksT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQzNCLE1BQU0sSUFBSSxtQkFBVyxDQUNuQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxXQUFXLEVBQzdCLFlBQVksT0FBTyxDQUFDLEtBQUssa0NBQWtDLENBQzVELENBQUE7SUFDSCxDQUFDO0FBQ0gsQ0FBQyxDQUNGLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtbm8tcGVuZGluZy1wcm9kdWN0LWNoYW5nZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcHJvZHVjdC1lZGl0L3N0ZXBzL3ZhbGlkYXRlLW5vLXBlbmRpbmctcHJvZHVjdC1jaGFuZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBR2tDO0FBQ2xDLHFFQUE0RTtBQUM1RSwyQ0FBcUQ7QUFFeEMsUUFBQSxvQ0FBb0MsR0FDL0MsdUNBQXVDLENBQUE7QUFNekM7Ozs7O0dBS0c7QUFDVSxRQUFBLGtDQUFrQyxHQUFHLElBQUEsMEJBQVUsRUFDMUQsNENBQW9DLEVBQ3BDLEtBQUssRUFDSCxFQUFFLFdBQVcsRUFBMkMsRUFDeEQsRUFBRSxTQUFTLEVBQUUsRUFDYixFQUFFO0lBQ0YsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUN4QixPQUFPLElBQUksNEJBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFBO0lBQ2pDLENBQUM7SUFFRCxNQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLGlDQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRWhFLE1BQU0sRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEdBQUcsTUFBTSxLQUFLLENBQUMsS0FBSyxDQUFDO1FBQzFDLE1BQU0sRUFBRSxnQkFBZ0I7UUFDeEIsTUFBTSxFQUFFLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRSxRQUFRLENBQUM7UUFDdEMsT0FBTyxFQUFFLEVBQUU7S0FDWixDQUFDLENBQUE7SUFFRixNQUFNLFNBQVMsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFBO0lBQ25DLEtBQUssTUFBTSxNQUFNLElBQUksT0FJbkIsRUFBRSxDQUFDO1FBQ0gsSUFDRSxNQUFNLENBQUMsTUFBTSxLQUFLLDJCQUFtQixDQUFDLE9BQU87WUFDN0MsTUFBTSxDQUFDLFVBQVU7WUFDakIsV0FBVyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLEVBQ3ZDLENBQUM7WUFDRCxTQUFTLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQTtRQUNsQyxDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksU0FBUyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ25CLE1BQU0sSUFBSSxtQkFBVyxDQUNuQixtQkFBVyxDQUFDLEtBQUssQ0FBQyxXQUFXLEVBQzdCLGVBQWUsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsK0VBQStFLENBQ3hILENBQUE7SUFDSCxDQUFDO0lBRUQsT0FBTyxJQUFJLDRCQUFZLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtBQUNqQyxDQUFDLENBQ0YsQ0FBQSJ9

package/.medusa/server/src/workflows/product-edit/steps/validate-product-change-is-pending.d.ts

@@ -0,0 +1,10 @@
+import { ProductChangeStatus } from "@mercurjs/types";
+export declare const validateProductChangeIsPendingStepId = "pc-validate-product-change-is-pending";
+type ValidateProductChangeIsPendingStepInput = {
+    change: {
+        id: string;
+        status: ProductChangeStatus | string;
+    };
+};
+export declare const validateProductChangeIsPendingStep: import("@medusajs/framework/workflows-sdk").StepFunction<ValidateProductChangeIsPendingStepInput, undefined>;
+export {};

package/.medusa/server/src/workflows/product-edit/steps/validate-product-change-is-pending.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProductChangeIsPendingStep = exports.validateProductChangeIsPendingStepId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const types_1 = require("@mercurjs/types");
+exports.validateProductChangeIsPendingStepId = "pc-validate-product-change-is-pending";
+exports.validateProductChangeIsPendingStep = (0, workflows_sdk_1.createStep)(exports.validateProductChangeIsPendingStepId, async ({ change }) => {
+    if (change.status !== types_1.ProductChangeStatus.PENDING) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Product change '${change.id}' has status '${change.status}', expected '${types_1.ProductChangeStatus.PENDING}'.`);
+    }
+    return new workflows_sdk_1.StepResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGUtcHJvZHVjdC1jaGFuZ2UtaXMtcGVuZGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcHJvZHVjdC1lZGl0L3N0ZXBzL3ZhbGlkYXRlLXByb2R1Y3QtY2hhbmdlLWlzLXBlbmRpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQXVEO0FBQ3ZELHFFQUE0RTtBQUM1RSwyQ0FBcUQ7QUFFeEMsUUFBQSxvQ0FBb0MsR0FDL0MsdUNBQXVDLENBQUE7QUFNNUIsUUFBQSxrQ0FBa0MsR0FBRyxJQUFBLDBCQUFVLEVBQzFELDRDQUFvQyxFQUNwQyxLQUFLLEVBQUUsRUFBRSxNQUFNLEVBQTJDLEVBQUUsRUFBRTtJQUM1RCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssMkJBQW1CLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDbEQsTUFBTSxJQUFJLG1CQUFXLENBQ25CLG1CQUFXLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFDN0IsbUJBQW1CLE1BQU0sQ0FBQyxFQUFFLGlCQUFpQixNQUFNLENBQUMsTUFBTSxnQkFBZ0IsMkJBQW1CLENBQUMsT0FBTyxJQUFJLENBQzFHLENBQUE7SUFDSCxDQUFDO0lBQ0QsT0FBTyxJQUFJLDRCQUFZLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtBQUNqQyxDQUFDLENBQ0YsQ0FBQSJ9

package/.medusa/server/src/workflows/product-edit/workflows/apply-product-attribute-change-actions.d.ts

@@ -0,0 +1,23 @@
+export type ApplyProductAttributeChangeActionsWorkflowInput = {
+    add_actions: Array<{
+        product_id: string;
+        attribute_id: string;
+        attribute_value_ids: string[];
+    }>;
+    remove_actions: Array<{
+        product_id: string;
+        attribute_id: string;
+    }>;
+};
+export declare const applyProductAttributeChangeActionsWorkflowId = "apply-product-attribute-change-actions";
+/**
+ * Per-bucket dispatcher for `ATTRIBUTE_ADD` / `ATTRIBUTE_REMOVE`
+ * actions surfaced by `applyProductChangeActionsWorkflow`. Extracted
+ * so the parent dispatcher stays a thin orchestrator and the
+ * attribute-attach/detach symmetry lives in one place (mirroring
+ * `addProductAttributeWorkflow` + `detachProductAttributeWorkflow`).
+ *
+ * Removes happen before adds so a single change can re-link the same
+ * attribute with a different value set in one round-trip.
+ */
+export declare const applyProductAttributeChangeActionsWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<ApplyProductAttributeChangeActionsWorkflowInput, undefined, []>;

package/.medusa/server/src/workflows/product-edit/workflows/apply-product-attribute-change-actions.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyProductAttributeChangeActionsWorkflow = exports.applyProductAttributeChangeActionsWorkflowId = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const types_1 = require("@mercurjs/types");
+const sync_product_attribute_options_1 = require("../../product-attribute/workflows/sync-product-attribute-options");
+exports.applyProductAttributeChangeActionsWorkflowId = "apply-product-attribute-change-actions";
+/**
+ * Per-bucket dispatcher for `ATTRIBUTE_ADD` / `ATTRIBUTE_REMOVE`
+ * actions surfaced by `applyProductChangeActionsWorkflow`. Extracted
+ * so the parent dispatcher stays a thin orchestrator and the
+ * attribute-attach/detach symmetry lives in one place (mirroring
+ * `addProductAttributeWorkflow` + `detachProductAttributeWorkflow`).
+ *
+ * Removes happen before adds so a single change can re-link the same
+ * attribute with a different value set in one round-trip.
+ */
+exports.applyProductAttributeChangeActionsWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.applyProductAttributeChangeActionsWorkflowId, function (input) {
+    (0, workflows_sdk_1.when)({ input }, ({ input }) => input.remove_actions.length > 0).then(() => {
+        const removedAttributeIds = (0, workflows_sdk_1.transform)({ input }, ({ input }) => Array.from(new Set(input.remove_actions.map((r) => r.attribute_id))));
+        const { data: valuesForRemoval } = (0, core_flows_1.useQueryGraphStep)({
+            entity: "product_attribute_value",
+            fields: ["id", "attribute.id"],
+            filters: { attribute_id: removedAttributeIds },
+        }).config({ name: "pa-apply-load-attribute-values-for-removal" });
+        const valueLinksToDismiss = (0, workflows_sdk_1.transform)({ input, valuesForRemoval }, ({ input, valuesForRemoval }) => {
+            const valuesByAttr = new Map();
+            for (const v of valuesForRemoval ?? []) {
+                const attrId = v.attribute?.id;
+                if (!attrId)
+                    continue;
+                const list = valuesByAttr.get(attrId) ?? [];
+                list.push(v.id);
+                valuesByAttr.set(attrId, list);
+            }
+            const links = [];
+            for (const r of input.remove_actions) {
+                const valueIds = valuesByAttr.get(r.attribute_id) ?? [];
+                for (const valueId of valueIds) {
+                    links.push({
+                        [utils_1.Modules.PRODUCT]: { product_id: r.product_id },
+                        [types_1.MercurModules.PRODUCT_ATTRIBUTE]: {
+                            product_attribute_value_id: valueId,
+                        },
+                    });
+                }
+            }
+            return links;
+        });
+        (0, core_flows_1.dismissRemoteLinkStep)(valueLinksToDismiss).config({
+            name: "pa-apply-dismiss-attribute-value-links",
+        });
+        const variantAttrLinksToDismiss = (0, workflows_sdk_1.transform)({ input }, ({ input }) => input.remove_actions.map((r) => ({
+            [utils_1.Modules.PRODUCT]: { product_id: r.product_id },
+            [types_1.MercurModules.PRODUCT_ATTRIBUTE]: {
+                product_attribute_id: r.attribute_id,
+            },
+        })));
+        (0, core_flows_1.dismissRemoteLinkStep)(variantAttrLinksToDismiss).config({
+            name: "pa-apply-dismiss-variant-attribute-links",
+        });
+    });
+    (0, workflows_sdk_1.when)({ input }, ({ input }) => input.add_actions.length > 0).then(() => {
+        const addedAttributeIds = (0, workflows_sdk_1.transform)({ input }, ({ input }) => Array.from(new Set(input.add_actions.map((a) => a.attribute_id))));
+        const { data: addedAttributes } = (0, core_flows_1.useQueryGraphStep)({
+            entity: "product_attribute",
+            fields: ["id", "name", "is_variant_axis", "values.id", "values.name"],
+            filters: { id: addedAttributeIds },
+        }).config({ name: "pa-apply-load-attributes-for-add" });
+        const valueLinksToCreate = (0, workflows_sdk_1.transform)({ input }, ({ input }) => input.add_actions.flatMap((a) => a.attribute_value_ids.map((valueId) => ({
+            [utils_1.Modules.PRODUCT]: { product_id: a.product_id },
+            [types_1.MercurModules.PRODUCT_ATTRIBUTE]: {
+                product_attribute_value_id: valueId,
+            },
+        }))));
+        (0, core_flows_1.createRemoteLinkStep)(valueLinksToCreate).config({
+            name: "pa-apply-create-attribute-value-links",
+        });
+        const variantAttrLinksToCreate = (0, workflows_sdk_1.transform)({ input, addedAttributes }, ({ input, addedAttributes }) => {
+            const variantAxisById = new Map();
+            for (const a of addedAttributes ?? []) {
+                variantAxisById.set(a.id, Boolean(a.is_variant_axis));
+            }
+            return input.add_actions
+                .filter((a) => variantAxisById.get(a.attribute_id) === true)
+                .map((a) => ({
+                [utils_1.Modules.PRODUCT]: { product_id: a.product_id },
+                [types_1.MercurModules.PRODUCT_ATTRIBUTE]: {
+                    product_attribute_id: a.attribute_id,
+                },
+            }));
+        });
+        (0, core_flows_1.createRemoteLinkStep)(variantAttrLinksToCreate).config({
+            name: "pa-apply-create-variant-attribute-links",
+        });
+        // Synthesize the corresponding stock product option for each
+        // variant-axis attribute add. Mirrors what
+        // `addProductAttributeWorkflow` does inline so a confirmed
+        // ATTRIBUTE_ADD reaches the same product-options state as a
+        // direct attach.
+        const optionsToUpsert = (0, workflows_sdk_1.transform)({ input, addedAttributes }, ({ input, addedAttributes }) => {
+            const byId = new Map();
+            for (const a of (addedAttributes ?? [])) {
+                byId.set(a.id, {
+                    name: a.name,
+                    is_variant_axis: Boolean(a.is_variant_axis),
+                    values: a.values ?? [],
+                });
+            }
+            const out = [];
+            for (const a of input.add_actions) {
+                const meta = byId.get(a.attribute_id);
+                if (!meta || !meta.is_variant_axis)
+                    continue;
+                const valueIdSet = new Set(a.attribute_value_ids);
+                const valueNames = meta.values
+                    .filter((v) => valueIdSet.has(v.id))
+                    .map((v) => v.name);
+                if (!valueNames.length)
+                    continue;
+                out.push({
+                    product_id: a.product_id,
+                    title: meta.name,
+                    values: valueNames,
+                });
+            }
+            return out;
+        });
+        sync_product_attribute_options_1.syncProductAttributeOptionsWorkflow.runAsStep({
+            input: (0, workflows_sdk_1.transform)({ optionsToUpsert }, ({ optionsToUpsert }) => ({
+                upsert: optionsToUpsert,
+            })),
+        });
+    });
+    return new workflows_sdk_1.WorkflowResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/product-edit/workflows/apply-product-change-actions.d.ts

@@ -0,0 +1,38 @@
+import { type ReturnWorkflow } from "@medusajs/framework/workflows-sdk";
+export type ApplyProductChangeActionsWorkflowInput = {
+    change_ids: string[];
+};
+export declare const applyProductChangeActionsWorkflowId = "apply-product-change-actions";
+/**
+ * Cross-module dispatcher for a confirmed `ProductChange`'s pending
+ * actions. Replaces the legacy `ProductModuleService.applyProductChangeActions_`
+ * by composing stock Medusa product workflows (update/create/delete
+ * variants, update/delete products) with the attribute apply workflow
+ * (`applyProductAttributeChangeActionsWorkflow`).
+ *
+ * Pattern-match `medusa/.../order/workflows/apply-order-change.ts`:
+ * load pending rows, bucket by action type, dispatch in dependency
+ * order, then mark `applied = true`.
+ *
+ * Ordering mirrors the legacy implementation:
+ *   1. Top-level field updates (STATUS_CHANGE / UPDATE) — collapsed by
+ *      product so each product hits `updateProductsWorkflow` once.
+ *   2. Variant deletes — frees up SKU / title uniqueness before adds.
+ *   3. Variant creates.
+ *   4. Variant updates — see a stable variant set.
+ *   5. Attribute add/remove + option sync — delegated to
+ *      `applyProductAttributeChangeActionsWorkflow`. Removes run
+ *      before adds inside that workflow so a single change can re-link
+ *      the same attribute with a different value set.
+ *   6. Product deletes — last so any audit-trail updates above write
+ *      through before the row is soft-deleted.
+ *   7. Mark action rows applied.
+ *
+ * `ATTRIBUTE_ADD` actions are expected to carry pre-resolved
+ * `attribute_value_ids` in their `details` JSON. The find-or-create
+ * branch lives upstream — workflows that stage an `ATTRIBUTE_ADD` call
+ * `upsertProductAttributeValuesWorkflow` first to resolve names into
+ * IDs before persisting the action.
+ */
+export declare const applyProductChangeActionsWorkflow: ReturnWorkflow<ApplyProductChangeActionsWorkflowInput, void, [
+]>;

package/.medusa/server/src/workflows/product-edit/workflows/apply-product-change-actions.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyProductChangeActionsWorkflow = exports.applyProductChangeActionsWorkflowId = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const types_1 = require("@mercurjs/types");
+const steps_1 = require("../steps");
+const apply_product_attribute_change_actions_1 = require("./apply-product-attribute-change-actions");
+exports.applyProductChangeActionsWorkflowId = "apply-product-change-actions";
+/**
+ * Cross-module dispatcher for a confirmed `ProductChange`'s pending
+ * actions. Replaces the legacy `ProductModuleService.applyProductChangeActions_`
+ * by composing stock Medusa product workflows (update/create/delete
+ * variants, update/delete products) with the attribute apply workflow
+ * (`applyProductAttributeChangeActionsWorkflow`).
+ *
+ * Pattern-match `medusa/.../order/workflows/apply-order-change.ts`:
+ * load pending rows, bucket by action type, dispatch in dependency
+ * order, then mark `applied = true`.
+ *
+ * Ordering mirrors the legacy implementation:
+ *   1. Top-level field updates (STATUS_CHANGE / UPDATE) — collapsed by
+ *      product so each product hits `updateProductsWorkflow` once.
+ *   2. Variant deletes — frees up SKU / title uniqueness before adds.
+ *   3. Variant creates.
+ *   4. Variant updates — see a stable variant set.
+ *   5. Attribute add/remove + option sync — delegated to
+ *      `applyProductAttributeChangeActionsWorkflow`. Removes run
+ *      before adds inside that workflow so a single change can re-link
+ *      the same attribute with a different value set.
+ *   6. Product deletes — last so any audit-trail updates above write
+ *      through before the row is soft-deleted.
+ *   7. Mark action rows applied.
+ *
+ * `ATTRIBUTE_ADD` actions are expected to carry pre-resolved
+ * `attribute_value_ids` in their `details` JSON. The find-or-create
+ * branch lives upstream — workflows that stage an `ATTRIBUTE_ADD` call
+ * `upsertProductAttributeValuesWorkflow` first to resolve names into
+ * IDs before persisting the action.
+ */
+exports.applyProductChangeActionsWorkflow = (0, workflows_sdk_1.createWorkflow)(exports.applyProductChangeActionsWorkflowId, function (input) {
+    const { data: actions } = (0, core_flows_1.useQueryGraphStep)({
+        entity: "product_change_action",
+        fields: ["id", "product_id", "action", "details", "applied"],
+        filters: {
+            product_change_id: input.change_ids,
+            applied: false,
+        },
+    }).config({ name: "pc-load-pending-actions" });
+    const buckets = (0, workflows_sdk_1.transform)({ actions }, ({ actions }) => {
+        const productUpdatesById = new Map();
+        const variantCreates = [];
+        const variantUpdates = [];
+        const variantDeletes = [];
+        const attributeAdds = [];
+        const attributeRemoves = [];
+        const productsToDelete = new Set();
+        const pendingActionIds = [];
+        for (const action of actions ?? []) {
+            if (!action || action.applied)
+                continue;
+            pendingActionIds.push(action.id);
+            const productId = action.product_id;
+            const details = (action.details ?? {});
+            switch (action.action) {
+                case types_1.ProductChangeActionType.STATUS_CHANGE: {
+                    const status = details.status;
+                    if (status === undefined)
+                        break;
+                    const u = productUpdatesById.get(productId) ?? { id: productId };
+                    u.status = status;
+                    productUpdatesById.set(productId, u);
+                    break;
+                }
+                case types_1.ProductChangeActionType.UPDATE: {
+                    const { field, value } = details;
+                    if (!field)
+                        break;
+                    const u = productUpdatesById.get(productId) ?? { id: productId };
+                    u[field] = value;
+                    productUpdatesById.set(productId, u);
+                    break;
+                }
+                case types_1.ProductChangeActionType.VARIANT_ADD: {
+                    const variant = details.variant;
+                    if (!variant)
+                        break;
+                    variantCreates.push({ ...variant, product_id: productId });
+                    break;
+                }
+                case types_1.ProductChangeActionType.VARIANT_UPDATE: {
+                    const { variant_id, fields } = details;
+                    if (!variant_id ||
+                        !fields ||
+                        !Object.keys(fields).length)
+                        break;
+                    variantUpdates.push({ id: variant_id, ...fields });
+                    break;
+                }
+                case types_1.ProductChangeActionType.VARIANT_REMOVE: {
+                    const variantId = details.variant_id;
+                    if (variantId)
+                        variantDeletes.push(variantId);
+                    break;
+                }
+                case types_1.ProductChangeActionType.ATTRIBUTE_ADD: {
+                    const { attribute_id, attribute_value_ids } = details;
+                    if (!attribute_id || !attribute_value_ids?.length)
+                        break;
+                    attributeAdds.push({
+                        product_id: productId,
+                        attribute_id,
+                        attribute_value_ids,
+                    });
+                    break;
+                }
+                case types_1.ProductChangeActionType.ATTRIBUTE_REMOVE: {
+                    const attributeId = details
+                        .attribute_id;
+                    if (!attributeId)
+                        break;
+                    attributeRemoves.push({
+                        product_id: productId,
+                        attribute_id: attributeId,
+                    });
+                    break;
+                }
+                case types_1.ProductChangeActionType.PRODUCT_DELETE: {
+                    productsToDelete.add(productId);
+                    break;
+                }
+            }
+        }
+        return {
+            productUpdates: Array.from(productUpdatesById.values()).filter((u) => Object.keys(u).length > 1),
+            variantCreates,
+            variantUpdates,
+            variantDeletes,
+            attributeAdds,
+            attributeRemoves,
+            productsToDelete: Array.from(productsToDelete),
+            pendingActionIds,
+        };
+    });
+    (0, workflows_sdk_1.when)({ buckets }, ({ buckets }) => buckets.productUpdates.length > 0).then(() => {
+        core_flows_1.updateProductsWorkflow.runAsStep({
+            input: (0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => ({
+                products: buckets.productUpdates,
+            })),
+        });
+    });
+    (0, workflows_sdk_1.when)({ buckets }, ({ buckets }) => buckets.variantDeletes.length > 0).then(() => {
+        core_flows_1.deleteProductVariantsWorkflow.runAsStep({
+            input: (0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => ({
+                ids: buckets.variantDeletes,
+            })),
+        });
+    });
+    (0, workflows_sdk_1.when)({ buckets }, ({ buckets }) => buckets.variantCreates.length > 0).then(() => {
+        core_flows_1.createProductVariantsWorkflow.runAsStep({
+            input: (0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => ({
+                product_variants: buckets.variantCreates,
+            })),
+        });
+    });
+    (0, workflows_sdk_1.when)({ buckets }, ({ buckets }) => buckets.variantUpdates.length > 0).then(() => {
+        core_flows_1.updateProductVariantsWorkflow.runAsStep({
+            input: (0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => ({
+                product_variants: buckets.variantUpdates,
+            })),
+        });
+    });
+    apply_product_attribute_change_actions_1.applyProductAttributeChangeActionsWorkflow.runAsStep({
+        input: (0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => ({
+            add_actions: buckets.attributeAdds,
+            remove_actions: buckets.attributeRemoves,
+        })),
+    });
+    (0, workflows_sdk_1.when)({ buckets }, ({ buckets }) => buckets.productsToDelete.length > 0).then(() => {
+        core_flows_1.deleteProductsWorkflow.runAsStep({
+            input: (0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => ({
+                ids: buckets.productsToDelete,
+            })),
+        });
+    });
+    (0, workflows_sdk_1.when)({ buckets }, ({ buckets }) => buckets.pendingActionIds.length > 0).then(() => {
+        (0, steps_1.updateProductChangeActionsStep)((0, workflows_sdk_1.transform)({ buckets }, ({ buckets }) => buckets.pendingActionIds.map((id) => ({ id, applied: true }))));
+    });
+    return new workflows_sdk_1.WorkflowResponse(void 0);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply-product-change-actions.js","sourceRoot":"","sources":["../../../../../../src/workflows/product-edit/workflows/apply-product-change-actions.ts"],"names":[],"mappings":";;;AAAA,qEAM0C;AAC1C,4DAOoC;AACpC,2CAAyD;AAEzD,oCAAyD;AACzD,qGAAqG;AAqBxF,QAAA,mCAAmC,GAC9C,8BAA8B,CAAA;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACU,QAAA,iCAAiC,GAI1C,IAAA,8BAAc,EAChB,2CAAmC,EACnC,UAAU,KAA6C;IACrD,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAA,8BAAiB,EAAC;QAC1C,MAAM,EAAE,uBAAuB;QAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC;QAC5D,OAAO,EAAE;YACP,iBAAiB,EAAE,KAAK,CAAC,UAAU;YACnC,OAAO,EAAE,KAAK;SACf;KACF,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,yBAAyB,EAAE,CAAC,CAAA;IAE9C,MAAM,OAAO,GAAG,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAmB,EAAE;QACtE,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAG/B,CAAA;QACH,MAAM,cAAc,GAEhB,EAAE,CAAA;QACN,MAAM,cAAc,GAAoD,EAAE,CAAA;QAC1E,MAAM,cAAc,GAAa,EAAE,CAAA;QACnC,MAAM,aAAa,GAAqC,EAAE,CAAA;QAC1D,MAAM,gBAAgB,GAAwC,EAAE,CAAA;QAChE,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAA;QAC1C,MAAM,gBAAgB,GAAa,EAAE,CAAA;QAErC,KAAK,MAAM,MAAM,IAAI,OAAO,IAAI,EAAE,EAAE,CAAC;YACnC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO;gBAAE,SAAQ;YACvC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAY,CAAC,CAAA;YAE1C,MAAM,SAAS,GAAG,MAAM,CAAC,UAAoB,CAAA;YAC7C,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAA4B,CAAA;YAEjE,QAAQ,MAAM,CAAC,MAAM,EAAE,CAAC;gBACtB,KAAK,+BAAuB,CAAC,aAAa,CAAC,CAAC,CAAC;oBAC3C,MAAM,MAAM,GAAI,OAA+B,CAAC,MAAM,CAAA;oBACtD,IAAI,MAAM,KAAK,SAAS;wBAAE,MAAK;oBAC/B,MAAM,CAAC,GAAG,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,EAAE,SAAS,EAAE,CAAA;oBAChE,CAAC,CAAC,MAAM,GAAG,MAAM,CAAA;oBACjB,kBAAkB,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;oBACpC,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,MAAM,CAAC,CAAC,CAAC;oBACpC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,OAGxB,CAAA;oBACD,IAAI,CAAC,KAAK;wBAAE,MAAK;oBACjB,MAAM,CAAC,GAAG,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,EAAE,SAAS,EAAE,CAAA;oBAChE,CAAC,CAAC,KAAK,CAAC,GAAG,KAAK,CAAA;oBAChB,kBAAkB,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;oBACpC,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,WAAW,CAAC,CAAC,CAAC;oBACzC,MAAM,OAAO,GACX,OACD,CAAC,OAAO,CAAA;oBACT,IAAI,CAAC,OAAO;wBAAE,MAAK;oBACnB,cAAc,CAAC,IAAI,CAAC,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAA;oBAC1D,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,cAAc,CAAC,CAAC,CAAC;oBAC5C,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,OAG9B,CAAA;oBACD,IACE,CAAC,UAAU;wBACX,CAAC,MAAM;wBACP,CAAC,MAAM,CAAC,IAAI,CAAC,MAAgB,CAAC,CAAC,MAAM;wBAErC,MAAK;oBACP,cAAc,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;oBAClD,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,cAAc,CAAC,CAAC,CAAC;oBAC5C,MAAM,SAAS,GAAI,OAAmC,CAAC,UAAU,CAAA;oBACjE,IAAI,SAAS;wBAAE,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;oBAC7C,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,aAAa,CAAC,CAAC,CAAC;oBAC3C,MAAM,EAAE,YAAY,EAAE,mBAAmB,EAAE,GAAG,OAG7C,CAAA;oBACD,IAAI,CAAC,YAAY,IAAI,CAAC,mBAAmB,EAAE,MAAM;wBAAE,MAAK;oBACxD,aAAa,CAAC,IAAI,CAAC;wBACjB,UAAU,EAAE,SAAS;wBACrB,YAAY;wBACZ,mBAAmB;qBACpB,CAAC,CAAA;oBACF,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,gBAAgB,CAAC,CAAC,CAAC;oBAC9C,MAAM,WAAW,GAAI,OAAqC;yBACvD,YAAY,CAAA;oBACf,IAAI,CAAC,WAAW;wBAAE,MAAK;oBACvB,gBAAgB,CAAC,IAAI,CAAC;wBACpB,UAAU,EAAE,SAAS;wBACrB,YAAY,EAAE,WAAW;qBAC1B,CAAC,CAAA;oBACF,MAAK;gBACP,CAAC;gBACD,KAAK,+BAAuB,CAAC,cAAc,CAAC,CAAC,CAAC;oBAC5C,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;oBAC/B,MAAK;gBACP,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO;YACL,cAAc,EAAE,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAC5D,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CACjC;YACD,cAAc;YACd,cAAc;YACd,cAAc;YACd,aAAa;YACb,gBAAgB;YAChB,gBAAgB,EAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC;YAC9C,gBAAgB;SACjB,CAAA;IACH,CAAC,CAAC,CAAA;IAEF,IAAA,oBAAI,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CACxE,GAAG,EAAE;QACH,mCAAsB,CAAC,SAAS,CAAC;YAC/B,KAAK,EAAE,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC9C,QAAQ,EAAE,OAAO,CAAC,cAAuB;aAC1C,CAAC,CAAC;SACJ,CAAC,CAAA;IACJ,CAAC,CACF,CAAA;IAED,IAAA,oBAAI,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CACxE,GAAG,EAAE;QACH,0CAA6B,CAAC,SAAS,CAAC;YACtC,KAAK,EAAE,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC9C,GAAG,EAAE,OAAO,CAAC,cAAc;aAC5B,CAAC,CAAC;SACJ,CAAC,CAAA;IACJ,CAAC,CACF,CAAA;IAED,IAAA,oBAAI,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CACxE,GAAG,EAAE;QACH,0CAA6B,CAAC,SAAS,CAAC;YACtC,KAAK,EAAE,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC9C,gBAAgB,EAAE,OAAO,CAAC,cAAuB;aAClD,CAAC,CAAC;SACJ,CAAC,CAAA;IACJ,CAAC,CACF,CAAA;IAED,IAAA,oBAAI,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CACxE,GAAG,EAAE;QACH,0CAA6B,CAAC,SAAS,CAAC;YACtC,KAAK,EAAE,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC9C,gBAAgB,EAAE,OAAO,CAAC,cAAuB;aAClD,CAAC,CAAC;SACJ,CAAC,CAAA;IACJ,CAAC,CACF,CAAA;IAED,mFAA0C,CAAC,SAAS,CAAC;QACnD,KAAK,EAAE,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;YAC9C,WAAW,EAAE,OAAO,CAAC,aAAa;YAClC,cAAc,EAAE,OAAO,CAAC,gBAAgB;SACzC,CAAC,CAAC;KACJ,CAAC,CAAA;IAEF,IAAA,oBAAI,EACF,EAAE,OAAO,EAAE,EACX,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,CACrD,CAAC,IAAI,CAAC,GAAG,EAAE;QACV,mCAAsB,CAAC,SAAS,CAAC;YAC/B,KAAK,EAAE,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC9C,GAAG,EAAE,OAAO,CAAC,gBAAgB;aAC9B,CAAC,CAAC;SACJ,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,IAAA,oBAAI,EACF,EAAE,OAAO,EAAE,EACX,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,CACrD,CAAC,IAAI,CAAC,GAAG,EAAE;QACV,IAAA,sCAA8B,EAC5B,IAAA,yBAAS,EAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACrC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAC9D,CACF,CAAA;IACH,CAAC,CAAC,CAAA;IAEF,OAAO,IAAI,gCAAgB,CAAC,KAAK,CAAC,CAAC,CAAA;AACrC,CAAC,CACF,CAAA"}