@hszrdm/core 1.4.0 → 1.6.0

package/.medusa/server/src/jobs/back-in-stock-reconciliation.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = backInStockReconciliation;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const back_in_stock_1 = require("../core/back-in-stock");
+const back_in_stock_2 = require("../modules/back-in-stock");
+const SUBSCRIPTION_PAGE_SIZE = 1_000;
+const VARIANT_BATCH_SIZE = 250;
+async function backInStockReconciliation(container) {
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:back-in-stock-reconciliation", () => runBatch(container), { timeout: 1, expire: 840 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "back-in-stock-reconciliation",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const service = container.resolve(back_in_stock_2.BACK_IN_STOCK_MODULE);
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const locking = container.resolve("locking");
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    // Build the active waiting-list snapshot before changing any subscription
+    // statuses. This avoids offset pagination skipping rows as notifications turn
+    // active records into notified records during the dispatch phase.
+    const variantIds = new Set();
+    let scanned = 0;
+    for (let skip = 0;; skip += SUBSCRIPTION_PAGE_SIZE) {
+        const subscriptions = await service.listBackInStockSubscriptions({ status: "active" }, { take: SUBSCRIPTION_PAGE_SIZE, skip, order: { created_at: "ASC" } });
+        scanned += subscriptions.length;
+        for (const subscription of subscriptions) {
+            const variantId = String(subscription.variant_id || "").trim();
+            if (variantId)
+                variantIds.add(variantId);
+        }
+        if (subscriptions.length < SUBSCRIPTION_PAGE_SIZE)
+            break;
+    }
+    const ids = [...variantIds];
+    let sent = 0;
+    for (let offset = 0; offset < ids.length; offset += VARIANT_BATCH_SIZE) {
+        const batchIds = ids.slice(offset, offset + VARIANT_BATCH_SIZE);
+        const { data: variants } = await query.graph({
+            entity: "product_variant",
+            fields: [
+                "id",
+                "title",
+                "sku",
+                "manage_inventory",
+                "allow_backorder",
+                "metadata",
+                "product.id",
+                "product.title",
+                "product.handle",
+                "product.metadata",
+            ],
+            filters: { id: batchIds },
+        });
+        for (const variant of variants) {
+            try {
+                const result = await locking.execute(`back-in-stock:variant:${variant.id}`, () => (0, back_in_stock_1.dispatchBackInStockVariant)({
+                    container: container,
+                    query,
+                    variant,
+                }), { timeout: 1, expire: 300 });
+                sent += result.sent;
+            }
+            catch (error) {
+                logger.info(JSON.stringify({
+                    event: "back_in_stock_variant_skipped_or_failed",
+                    variant_id: variant.id,
+                    message: error instanceof Error ? error.message : String(error),
+                }));
+            }
+        }
+    }
+    return { scanned, variants: ids.length, sent };
+}
+exports.config = {
+    name: "back-in-stock-reconciliation",
+    schedule: "*/15 * * * *",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/dpd-statusdata-sync.d.ts

@@ -0,0 +1,17 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+export default function dpdStatusdataSync(container: MedusaContainer): Promise<{
+    files: number;
+    processedFiles: number;
+    records: number;
+    matched: number;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    files: number;
+    processedFiles: number;
+    records: number;
+    matched: number;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};

package/.medusa/server/src/jobs/dpd-statusdata-sync.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = dpdStatusdataSync;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const dpd_1 = require("../providers/dpd");
+const integration_operation_1 = require("../modules/integration-operation");
+const state_1 = require("../modules/integration-operation/state");
+const shipping_1 = require("../lib/modules/shipping");
+async function dpdStatusdataSync(container) {
+    if (process.env.DPD_STATUSDATA_ENABLED !== "true")
+        return;
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:dpd-statusdata-sync", () => runBatch(container), { timeout: 1, expire: 14 * 60 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "dpd-statusdata-sync",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const orderService = container.resolve("order");
+    const operationStore = container.resolve(integration_operation_1.INTEGRATION_OPERATION_MODULE);
+    const client = new dpd_1.DpdStatusdataFtpClient((0, dpd_1.dpdStatusdataFtpConfigFromEnv)());
+    const files = (await client.listFiles()).sort();
+    let processedFiles = 0;
+    let records = 0;
+    let matched = 0;
+    for (const filename of files) {
+        const acquired = await (0, state_1.acquireOperation)(operationStore, {
+            provider: "dpd",
+            operation_type: "statusdata.file",
+            entity_type: "statusdata_file",
+            entity_id: filename,
+            idempotency_key: `dpd:statusdata:file:${filename}`,
+            reference_data: {
+                replay_safe: true,
+                filename,
+            },
+        });
+        if (!acquired.acquired) {
+            if (acquired.operation.status === "succeeded")
+                continue;
+            logger.info(`[dpd-statusdata-sync] ${filename}: a fájl már feldolgozás alatt áll.`);
+            continue;
+        }
+        try {
+            const content = await client.readFile(filename);
+            const parsed = (0, dpd_1.parseDpdStatusdata)(content);
+            let fileMatched = 0;
+            let fileUnmatched = 0;
+            for (const record of parsed) {
+                const result = await (0, shipping_1.applyNormalizedTrackingEvent)({
+                    orderService,
+                    operationStore,
+                    event: (0, dpd_1.dpdStatusdataEvent)(record),
+                });
+                if (result)
+                    fileMatched += 1;
+                else
+                    fileUnmatched += 1;
+            }
+            if (fileUnmatched > 0) {
+                // Keep the file replayable. Rows already applied above are independently
+                // idempotent, so a later retry only has to match the previously missing rows.
+                throw new Error(`${fileUnmatched} DPD Statusdata eseményhez még nem található rendelés.`);
+            }
+            await (0, state_1.operationSucceeded)(operationStore, acquired.operation, filename, {
+                replay_safe: true,
+                filename,
+                record_count: parsed.length,
+                matched_count: fileMatched,
+                processed_at: new Date().toISOString(),
+            });
+            processedFiles += 1;
+            records += parsed.length;
+            matched += fileMatched;
+        }
+        catch (error) {
+            await (0, state_1.operationFailed)(operationStore, acquired.operation, error, false, filename, {
+                replay_safe: true,
+                filename,
+            });
+            logger.warn(`[dpd-statusdata-sync] ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        files: files.length,
+        processedFiles,
+        records,
+        matched,
+    };
+}
+// DPD Hungary generates Statusdata when statuses changed (hourly). Poll the
+// dedicated FTP every 15 minutes so a newly generated file is picked up quickly.
+exports.config = {
+    name: "dpd-statusdata-sync",
+    schedule: "*/15 * * * *",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/mpl-push-tracking.d.ts

@@ -0,0 +1,19 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+export default function mplPushTracking(container: MedusaContainer): Promise<{
+    records: number;
+    applied: number;
+    malformed: number;
+    unmatched: number;
+    lastRead: string | null;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    records: number;
+    applied: number;
+    malformed: number;
+    unmatched: number;
+    lastRead: string | null;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};

package/.medusa/server/src/jobs/mpl-push-tracking.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = mplPushTracking;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const mpl_1 = require("../providers/mpl");
+const integration_operation_1 = require("../modules/integration-operation");
+const shipping_1 = require("../lib/modules/shipping");
+const STATE_KEY = "mpl:tracking:push:subscription";
+const TOKEN_RENEW_AFTER_MS = 23 * 60 * 60 * 1000;
+async function mplPushTracking(container) {
+    if (process.env.MPL_ENABLED !== "true" ||
+        process.env.MPL_PUSH_TRACKING_ENABLED !== "true") {
+        return;
+    }
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:mpl-push-tracking", () => runBatch(container), { timeout: 1, expire: 14 * 60 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "mpl-push-tracking",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const operationStore = container.resolve(integration_operation_1.INTEGRATION_OPERATION_MODULE);
+    const orderService = container.resolve("order");
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const state = await loadOrCreateState(operationStore);
+    const reference = state.reference_data && typeof state.reference_data === "object"
+        ? state.reference_data
+        : {};
+    let subscriptionToken = text(reference.subscription_token);
+    let subscribedAt = dateValue(reference.subscribed_at);
+    let lastRead = text(reference.last_read) || undefined;
+    const tokenExpired = !subscriptionToken || !subscribedAt ||
+        Date.now() - subscribedAt.getTime() >= TOKEN_RENEW_AFTER_MS;
+    if (tokenExpired) {
+        subscriptionToken = await mpl_1.mplService.client.subscribePushTracking();
+        subscribedAt = new Date();
+        // lastRead is intentionally preserved across subscription renewal. MPL keeps
+        // events for 24 hours and officially supports reconnecting with lastRead.
+    }
+    const records = await mpl_1.mplService.client.readPushTracking(subscriptionToken, lastRead);
+    let applied = 0;
+    let malformed = 0;
+    let unmatched = 0;
+    let newestLastRead = lastRead;
+    let blockedPackageId;
+    let blockedInsertedAt;
+    for (const record of records) {
+        const packageId = text(record.PackageId);
+        const insertedAt = text(record.InsertedAt) || undefined;
+        if (!packageId) {
+            malformed += 1;
+            logger.warn("[mpl-push-tracking] MPL PUSH rekord PackageId nélkül; a rekord kihagyva.");
+            // A malformed provider record can never be correlated. Advancing over it
+            // prevents one invalid record from permanently blocking the stream.
+            newestLastRead = laterTimestamp(newestLastRead, insertedAt) || newestLastRead;
+            continue;
+        }
+        const occurredAt = text(record.EventDateTime) || undefined;
+        const status = (0, shipping_1.mapMplPushStatus)(record.PackageStatus, record.PackageStatusText);
+        const result = await (0, shipping_1.applyNormalizedTrackingEvent)({
+            orderService,
+            operationStore,
+            event: {
+                carrier: "mpl",
+                shipmentIdentifiers: [packageId],
+                status,
+                rawStatus: text(record.PackageStatus) || null,
+                statusText: text(record.PackageStatusText) || null,
+                occurredAt: occurredAt || insertedAt || null,
+                eventId: text(record.TrackingRecordId) || null,
+                source: "push",
+                trackingNumber: packageId,
+                extra: {
+                    lastEvent: text(record.PackageStatusText) || undefined,
+                    lastEventCategory: text(record.PackageStatus) || undefined,
+                    lastEventAt: occurredAt || insertedAt,
+                    trackingSource: "push",
+                    eventPlace: text(record.EventPlace) || undefined,
+                    insertedAt,
+                },
+            },
+        });
+        if (!result) {
+            // Do not checkpoint past an event whose order is not visible yet. On the
+            // next reconnect MPL replays it from lastRead; the failed event operation
+            // itself is retry-safe through the existing idempotency machinery.
+            unmatched += 1;
+            blockedPackageId = packageId;
+            blockedInsertedAt = insertedAt;
+            break;
+        }
+        applied += 1;
+        newestLastRead = laterTimestamp(newestLastRead, insertedAt) || newestLastRead;
+    }
+    await operationStore.updateIntegrationOperations({
+        id: state.id,
+        status: "succeeded",
+        error_summary: unmatched
+            ? "Az MPL PUSH cursor egy még nem párosítható esemény előtt megállt; a következő futás újrapróbálja."
+            : null,
+        completed_at: new Date(),
+        reference_data: {
+            replay_safe: true,
+            subscription_token: subscriptionToken,
+            subscribed_at: subscribedAt?.toISOString() || new Date().toISOString(),
+            last_read: newestLastRead || null,
+            last_poll_at: new Date().toISOString(),
+            last_record_count: records.length,
+            last_applied_count: applied,
+            last_malformed_count: malformed,
+            last_unmatched_count: unmatched,
+            blocked_package_id: blockedPackageId || null,
+            blocked_inserted_at: blockedInsertedAt || null,
+        },
+    });
+    return {
+        records: records.length,
+        applied,
+        malformed,
+        unmatched,
+        lastRead: newestLastRead || null,
+    };
+}
+async function loadOrCreateState(store) {
+    const [existing] = await store.listIntegrationOperations({ idempotency_key: STATE_KEY }, { take: 1 });
+    if (existing)
+        return existing;
+    try {
+        return await store.createIntegrationOperations({
+            provider: "mpl",
+            operation_type: "tracking.push.subscription",
+            entity_type: "tracking_subscription",
+            entity_id: "global",
+            idempotency_key: STATE_KEY,
+            status: "succeeded",
+            attempts: 1,
+            error_summary: null,
+            next_attempt_at: null,
+            completed_at: new Date(),
+            reference_data: { replay_safe: true },
+        });
+    }
+    catch (error) {
+        const [raced] = await store.listIntegrationOperations({ idempotency_key: STATE_KEY }, { take: 1 });
+        if (raced)
+            return raced;
+        throw error;
+    }
+}
+function text(value) {
+    return value == null ? "" : String(value).trim();
+}
+function dateValue(value) {
+    const date = value ? new Date(String(value)) : null;
+    return date && !Number.isNaN(date.getTime()) ? date : null;
+}
+function laterTimestamp(left, right) {
+    if (!right)
+        return left;
+    if (!left)
+        return right;
+    const leftTime = Date.parse(left);
+    const rightTime = Date.parse(right);
+    if (!Number.isFinite(leftTime))
+        return right;
+    if (!Number.isFinite(rightTime))
+        return left;
+    return rightTime > leftTime ? right : left;
+}
+exports.config = {
+    name: "mpl-push-tracking",
+    schedule: "*/15 * * * *",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/mpl-status-sync.d.ts

@@ -1,6 +1,12 @@
 import type { MedusaContainer } from "@medusajs/framework/types";
-export default function mplStatusSync(container: MedusaContainer): Promise<void>;
-export declare function runBatch(container: MedusaContainer): Promise<void>;
+export default function mplStatusSync(container: MedusaContainer): Promise<{
+    scanned: number;
+    refreshed: number;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    scanned: number;
+    refreshed: number;
+}>;
 export declare const config: {
     name: string;
     schedule: string;

package/.medusa/server/src/jobs/mpl-status-sync.js

@@ -7,14 +7,13 @@ const utils_1 = require("@medusajs/framework/utils");
 const shipping_1 = require("../lib/modules/shipping");
 const TERMINAL = new Set(["DELIVERED", "RETURNED", "CANCELLED"]);
 const PAGE_SIZE = 200;
-const MAX_ORDERS_SCANNED = 2000;
 async function mplStatusSync(container) {
     if (process.env.MPL_ENABLED !== "true" || process.env.MPL_TRACKING_ENABLED !== "true") {
         return;
     }
     const locking = container.resolve("locking");
     try {
-        return await locking.execute("job:mpl-status-sync", () => runBatch(container), { timeout: 1, expire: 3 * 60 * 60 + 50 * 60 });
+        return await locking.execute("job:mpl-status-sync", () => runBatch(container), { timeout: 1, expire: 55 * 60 });
     }
     catch (error) {
         const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
@@ -27,9 +26,12 @@ async function mplStatusSync(container) {
 }
 async function runBatch(container) {
     const orderService = container.resolve("order");
-    for (let skip = 0; skip < MAX_ORDERS_SCANNED; skip += PAGE_SIZE) {
+    let scanned = 0;
+    let refreshed = 0;
+    for (let skip = 0;; skip += PAGE_SIZE) {
         const orders = await orderService.listOrders({}, { take: PAGE_SIZE, skip, order: { created_at: "DESC" } });
         for (const order of orders) {
+            scanned += 1;
             if ((0, shipping_1.carrierForOrder)(order) !== "mpl")
                 continue;
             const shipment = order.metadata?.mpl;
@@ -42,8 +44,9 @@ async function runBatch(container) {
                     orderService,
                     orderId: order.id,
                     action: "status",
-                    actorId: "mpl-four-hour-status-sync",
+                    actorId: "mpl-hourly-status-sync",
                 });
+                refreshed += 1;
             }
             catch (error) {
                 console.error(`[mpl-status-sync] ${order.id}:`, error instanceof Error ? error.message : error);
@@ -52,7 +55,9 @@ async function runBatch(container) {
         if (orders.length < PAGE_SIZE)
             break;
     }
+    return { scanned, refreshed };
 }
-// Magyar Posta tracking guidance discourages frequent repeated queries for the same item.
-exports.config = { name: "mpl-status-sync", schedule: "15 */4 * * *" };
-//# sourceMappingURL=data:application/json;base64,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
+// Magyar Posta PULL guidance says the same tracking ID must not be queried more
+// often than once per hour. PUSH is the primary path; this hourly job is fallback.
+exports.config = { name: "mpl-status-sync", schedule: "15 * * * *" };
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/jobs/product-review-request-dispatch.d.ts

@@ -0,0 +1,28 @@
+import type { MedusaContainer } from "@medusajs/framework/types";
+import { type ReviewRequestTrigger } from "../core/review-request";
+export default function productReviewRequestDispatch(container: MedusaContainer): Promise<{
+    scanned: number;
+    sent: number;
+    trigger?: undefined;
+    delayDays?: undefined;
+} | {
+    scanned: number;
+    sent: number;
+    trigger: ReviewRequestTrigger;
+    delayDays: number;
+} | undefined>;
+export declare function runBatch(container: MedusaContainer): Promise<{
+    scanned: number;
+    sent: number;
+    trigger?: undefined;
+    delayDays?: undefined;
+} | {
+    scanned: number;
+    sent: number;
+    trigger: ReviewRequestTrigger;
+    delayDays: number;
+}>;
+export declare const config: {
+    name: string;
+    schedule: string;
+};

package/.medusa/server/src/jobs/product-review-request-dispatch.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = productReviewRequestDispatch;
+exports.runBatch = runBatch;
+const utils_1 = require("@medusajs/framework/utils");
+const product_review_1 = require("../modules/product-review");
+const review_request_1 = require("../core/review-request");
+const PAGE_SIZE = 100;
+const MAX_ORDERS_SCANNED = 2000;
+async function productReviewRequestDispatch(container) {
+    const locking = container.resolve("locking");
+    try {
+        return await locking.execute("job:product-review-request-dispatch", () => runBatch(container), { timeout: 1, expire: 3300 });
+    }
+    catch (error) {
+        const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        logger.info(JSON.stringify({
+            event: "scheduled_job_skipped_locked",
+            job: "product-review-request-dispatch",
+            message: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+async function runBatch(container) {
+    const reviewService = container.resolve(product_review_1.PRODUCT_REVIEW_MODULE);
+    const [settings] = await reviewService.listProductReviewSettings({}, { take: 1 });
+    if (!settings?.request_email_enabled)
+        return { scanned: 0, sent: 0 };
+    const trigger = normalizeTrigger(settings.request_trigger);
+    const delayDays = Math.max(0, Math.min(90, Math.trunc(Number(settings.request_delay_days) || 0)));
+    const orderService = container.resolve("order");
+    let scanned = 0;
+    let sent = 0;
+    for (let skip = 0; skip < MAX_ORDERS_SCANNED; skip += PAGE_SIZE) {
+        const orders = await orderService.listOrders({}, {
+            take: PAGE_SIZE,
+            skip,
+            order: { created_at: "DESC" },
+            relations: ["items", "customer", "fulfillments"],
+        });
+        for (const order of orders) {
+            scanned += 1;
+            if (!order.customer_id || !order.email)
+                continue;
+            if (order.canceled_at || String(order.status || "").toLowerCase() === "canceled")
+                continue;
+            if (order.metadata?.review_request_email_sent_at)
+                continue;
+            if (!Array.isArray(order.items) || !order.items.some((item) => item?.product_id))
+                continue;
+            const dueAt = (0, review_request_1.reviewRequestDueAt)(order, trigger, delayDays);
+            if (!dueAt || dueAt.getTime() > Date.now())
+                continue;
+            try {
+                const result = await (0, review_request_1.sendReviewRequestEmail)({ container: container, order: order });
+                if (result?.skipped)
+                    continue;
+                await orderService.updateOrders([{
+                        id: order.id,
+                        metadata: {
+                            ...(order.metadata || {}),
+                            review_request_email_sent_at: new Date().toISOString(),
+                            review_request_trigger: trigger,
+                            review_request_delay_days: delayDays,
+                        },
+                    }]);
+                sent += 1;
+            }
+            catch (error) {
+                const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+                logger.warn(`[product-review-request-dispatch] ${order.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (orders.length < PAGE_SIZE)
+            break;
+    }
+    return { scanned, sent, trigger, delayDays };
+}
+function normalizeTrigger(value) {
+    return value === "order" || value === "fulfillment" || value === "delivery" ? value : "delivery";
+}
+exports.config = { name: "product-review-request-dispatch", schedule: "15 * * * *" };
+//# sourceMappingURL=data:application/json;base64,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