@fanfare-io/fanfare-sdk-shopify 0.2.0 → 0.3.0

package/README.md

@@ -7,29 +7,59 @@ It builds on the framework-free storefront-adapter contract published from
 
 ## Entry points
 
-| Import                                  | Runtime    | Contents                                                                                                                                                                                       |
-| --------------------------------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@fanfare-io/fanfare-sdk-shopify`       | isomorphic | `createShopifyExperienceResolver`, `shopifyCheckoutVerifier`, `FANFARE_PRODUCT_METAFIELD`, `parseExperienceIds`, `parseFirstExperienceId`, and a re-export of core's `./storefront` vocabulary |
-| `@fanfare-io/fanfare-sdk-shopify/react` | client     | `FanfareAdapterProvider`, `useFanfareAdapter`, `FanfareAdapterValue` (`"use client"`)                                                                                                          |
+| Import                                  | Runtime    | Contents                                                                                                                                                                                                                                                        |
+| --------------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@fanfare-io/fanfare-sdk-shopify`       | isomorphic | `createShopifyExperienceResolver`, `createShopifyCheckoutVerifier`, `createShopifyCheckoutClaimer`, `shopifyCheckoutVerifier`, `FANFARE_PRODUCT_METAFIELD`, `parseExperienceIds`, `parseFirstExperienceId`, and a re-export of core's `./storefront` vocabulary |
+| `@fanfare-io/fanfare-sdk-shopify/react` | client     | `FanfareAdapterProvider`, `useFanfareAdapter`, `FanfareAdapterValue` (`"use client"`)                                                                                                                                                                           |
 
 The root entry imports zero React, so a server-only consumer (Hydrogen/Oxygen
 loader, Next/Remix server component) installs and uses it without React. React
 is an optional peer dependency, needed only for the `/react` subpath.
 
-## Placeholder seams (final-shaped signatures)
+## Claim vs verify (two separate factories, on purpose)
 
-Two seam bodies are honest local placeholders today; their **signatures are
-final** and the wiring lands behind them with no surface change:
+`createShopifyCheckoutClaimer` and `createShopifyCheckoutVerifier` relay the same
+`{ credential, distributionId, cartId }` body to the same proxy host, but they
+are deliberately **separate factories** — not one factory with an endpoint flag
+— because they sit on opposite sides of the admission authority's
+validate / reserve / spend boundary:
+
+- **Claimer** fires _on grant_ → the non-consuming `admissions/claim` route
+  (validate → mint gate token → write the cart metafield). It reserves and spends
+  nothing, and returns the minted token's `expDate`, so its result is
+  `{ ok:true; expDate } | { ok:false; reason }`.
+- **Verifier** fires _at checkout entry_ → the `admissions/reserve` route
+  (validate **and** reserve), and returns a bare `{ ok; reason? }` decision
+  whose body it ignores.
+
+The split is load-bearing in four ways: (1) different result shapes (the claimer
+carries `expDate`, the verifier doesn't read the body); (2) different
+context-readiness policies (the claimer fires automatically on every grant, so a
+missing context is a benign `{ ok:false, reason:"no_claim_context" }` no-op — the
+verifier _requires_ its context getter and throws at construction); (3) the
+claimer is **not** a `CheckoutVerifier` and is invoked directly by the
+storefront, never threaded through the React adapter's `recordGrant` seam; and
+(4) it targets a different, non-consuming endpoint. They share exactly one
+contract — the cart-bridge token correlation, the `$app:gate/token` metafield
+key, and the `gate_grants` schema — which both must honor in lockstep.
+
+## Default vs. proxy-backed seams
+
+Each seam has a default that runs locally and network-free, and a proxy-backed
+factory for server-side enforcement. Both share the same `resolve(product)` /
+`verify(grant)` signature, so moving from one to the other is a config change,
+not a surface change:
 
 - **`createShopifyExperienceResolver(config)`** — `resolve(product)` resolves
   from a config-supplied static `metafieldValues` map (handle → raw metafield
-  value) so the parser path is exercised end-to-end without a network. The live
-  Storefront-API read of the reified `app--<fanfareAppId>--product` /
-  `experienceIds` metafield is the only change that lands later.
-- **`shopifyCheckoutVerifier`** — `verify(grant)` enforces only client-side grant
-  expiry today. The ENG-913 server-validatable handoff (mint at claim, redeem +
-  validate at checkout entry) slots in behind the same `verify(grant)`
-  signature. `verify` is **total**: it resolves for every grant and never
-  rejects, so a future throwing redeem path must be wrapped into a denied result.
-
-No exported identifier says mock/demo.
+  value), so it runs SSR-safe and network-free. The live Storefront-API read of
+  the reified `app--<fanfareAppId>--product` / `experienceIds` metafield uses
+  the same `resolve(product)` seam.
+- **`shopifyCheckoutVerifier`** — the zero-config default; `verify(grant)`
+  enforces only client-side grant expiry, so a storefront can render the gate
+  without any server wiring. For server-side enforcement, use
+  **`createShopifyCheckoutVerifier(config)`**, which drives the Fanfare Shopify
+  app proxy: a non-consuming admission-credential validation (validate, then
+  reserve + gate-token re-mint at checkout entry). Both share the same
+  `verify(grant)` signature. `verify` is **total**: it resolves for every grant
+  and never rejects, so a throwing transport is wrapped into a denied result.

package/dist/claimer.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shopify checkout CLAIMER — the on-grant, NON-CONSUMING sibling of
+ * `createShopifyCheckoutVerifier`.
+ *
+ * The claimer and the verifier relay the same `{ credential, distributionId,
+ * cartId }` body to the same proxy host, but they sit on opposite sides of the
+ * admission authority's validate / reserve / spend boundary and are deliberately
+ * SEPARATE factories — not one factory with an endpoint flag:
+ *
+ *  - The CLAIMER fires *on grant*: it POSTs to the non-consuming `admissions/claim`
+ *    route, which validates the credential, mints a short-lived gate token, and
+ *    writes it to the cart metafield. It reserves and spends nothing. It returns
+ *    the minted token's `expDate` so the storefront can surface a continuity
+ *    signal — so its result carries a body the caller reads.
+ *  - The VERIFIER fires *at checkout entry*: it POSTs to the `admissions/reserve`
+ *    route which validates *and reserves*, and returns a bare gate decision whose
+ *    body it ignores.
+ *
+ * The claimer is NOT a `CheckoutVerifier`: different result shape (carries
+ * `expDate`), different context-readiness policy (a missing context is a benign
+ * no-op, not a construction error — the claimer fires automatically on every
+ * grant), and it is invoked directly by the storefront, never threaded through
+ * the React adapter's `recordGrant` seam.
+ *
+ * TOTAL by construction: a missing/`null` context, a non-2xx proxy response, a
+ * 2xx body without a parseable `expDate`, and any transport throw all resolve to
+ * a denied `{ ok:false, reason }`. It NEVER rejects.
+ */
+/** The live context a claim needs. Separate from `ShopifyCheckoutContext` so the
+ * claim and verify seams can diverge without breaking each other. */
+export interface ShopifyClaimContext {
+    /** The consumer's admission credential (the `admissionGrant` from the
+     * consumer-me snapshot). Relayed to the proxy; never persisted in Shopify. */
+    credential: string;
+    distributionId: string;
+    /** Ajax cart token (incl. `?key=`) for Liquid themes, or the Storefront cart
+     * GID for headless. The proxy/cart-bridge resolves it to a cart GID. */
+    cartId: string;
+}
+export type ShopifyClaimResult = {
+    ok: true;
+    expDate: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface ShopifyClaimConfig {
+    /** App-proxy base, e.g. "/apps/fanfare/api". `claim` POSTs to
+     * `${proxyBaseUrl}/${endpoint}`. */
+    proxyBaseUrl: string;
+    /**
+     * Supplies the live claim context. Returns `null` when the storefront is not
+     * ready to claim (no credential/cart yet), which `claim` surfaces as a benign
+     * denied result rather than a thrown error. Absent ⇒ always not-ready.
+     */
+    getClaimContext?: () => ShopifyClaimContext | null | Promise<ShopifyClaimContext | null>;
+    /** Proxy path under `proxyBaseUrl`. Defaults to the non-consuming claim route. */
+    endpoint?: string;
+    /** Injectable for SSR/test. Defaults to `globalThis.fetch`. */
+    fetchImpl?: typeof fetch;
+    /**
+     * Abort the proxy request after this many ms so a stalled (connected but
+     * unresponsive) proxy can't leave `claim()` pending — TOTAL requires every
+     * outcome to resolve. The abort surfaces as a denied result. Defaults to 10s.
+     */
+    timeoutMs?: number;
+}
+export interface ShopifyCheckoutClaimer {
+    claim(): Promise<ShopifyClaimResult>;
+}
+/**
+ * Build a Shopify checkout claimer. The proxy — not this client — is the trust
+ * boundary; a `{ ok:true }` means the authority validated the admission and the
+ * gate token was minted+written for this cart, never a client assertion.
+ *
+ * A 409 `cart_not_materialized` is surfaced verbatim as the reason (not a generic
+ * `proxy_409`) so the storefront can materialize a real cart and re-claim — the
+ * claimer does NOT own materialization, which is context-specific (the Ajax cart
+ * bridge for themes vs the Storefront cart GID for headless) and lives in the
+ * caller that holds that knowledge.
+ */
+export declare function createShopifyCheckoutClaimer(config: ShopifyClaimConfig): ShopifyCheckoutClaimer;

package/dist/claimer.js

@@ -0,0 +1 @@
+function t(t){if(!t.proxyBaseUrl||""===t.proxyBaseUrl.trim())throw new Error("createShopifyCheckoutClaimer: proxyBaseUrl is required");const e=`${t.proxyBaseUrl.replace(/\/+$/,"")}/${(t.endpoint??"admissions/claim").replace(/^\/+/,"")}`,r=t.fetchImpl??globalThis.fetch;return{async claim(){try{const a=t.getClaimContext?await t.getClaimContext():null;if(null==a)return{ok:!1,reason:"no_claim_context"};const n=await r(e,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({credential:a.credential,distributionId:a.distributionId,cartId:a.cartId}),signal:AbortSignal.timeout(t.timeoutMs??1e4)});if(!n.ok){const t=await async function(t){if(409===t.status)try{const e=await t.json();if("cart_not_materialized"===e?.error)return"cart_not_materialized"}catch{}return`proxy_${t.status}`}(n);return{ok:!1,reason:t}}const o=await async function(t){try{const e=await t.json();return"string"==typeof e?.expDate&&e.expDate.length>0?e.expDate:null}catch{return null}}(n);return null===o?{ok:!1,reason:"claim_malformed"}:{ok:!0,expDate:o}}catch{return{ok:!1,reason:"claim_unreachable"}}}}}export{t as createShopifyCheckoutClaimer};

package/dist/index.d.ts

@@ -7,14 +7,21 @@
  * component) installs and uses this package without React. The React provider /
  * hooks live in `@fanfare-io/fanfare-sdk-shopify/react`.
  *
- * The resolver/verifier bodies are honest local placeholders pending the live
- * Storefront-API metafield read and the ENG-913 handoff (see the JSDoc on
- * createShopifyExperienceResolver / shopifyCheckoutVerifier) — their signatures
- * are final and the wiring lands behind them with no surface change.
+ * The default resolver and verifier run locally and network-free:
+ * `createShopifyExperienceResolver` resolves from a config-supplied metafield
+ * map, and `shopifyCheckoutVerifier` enforces client-side grant expiry. For
+ * server-backed behavior — the live Storefront-API metafield read and
+ * admission-credential validation through the Fanfare Shopify app proxy — use
+ * the proxy-backed factories `createShopifyCheckoutVerifier` and
+ * `createShopifyCheckoutClaimer` (see their JSDoc). Both default and
+ * proxy-backed paths share the same `resolve(product)` / `verify(grant)` seams.
  */
+export { createShopifyCheckoutClaimer } from './claimer';
+export type { ShopifyCheckoutClaimer, ShopifyClaimConfig, ShopifyClaimContext, ShopifyClaimResult } from './claimer';
 export { FANFARE_PRODUCT_METAFIELD, parseExperienceIds, parseFirstExperienceId } from './metafield';
 export { createShopifyExperienceResolver } from './resolver';
 export type { ShopifyExperienceResolverConfig } from './resolver';
-export { shopifyCheckoutVerifier } from './verifier';
+export { createShopifyCheckoutVerifier, shopifyCheckoutVerifier } from './verifier';
+export type { ShopifyCheckoutContext, ShopifyCheckoutVerifierConfig } from './verifier';
 export { ACCESS_STATUSES, snapshotToAccessStatus } from '@fanfare-io/fanfare-sdk-core/storefront';
 export type { AccessStatus, CheckoutAccess, CheckoutVerifier, ExperienceResolver, GrantRecord, VerificationResult, } from '@fanfare-io/fanfare-sdk-core/storefront';

package/dist/index.js

@@ -1 +1 @@
-import{FANFARE_PRODUCT_METAFIELD as r,parseExperienceIds as o,parseFirstExperienceId as e}from"./metafield.js";import{createShopifyExperienceResolver as f}from"./resolver.js";import{shopifyCheckoutVerifier as m}from"./verifier.js";import{ACCESS_STATUSES as i,snapshotToAccessStatus as t}from"@fanfare-io/fanfare-sdk-core/storefront";export{i as ACCESS_STATUSES,r as FANFARE_PRODUCT_METAFIELD,f as createShopifyExperienceResolver,o as parseExperienceIds,e as parseFirstExperienceId,m as shopifyCheckoutVerifier,t as snapshotToAccessStatus};
+import{createShopifyCheckoutClaimer as r}from"./claimer.js";import{FANFARE_PRODUCT_METAFIELD as o,parseExperienceIds as e,parseFirstExperienceId as f}from"./metafield.js";import{createShopifyExperienceResolver as m}from"./resolver.js";import{createShopifyCheckoutVerifier as i,shopifyCheckoutVerifier as t}from"./verifier.js";import{ACCESS_STATUSES as s,snapshotToAccessStatus as a}from"@fanfare-io/fanfare-sdk-core/storefront";export{s as ACCESS_STATUSES,o as FANFARE_PRODUCT_METAFIELD,r as createShopifyCheckoutClaimer,i as createShopifyCheckoutVerifier,m as createShopifyExperienceResolver,e as parseExperienceIds,f as parseFirstExperienceId,t as shopifyCheckoutVerifier,a as snapshotToAccessStatus};

package/dist/metafield.d.ts

@@ -5,9 +5,9 @@
  * reified namespace — the literal form returns null. The numeric app id is not
  * storefront-readable and is provisioned out-of-band.
  *
- * PLACEHOLDER NOTE: the reified-namespace read against the live Storefront API is
- * wired by createShopifyExperienceResolver; the constant and parser below are the
- * stable, final-shaped primitives that read does not change.
+ * The reified-namespace read against the live Storefront API is performed by
+ * createShopifyExperienceResolver; the constant and parser below are the stable
+ * primitives that read builds on.
  */
 export declare const FANFARE_PRODUCT_METAFIELD: {
     readonly key: "experienceIds";
@@ -20,7 +20,7 @@ export declare const FANFARE_PRODUCT_METAFIELD: {
  *  - JSON array of strings → that array, order preserved
  *  - array containing any non-string entry → [] (the platform contract is a
  *    list of single-line text fields; a structurally mixed array is unusable)
- *  - non-array / pre-migration scalar / malformed JSON → []
+ *  - non-array / bare scalar / malformed JSON → []
  *  - absent / empty → []
  */
 export declare function parseExperienceIds(metafieldValue: string | null | undefined): string[];

package/dist/resolver.d.ts

@@ -9,21 +9,19 @@ export interface ShopifyExperienceResolverConfig {
     /** Numeric Shopify app id, provisioned out-of-band; reifies the namespace. */
     fanfareAppId: string;
     /**
-     * PLACEHOLDER-ONLY static map of product `handle` → raw `experienceIds`
-     * metafield value. The placeholder body resolves `resolve(product)` from this
-     * map via `parseFirstExperienceId`, so the contract + parser path is exercised
-     * end-to-end without a network. The live Storefront-API read of the reified
-     * `app--<fanfareAppId>--product` / `experienceIds` metafield replaces this map
-     * (the only body change that lands later) — `resolve(product)`'s signature does
-     * NOT change. Omit it once the live read is wired.
+     * Static map of product `handle` → raw `experienceIds` metafield value. When
+     * supplied, `resolve(product)` reads from this map via `parseFirstExperienceId`
+     * and performs no network call, so the resolver runs SSR-safe and network-free.
+     * Provide it to resolve from values you have already loaded; omit it to fall
+     * back to an empty map (every product resolves to `null`).
      */
     metafieldValues?: Record<string, string>;
     /**
-     * RESERVED — not read by the placeholder body. The live Storefront-API read
-     * will use this injectable (SSR/test seam) and default to `globalThis.fetch`.
-     * Until that read lands, supplying it is a no-op: the placeholder resolves
-     * from `metafieldValues` and never performs a network call. A contract test
-     * pins this (a supplied `fetchImpl` is never invoked).
+     * Injectable fetch (SSR/test seam) for the live Storefront-API read of the
+     * reified `app--<fanfareAppId>--product` / `experienceIds` metafield. Defaults
+     * to `globalThis.fetch`. The default resolver path reads from `metafieldValues`
+     * and never invokes this; it is only exercised when the resolver performs the
+     * live read.
      */
     fetchImpl?: typeof fetch;
 }
@@ -32,12 +30,11 @@ export interface ShopifyExperienceResolverConfig {
  * id carried by the product's `experienceIds` metafield (first id wins), or null
  * when the product is not covered.
  *
- * PLACEHOLDER (no signature impact): the body currently resolves from the
- * in-config static `metafieldValues` map (handle → raw metafield value) via
- * `parseFirstExperienceId`, so the contract and parser path are exercised
- * end-to-end without a network. Wiring the live Storefront-API read of the
- * reified `app--<fanfareAppId>--product` / `experienceIds` metafield is the only
- * change that lands later — the returned resolver's `resolve(product)` signature
- * does NOT change. See ENG-931 metafield-wiring TODO.
+ * `resolve(product)` reads from the in-config static `metafieldValues` map
+ * (handle → raw metafield value) via `parseFirstExperienceId`, so it runs
+ * SSR-safe and network-free. The live Storefront-API read of the reified
+ * `app--<fanfareAppId>--product` / `experienceIds` metafield uses the same
+ * `resolve(product)` seam, so swapping in server-backed resolution is a
+ * config concern, not a signature change.
  */
 export declare function createShopifyExperienceResolver(config: ShopifyExperienceResolverConfig): ExperienceResolver;

package/dist/verifier.d.ts

@@ -9,13 +9,66 @@ import { CheckoutVerifier } from '@fanfare-io/fanfare-sdk-core/storefront';
  * { ok:false, reason:"grant_expired" }; any unexpected throw is caught and
  * resolves { ok:false, reason:"verify_failed" }.
  *
- * PLACEHOLDER (no signature impact): the body currently enforces only client-side
- * expiry (rejects an expired grant, accepts an unexpired one). The ENG-913
- * server-validatable handoff — mint at claim, redeem + validate at checkout entry
- * — slots in behind this exact `verify(grant)` signature later; callers do not
- * change. The ENG-913 body redeems `grant.token` (the minted handoff token,
- * marked by `grant.handoffToken === true`) via core's `processHandoffToken`, which
- * THROWS on invalid/expired/replayed — the verifier MUST catch that and return
- * { ok:false, reason } so the contract stays total. See ENG-913.
+ * This zero-config default enforces only client-side grant expiry, so a
+ * storefront can render the gate without any server wiring. For server-side
+ * enforcement, use `createShopifyCheckoutVerifier(config)` below, which drives
+ * the Fanfare Shopify app proxy.
  */
 export declare const shopifyCheckoutVerifier: CheckoutVerifier;
+/**
+ * The live checkout context the `verify(grant)` seam does not itself carry. The
+ * `CheckoutVerifier.verify` contract receives only a `GrantRecord` (UX/continuity
+ * state), but driving the proxy needs the consumer's admission credential, the
+ * distribution being checked out, and the cart to gate. The integration supplies
+ * these from its own journey state via `config.getCheckoutContext` — keeping the
+ * credential out of `GrantRecord` and the published surface minimal.
+ */
+export interface ShopifyCheckoutContext {
+    /** The consumer's admission credential (the `admissionGrant` from the
+     * consumer-me snapshot). Proof of admission — relayed to the proxy, never
+     * persisted in Shopify. */
+    credential: string;
+    distributionId: string;
+    /** Ajax cart token (including `?key=`) for Liquid themes, or the Storefront
+     * cart GID for headless. The proxy/cart-bridge resolves it to a cart GID. */
+    cartId: string;
+}
+export interface ShopifyCheckoutVerifierConfig {
+    /** App-proxy base, e.g. "/apps/fanfare/api". `verify` POSTs to
+     * `${proxyBaseUrl}/${endpoint}`. */
+    proxyBaseUrl: string;
+    /**
+     * Supplies the live checkout context the grant seam omits. Returns `null` when
+     * the storefront is not ready to check out (no credential/cart yet), which
+     * `verify` surfaces as a denied result rather than a thrown error.
+     */
+    getCheckoutContext: () => ShopifyCheckoutContext | null | Promise<ShopifyCheckoutContext | null>;
+    /**
+     * Proxy path under `proxyBaseUrl`. Defaults to the checkout-entry reserve
+     * endpoint (validate + reserve + gate-token re-mint). A pre-reservation
+     * eligibility check can point this at the non-consuming claim/validate path.
+     */
+    endpoint?: string;
+    /** Injectable for SSR/test. Defaults to `globalThis.fetch`. */
+    fetchImpl?: typeof fetch;
+    /**
+     * Abort the proxy request after this many ms. Without it, a proxy that accepts
+     * the connection but stalls (never responds) leaves `verify()` pending forever
+     * — breaking the TOTAL contract (the consumer is stuck in `checking`). The
+     * abort surfaces as a denied result. Defaults to 10s.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Build a Shopify `CheckoutVerifier` that drives the Fanfare app proxy at
+ * checkout entry: it relays the admission credential + cart to the proxy, which
+ * validates against the admission authority, reserves the admission, and
+ * re-mints the platform gate token into the cart metafield. The proxy — not this
+ * client — is the trust boundary; a positive result means "the authority
+ * currently accepts this admission for this cart", never a client assertion.
+ *
+ * TOTAL by construction: client-side expiry is a cheap pre-check; a missing
+ * context, a non-2xx proxy response, and any transport throw all resolve to a
+ * denied `{ ok:false, reason }`. It never rejects.
+ */
+export declare function createShopifyCheckoutVerifier(config: ShopifyCheckoutVerifierConfig): CheckoutVerifier;

package/dist/verifier.js

@@ -1 +1 @@
-const e={async verify(e){try{return void 0!==e.expiresAt&&Date.now()>e.expiresAt?{ok:!1,reason:"grant_expired"}:{ok:!0}}catch{return{ok:!1,reason:"verify_failed"}}}};export{e as shopifyCheckoutVerifier};
+const e={async verify(e){try{return void 0!==e.expiresAt&&Date.now()>e.expiresAt?{ok:!1,reason:"grant_expired"}:{ok:!0}}catch{return{ok:!1,reason:"verify_failed"}}}};function r(e){if(!e.proxyBaseUrl||""===e.proxyBaseUrl.trim())throw new Error("createShopifyCheckoutVerifier: proxyBaseUrl is required");if("function"!=typeof e.getCheckoutContext)throw new Error("createShopifyCheckoutVerifier: getCheckoutContext is required");const r=`${e.proxyBaseUrl.replace(/\/+$/,"")}/${(e.endpoint??"admissions/reserve").replace(/^\/+/,"")}`,t=e.fetchImpl??globalThis.fetch;return{async verify(o){try{if(void 0!==o.expiresAt&&Date.now()>o.expiresAt)return{ok:!1,reason:"grant_expired"};const i=await e.getCheckoutContext();if(null==i)return{ok:!1,reason:"no_checkout_context"};const n=await t(r,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({credential:i.credential,distributionId:i.distributionId,cartId:i.cartId}),signal:AbortSignal.timeout(e.timeoutMs??1e4)});return n.ok?{ok:!0}:{ok:!1,reason:`proxy_${n.status}`}}catch{return{ok:!1,reason:"verify_unreachable"}}}}}export{r as createShopifyCheckoutVerifier,e as shopifyCheckoutVerifier};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanfare-io/fanfare-sdk-shopify",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Shopify storefront adapter for Fanfare SDK: product→experience resolver, checkout verifier, and experienceIds metafield primitives",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -39,7 +39,7 @@
   "peerDependencies": {
     "react": "^18.0.0 || ^19.1.1",
     "react-dom": "^18.0.0 || ^19.1.1",
-    "@fanfare-io/fanfare-sdk-core": "0.2.0"
+    "@fanfare-io/fanfare-sdk-core": "0.3.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -64,7 +64,7 @@
     "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@fanfare-io/fanfare-sdk-core": "0.2.0"
+    "@fanfare-io/fanfare-sdk-core": "0.3.0"
   },
   "sideEffects": false,
   "keywords": [