@factorypure/client-helpers 1.2.1 → 1.3.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { MatchResult } from '@factorypure/matching-engine';
 import { z } from 'zod';
+export * from './repricing.js';
 /**
  * @packageDocumentation
  * @module @factorypure/client-helpers
@@ -932,4 +933,3 @@ export declare function getUndercutResults(shownResults: (ScrapeResultsType | Im
  * Results are sorted by price ascending.
  */
 export declare function getNeedsReviewResults(sortedResults: (ScrapeResultsType | ImmersiveScrapeResultsType)[], shownResults: (ScrapeResultsType | ImmersiveScrapeResultsType)[], variantPrice: number): (ScrapeResultsType | ImmersiveScrapeResultsType)[];
-export {};

package/dist/index.js

@@ -3,6 +3,7 @@ import { startOfDay, subDays } from 'date-fns';
 import { Index } from 'flexsearch';
 import EnglishPreset from 'flexsearch/lang/en';
 import { z } from 'zod';
+export * from './repricing.js';
 //  GOTCHA must restart client
 //  npm install /Users/kokkoalex/Documents/GitHub/npm-packages/client-helpers
 //  npm uninstall @factorypure/client-helpers

package/dist/repricing.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Automated repricing decision engine.
+ *
+ * Pure functions only (no I/O) so the same logic powers the fpjobs repricing job,
+ * the fpdash-server simulate endpoint, and client-side previews.
+ *
+ * Margin/profit/shipping math intentionally mirrors fpdash-client `getMargin`,
+ * `getProfit`, `getShippingFeeDetails` and `getShouldUseShippingInProfitMargin`.
+ */
+export type RepricingUndercutType = 'FIXED' | 'PERCENT';
+export type RepricingFloorBehavior = 'skip' | 'match' | 'clamp_to_floor';
+export type RepricingCeilingSource = 'baseline' | 'msrp' | 'lowest_of_both';
+export type RepricingRounding = 'none' | '99' | 'whole';
+export type RepricingCompareAtBehavior = 'leave' | 'set_old_price' | 'clear';
+export type RepricingLowStockAction = 'none' | 'skip_decrease';
+export type RepricingStrategy = 'beat_lowest' | 'raise_recovery';
+export type RepricingAction = 'auto' | 'approval' | 'skip' | 'none';
+export type RepricingRuleScope = 'global' | 'company' | 'variant';
+export interface RepricingRules {
+    enabled: boolean;
+    /**
+     * Off switch / live mode. When false, decisions are only logged (observe-only) and
+     * nothing is applied or queued. Only true when the global layer also enables it.
+     */
+    live_enabled: boolean;
+    undercut_type: RepricingUndercutType;
+    undercut_value: number;
+    floor_behavior: RepricingFloorBehavior;
+    min_margin_pct: number | null;
+    min_profit: number | null;
+    respect_map: boolean;
+    allow_raise: boolean;
+    raise_requires_approval: boolean;
+    ceiling_source: RepricingCeilingSource;
+    rounding: RepricingRounding;
+    compare_at_behavior: RepricingCompareAtBehavior;
+    /** Ignore changes smaller than this many dollars. */
+    min_change_amt: number;
+    /** Auto-apply only when |change| <= this percent of current price. null = no limit. */
+    auto_max_change_pct: number | null;
+    /** Auto-apply only when |change| <= this many dollars. null = no limit. */
+    auto_max_change_amt: number | null;
+    min_hours_between_changes: number;
+    stale_hours: number;
+    excluded_sources: string[];
+    min_variant_price: number;
+    low_stock_threshold: number | null;
+    low_stock_action: RepricingLowStockAction;
+    max_auto_changes_per_day: number | null;
+    approval_expiry_hours: number | null;
+}
+/** Conservative placeholders until management sets real values. */
+export declare const DEFAULT_REPRICING_RULES: Readonly<RepricingRules>;
+export declare const REPRICING_RULE_KEYS: (keyof RepricingRules)[];
+export type RepricingRuleLayer = {
+    [K in keyof RepricingRules]?: RepricingRules[K] | null;
+};
+/** Coerces a DB row (TINYINT/DECIMAL strings/JSON text) into a typed rule layer. */
+export declare function normalizeRepricingRuleLayer(row: Record<string, unknown> | null | undefined): RepricingRuleLayer;
+/**
+ * Merges layers broadest-first (global, company, variant). NULL/undefined values inherit.
+ * `live_enabled` additionally requires the global layer to be explicitly enabled so
+ * a single global switch can stop all automatic changes.
+ */
+export declare function resolveRepricingRules(layers: {
+    global?: RepricingRuleLayer | null;
+    company?: RepricingRuleLayer | null;
+    variant?: RepricingRuleLayer | null;
+}): RepricingRules;
+export interface RepricingVariantInput {
+    id: number;
+    price: number;
+    compare_at_price?: number | null;
+    unit_cost: number | null;
+    custom_map_price?: number | null;
+    custom_msrp?: number | null;
+    median_shipping_cost?: number | null;
+    custom_projected_shipping_fee?: number | null;
+    shipping_included_in_cost?: 0 | 1 | null;
+    inventory_quantity?: number | null;
+    tracks_inventory?: 0 | 1 | boolean | null;
+    inventory_policy?: string | null;
+    product_status?: string | null;
+    ignore_auto_price_updates?: boolean;
+    has_active_price_cut?: boolean;
+    /** When the variant was last scraped (any result). Used to tell "competitor gone" from "no data". */
+    last_scraped_at?: Date | string | null;
+}
+export interface RepricingVariantState {
+    baseline_price?: number | null;
+    last_changed_at?: Date | string | null;
+}
+export interface CompetitorObservation {
+    listing_hash: string;
+    source: string | null;
+    title?: string | null;
+    /** Delivered total when known, otherwise listed price. */
+    price: number;
+    seen_at: Date | string;
+    out_of_stock?: boolean;
+}
+export interface RepricingReason {
+    code: string;
+    message: string;
+}
+export interface RepricingDecision {
+    action: RepricingAction;
+    strategy: RepricingStrategy | null;
+    old_price: number;
+    target_price: number | null;
+    old_compare_at_price: number | null;
+    /** undefined = leave unchanged. */
+    new_compare_at_price: number | null | undefined;
+    floor_price: number | null;
+    ceiling_price: number | null;
+    competitor: CompetitorObservation | null;
+    usable_competitor_count: number;
+    unit_cost: number | null;
+    shipping_cost: number;
+    margin_before: number | null;
+    margin_after: number | null;
+    profit_after: number | null;
+    reasons: RepricingReason[];
+}
+export declare const round2: (n: number) => number;
+/** Largest "nice" price <= value (used when lowering toward a competitor). */
+export declare function roundPriceDown(value: number, rounding: RepricingRounding): number;
+/** Smallest "nice" price >= value (used when respecting a floor). */
+export declare function roundPriceUp(value: number, rounding: RepricingRounding): number;
+export declare function getRepricingShippingCost(variant: RepricingVariantInput): number;
+export declare function computeRepricingMargin(price: number, variant: RepricingVariantInput): number | null;
+export declare function computeRepricingProfit(price: number, variant: RepricingVariantInput): number | null;
+/** Lowest price that satisfies margin, profit and MAP guardrails. */
+export declare function computeRepricingFloor(variant: RepricingVariantInput, rules: RepricingRules): number;
+export declare function computeRepricingCeiling(variant: RepricingVariantInput, state: RepricingVariantState | null | undefined, rules: RepricingRules): number;
+/**
+ * Filters competitor observations down to the ones allowed to drive a price change.
+ * Returns usable observations (cheapest first) plus the reasons others were dropped.
+ */
+export declare function filterRepricingCompetitors({ variant, competitors, rules, now, }: {
+    variant: RepricingVariantInput;
+    competitors: CompetitorObservation[];
+    rules: RepricingRules;
+    now: Date;
+}): {
+    usable: CompetitorObservation[];
+    dropped: Record<string, number>;
+    freshCount: number;
+};
+export declare function computeRepricingDecision({ variant, competitors, rules, state, now, }: {
+    variant: RepricingVariantInput;
+    competitors: CompetitorObservation[];
+    rules: RepricingRules;
+    state?: RepricingVariantState | null;
+    now?: Date;
+}): RepricingDecision;

package/dist/repricing.js

@@ -0,0 +1,411 @@
+/**
+ * Automated repricing decision engine.
+ *
+ * Pure functions only (no I/O) so the same logic powers the fpjobs repricing job,
+ * the fpdash-server simulate endpoint, and client-side previews.
+ *
+ * Margin/profit/shipping math intentionally mirrors fpdash-client `getMargin`,
+ * `getProfit`, `getShippingFeeDetails` and `getShouldUseShippingInProfitMargin`.
+ */
+/** Conservative placeholders until management sets real values. */
+export const DEFAULT_REPRICING_RULES = Object.freeze({
+    enabled: false,
+    live_enabled: false,
+    undercut_type: 'FIXED',
+    undercut_value: 1,
+    floor_behavior: 'skip',
+    min_margin_pct: 11,
+    min_profit: null,
+    respect_map: true,
+    allow_raise: true,
+    raise_requires_approval: true,
+    ceiling_source: 'baseline',
+    rounding: 'none',
+    compare_at_behavior: 'leave',
+    min_change_amt: 1,
+    auto_max_change_pct: 5,
+    auto_max_change_amt: 25,
+    min_hours_between_changes: 24,
+    stale_hours: 48,
+    excluded_sources: [],
+    min_variant_price: 100,
+    low_stock_threshold: null,
+    low_stock_action: 'none',
+    max_auto_changes_per_day: 50,
+    approval_expiry_hours: 72,
+});
+export const REPRICING_RULE_KEYS = Object.keys(DEFAULT_REPRICING_RULES);
+const BOOLEAN_RULE_KEYS = [
+    'enabled',
+    'live_enabled',
+    'respect_map',
+    'allow_raise',
+    'raise_requires_approval',
+];
+/** Coerces a DB row (TINYINT/DECIMAL strings/JSON text) into a typed rule layer. */
+export function normalizeRepricingRuleLayer(row) {
+    const layer = {};
+    if (!row)
+        return layer;
+    for (const key of REPRICING_RULE_KEYS) {
+        const raw = row[key];
+        if (raw === null || raw === undefined)
+            continue;
+        const defaultValue = DEFAULT_REPRICING_RULES[key];
+        if (BOOLEAN_RULE_KEYS.includes(key)) {
+            layer[key] = raw === true || raw === 1 || raw === '1';
+        }
+        else if (key === 'excluded_sources') {
+            const parsed = typeof raw === 'string' ? safeJsonParse(raw) : raw;
+            layer[key] = Array.isArray(parsed) ? parsed.map(String) : [];
+        }
+        else if (typeof defaultValue === 'number' || defaultValue === null) {
+            const num = Number(raw);
+            if (Number.isFinite(num))
+                layer[key] = num;
+        }
+        else {
+            layer[key] = raw;
+        }
+    }
+    return layer;
+}
+/**
+ * Merges layers broadest-first (global, company, variant). NULL/undefined values inherit.
+ * `live_enabled` additionally requires the global layer to be explicitly enabled so
+ * a single global switch can stop all automatic changes.
+ */
+export function resolveRepricingRules(layers) {
+    const resolved = { ...DEFAULT_REPRICING_RULES };
+    for (const layer of [layers.global, layers.company, layers.variant]) {
+        if (!layer)
+            continue;
+        for (const key of REPRICING_RULE_KEYS) {
+            const value = layer[key];
+            if (value !== null && value !== undefined)
+                resolved[key] = value;
+        }
+    }
+    const globalLive = layers.global?.live_enabled === true;
+    resolved.live_enabled = globalLive && resolved.live_enabled === true;
+    return resolved;
+}
+const OUR_SOURCE_NAMES = ['factorypure', 'factory pure'];
+const OUTLIER_LOW_RATIO = 0.5;
+const OUTLIER_HIGH_RATIO = 2;
+export const round2 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
+/** Largest "nice" price <= value (used when lowering toward a competitor). */
+export function roundPriceDown(value, rounding) {
+    if (rounding === 'whole')
+        return Math.floor(value + 1e-9);
+    if (rounding === '99')
+        return round2(Math.floor(value + 0.01 + 1e-9) - 0.01);
+    return round2(Math.floor(value * 100 + 1e-6) / 100);
+}
+/** Smallest "nice" price >= value (used when respecting a floor). */
+export function roundPriceUp(value, rounding) {
+    if (rounding === 'whole')
+        return Math.ceil(value - 1e-9);
+    if (rounding === '99')
+        return round2(Math.ceil(value + 0.01 - 1e-9) - 0.01);
+    return round2(Math.ceil(value * 100 - 1e-6) / 100);
+}
+export function getRepricingShippingCost(variant) {
+    const median = Number(variant.median_shipping_cost ?? 0);
+    if (median > 0)
+        return median;
+    return Number(variant.custom_projected_shipping_fee ?? 0);
+}
+function usesShippingInMargin(variant) {
+    return variant.shipping_included_in_cost === undefined ? true : !variant.shipping_included_in_cost;
+}
+export function computeRepricingMargin(price, variant) {
+    if (!price || !isFinite(price) || variant.unit_cost === null || variant.unit_cost === undefined)
+        return null;
+    const shipping = usesShippingInMargin(variant) ? getRepricingShippingCost(variant) : 0;
+    return round2(((price - Number(variant.unit_cost) - shipping) / price) * 100);
+}
+export function computeRepricingProfit(price, variant) {
+    if (variant.unit_cost === null || variant.unit_cost === undefined)
+        return null;
+    const shipping = usesShippingInMargin(variant) ? getRepricingShippingCost(variant) : 0;
+    return round2(price - Number(variant.unit_cost) - shipping);
+}
+/** Lowest price that satisfies margin, profit and MAP guardrails. */
+export function computeRepricingFloor(variant, rules) {
+    const cost = Number(variant.unit_cost ?? 0);
+    const shipping = usesShippingInMargin(variant) ? getRepricingShippingCost(variant) : 0;
+    const floors = [0.01];
+    if (rules.min_margin_pct !== null && rules.min_margin_pct < 100) {
+        floors.push((cost + shipping) / (1 - rules.min_margin_pct / 100));
+    }
+    if (rules.min_profit !== null) {
+        floors.push(cost + shipping + rules.min_profit);
+    }
+    if (rules.respect_map && variant.custom_map_price && Number(variant.custom_map_price) > 0) {
+        floors.push(Number(variant.custom_map_price));
+    }
+    return roundPriceUp(Math.max(...floors), 'none');
+}
+export function computeRepricingCeiling(variant, state, rules) {
+    const baseline = Number(state?.baseline_price ?? variant.price);
+    const msrp = variant.custom_msrp && Number(variant.custom_msrp) > 0 ? Number(variant.custom_msrp) : null;
+    if (rules.ceiling_source === 'msrp')
+        return msrp ?? baseline;
+    if (rules.ceiling_source === 'lowest_of_both')
+        return msrp !== null ? Math.min(msrp, baseline) : baseline;
+    return baseline;
+}
+function toTime(value) {
+    if (value === null || value === undefined)
+        return null;
+    const t = value instanceof Date ? value.getTime() : new Date(value).getTime();
+    return Number.isFinite(t) ? t : null;
+}
+function isOurOutOfStock(variant) {
+    const tracks = variant.tracks_inventory === 1 || variant.tracks_inventory === true;
+    if (!tracks)
+        return false;
+    if (variant.inventory_policy === 'continue')
+        return false;
+    return Number(variant.inventory_quantity ?? 0) <= 0;
+}
+function isLowStock(variant, rules) {
+    if (rules.low_stock_threshold === null)
+        return false;
+    const tracks = variant.tracks_inventory === 1 || variant.tracks_inventory === true;
+    if (!tracks)
+        return false;
+    return Number(variant.inventory_quantity ?? 0) <= rules.low_stock_threshold;
+}
+function applyUndercut(competitorPrice, rules) {
+    if (rules.undercut_type === 'PERCENT')
+        return competitorPrice * (1 - rules.undercut_value / 100);
+    return competitorPrice - rules.undercut_value;
+}
+function computeCompareAt(variant, newPrice, rules) {
+    const current = variant.compare_at_price !== null && variant.compare_at_price !== undefined
+        ? Number(variant.compare_at_price)
+        : null;
+    if (rules.compare_at_behavior === 'clear')
+        return current === null ? undefined : null;
+    if (rules.compare_at_behavior === 'set_old_price') {
+        if (newPrice < variant.price) {
+            const target = current !== null && current > variant.price ? current : variant.price;
+            return target === current ? undefined : round2(target);
+        }
+        if (current !== null && current <= newPrice)
+            return null;
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Filters competitor observations down to the ones allowed to drive a price change.
+ * Returns usable observations (cheapest first) plus the reasons others were dropped.
+ */
+export function filterRepricingCompetitors({ variant, competitors, rules, now, }) {
+    const excluded = new Set(rules.excluded_sources.map((s) => s.trim().toLowerCase()).filter(Boolean));
+    const staleCutoff = now.getTime() - rules.stale_hours * 3_600_000;
+    const dropped = {};
+    const drop = (code) => (dropped[code] = (dropped[code] ?? 0) + 1);
+    const usable = [];
+    let freshCount = 0;
+    for (const c of competitors) {
+        const source = (c.source ?? '').trim().toLowerCase();
+        const seen = toTime(c.seen_at);
+        if (seen === null || seen < staleCutoff) {
+            drop('stale');
+            continue;
+        }
+        freshCount++;
+        if (OUR_SOURCE_NAMES.includes(source)) {
+            drop('our_listing');
+            continue;
+        }
+        if (excluded.has(source)) {
+            drop('excluded_source');
+            continue;
+        }
+        if (c.out_of_stock) {
+            drop('out_of_stock');
+            continue;
+        }
+        if (!(c.price > 0)) {
+            drop('no_price');
+            continue;
+        }
+        if (c.price < variant.price * OUTLIER_LOW_RATIO || c.price > variant.price * OUTLIER_HIGH_RATIO) {
+            drop('price_outlier');
+            continue;
+        }
+        usable.push(c);
+    }
+    usable.sort((a, b) => a.price - b.price);
+    return { usable, dropped, freshCount };
+}
+export function computeRepricingDecision({ variant, competitors, rules, state, now = new Date(), }) {
+    const price = Number(variant.price);
+    const reasons = [];
+    const shipping = usesShippingInMargin(variant) ? getRepricingShippingCost(variant) : 0;
+    const base = {
+        action: 'none',
+        strategy: null,
+        old_price: price,
+        target_price: null,
+        old_compare_at_price: variant.compare_at_price !== null && variant.compare_at_price !== undefined
+            ? Number(variant.compare_at_price)
+            : null,
+        new_compare_at_price: undefined,
+        floor_price: null,
+        ceiling_price: null,
+        competitor: null,
+        usable_competitor_count: 0,
+        unit_cost: variant.unit_cost === null || variant.unit_cost === undefined ? null : Number(variant.unit_cost),
+        shipping_cost: round2(shipping),
+        margin_before: computeRepricingMargin(price, variant),
+        margin_after: null,
+        profit_after: null,
+        reasons,
+    };
+    const skip = (code, message) => {
+        reasons.push({ code, message });
+        return { ...base, action: 'skip' };
+    };
+    const none = (code, message) => {
+        reasons.push({ code, message });
+        return { ...base, action: 'none' };
+    };
+    if (!rules.enabled)
+        return skip('disabled', 'Repricing is not enabled for this product');
+    if (variant.product_status && variant.product_status !== 'active') {
+        return skip('inactive_product', `Product status is ${variant.product_status}`);
+    }
+    if (variant.ignore_auto_price_updates)
+        return skip('ignore_auto_updates', 'Product is marked "don\'t auto-update price"');
+    if (variant.has_active_price_cut)
+        return skip('active_price_cut', 'Product is in an active price cut');
+    if (!(price > 0))
+        return skip('no_price', 'Product has no current price');
+    if (price < rules.min_variant_price) {
+        return skip('below_min_variant_price', `Price $${price.toFixed(2)} is below the $${rules.min_variant_price} minimum`);
+    }
+    if (base.unit_cost === null || base.unit_cost <= 0)
+        return skip('missing_cost', 'Product cost is missing');
+    if (isOurOutOfStock(variant))
+        return skip('our_out_of_stock', 'We are out of stock');
+    const lastChanged = toTime(state?.last_changed_at);
+    if (lastChanged !== null && now.getTime() - lastChanged < rules.min_hours_between_changes * 3_600_000) {
+        return skip('cooldown', `Price changed within the last ${rules.min_hours_between_changes} hours`);
+    }
+    const floor = computeRepricingFloor(variant, rules);
+    const ceiling = Math.max(computeRepricingCeiling(variant, state, rules), floor);
+    base.floor_price = floor;
+    base.ceiling_price = round2(ceiling);
+    const { usable, dropped, freshCount } = filterRepricingCompetitors({ variant, competitors, rules, now });
+    base.usable_competitor_count = usable.length;
+    for (const [code, count] of Object.entries(dropped)) {
+        reasons.push({
+            code: `ignored_${code}`,
+            message: `${count} confirmed listing(s) ignored: ${code.replace(/_/g, ' ')}`,
+        });
+    }
+    const lowest = usable[0] ?? null;
+    base.competitor = lowest;
+    let strategy;
+    let target;
+    if (lowest && lowest.price <= price) {
+        strategy = 'beat_lowest';
+        const beat = roundPriceDown(applyUndercut(lowest.price, rules), rules.rounding);
+        if (beat >= floor) {
+            target = beat;
+        }
+        else if (rules.floor_behavior === 'match' && lowest.price >= floor) {
+            target = round2(lowest.price);
+            reasons.push({
+                code: 'matched_instead_of_beat',
+                message: 'Beating would break the floor, so matching instead',
+            });
+        }
+        else if (rules.floor_behavior === 'clamp_to_floor') {
+            target = roundPriceUp(floor, rules.rounding);
+            reasons.push({ code: 'clamped_to_floor', message: `Held at floor $${floor.toFixed(2)}` });
+        }
+        else {
+            return {
+                ...skip('below_floor', `Beating $${lowest.price.toFixed(2)} would go below the $${floor.toFixed(2)} floor`),
+                strategy,
+            };
+        }
+    }
+    else {
+        if (!rules.allow_raise)
+            return none('raise_disabled', 'Not undercut, and raising is disabled');
+        if (!lowest) {
+            const lastScraped = toTime(variant.last_scraped_at);
+            const staleCutoff = now.getTime() - rules.stale_hours * 3_600_000;
+            if (competitors.length === 0 && !state?.baseline_price) {
+                return none('no_trusted_competitors', 'No human-confirmed competitor listings');
+            }
+            if (freshCount === 0 && (lastScraped === null || lastScraped < staleCutoff)) {
+                return skip('stale_data', 'No fresh competitor data to act on');
+            }
+        }
+        strategy = 'raise_recovery';
+        const desired = lowest ? roundPriceDown(applyUndercut(lowest.price, rules), rules.rounding) : ceiling;
+        target = Math.max(Math.min(desired, ceiling), floor);
+        if (target <= price)
+            return { ...none('already_competitive', 'Price is already competitive'), strategy };
+        reasons.push({
+            code: lowest ? 'competitor_raised' : 'competitor_gone',
+            message: lowest
+                ? `Lowest trusted competitor is $${lowest.price.toFixed(2)}`
+                : 'No in-stock trusted competitor is currently cheaper',
+        });
+    }
+    target = round2(target);
+    const delta = round2(target - price);
+    const result = {
+        ...base,
+        strategy,
+        target_price: target,
+        new_compare_at_price: computeCompareAt(variant, target, rules),
+        margin_after: computeRepricingMargin(target, variant),
+        profit_after: computeRepricingProfit(target, variant),
+    };
+    if (Math.abs(delta) < rules.min_change_amt) {
+        reasons.push({
+            code: 'change_too_small',
+            message: `Change of $${Math.abs(delta).toFixed(2)} is below the minimum`,
+        });
+        return { ...result, action: 'none' };
+    }
+    if (delta < 0 && rules.low_stock_action === 'skip_decrease' && isLowStock(variant, rules)) {
+        reasons.push({ code: 'low_stock', message: 'Our stock is low, so not lowering the price' });
+        return { ...result, action: 'skip' };
+    }
+    const changePct = (Math.abs(delta) / price) * 100;
+    const withinPct = rules.auto_max_change_pct === null || changePct <= rules.auto_max_change_pct;
+    const withinAmt = rules.auto_max_change_amt === null || Math.abs(delta) <= rules.auto_max_change_amt;
+    const raiseBlocked = delta > 0 && rules.raise_requires_approval;
+    if (raiseBlocked) {
+        reasons.push({ code: 'raise_needs_approval', message: 'Price increases require approval' });
+        return { ...result, action: 'approval' };
+    }
+    if (!withinPct || !withinAmt) {
+        reasons.push({
+            code: 'change_too_large',
+            message: `Change of $${Math.abs(delta).toFixed(2)} (${changePct.toFixed(1)}%) exceeds the automatic limit`,
+        });
+        return { ...result, action: 'approval' };
+    }
+    return { ...result, action: 'auto' };
+}
+function safeJsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@factorypure/client-helpers",
-    "version": "1.2.1",
+    "version": "1.3.0",
     "description": "",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -11,7 +11,7 @@
     "scripts": {
         "build": "tsc",
         "watch": "tsc --watch",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "npm run build && node --test test/*.test.js"
     },
     "keywords": [],
     "author": "",