@tokenoftrust/storefront-runner 2.4.13 → 2.4.15

package/agency-kit/tools/lib/catalog-model/model.mjs

@@ -91,6 +91,15 @@ export const CATALOG_MODEL = {
       "locale?": "string",
       accepted_at: "string",
       facts: "CatalogFact[]",
+      "setup_policy?": "CatalogSetupProvenance",
+    },
+  },
+  CatalogSetupPriceAcceptance: { fields: { engine_version: "string", policy_revision: "number", value: "number", input: "Record<string, unknown>" } },
+  CatalogSetupSkuAcceptance: { fields: { engine_version: "string", policy_revision: "number", value: "string", input: "Record<string, unknown>" } },
+  CatalogSetupProvenance: {
+    fields: {
+      tenant_id: "string", currency: "Currency",
+      "pricing?": "CatalogSetupPriceAcceptance", "sku?": "CatalogSetupSkuAcceptance",
     },
   },
   CatalogOverrideField: { alias: '"title" | "description_html" | "images" | "vendor" | "product_type"' },

package/apps/storefront/migrations-apps/0015_merchant_calculation_settings.sql

@@ -0,0 +1,31 @@
+-- Current merchant pricing and SKU defaults. One row per tenant. `revision` is the
+-- compare-and-swap token: a create lands only while the tenant has no row, and an
+-- update lands only when `revision` is still the caller's expected value.
+CREATE TABLE `merchant_calculation_settings` (
+  `tenant_id` text PRIMARY KEY NOT NULL,
+  `revision` integer NOT NULL,
+  `currency` text NOT NULL,
+  `engine_version` text NOT NULL,
+  `pricing_json` text NOT NULL,
+  `sku_json` text NOT NULL
+);
+--> statement-breakpoint
+-- Append-only copy of each accepted save. Rows are never updated. The current
+-- table is the only compare-and-swap target.
+CREATE TABLE `merchant_calculation_settings_revisions` (
+  `id` text PRIMARY KEY NOT NULL,
+  `tenant_id` text NOT NULL,
+  `revision` integer NOT NULL,
+  `currency` text NOT NULL,
+  `engine_version` text NOT NULL,
+  `pricing_json` text NOT NULL,
+  `sku_json` text NOT NULL,
+  `actor` text NOT NULL,
+  `saved_at` text NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `uq_merchant_calculation_settings_revision`
+  ON `merchant_calculation_settings_revisions` (`tenant_id`, `revision`);
+--> statement-breakpoint
+CREATE INDEX `idx_merchant_calculation_settings_revisions_tenant`
+  ON `merchant_calculation_settings_revisions` (`tenant_id`);

package/apps/storefront/src/components/islands/VariantSelector.tsx

@@ -29,6 +29,23 @@ import { priceForPurchaseOption } from "@tot/public-runtime";
 import { formatPrice } from "@/lib/format";
 import { useCheckoutHandoffCorrelation } from "@/components/islands/useCheckoutHandoffCorrelation";
 
+export type PublicSelectorVariant = Pick<CatalogVariant,
+  "id" | "sku" | "price" | "compare_at_price" | "option_values" | "inventory" | "image_id">;
+
+/** An explicit allowlist also excludes future internal variant fields from Astro hydration. */
+export function publicSelectorVariants(variants: readonly CatalogVariant[]): PublicSelectorVariant[] {
+  return variants.map((variant) => ({
+    id: variant.id,
+    ...(variant.sku !== undefined ? { sku: variant.sku } : {}),
+    price: variant.price,
+    ...(variant.compare_at_price !== undefined ? { compare_at_price: variant.compare_at_price } : {}),
+    option_values: { ...variant.option_values },
+    inventory: { available: variant.inventory.available,
+      ...(variant.inventory.quantity !== undefined ? { quantity: variant.inventory.quantity } : {}) },
+    ...(variant.image_id !== undefined ? { image_id: variant.image_id } : {}),
+  }));
+}
+
 interface OptionDef {
   name: string;
   position: number;
@@ -36,7 +53,7 @@ interface OptionDef {
 }
 
 interface Props {
-  variants: CatalogVariant[];
+  variants: PublicSelectorVariant[];
   options: OptionDef[];
   currency: string;
   locale?: string;
@@ -77,14 +94,14 @@ const LOW_STOCK_THRESHOLD = 5;
 
 type Selection = Record<string, string>;
 
-function variantMatches(v: CatalogVariant, sel: Selection): boolean {
+function variantMatches(v: PublicSelectorVariant, sel: Selection): boolean {
   return Object.entries(sel).every(([name, value]) => v.option_values[name] === value);
 }
 
 function findVariant(
-  variants: CatalogVariant[],
+  variants: PublicSelectorVariant[],
   sel: Selection,
-): CatalogVariant | undefined {
+): PublicSelectorVariant | undefined {
   return variants.find((v) => variantMatches(v, sel));
 }
 

package/apps/storefront/src/lib/admin/catalogSettingsClient.ts

@@ -0,0 +1,361 @@
+/**
+ * /admin/catalog-settings client. Field values are text nodes. A 409 keeps the
+ * open draft; replacing it requires the explicit reload control.
+ */
+import {
+  applySaveResult,
+  draftIsDirty,
+  editorFromPayload,
+  saveBody,
+  type SettingsEditorState,
+  type SettingsPayload,
+} from "@/lib/admin/catalogSettingsState";
+
+interface MethodOption {
+  id: string;
+  title: string;
+  reason: string;
+}
+
+interface SettingsResponse extends SettingsPayload {
+  ok: true;
+  pricingMethods: MethodOption[];
+  skuMethods: MethodOption[];
+  history: Array<{ revision: number; savedAt: string; actor: string }>;
+  historyUnavailable: boolean;
+}
+
+type Child = Node | string | null | undefined | false;
+
+function h<K extends keyof HTMLElementTagNameMap>(
+  tag: K,
+  attrs: Record<string, string | boolean | undefined> = {},
+  ...children: Child[]
+): HTMLElementTagNameMap[K] {
+  const node = document.createElement(tag);
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value === undefined || value === false) continue;
+    node.setAttribute(key, value === true ? "" : value);
+  }
+  for (const child of children) if (child !== null && child !== undefined && child !== false) node.append(child);
+  return node;
+}
+
+const PRICING_NUMBERS: Array<[string, string]> = [
+  ["targetMargin", "Target margin (%)"],
+  ["markup", "Markup (%)"],
+  ["msrpAdjustment", "MSRP adjustment (%)"],
+  ["fixedMarkup", "Dollar markup"],
+  ["additionalCost", "Additional cost"],
+  ["additionalCostPercent", "Additional cost (%)"],
+  ["increment", "Rounding increment"],
+  ["minimumPrice", "Minimum price"],
+  ["maximumPrice", "Maximum price"],
+  ["minimumMargin", "Minimum margin (%)"],
+];
+
+const PRICING_SELECTS: Array<[string, string, string[]]> = [
+  ["costBasis", "Cost basis", ["wholesale", "adjusted"]],
+  ["rounding", "Rounding", ["none", "increment", "ending"]],
+  ["direction", "Round direction", ["up", "nearest", "down"]],
+  ["missingData", "Missing data", ["review", "fallback"]],
+  ["fallbackMethod", "Fallback method", ["msrp", "margin", "markup", "fixed"]],
+  ["updatePolicy", "When costs change", ["on-add", "manual", "automatic"]],
+];
+
+const PRICING_FLAGS: Array<[string, string]> = [
+  ["preserveMsrp", "Preserve MSRP as compare-at"],
+  ["capAtMsrp", "Cap the price at MSRP"],
+  ["includeManualOverrides", "Include manual product overrides"],
+];
+
+const RULE_NUMBERS: Array<[string, string]> = [
+  ["targetMargin", "Target margin (%)"],
+  ["markup", "Markup (%)"],
+  ["msrpAdjustment", "MSRP adjustment (%)"],
+  ["fixedMarkup", "Dollar markup"],
+];
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" ? value as Record<string, unknown> : {};
+}
+
+function numberOrBlank(raw: string): number | "" {
+  if (raw.trim() === "") return "";
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : "";
+}
+
+function fieldString(record: Record<string, unknown>, key: string): string {
+  const value = record[key];
+  return typeof value === "number" || typeof value === "string" ? String(value) : "";
+}
+
+export function initCatalogSettingsPage(root: HTMLElement): void {
+  const found = root.querySelector<HTMLElement>("[data-settings-app]");
+  const api = root.dataset.api ?? "";
+  const previewUrl = root.dataset.preview ?? "";
+  if (!found || !api || !previewUrl) return;
+  const panel: HTMLElement = found;
+
+  let state: SettingsEditorState | null = null;
+  let storeCurrency = root.dataset.currency ?? "";
+  let pricingMethods: MethodOption[] = [];
+  let skuMethods: MethodOption[] = [];
+  let history: SettingsResponse["history"] = [];
+  let historyUnavailable = false;
+  const sample: Record<string, number | ""> = { wholesale: "", msrp: "", minimum: "", maximum: "" };
+  const sampleText: Record<string, string> = { productKey: "", assortment: "", category: "", brand: "", selectedRuleId: "" };
+  const status = h("div", { "aria-live": "polite" });
+  const previewOut = h("div", { class: "preview-out" });
+
+  function paintStatus(extra?: string): void {
+    if (!state) return;
+    const dirty = draftIsDirty(state);
+    const revision = state.savedRevision === null ? "Not saved yet" : `Saved revision ${state.savedRevision}`;
+    const lines: Node[] = [h("p", { class: "muted" }, `${revision} · ${state.currency} · ${dirty ? "Unsaved edits" : "Matches the saved defaults"}`)];
+    if (storeCurrency && state.currency !== storeCurrency) {
+      lines.push(h("p", { class: "notice error", role: "alert" }, `Saved defaults are in ${state.currency}. This store is ${storeCurrency}. No currency conversion is applied.`));
+    }
+    if (state.conflict) {
+      lines.push(h("p", { class: "notice error", role: "alert" }, state.conflict.message));
+      lines.push(h("button", { type: "button", class: "btn", "data-reload": "true" }, "Load the saved revision"));
+    }
+    if (extra) lines.push(h("p", { class: "notice error", role: "alert" }, extra));
+    status.replaceChildren(...lines);
+    status.querySelector("[data-reload]")?.addEventListener("click", () => void load());
+  }
+
+  function select(record: Record<string, unknown>, key: string, label: string, options: Array<{ value: string; label: string }>, onChange: () => void): HTMLElement {
+    const current = fieldString(record, key);
+    const known = options.some((option) => option.value === current);
+    const control = h("select", { "aria-label": label }) as HTMLSelectElement;
+    if (current && !known) control.append(h("option", { value: current }, current));
+    for (const option of options) control.append(h("option", { value: option.value }, option.label));
+    control.value = current;
+    control.addEventListener("change", () => {
+      record[key] = control.value;
+      onChange();
+    });
+    return h("label", {}, label, control);
+  }
+
+  function numberField(record: Record<string, unknown>, key: string, label: string, onChange: () => void): HTMLElement {
+    const control = h("input", { type: "text", inputmode: "decimal", "aria-label": label, value: fieldString(record, key) }) as HTMLInputElement;
+    control.addEventListener("input", () => {
+      record[key] = numberOrBlank(control.value);
+      onChange();
+    });
+    return h("label", {}, label, control);
+  }
+
+  function textField(record: Record<string, unknown>, key: string, label: string, onChange: () => void, attrs: Record<string, string> = {}): HTMLElement {
+    const control = h("input", { type: "text", "aria-label": label, value: fieldString(record, key), ...attrs }) as HTMLInputElement;
+    control.addEventListener("input", () => {
+      record[key] = control.value;
+      onChange();
+    });
+    return h("label", {}, label, control);
+  }
+
+  function flag(record: Record<string, unknown>, key: string, label: string, onChange: () => void): HTMLElement {
+    const control = h("input", { type: "checkbox" }) as HTMLInputElement;
+    control.checked = record[key] === true;
+    control.addEventListener("change", () => {
+      record[key] = control.checked;
+      onChange();
+    });
+    return h("label", { class: "inline" }, control, ` ${label}`);
+  }
+
+  function configured(key: "pricingConfigured" | "skuConfigured", label: string): HTMLElement {
+    const control = h("input", { type: "checkbox" }) as HTMLInputElement;
+    control.checked = state?.draft[key] === true;
+    control.addEventListener("change", () => {
+      if (!state) return;
+      state.draft[key] = control.checked;
+      paintStatus();
+    });
+    return h("label", { class: "inline" }, control, ` ${label}`);
+  }
+
+  function ruleRows(list: Record<string, unknown>[], kind: "exception" | "tier" | "override", onChange: () => void): HTMLElement {
+    const rows = list.map((rule, index) => {
+      const remove = h("button", { type: "button", class: "btn small" }, "Remove");
+      remove.addEventListener("click", () => {
+        list.splice(index, 1);
+        renderForm();
+      });
+      const methodOptions = (kind === "tier" ? ["margin", "markup", "fixed"] : ["msrp", "margin", "markup", "msrp-adjustment", "fixed"])
+        .map((id) => ({ value: id, label: id }));
+      return h(
+        "div",
+        { class: "rule" },
+        textField(rule, "id", "Id", onChange),
+        kind !== "override" ? null : textField(rule, "productKey", "Product", onChange),
+        kind === "override" ? numberField(rule, "price", "Price", onChange) : null,
+        kind === "exception" ? textField(rule, "name", "Name", onChange) : null,
+        kind === "exception" ? select(rule, "scope", "Scope", ["assortment", "category", "brand"].map((id) => ({ value: id, label: id })), onChange) : null,
+        kind === "exception" ? textField(rule, "match", "Match", onChange) : null,
+        kind === "tier" ? numberField(rule, "minimumCost", "Minimum cost", onChange) : null,
+        kind === "tier" ? numberField(rule, "maximumCost", "Maximum cost", onChange) : null,
+        kind === "override" ? null : select(rule, "method", "Method", methodOptions, onChange),
+        kind === "override" ? null : h("div", { class: "grid" }, ...RULE_NUMBERS.filter(([key]) => kind === "exception" || key !== "msrpAdjustment").map(([key, label]) => numberField(rule, key, label, onChange))),
+        remove,
+      );
+    });
+    return h("div", { class: "rules" }, ...rows);
+  }
+
+  function renderForm(): void {
+    if (!state) return;
+    const pricing = state.draft.pricing;
+    const sku = state.draft.sku;
+    const touch = () => paintStatus();
+    const exceptions = Array.isArray(pricing.exceptions) ? pricing.exceptions.map(asRecord) : [];
+    const tiers = Array.isArray(pricing.costTiers) ? pricing.costTiers.map(asRecord) : [];
+    const overrides = Array.isArray(pricing.productOverrides) ? pricing.productOverrides.map(asRecord) : [];
+    pricing.exceptions = exceptions;
+    pricing.costTiers = tiers;
+    pricing.productOverrides = overrides;
+
+    const add = (list: Record<string, unknown>[], blank: Record<string, unknown>, label: string) => {
+      const button = h("button", { type: "button", class: "btn small" }, label);
+      button.addEventListener("click", () => {
+        list.push({ ...blank, id: `${label.slice(0, 3).toLowerCase()}-${list.length + 1}` });
+        renderForm();
+      });
+      return button;
+    };
+
+    panel.replaceChildren(
+      status,
+      h("section", { class: "panel" },
+        h("h2", {}, "Pricing"),
+        configured("pricingConfigured", "Use these pricing defaults"),
+        h("div", { class: "grid" },
+          select(pricing, "method", "Method", pricingMethods.map((method) => ({ value: method.id, label: method.title })), touch),
+          ...PRICING_NUMBERS.map(([key, label]) => numberField(pricing, key, label, touch)),
+          ...PRICING_SELECTS.map(([key, label, values]) => select(pricing, key, label, values.map((value) => ({ value, label: value })), touch)),
+          textField(pricing, "ending", "Price ending", touch, { maxlength: "2" }),
+        ),
+        h("div", { class: "flags" }, ...PRICING_FLAGS.map(([key, label]) => flag(pricing, key, label, touch))),
+        h("h3", {}, "Exceptions"),
+        ruleRows(exceptions, "exception", touch),
+        add(exceptions, { name: "Exception", scope: "brand", match: "", method: "margin", targetMargin: 40, markup: "", msrpAdjustment: "", fixedMarkup: "" }, "Add exception"),
+        h("h3", {}, "Cost tiers"),
+        ruleRows(tiers, "tier", touch),
+        add(tiers, { minimumCost: 0, maximumCost: "", method: "margin", targetMargin: 40, markup: "", fixedMarkup: "" }, "Add cost tier"),
+        h("h3", {}, "Product price overrides"),
+        ruleRows(overrides, "override", touch),
+        add(overrides, { productKey: "", price: 0 }, "Add product override"),
+      ),
+      h("section", { class: "panel" },
+        h("h2", {}, "SKUs"),
+        configured("skuConfigured", "Use these SKU defaults"),
+        h("div", { class: "grid" },
+          select(sku, "method", "Method", skuMethods.map((method) => ({ value: method.id, label: method.title })), touch),
+          textField(sku, "prefix", "Prefix", touch, { maxlength: "12" }),
+          numberField(sku, "startingNumber", "Starting number", touch),
+          select(sku, "separator", "Separator", [{ value: "-", label: "Hyphen" }, { value: "_", label: "Underscore" }, { value: "", label: "None" }], touch),
+        ),
+      ),
+      h("section", { class: "panel" },
+        h("h2", {}, "Preview a sample"),
+        h("p", { class: "muted small" }, "The server calculates this sample with the open draft. Saving defaults does not change prices or SKUs already on your products."),
+        h("div", { class: "grid" },
+          ...(["wholesale", "msrp", "minimum", "maximum"] as const).map((key) => {
+            const control = h("input", { type: "text", inputmode: "decimal", "aria-label": key, value: String(sample[key] ?? "") }) as HTMLInputElement;
+            control.addEventListener("input", () => { sample[key] = numberOrBlank(control.value); });
+            return h("label", {}, key, control);
+          }),
+          ...(["productKey", "assortment", "category", "brand", "selectedRuleId"] as const).map((key) => {
+            const control = h("input", { type: "text", "aria-label": key, value: sampleText[key] ?? "" }) as HTMLInputElement;
+            control.addEventListener("input", () => { sampleText[key] = control.value; });
+            return h("label", {}, key, control);
+          }),
+        ),
+        h("button", { type: "button", class: "btn", "data-preview": "true" }, "Calculate sample"),
+        previewOut,
+      ),
+      h("section", { class: "panel" },
+        h("h2", {}, "Saved revisions"),
+        historyUnavailable ? h("p", { class: "muted" }, "Saved history is unavailable.") : null,
+        history.length === 0 && !historyUnavailable ? h("p", { class: "muted" }, "No saved revision yet.") : null,
+        ...history.map((entry) => h("p", { class: "small" }, `Revision ${entry.revision} · ${entry.savedAt}`)),
+      ),
+      h("div", { class: "row" },
+        h("button", { type: "button", class: "btn primary", "data-save": "true" }, "Save defaults"),
+      ),
+    );
+    panel.querySelector("[data-preview]")?.addEventListener("click", () => void preview());
+    panel.querySelector("[data-save]")?.addEventListener("click", () => void save());
+    paintStatus();
+  }
+
+  async function load(): Promise<void> {
+    const response = await fetch(api, { headers: { accept: "application/json" } });
+    const body = await response.json() as SettingsResponse & { message?: string };
+    if (!response.ok || !body.ok) {
+      panel.replaceChildren(h("p", { class: "notice error", role: "alert" }, body.message || "Pricing and SKU defaults could not be loaded."));
+      return;
+    }
+    pricingMethods = body.pricingMethods;
+    skuMethods = body.skuMethods;
+    history = body.history;
+    historyUnavailable = body.historyUnavailable;
+    state = editorFromPayload(body);
+    if (typeof body.storeCurrency === "string") storeCurrency = body.storeCurrency;
+    renderForm();
+  }
+
+  async function save(): Promise<void> {
+    if (!state) return;
+    const current = state;
+    if (storeCurrency && current.currency !== storeCurrency) {
+      paintStatus(`Saved defaults are in ${current.currency}. This store is ${storeCurrency}. No currency conversion is applied.`);
+      return;
+    }
+    const response = await fetch(api, { method: "PUT", headers: { "content-type": "application/json", accept: "application/json" }, body: JSON.stringify(saveBody(current)) });
+    const body = await response.json() as { ok: boolean; code?: string; revision?: number | null; message?: string; issues?: string[]; pricing?: SettingsPayload["pricing"]; sku?: SettingsPayload["sku"] };
+    if (body.code === "revision_conflict") {
+      state = applySaveResult(current, { ok: false, code: "revision_conflict", revision: typeof body.revision === "number" ? body.revision : null, message: body.message || "These defaults changed. Your edits are still here." });
+      paintStatus();
+      return;
+    }
+    if (!response.ok || !body.ok || typeof body.revision !== "number" || !body.pricing || !body.sku) {
+      paintStatus([body.message, ...(body.issues ?? [])].filter(Boolean).join(" "));
+      return;
+    }
+    state = applySaveResult(current, { ok: true, revision: body.revision, pricing: body.pricing, sku: body.sku });
+    renderForm();
+  }
+
+  async function preview(): Promise<void> {
+    if (!state) return;
+    const current = state;
+    const draft = saveBody(current);
+    delete draft.expectedRevision;
+    const response = await fetch(previewUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify({ ...draft, sample: { ...sample, ...Object.fromEntries(Object.entries(sampleText).filter(([, value]) => value !== "")) } }),
+    });
+    const body = await response.json() as { ok?: boolean; message?: string; issues?: string[]; pricing?: { status: string; preview?: { price: number | null; calculation: string; issues: string[]; ruleExplanation: string } }; sku?: { status: string; value?: string } };
+    previewOut.replaceChildren();
+    if (!response.ok || !body.ok) {
+      previewOut.append(h("p", { class: "notice error" }, [body.message, ...(body.issues ?? [])].filter(Boolean).join(" ")));
+      return;
+    }
+    if (body.pricing?.status === "ok" && body.pricing.preview) {
+      const calculated = body.pricing.preview;
+      previewOut.append(h("p", {}, calculated.price === null ? "No price" : `${current.currency} ${calculated.price.toFixed(2)}`));
+      if (calculated.calculation) previewOut.append(h("p", { class: "muted small" }, calculated.calculation));
+      if (calculated.ruleExplanation) previewOut.append(h("p", { class: "muted small" }, calculated.ruleExplanation));
+      for (const issue of calculated.issues) previewOut.append(h("p", { class: "notice error" }, issue));
+    } else previewOut.append(h("p", { class: "muted" }, "Pricing defaults are off for this draft."));
+    previewOut.append(h("p", {}, body.sku?.status === "ok" ? `SKU ${body.sku.value ?? ""}` : "SKU defaults are off for this draft."));
+  }
+
+  void load();
+}

package/apps/storefront/src/lib/admin/catalogSettingsState.ts

@@ -0,0 +1,103 @@
+/**
+ * Pure editor state for pricing and SKU defaults.
+ * A revision conflict keeps the unsaved draft object. Loading a saved row is a
+ * separate, explicit step.
+ */
+
+export interface SettingsSection {
+  configured: boolean;
+  settings?: Record<string, unknown>;
+}
+
+export interface SettingsPayload {
+  contractRevision: string;
+  currency: string;
+  storeCurrency?: string;
+  engineVersion: string;
+  revision: number | null;
+  pricing: SettingsSection | null;
+  sku: SettingsSection | null;
+  draftDefaults: { pricing: Record<string, unknown>; sku: Record<string, unknown> };
+}
+
+export interface CalculationDraft {
+  pricingConfigured: boolean;
+  skuConfigured: boolean;
+  pricing: Record<string, unknown>;
+  sku: Record<string, unknown>;
+}
+
+export interface SettingsEditorState {
+  contractRevision: string;
+  expectedRevision: number | null;
+  savedRevision: number | null;
+  currency: string;
+  engineVersion: string;
+  draft: CalculationDraft;
+  saved: CalculationDraft | null;
+  conflict: { revision: number | null; message: string } | null;
+}
+
+export type SaveOutcome =
+  | { ok: true; revision: number; pricing: SettingsSection; sku: SettingsSection }
+  | { ok: false; code: "revision_conflict"; revision: number | null; message: string }
+  | { ok: false; code: string; message?: string };
+
+function sectionSettings(section: SettingsSection | null, fallback: Record<string, unknown>, configured: boolean): Record<string, unknown> {
+  if (configured && section?.configured === true && section.settings) return structuredClone(section.settings);
+  return structuredClone(fallback);
+}
+
+export function editorFromPayload(payload: SettingsPayload): SettingsEditorState {
+  const draft: CalculationDraft = {
+    pricingConfigured: payload.pricing?.configured === true,
+    skuConfigured: payload.sku?.configured === true,
+    pricing: sectionSettings(payload.pricing, payload.draftDefaults.pricing, payload.pricing?.configured === true),
+    sku: sectionSettings(payload.sku, payload.draftDefaults.sku, payload.sku?.configured === true),
+  };
+  return {
+    contractRevision: payload.contractRevision,
+    expectedRevision: payload.revision,
+    savedRevision: payload.revision,
+    currency: payload.currency,
+    engineVersion: payload.engineVersion,
+    draft,
+    saved: structuredClone(draft),
+    conflict: null,
+  };
+}
+
+export function saveBody(state: SettingsEditorState): Record<string, unknown> {
+  return {
+    contractRevision: state.contractRevision,
+    expectedRevision: state.expectedRevision,
+    engineVersion: state.engineVersion,
+    currency: state.currency,
+    pricing: state.draft.pricingConfigured ? { configured: true, settings: state.draft.pricing } : { configured: false },
+    sku: state.draft.skuConfigured ? { configured: true, settings: state.draft.sku } : { configured: false },
+  };
+}
+
+export function draftIsDirty(state: SettingsEditorState): boolean {
+  return JSON.stringify(state.draft) !== JSON.stringify(state.saved);
+}
+
+/** A conflict leaves the draft reference in place and does not move the expected revision. */
+export function applySaveResult(state: SettingsEditorState, result: SaveOutcome): SettingsEditorState {
+  if (result.ok) {
+    const next = editorFromPayload({
+      contractRevision: state.contractRevision,
+      currency: state.currency,
+      engineVersion: state.engineVersion,
+      revision: result.revision,
+      pricing: result.pricing,
+      sku: result.sku,
+      draftDefaults: { pricing: state.draft.pricing, sku: state.draft.sku },
+    });
+    return { ...next, conflict: null };
+  }
+  if (result.code === "revision_conflict" && "revision" in result) {
+    return { ...state, draft: state.draft, conflict: { revision: result.revision, message: result.message } };
+  }
+  return { ...state, draft: state.draft };
+}

package/apps/storefront/src/lib/d1/schema-apps.ts

@@ -726,3 +726,42 @@ export const orderAttribution = sqliteTable(
   },
   (t) => ({ pk: primaryKey({ columns: [t.tenantId, t.externalOrderId] }) }),
 );
+
+// Merchant pricing and SKU defaults. One current row per tenant is the
+// compare-and-swap target (`revision` must still be the caller's expected
+// value). `merchant_calculation_settings_revisions` is the append-only copy of
+// each accepted save: tenant_id is the isolation boundary, actor is an opaque
+// id, and rows are never updated. Absence of a current row means the merchant
+// has not saved defaults.
+export const merchantCalculationSettings = sqliteTable("merchant_calculation_settings", {
+  tenantId: text("tenant_id").primaryKey(),
+  revision: integer("revision").notNull(),
+  currency: text("currency").notNull(),
+  engineVersion: text("engine_version").notNull(),
+  pricingJson: text("pricing_json").notNull(),
+  skuJson: text("sku_json").notNull(),
+});
+
+export const merchantCalculationSettingsRevisions = sqliteTable(
+  "merchant_calculation_settings_revisions",
+  {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    revision: integer("revision").notNull(),
+    currency: text("currency").notNull(),
+    engineVersion: text("engine_version").notNull(),
+    pricingJson: text("pricing_json").notNull(),
+    skuJson: text("sku_json").notNull(),
+    actor: text("actor").notNull(),
+    savedAt: text("saved_at").notNull(),
+  },
+  (t) => ({
+    uqMerchantCalculationSettingsRevision: uniqueIndex("uq_merchant_calculation_settings_revision").on(
+      t.tenantId,
+      t.revision,
+    ),
+    idxMerchantCalculationSettingsRevisionsTenant: index("idx_merchant_calculation_settings_revisions_tenant").on(
+      t.tenantId,
+    ),
+  }),
+);

package/apps/storefront/src/pages/products/[handle].astro

@@ -12,7 +12,7 @@ import Badge from "@/components/Badge.astro";
 import ProductCard from "@/components/ProductCard.astro";
 import Section from "@/components/Section.astro";
 import ImageGallery from "@/components/islands/ImageGallery.tsx";
-import VariantSelector from "@/components/islands/VariantSelector.tsx";
+import VariantSelector, { publicSelectorVariants } from "@/components/islands/VariantSelector.tsx";
 import CheckoutComplianceGate from "@/components/islands/CheckoutComplianceGate.tsx";
 import RecentlyViewed from "@/components/islands/RecentlyViewed.tsx";
 import NicotineWarning from "@/components/compliance/NicotineWarning.astro";
@@ -361,7 +361,7 @@ const jsonLd = [productJsonLd, breadcrumbLd(crumbs, canonicalBase)];
       <div class="mt-7">
         <VariantSelector
           client:load
-          variants={product.variants}
+          variants={publicSelectorVariants(product.variants)}
           options={product.options}
           currency={product.price_range.currency}
           locale={tenant.locale}

package/apps/storefront/src/pages/style-guide/[tenant]/[theme].astro

@@ -68,7 +68,7 @@ import HowItWorksSteps from "@/components/subscription/HowItWorksSteps.astro";
 import SavingsExplainer from "@/components/subscription/SavingsExplainer.astro";
 import ManageSubscriptionEntry from "@/components/subscription/ManageSubscriptionEntry.astro";
 import AgeGate from "@/components/islands/AgeGate.tsx";
-import VariantSelector from "@/components/islands/VariantSelector.tsx";
+import VariantSelector, { publicSelectorVariants } from "@/components/islands/VariantSelector.tsx";
 import QuickView from "@/components/islands/QuickView.tsx";
 import SearchTypeahead from "@/components/islands/SearchTypeahead.tsx";
 import MobileNav from "@/components/islands/MobileNav.tsx";
@@ -1424,7 +1424,7 @@ const componentVarsInline = [
         <p class="sg-cap" style="margin:22px 0 8px">VariantSelector — PDP option picker (radiogroup + live price/SKU/stock region)</p>
         <VariantSelector
           client:load
-          variants={sampleFromProduct.variants}
+          variants={publicSelectorVariants(sampleFromProduct.variants)}
           options={sampleFromProduct.options}
           currency={sampleFromProduct.price_range.currency}
           locale="en-US"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenoftrust/storefront-runner",
-  "version": "2.4.13",
+  "version": "2.4.15",
   "license": "SEE LICENSE IN LICENSE",
   "description": "World-shareable storefront runner: multi-tenant renderer on Astro/Cloudflare. No control plane.",
   "packageManager": "pnpm@11.9.0",

package/packages/public-runtime/src/product.ts

@@ -168,6 +168,31 @@ export interface CatalogLink {
   /** ISO 8601. */
   accepted_at: string;
   facts: CatalogFact[];
+  /** Server-verified defaults adopted by the merchant; replayable without the current policy. */
+  setup_policy?: CatalogSetupProvenance;
+}
+
+export interface CatalogSetupPriceAcceptance {
+  engine_version: string;
+  policy_revision: number;
+  value: number;
+  /** Producer schema validated settings, source facts and resolved sample. */
+  input: Record<string, unknown>;
+}
+
+export interface CatalogSetupSkuAcceptance {
+  engine_version: string;
+  policy_revision: number;
+  value: string;
+  /** Producer schema validated settings and identity/attribute inputs. */
+  input: Record<string, unknown>;
+}
+
+export interface CatalogSetupProvenance {
+  tenant_id: string;
+  currency: Currency;
+  pricing?: CatalogSetupPriceAcceptance;
+  sku?: CatalogSetupSkuAcceptance;
 }
 
 /** Product fields a merchant set away from the accepted catalog content. */