@wix/agent-skills 1.33.1 → 1.35.0

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

@@ -0,0 +1,177 @@
+'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

@@ -0,0 +1,151 @@
+'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 };