@wix/agent-skills 1.35.1 → 1.36.1

package/skills/wix-replatform/resources/rp-target-wix/lib/pricing-plan-definition.js

@@ -1,177 +0,0 @@
-'use strict';
-
-// Pricing-plan DEFINITIONS: a row-count gate, an unpurchasable write, and
-// an honest "none found".
-//
-// A store can have zero plan-shaped rows (no subscription products, no membership
-// CPT, no recurring-plan meta), so the first deliverable here is the gate and the wording: a store
-// with nothing reports "no pricing plans found", never "pricing plans not supported" -- the
-// must-not/cannot distinction is easy to get backwards. When rows do exist, the
-// definition lands PRIVATE and unbuyable, so it is on the site without becoming purchasable; the
-// subscriptions themselves are phase 2.
-//
-// Pure: builds request bodies and decisions. The transport lives in wix-writers.js.
-
-const crypto = require('node:crypto');
-
-const SOURCES = Object.freeze(['B1', 'B2', 'B3']);
-const SOURCE_LABELS = Object.freeze({
-  B1: 'subscription products (product type + postmeta)',
-  B2: 'membership plans (wps_membership* CPT)',
-  B3: 'recurring plan definitions (WP Swings meta)',
-});
-const OUTCOMES = Object.freeze({
-  NONE_FOUND: 'plans-none-found',
-  WRITTEN: 'plan-written',
-  RECONCILED: 'plan-reconciled-existing',
-  AMBIGUOUS: 'plan-reconciliation-ambiguous',
-  UNMAPPABLE: 'plan-unmappable',
-  FAILED: 'plan-failed',
-  TARGET_READ_FAILED: 'plan-target-read-failed',
-});
-// Wix's own limits (plan.json pitfalls, verified live 2026-08-16).
-const LIMITS = Object.freeze({ name: 50, description: 450, minCycleDays: 7, maxPlanYears: 10, maxCycleCount: 2000, maxTrialDays: 999 });
-// Conservative for the MAXIMUM check (31-day months, 366-day years): Wix's own rule is calendar
-// arithmetic, and 121 monthly cycles at 30 days passed a 10-year test the API then refused.
-const PERIOD_DAYS = Object.freeze({ DAY: 1, WEEK: 7, MONTH: 31, YEAR: 366 });
-const PERIODS = Object.freeze({ day: 'DAY', week: 'WEEK', month: 'MONTH', year: 'YEAR' });
-
-// The gate. Row counts, never plugin detection (PS-13). All three at zero -> the area does not run.
-function evaluatePlanSources(rowCounts = {}) {
-  const counts = {};
-  for (const source of SOURCES) {
-    const value = rowCounts[source];
-    const n = value === undefined || value === null ? 0 : Number(value);
-    if (!Number.isInteger(n) || n < 0) throw new Error(`plan source ${source} row count must be a non-negative integer, got ${JSON.stringify(value)}`);
-    counts[source] = n;
-  }
-  const total = SOURCES.reduce((sum, s) => sum + counts[s], 0);
-  return {
-    counts,
-    total,
-    run: total > 0,
-    outcome: total > 0 ? null : OUTCOMES.NONE_FOUND,
-    // The wording is part of the contract: measured absence, not a missing capability.
-    message: total > 0 ? `${total} plan definition(s) found across ${SOURCES.filter((s) => counts[s] > 0).join(', ')}` : 'no pricing plans found in the source (all three plan-shaped sources hold zero rows)',
-  };
-}
-
-function uuidV5ish(name) {
-  const hash = crypto.createHash('sha1').update(name).digest();
-  hash[6] = (hash[6] & 0x0f) | 0x50;
-  hash[8] = (hash[8] & 0x3f) | 0x80;
-  const hex = hash.toString('hex');
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
-
-function truncate(text, limit, code, field, findings) {
-  const value = text === undefined || text === null ? '' : String(text);
-  if (value.length <= limit) return value;
-  findings.push({ code, field, length: value.length, limit });
-  return value.slice(0, limit);
-}
-
-// A normalized source offer -> the Plans V3 create body. The offer is source-agnostic:
-//   { sourceId, name, description, amount, currency?, period: day|week|month|year, interval,
-//     lengthCycles (0 = open-ended), trialDays, signupFee }
-// Returns { plan, findings, unmappable } -- `unmappable` names the reason when no body can be built.
-function buildPlanDefinition(offer = {}, { sourceSiteHost = 'source' } = {}) {
-  const findings = [];
-  if (!offer || typeof offer !== 'object') throw new Error('buildPlanDefinition needs a source offer object');
-  if (offer.sourceId === undefined || offer.sourceId === null || String(offer.sourceId).trim() === '') {
-    throw new Error('a plan offer needs a sourceId: the variant id and idempotency key derive from it');
-  }
-  const period = PERIODS[String(offer.period || '').toLowerCase()];
-  const interval = Number(offer.interval === undefined || offer.interval === null ? 1 : offer.interval);
-  if (!period) return { plan: null, findings, unmappable: { code: OUTCOMES.UNMAPPABLE, reason: 'unknown-period', period: offer.period } };
-  if (!Number.isInteger(interval) || interval < 1) return { plan: null, findings, unmappable: { code: OUTCOMES.UNMAPPABLE, reason: 'invalid-interval', interval: offer.interval } };
-  const cycleDays = PERIOD_DAYS[period] * interval;
-  if (cycleDays < LIMITS.minCycleDays) {
-    // Wix's billing cycle is at least 7 days. A source cadence of every 1-6 days cannot be recreated.
-    return { plan: null, findings, unmappable: { code: OUTCOMES.UNMAPPABLE, reason: 'billing-cycle-under-7-days', cycleDays } };
-  }
-  if (cycleDays > LIMITS.maxPlanYears * 366) {
-    // One cycle longer than the whole plan may be: no end type rescues it.
-    return { plan: null, findings, unmappable: { code: OUTCOMES.UNMAPPABLE, reason: 'billing-cycle-over-10-years', cycleDays } };
-  }
-  const amount = offer.amount === undefined || offer.amount === null ? null : String(offer.amount).trim();
-  if (amount === null || !/^\d+(\.\d{1,4})?$/.test(amount)) {
-    return { plan: null, findings, unmappable: { code: OUTCOMES.UNMAPPABLE, reason: 'amount-not-decimal', amount: offer.amount } };
-  }
-
-  const name = truncate(offer.name || `Plan ${offer.sourceId}`, LIMITS.name, 'plan-name-truncated', 'name', findings);
-  // The Stores-product linkage is severed by design; the source reference lives in the description.
-  const sourceRef = `Source: ${sourceSiteHost} offer ${offer.sourceId}${offer.name ? ` (${offer.name})` : ''}`;
-  const description = truncate([offer.description || '', sourceRef].filter(Boolean).join('\n'), LIMITS.description, 'plan-description-truncated', 'description', findings);
-
-  const billingTerms = { billingCycle: { period, count: String(interval) }, startType: 'ON_PURCHASE' };
-  const lengthCycles = Number(offer.lengthCycles === undefined || offer.lengthCycles === null ? 0 : offer.lengthCycles);
-  if (!Number.isInteger(lengthCycles) || lengthCycles < 0) return { plan: null, findings, unmappable: { code: OUTCOMES.UNMAPPABLE, reason: 'invalid-length', lengthCycles: offer.lengthCycles } };
-  if (lengthCycles === 0) {
-    billingTerms.endType = 'UNTIL_CANCELLED';
-  } else if (lengthCycles > LIMITS.maxCycleCount || cycleDays * lengthCycles > LIMITS.maxPlanYears * 366) {
-    // Longer than Wix allows: open-ended, with the loss recorded.
-    billingTerms.endType = 'UNTIL_CANCELLED';
-    findings.push({ code: 'plan-duration-exceeds-limit', lengthCycles, cycleDays, note: 'imported as UNTIL_CANCELLED' });
-  } else {
-    billingTerms.endType = 'CYCLES_COMPLETED';
-    billingTerms.cyclesCompletedDetails = { billingCycleCount: String(lengthCycles) };
-  }
-
-  const variant = {
-    // Client-minted, preserved verbatim by Wix (verified live 2026-08-16), so it is stable per offer.
-    id: uuidV5ish(`replatform:pricing-plan-variant:${sourceSiteHost}:${offer.sourceId}`),
-    name: `${interval > 1 ? `Every ${interval} ${period.toLowerCase()}s` : `${period.charAt(0)}${period.slice(1).toLowerCase()}ly`}`.replace('Dayly', 'Daily').replace('Monthly', 'Monthly'),
-    billingTerms,
-    pricingStrategies: [{ flatRate: { amount } }],
-  };
-  const rawTrial = Number(offer.trialDays === undefined || offer.trialDays === null ? 0 : offer.trialDays);
-  const trialDays = Number.isFinite(rawTrial) ? Math.floor(rawTrial) : 0;
-  if (Number.isFinite(rawTrial) && rawTrial !== trialDays) findings.push({ code: 'plan-trial-rounded', trialDays: rawTrial, used: trialDays });
-  if (Number.isInteger(trialDays) && trialDays > 0) {
-    variant.freeTrialDays = Math.min(trialDays, LIMITS.maxTrialDays);
-    if (trialDays > LIMITS.maxTrialDays) findings.push({ code: 'plan-trial-truncated', trialDays, limit: LIMITS.maxTrialDays });
-  }
-  const signupFee = offer.signupFee === undefined || offer.signupFee === null ? null : String(offer.signupFee).trim();
-  if (signupFee && /^\d+(\.\d{1,4})?$/.test(signupFee) && Number(signupFee) > 0) {
-    variant.fees = [{ name: 'Signup fee', priceType: 'FIXED_AMOUNT', fixedAmountOptions: { amount: signupFee }, appliedAt: 'FIRST_PAYMENT' }];
-  }
-
-  const plan = {
-    name,
-    description,
-    // The two flags that keep an imported definition inert, plus the status
-    // the API requires and the docs do not list (plan.json: status-required-on-create).
-    visibility: 'PRIVATE',
-    buyable: false,
-    status: 'ACTIVE',
-    buyerCanCancel: true,
-    pricingVariants: [variant],
-  };
-  return { plan, findings, unmappable: null, idempotencyKey: uuidV5ish(`replatform:pricing-plan:${sourceSiteHost}:${offer.sourceId}`) };
-}
-
-// The two invariants a test pins on the request body, kept as a function so the writer can refuse
-// a body that lost them between here and the send.
-function assertInertPlan(plan) {
-  if (!plan || plan.visibility !== 'PRIVATE' || plan.buyable !== false) {
-    throw new Error('a migrated plan definition must be visibility PRIVATE and buyable false; anything else becomes purchasable on a live site');
-  }
-}
-
-// Where ensurePlanDefinition's outcomes fold in the report: reconciled-existing is on the target,
-// so it counts as written; everything else is skipped, reasons kept for the notes.
-// Takes the writer's result objects (preferred) or bare outcome strings. A `plan-failed` whose
-// purchasable plan could NOT be archived (`error.archived === false`) is a live-site hazard, counted
-// on its own line so the report blocks on it -- review demonstrated the archive's 403 reported as
-// "archived: true" while the plan stayed buyable.
-function tallyPlanWriteOutcomes(results = []) {
-  const outcomes = results.map((r) => (r && typeof r === 'object' ? r.outcome : r));
-  const written = outcomes.filter((o) => o === OUTCOMES.WRITTEN || o === OUTCOMES.RECONCILED).length;
-  const skippedBy = {};
-  for (const o of outcomes) { if (o === OUTCOMES.WRITTEN || o === OUTCOMES.RECONCILED) continue; skippedBy[o] = (skippedBy[o] || 0) + 1; }
-  const hazards = results.filter((r) => r && typeof r === 'object' && r.outcome === OUTCOMES.FAILED && r.error && r.error.cause === 'created-plan-not-inert' && r.error.archived === false).length;
-  return { 'plans-written': written, 'plans-skipped': outcomes.length - written, 'plans-live-hazard': hazards, skippedBy };
-}
-
-module.exports = { SOURCES, SOURCE_LABELS, OUTCOMES, LIMITS, evaluatePlanSources, buildPlanDefinition, assertInertPlan, tallyPlanWriteOutcomes };

package/skills/wix-replatform/resources/rp-target-wix/lib/product-import.js

@@ -1,151 +0,0 @@
-'use strict';
-const w = require('./wix-writers');
-const v = require('./write-verification');
-const stateIO = require('../../../lib/write-verification-state');
-const local = require('../../../lib/local-state');
-const seo = require('./product-seo');
-const at = (object, path) => path.split('.').reduce((value, key) => value?.[key], object);
-const pause = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-// Match source-fixed variant projections, never the order of a returned array. The
-// mapper chooses unique SKU/choice projections before execution; ambiguity is a gap.
-function resolveVariants(expectations, product) {
-  const seen = new Set();
-  return expectations.map(row => {
-    if (!row.sourceKey || !row.expected || !Object.keys(row.expected).length) throw new Error('Source variant correspondence is required');
-    const matches = (product?.variantsInfo?.variants || []).filter(variant => v.compareProjection(row.expected, variant).verified);
-    if (matches.length !== 1 || !matches[0].id || seen.has(matches[0].id)) throw new Error('Ambiguous source-to-target variant correspondence');
-    seen.add(matches[0].id);
-    return { ...row, variantId: matches[0].id };
-  });
-}
-async function verifyProductCandidate(wix, { siteId, sourceKey, expected, targetId, marker, variantExpectations, verifyAttempts = 3, sleep = pause }) {
-  let receipt, error;
-  for (let attempt = 1; attempt <= verifyAttempts; attempt++) {
-    try {
-      // getStoresProduct's bare GET omits plainDescription entirely and collapses media to
-      // `media.main` only (see getStoresProductForVerification's comment in wix-writers.js) --
-      // a verification read needs both fields or it can never confirm what create actually wrote.
-      const actual = await w.getStoresProductForVerification(wix, targetId);
-      const identityConflict = actual?.id !== targetId || at(actual, marker.path) !== marker.value;
-      if (identityConflict) return { sourceKey, targetId, identityConflict: true, outcome: 'needs_verification', error: 'Product identity does not agree' };
-      const variants = resolveVariants(variantExpectations, actual);
-      receipt = v.receipt({ siteId, sourceKey, kind: 'product', expected, targetId, actual, marker, variants, operation: 'product-import', attempts: attempt });
-      if (receipt.verified) return { targetId, sourceKey, receipt, outcome: 'verified', variants };
-    } catch (e) { error = e.message; }
-    if (attempt < verifyAttempts) await sleep(100 * attempt);
-  }
-  return { sourceKey, targetId, receipt, outcome: 'needs_verification', error: error || 'Product identity or values do not agree' };
-}
-async function importProducts(wix, { projectDir, siteId, rows, verifyAttempts = 3, sleep = pause, dryRun = false, seoConflictDecisions = {}, seoSleep = null, seoPacer = null }) {
-  if (!siteId || !projectDir || !Array.isArray(rows) || !Number.isInteger(verifyAttempts) || verifyAttempts < 1 || verifyAttempts > 5) throw new Error('Invalid product import arguments');
-  if (rows.some(r => !r.sourceKey || !r.expected || !Object.keys(r.expected).length || !r.marker?.path || r.marker.value == null || r.marker.value === '' || !Array.isArray(r.variantExpectations) || !r.variantExpectations.length) || new Set(rows.map(r => r.sourceKey)).size !== rows.length) throw new Error('Product source identity, projection and variant expectations are required');
-  // A caller cannot omit a submitted field from verification merely to make it pass.
-  for (const row of rows) {
-    v.assertProjection(row.expected);
-    for (const variant of row.variantExpectations) v.assertProjection(variant.expected, 'variant.expected');
-    // A row carrying an SEO plan has its seoData verified per field by the SEO stage
-    // (product read-back AND resolvedTags), so it is kept out of the generic comparator: a create
-    // that drops seoData must not fail catalog identity, it must be reconciled by a guarded PATCH.
-    if (row.seo) {
-      if (!row.seo.fields || !Array.isArray(row.seo.tags)) throw new Error('row.seo must be a planProductSeo() plan');
-      if (Object.prototype.hasOwnProperty.call(row.expected, 'seoData')) throw new Error('seoData is verified by the SEO stage; omit it from expected when row.seo is set');
-      if (seo.canonicalJson(row.product?.seoData?.tags || []) !== seo.canonicalJson(row.seo.tags)) throw new Error('product.seoData must equal the SEO plan tags');
-    }
-    for (const key of Object.keys(row.product || {})) if (key !== 'variantsInfo' && !(key === 'seoData' && row.seo) && !Object.prototype.hasOwnProperty.call(row.expected, key)) throw new Error(`Missing product verification field: ${key}`);
-    const sourceVariants = row.product?.variantsInfo?.variants;
-    if (!Array.isArray(sourceVariants) || sourceVariants.length !== row.variantExpectations.length || new Set(row.variantExpectations.map(r => r.sourceKey)).size !== sourceVariants.length) throw new Error('Complete source variant expectations required');
-    sourceVariants.forEach((variant, index) => {
-      for (const key of Object.keys(variant)) if (key !== 'inventoryItem' && !Object.prototype.hasOwnProperty.call(row.variantExpectations[index].expected, key)) throw new Error(`Missing variant verification field: ${key}`);
-    });
-  }
-  if (dryRun) {
-    const seoRows = rows.filter(r => r.seo).map(r => ({ sourceKey: r.sourceKey, plan: r.seo }));
-    const seoPreview = seoRows.length ? seo.previewProductSeo(seoRows, await seo.loadSeoState(projectDir, siteId)) : [];
-    return { siteId, intended: rows.length, status: 'simulated', verified: 0, rows: [], seoPreview };
-  }
-  return local.withStateLock(projectDir, async () => {
-    const state = await stateIO.load(projectDir, siteId), crosswalk = await local.loadCrosswalk(projectDir);
-    const work = rows.map(r => ({ ...r, baseline: crosswalk.bySource[r.sourceKey] || state.rows[r.sourceKey]?.baseline || null, targetId: state.rows[r.sourceKey]?.targetId || crosswalk.bySource[r.sourceKey]?.targetId, uncertain: state.rows[r.sourceKey]?.uncertain }));
-    let catalog;
-    try { catalog = await w.queryAllStoresProducts(wix); }
-    catch (e) { for (const r of work) r.error = `Product reconciliation read failed: ${e.message}`; }
-    for (const r of work) {
-      if (r.error) continue;
-      const matches = catalog.filter(p => at(p, r.marker.path) === r.marker.value);
-      if (matches.length > 1 || (r.targetId && matches.some(p => p.id !== r.targetId))) { r.error = 'Ambiguous product marker or crosswalk'; r.identityConflict = true; }
-      else if (!r.targetId && matches.length) r.targetId = matches[0].id;
-      else if (!r.targetId && r.uncertain) r.error = 'Previous product write is uncertain; reconcile before retry';
-      if (work.some(other => other !== r && other.marker.path === r.marker.path && other.marker.value === r.marker.value)) { r.error = 'Duplicate source product marker'; r.identityConflict = true; }
-      if (r.targetId && crosswalk.rows.some(c => c.sourceStableKey !== r.sourceKey && c.targetSystem === 'wix' && c.targetId === r.targetId)) { r.error = 'Product target belongs to another source key'; r.identityConflict = true; }
-    }
-    for (const r of work) if (r.targetId && work.some(other => other !== r && other.targetId === r.targetId)) { r.error = 'Distinct source keys share a target product'; r.identityConflict = true; }
-    const save = r => {
-      const previous = state.rows[r.sourceKey];
-      const lastVerifiedReceipt = v.validReceipt(previous?.receipt) ? previous.receipt : previous?.lastVerifiedReceipt || null;
-      state.rows[r.sourceKey] = { sourceKey: r.sourceKey, targetId: r.targetId || null, baseline: r.baseline, identityConflict: Boolean(r.identityConflict),
-        uncertain: Boolean(r.uncertain), outcome: r.outcome || 'needs_verification', error: r.error || null, receipt: r.receipt || null, lastVerifiedReceipt };
-    };
-    for (const r of work) save(r);
-    await stateIO.checkpoint(projectDir, state, work);
-    // Batch by every API cap, not only product count.
-    const batches = []; let batch = [], cost = {};
-    for (const r of work.filter(r => !r.error && !r.targetId)) {
-      const next = { records: 1, ...w.storesProductBulkCost(r.product) };
-      if (Object.entries(next).some(([key, n]) => n > w.BULK_PRODUCT_LIMITS[key])) { r.error = 'Product exceeds bulk limits'; continue; }
-      if (batch.length && Object.entries(next).some(([key, n]) => (cost[key] || 0) + n > w.BULK_PRODUCT_LIMITS[key])) { batches.push(batch); batch = []; cost = {}; }
-      batch.push(r); for (const [key, n] of Object.entries(next)) cost[key] = (cost[key] || 0) + n;
-    }
-    if (batch.length) batches.push(batch);
-    for (const group of batches) {
-      for (const r of group) { r.uncertain = true; save(r); }
-      await stateIO.checkpoint(projectDir, state, group);
-      try {
-        const result = await w.bulkCreateStoresProductsWithInventory(wix, group.map(r => r.product));
-        for (const outcome of result.results) if (outcome.correlated) {
-          const r = group[outcome.index];
-          if (outcome.success) { r.targetId = outcome.productId; r.uncertain = false; r.confirmedCreate = true; }
-          else { r.error = outcome.errorCode || 'Product create failed'; r.uncertain = false; }
-          save(r);
-        }
-        for (const index of result.unresolvedIndexes) { group[index].error = 'Unresolved bulk product result'; save(group[index]); }
-      } catch (e) { for (const r of group) { r.error = e.message; save(r); } }
-      await stateIO.checkpoint(projectDir, state, group);
-    }
-    for (const r of work) if (r.targetId && work.some(other => other !== r && other.targetId === r.targetId)) { r.error = 'Distinct source keys share a target product'; r.identityConflict = true; }
-    const publications = [];
-    let verifiedBatch = [];
-    for (const r of work) {
-      if (!r.error && r.targetId) Object.assign(r, await verifyProductCandidate(wix, { ...r, siteId, verifyAttempts, sleep }));
-      save(r);
-      if (r.receipt?.verified && !r.error) publications.push({ row: { schemaVersion: 1, sourceSystem: r.sourceSystem || 'source', sourceEntityType: 'product', sourceId: r.sourceId || r.sourceKey,
-        sourceStableKey: r.sourceKey, targetSystem: 'wix', targetEntityType: 'product', targetId: r.targetId, status: 'imported' }, receipt: r.receipt, options: r });
-      verifiedBatch.push(r);
-      if (verifiedBatch.length === 100) { await stateIO.checkpoint(projectDir, state, verifiedBatch); verifiedBatch = []; }
-    }
-    await stateIO.checkpoint(projectDir, state, verifiedBatch);
-    await stateIO.persist(projectDir, state);
-    await stateIO.publishMany(projectDir, publications, work.filter(r => r.identityConflict).map(r => r.sourceKey));
-    const report = stateIO.report(work.map(r => state.rows[r.sourceKey]), siteId);
-    // Product SEO after the product exists and its identity is verified. SEO
-    // failures add stage residuals; they never un-import the product.
-    const seoRows = work.filter(r => r.seo && !r.error && r.targetId && r.receipt?.verified).map(r => ({
-      sourceKey: r.sourceKey, targetId: r.targetId, plan: r.seo,
-      // The revision this import owns: a product created or first adopted in this run starts from
-      // its verified read; a previously imported one from its crosswalk baseline (none = review).
-      savedRevision: r.confirmedCreate || !r.baseline ? r.receipt.actual?.revision ?? null : r.baseline.targetRevision ?? null,
-    }));
-    if (work.some(r => r.seo)) {
-      report.seo = seoRows.length ? await seo.reconcileProductSeo({ projectDir, siteId, rows: seoRows, conflictDecisions: seoConflictDecisions, sleep: seoSleep || sleep, pacer: seoPacer || w.sharedTargetReadPacer(),
-        readProduct: id => w.getStoresProductForVerification(wix, id),
-        patchProduct: payload => w.patchStoresProduct(wix, payload),
-        readItemSeoTags: id => w.getItemSeoTags(wix, seo.STORES_PRODUCT_ITEM_TYPE, id) }) : { siteId, results: [], stageResiduals: [] };
-      // Products whose identity did not verify still owe their held/accepted SEO rows.
-      const reconciled = new Set(seoRows.map(r => r.sourceKey));
-      const unreconciled = work.filter(r => r.seo && !reconciled.has(r.sourceKey)).map(r => ({ sourceKey: r.sourceKey, residuals: r.seo.residuals }));
-      report.seo.stageResiduals = seo.collectSeoStageResiduals([...report.seo.results, ...unreconciled]);
-    }
-    return report;
-  });
-}
-module.exports = { resolveVariants, verifyProductCandidate, importProducts };