@drip-apex/sdk 0.1.0 → 0.2.0

package/src/assignment-store.test.ts

@@ -118,6 +118,62 @@ describe("persisted assignment store", () => {
     expect(localStorage.getItem("drip_assignments_v1")).toBeNull();
   });
 
+  it("restores a persisted redirect control assignment after navigation off the source URL", async () => {
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_1: ["exp_1_control", 1, 123] }),
+    );
+    const { evaluate } = await import("./index");
+    const redirect = experiment("exp_1", [1, 0]);
+    redirect.experimentType = "redirect";
+    redirect.targeting = {
+      url: [{ type: "simple", pattern: "/products/source" }],
+    };
+    redirect.variations[1].redirectUrl = "https://store.test/landing";
+
+    expect(evaluate([redirect], {
+      url: "https://store.test/checkout",
+      userId: "visitor-1",
+    })).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_1",
+        variationId: "exp_1_control",
+      }),
+    ]);
+  });
+
+  it("drops a persisted redirect control assignment when its segment gate fails", async () => {
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_1: ["exp_1_control", 1, 123] }),
+    );
+    const { evaluate } = await import("./index");
+    const redirect = experiment("exp_1", [1, 0]);
+    redirect.experimentType = "redirect";
+    redirect.targeting = {
+      url: [{ type: "simple", pattern: "/products/source" }],
+      segmentRules: [{
+        id: "vip-segment",
+        rules: {
+          version: 1,
+          operator: "and",
+          conditions: [{
+            signal: "customer.tier",
+            operator: "equals",
+            value: "vip",
+          }],
+        },
+      }],
+    };
+    redirect.variations[1].redirectUrl = "https://store.test/landing";
+
+    expect(evaluate([redirect], {
+      attributes: { "customer.tier": "standard" },
+      url: "https://store.test/checkout",
+      userId: "visitor-1",
+    })).toEqual([]);
+  });
+
   it("does not restore when non-page audience targeting is no longer eligible", async () => {
     localStorage.setItem(
       "drip_assignments_v1",

package/src/assignment-store.ts

@@ -1,4 +1,7 @@
 import type { Experiment, Variation } from "./types";
+import { decodeCompactStore } from "./compact-store";
+import { decodePersistedAssignments, type PersistedAssignmentRecord } from "./persistence-decoders";
+export { decodePersistedAssignments, type PersistedAssignmentRecord } from "./persistence-decoders";
 
 const STORAGE_KEY = "drip_assignments_v1"; // gitleaks:allow — public storage key name, not a credential
 const COOKIE_NAME = "drip_assignments_v1";
@@ -6,12 +9,6 @@ const MAX_ENTRIES = 80;
 const MAX_COOKIE_ENTRIES = 20;
 const COOKIE_MAX_AGE_SECONDS = 365 * 24 * 60 * 60;
 
-export type PersistedAssignmentRecord = {
-  variationId: string;
-  epoch: number;
-  assignedAt: number;
-};
-
 type CompactRecord = [string, number, number];
 type CompactStore = Record<string, CompactRecord>;
 
@@ -72,28 +69,8 @@ function clearCookie(): void {
   }
 }
 
-function parseStore(raw: string | null): CompactStore {
-  if (!raw) return {};
-  try {
-    const parsed = JSON.parse(raw) as unknown;
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-    const out: CompactStore = {};
-    for (const [experimentId, value] of Object.entries(parsed)) {
-      if (
-        typeof experimentId !== "string" ||
-        !Array.isArray(value) ||
-        typeof value[0] !== "string" ||
-        typeof value[1] !== "number" ||
-        typeof value[2] !== "number"
-      ) {
-        continue;
-      }
-      out[experimentId] = [value[0], value[1], value[2]];
-    }
-    return out;
-  } catch {
-    return {};
-  }
+export function decodeCompactAssignmentStore(raw: string | null): CompactStore {
+  return decodeCompactStore(raw, 3) as CompactStore;
 }
 
 function serializeStore(store: CompactStore, maxEntries = MAX_ENTRIES): string {
@@ -109,15 +86,7 @@ function serializeStore(store: CompactStore, maxEntries = MAX_ENTRIES): string {
 }
 
 export function readPersistedAssignments(): Record<string, PersistedAssignmentRecord> {
-  const compact = {
-    ...parseStore(readCookie()),
-    ...parseStore(readLocalStorage()),
-  };
-  const out: Record<string, PersistedAssignmentRecord> = {};
-  for (const [experimentId, [variationId, epoch, assignedAt]] of Object.entries(compact)) {
-    out[experimentId] = { variationId, epoch, assignedAt };
-  }
-  return out;
+  return decodePersistedAssignments(readLocalStorage(), readCookie());
 }
 
 export function writePersistedAssignments(
@@ -203,6 +172,6 @@ export const __assignmentStoreInternals = {
   STORAGE_KEY,
   COOKIE_NAME,
   assignmentEpoch,
-  parseStore,
+  parseStore: decodeCompactAssignmentStore,
   serializeStore,
 };

package/src/bucket.ts

@@ -1,18 +1,3 @@
-export function inTrafficAllocation(hashValue: number, allocation = 1): boolean {
-  if (allocation <= 0) return false;
-  if (allocation >= 1) return true;
-  return hashValue < allocation;
-}
-
-export function chooseVariation(hashValue: number, weights: number[]): number {
-  if (!weights.length) return -1;
-  const total = weights.reduce((sum, w) => sum + (w > 0 ? w : 0), 0);
-  if (total <= 0) return 0;
-  const n = hashValue * total;
-  let acc = 0;
-  for (let i = 0; i < weights.length; i++) {
-    acc += weights[i] > 0 ? weights[i] : 0;
-    if (n < acc) return i;
-  }
-  return weights.length - 1;
-}
+// The bucketing kernel lives in @drip/shared-runtime/bucketing (#2476). This
+// module keeps re-exporting it so SDK call sites stay unchanged.
+export { chooseVariation, inTrafficAllocation } from "@drip/shared-runtime/bucketing";

package/src/commerce-analytics-lifecycle.test.ts

@@ -19,6 +19,7 @@ describe("commerce analytics lifecycle", () => {
     delete (globalThis as any).Apex;
     localStorage.clear();
     sessionStorage.clear();
+    document.cookie = "drip_assignments_v1=; Max-Age=0; Path=/; SameSite=Lax";
     installCommerceProductPage();
     fetchMock = vi.fn(async (input: RequestInfo | URL) =>
       String(input).endsWith("/cart.js")
@@ -29,7 +30,9 @@ describe("commerce analytics lifecycle", () => {
     globalThis.fetch = fetchMock as typeof fetch;
   });
 
-  afterEach(() => {
+  afterEach(async () => {
+    const { cleanupCommerceShipping } = await import("./commerce-shipping");
+    cleanupCommerceShipping();
     vi.clearAllTimers();
     vi.useRealTimers();
     vi.restoreAllMocks();
@@ -157,7 +160,7 @@ describe("commerce analytics lifecycle", () => {
     });
   });
 
-  it("keeps an off-target resurrected pin in the price plane only", async () => {
+  it("keeps an off-target persisted price pin attributable without rendering it", async () => {
     delete (window as Window & { ShopifyAnalytics?: unknown }).ShopifyAnalytics;
     document.body.insertAdjacentHTML(
       "beforeend",
@@ -202,6 +205,10 @@ describe("commerce analytics lifecycle", () => {
           })
         : new Response("ok", { status: 202 }));
     globalThis.fetch = fetchMock as typeof fetch;
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_price: ["treatment", 1, 123] }),
+    );
     const onExperimentViewed = vi.fn();
     const { flush, getAssignments, init, trackRevenue } = await import("./index");
 
@@ -222,24 +229,44 @@ describe("commerce analytics lifecycle", () => {
     });
     expect(document.querySelector(".price")?.textContent).toBe("€1.299,00");
     expect(document.querySelector(".companion")?.textContent).toBe("Control companion");
-    expect(getAssignments()).toEqual([]);
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_price",
+        variationId: "treatment",
+        pageActive: false,
+      }),
+    ]);
     expect(onExperimentViewed).not.toHaveBeenCalled();
     expect(localStorage.getItem("drip_exposures")).toBeNull();
 
     trackRevenue(19.99, { orderId: "off-target-order" });
     await flush();
     const trackedEvents = fetchMock.mock.calls
-      .filter(([url]) => String(url) === "https://events.test/events")
+      .filter(([url]) => String(url) === "https://events.test/v1/events")
       .flatMap(([, options]) => JSON.parse(String(options?.body)).events);
     expect(trackedEvents.some((event: { type: string }) =>
-      event.type === "experiment_viewed" || event.type === "goal"
+      event.type === "experiment_viewed"
     )).toBe(false);
+    expect(trackedEvents).toContainEqual(expect.objectContaining({
+      type: "goal",
+      experimentId: "exp_price",
+      variationId: "treatment",
+      data: expect.objectContaining({
+        goalId: "__revenue__",
+        revenue: 19.99,
+        orderId: "off-target-order",
+      }),
+    }));
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"))
+      .toHaveProperty("exp_price", ["treatment", 1, 123]);
     const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
-    expect(JSON.parse(String(cartUpdate?.[1]?.body)).attributes).toMatchObject({
-      apex_assignments: JSON.stringify([{ e: "exp_price", v: "treatment", ep: 1 }]),
+    const cartAttributes = JSON.parse(String(cartUpdate?.[1]?.body)).attributes;
+    expect(cartAttributes).toMatchObject({
       apex_assignment_authorization: pinnedToken,
     });
-
+    expect(JSON.parse(cartAttributes.apex_assignments)).toEqual([
+      { e: "exp_price", v: "treatment", ep: 1 },
+    ]);
   });
 
   it("keeps off-target offer pins charge-only while applying targeted offers", async () => {
@@ -318,8 +345,12 @@ describe("commerce analytics lifecycle", () => {
           })
         : new Response("ok", { status: 202 }));
     globalThis.fetch = fetchMock as typeof fetch;
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_offer_off_target: ["off_target_treatment", 1, 123] }),
+    );
     const onExperimentViewed = vi.fn();
-    const { getAssignments, init } = await import("./index");
+    const { flush, getAssignments, init, trackRevenue } = await import("./index");
 
     init({
       antiFlickerMode: "off",
@@ -350,23 +381,52 @@ describe("commerce analytics lifecycle", () => {
       .toBe("Off-target control");
     expect(document.querySelector(".targeted-offer")?.textContent)
       .toBe("Targeted treatment");
-    expect(getAssignments()).toEqual([
-      expect.objectContaining({ experimentId: "exp_offer_targeted" }),
-    ]);
+    expect(getAssignments()).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        experimentId: "exp_offer_off_target",
+        variationId: "off_target_treatment",
+        pageActive: false,
+      }),
+      expect.objectContaining({
+        experimentId: "exp_offer_targeted",
+        variationId: "targeted_treatment",
+        pageActive: true,
+      }),
+    ]));
     expect(onExperimentViewed).toHaveBeenCalledTimes(1);
     expect(onExperimentViewed).toHaveBeenCalledWith(
       expect.objectContaining({ experimentId: "exp_offer_targeted" }),
     );
     expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"))
-      .not.toHaveProperty("exp_offer_off_target");
+      .toHaveProperty("exp_offer_off_target", ["off_target_treatment", 1, expect.any(Number)]);
     expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}"))
       .toHaveProperty("exp_offer_targeted");
+    trackRevenue(24.99, { orderId: "off-target-offer-order" });
+    await flush();
+    const trackedEvents = fetchMock.mock.calls
+      .filter(([url]) => String(url) === "https://events.test/v1/events")
+      .flatMap(([, options]) => JSON.parse(String(options?.body)).events);
+    expect(trackedEvents).toContainEqual(expect.objectContaining({
+      type: "goal",
+      experimentId: "exp_offer_off_target",
+      variationId: "off_target_treatment",
+      data: expect.objectContaining({
+        goalId: "__revenue__",
+        revenue: 24.99,
+        orderId: "off-target-offer-order",
+      }),
+    }));
     const cartUpdate = fetchMock.mock.calls.find(([url]) => url === "/cart/update.js");
-    expect(JSON.parse(JSON.parse(String(cartUpdate?.[1]?.body)).attributes.apex_assignments))
-      .toEqual(expect.arrayContaining([
+    const stampedAssignments = JSON.parse(
+      JSON.parse(String(cartUpdate?.[1]?.body)).attributes.apex_assignments,
+    );
+    expect(stampedAssignments).toEqual(expect.arrayContaining([
         { e: "exp_offer_off_target", v: "off_target_treatment", ep: 1 },
         { e: "exp_offer_targeted", v: "targeted_treatment", ep: 1 },
       ]));
+    expect(stampedAssignments.filter(
+      (assignment: { e: string }) => assignment.e === "exp_offer_off_target",
+    )).toHaveLength(1);
     await expect(window.fetch("/cart/add.js", { method: "POST" }))
       .resolves.toMatchObject({ status: 202 });
   });

package/src/commerce-config-lifecycle.test.ts

@@ -54,7 +54,11 @@ describe("commerce config lifecycle", () => {
     }) as typeof fetch;
   });
 
-  afterEach(() => {
+  afterEach(async () => {
+    const { cleanupCommercePrice } = await import("./commerce-price");
+    const { cleanupCommerceShipping } = await import("./commerce-shipping");
+    cleanupCommercePrice();
+    cleanupCommerceShipping();
     vi.restoreAllMocks();
     delete (globalThis as typeof globalThis & { __drip?: unknown }).__drip;
     globalThis.fetch = originalFetch;
@@ -211,6 +215,82 @@ describe("commerce config lifecycle", () => {
     });
   });
 
+  it("cannot reassert a deactivated Page price while a non-commerce assignment remains", async () => {
+    history.replaceState({}, "", "/products/current-product");
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/cart.js")) {
+        return Response.json({ token: "cart-page-price?key=runtime-secret" });
+      }
+      if (url.includes("/v1/assign")) {
+        return Response.json(commerceAssignmentResponseFixture);
+      }
+      return new Response("ok", { status: 200 });
+    }) as typeof fetch;
+    const targetedExperiments = [
+      {
+        ...experiments[0]!,
+        targeting: {
+          pageRules: [{
+            id: "page_price_product",
+            includeRules: [{ type: "simple" as const, pattern: "/products/*" }],
+            trigger: { deactivationMode: "reset" as const },
+          }],
+        },
+        variations: [{
+          ...experiments[0]!.variations[0]!,
+          js: "window.__pricePageApplied=true;",
+        }],
+      },
+      {
+        id: "exp_non_commerce_sibling",
+        status: "running" as const,
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_non_commerce_sibling",
+          weight: 1,
+          mutations: [],
+          js: "window.__nonCommerceSiblingApplied=true;",
+        }],
+      },
+    ];
+    const disconnect = vi.spyOn(MutationObserver.prototype, "disconnect");
+    const { getAssignments, init, reInit } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      commerce,
+      endpoint: "https://events.test",
+      experiments: targetedExperiments,
+      ingestSignature: "ingest-token",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_page_price",
+    });
+    await waitForPrice("€1.149,95");
+
+    history.replaceState({}, "", "/collections/all");
+    reInit();
+    expect(getAssignments()).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        experimentId: "exp_price",
+        pageActive: false,
+      }),
+      expect.objectContaining({
+        experimentId: "exp_non_commerce_sibling",
+        pageActive: true,
+      }),
+    ]));
+    await waitForPrice("€1.299,00");
+    expect(disconnect).toHaveBeenCalled();
+
+    const price = document.querySelector(".price")!;
+    price.textContent = "€1.399,00";
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(price.textContent).toBe("€1.399,00");
+  });
+
   it("clears a stale shipping authorization after the Worker confirms the assignment disappeared", async () => {
     sessionStorage.setItem("drip_cart_attr", JSON.stringify({
       assignments: [["exp_shipping", "treatment", 6]],

package/src/commerce-price-preserve.test.ts

@@ -0,0 +1,133 @@
+// @vitest-environment jsdom
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { applyMutations, reassertNonStructuralMutations } from "./mutate";
+import { applyMutationWithWait } from "./wait";
+
+describe("content treatment price preservation", () => {
+  beforeEach(() => { document.body.innerHTML = ""; });
+
+  function apply(text: string, replacement: string, options: Record<string, unknown> = {}) {
+    document.body.innerHTML = `<div class="target">${text}</div>`;
+    const onViolation = vi.fn();
+    applyMutations([{ selector: ".target", action: "text", text: replacement }], {
+      preservePrices: true,
+      onPricePreservationViolation: onViolation,
+      ...options,
+    });
+    return { element: document.querySelector(".target")!, onViolation };
+  }
+
+  it("applies content when every displayed price survives", () => {
+    const result = apply("Now $1,299.95", "Only $1,299.95 today");
+    expect(result.element.textContent).toBe("Only $1,299.95 today");
+    expect(result.onViolation).not.toHaveBeenCalled();
+  });
+
+  it("reverts and reports content that drops a price", () => {
+    const result = apply("Now €1.299,95", "On sale");
+    expect(result.element.textContent).toBe("Now €1.299,95");
+    expect(result.onViolation).toHaveBeenCalledWith(expect.objectContaining({
+      selector: ".target",
+      originalPriceTokens: [expect.objectContaining({ raw: "€1.299,95" })],
+    }));
+  });
+
+  it("reverts a changed price value", () => {
+    expect(apply("£99.00", "£79.00").element.textContent).toBe("£99.00");
+  });
+
+  it.each([
+    ["Now 1.299,95 \u20ac", "1.299,95 \u20ac"],
+    ["Now CHF 99.00", "CHF 99.00"],
+    ["Now 99.00 EUR", "99.00 EUR"],
+    ["Now 99 kr", "99 kr"],
+  ])("reverts and reports dropped suffix/code price %s", (text, raw) => {
+    const result = apply(text, "On sale");
+    expect(result.element.textContent).toBe(text);
+    expect(result.onViolation).toHaveBeenCalledWith(expect.objectContaining({
+      originalPriceTokens: [expect.objectContaining({ raw })],
+    }));
+  });
+
+  it("does not treat bare numbers as money", () => {
+    const result = apply("Model SKU 1299", "Model SKU 1200");
+    expect(result.element.textContent).toBe("Model SKU 1200");
+    expect(result.onViolation).not.toHaveBeenCalled();
+  });
+
+  it("keeps a rejected mutation blocked during reassertion", () => {
+    const mutation = { selector: ".target", action: "text" as const, text: "On sale" };
+    document.body.innerHTML = '<div class="target">Now $19.00</div>';
+    applyMutations([mutation], { preservePrices: true });
+
+    reassertNonStructuralMutations([mutation]);
+
+    expect(document.querySelector(".target")?.textContent).toBe("Now $19.00");
+  });
+
+  it("reverts and reports setText content that drops a price", () => {
+    document.body.innerHTML = '<div class="target">Now $29.00</div>';
+    const onViolation = vi.fn();
+    applyMutations([{ selector: ".target", action: "setText", text: "On sale" }], {
+      preservePrices: true,
+      onPricePreservationViolation: onViolation,
+    });
+
+    expect(document.querySelector(".target")?.textContent).toBe("Now $29.00");
+    expect(onViolation).toHaveBeenCalledWith(expect.objectContaining({
+      selector: ".target",
+      originalPriceTokens: [expect.objectContaining({ raw: "$29.00" })],
+    }));
+  });
+
+  it("guards setText content applied through the wait path", () => {
+    document.body.innerHTML = '<div class="target">Now $39.00</div>';
+    const onViolation = vi.fn();
+    applyMutationWithWait(
+      { selector: ".target", action: "setText", text: "On sale" },
+      0,
+      undefined,
+      undefined,
+      [],
+      undefined,
+      0,
+      { enabled: true, onViolation },
+    );
+
+    expect(document.querySelector(".target")?.textContent).toBe("Now $39.00");
+    expect(onViolation).toHaveBeenCalledWith(expect.objectContaining({
+      selector: ".target",
+      originalPriceTokens: [expect.objectContaining({ raw: "$39.00" })],
+    }));
+  });
+
+  it("resolves observer reveal accounting immediately when the guard rejects", () => {
+    document.body.innerHTML = '<div class="target">Now $39.00</div>';
+    const onApplied = vi.fn();
+    const onMiss = vi.fn();
+    applyMutationWithWait(
+      { selector: ".target", action: "setText", text: "On sale" },
+      0,
+      onApplied,
+      onMiss,
+      [],
+      undefined,
+      0,
+      { enabled: true, onViolation: vi.fn() },
+    );
+
+    expect(onMiss).toHaveBeenCalledTimes(1);
+    expect(onApplied).not.toHaveBeenCalled();
+    expect(document.querySelector(".target")?.textContent).toBe("Now $39.00");
+  });
+
+  it("preserves multiple currencies and values", () => {
+    const result = apply("¥1000 / ₹1,000 / $10", "Compare ¥1000, ₹1,000 and $10");
+    expect(result.element.textContent).toContain("Compare");
+  });
+
+  it("keeps the no-price fast path and intentional price tests exempt", () => {
+    expect(apply("Hello", "Goodbye").element.textContent).toBe("Goodbye");
+    expect(apply("$10", "$12", { priceTestExempt: true }).element.textContent).toBe("$12");
+  });
+});

package/src/commerce-price.test.ts

@@ -87,6 +87,103 @@ describe("commerce price display swap", () => {
     );
   });
 
+  it.each([
+    {
+      currency: "JPY",
+      published: 129900,
+      treatment: "1149",
+      before: "¥1,299",
+      after: "¥1,149",
+    },
+    {
+      currency: "BHD",
+      published: 128.2,
+      treatment: "1.123",
+      before: "KD 1.282",
+      after: "KD 1.123",
+    },
+  ])("swaps $currency prices at their ISO-4217 scale", ({
+    currency,
+    published,
+    treatment,
+    before,
+    after,
+  }) => {
+    shopify("product", currency);
+    Object.assign((window as any).ShopifyAnalytics.meta.product, {
+      variants: [{ id: 123, price: published }],
+    });
+    document.body.innerHTML = `<div class="price">${before}</div>`;
+    const scaledSettings: CommercePriceSettings = {
+      ...settings,
+      experiments: [{
+        ...settings.experiments[0],
+        currency,
+        variants: {
+          treatment: [{
+            variant_gid: "gid://shopify/ProductVariant/123",
+            fixedPricePerUnit: treatment,
+          }],
+        },
+      }],
+    };
+
+    applyCommercePrice(scaledSettings, assignments);
+
+    expect(document.querySelector(".price")?.textContent).toBe(after);
+  });
+
+  it("fails closed when a Shopify stored price cannot represent whole minor units", () => {
+    shopify("product", "BHD");
+    Object.assign((window as any).ShopifyAnalytics.meta.product, {
+      variants: [{ id: 123, price: 128.25 }],
+    });
+    document.body.innerHTML = '<div class="price">KD 1.282</div>';
+    const bhdSettings: CommercePriceSettings = {
+      ...settings,
+      experiments: [{
+        ...settings.experiments[0],
+        currency: "BHD",
+        variants: {
+          treatment: [{
+            variant_gid: "gid://shopify/ProductVariant/123",
+            fixedPricePerUnit: "1.123",
+          }],
+        },
+      }],
+    };
+
+    applyCommercePrice(bhdSettings, assignments);
+
+    expect(document.querySelector(".price")?.textContent).toBe("KD 1.282");
+  });
+
+  it("fails closed when the active currency has unknown precision", () => {
+    shopify("product", "ZZZ");
+    Object.assign((window as any).ShopifyAnalytics.meta.product, {
+      variants: [{ id: 123, price: 1000 }],
+    });
+    document.body.innerHTML = '<div class="price">ZZ 10.00</div>';
+    const unknownSettings: CommercePriceSettings = {
+      ...settings,
+      experiments: [{
+        ...settings.experiments[0],
+        currency: "ZZZ",
+        variants: {
+          treatment: [{
+            variant_gid: "gid://shopify/ProductVariant/123",
+            fixedPricePerUnit: "9.00",
+          }],
+        },
+      }],
+    };
+
+    applyCommercePrice(unknownSettings, assignments);
+
+    expect(document.querySelector(".price")?.textContent).toBe("ZZ 10.00");
+    expect(isCommercePriceActive(unknownSettings, assignments)).toBe(false);
+  });
+
   it("keeps the published price when the active plane does not authorize the assignment", () => {
     document.body.innerHTML = '<div class="price">€1.299,00</div>';
     const authorizeNone = () => false;