@umxr/bagsy 0.0.0-stage → 0.2.0

package/dist/hydrogen.d.ts

@@ -0,0 +1,73 @@
+import { RelayResponse } from './index.js';
+import { CreateBagsyServerOptions, BagsyServer, Shopper, WritableShopper, CustomerResolver } from './server.js';
+import * as _shopify_hydrogen from '@shopify/hydrogen';
+import { ShopifyRequestContext } from '@shopify/hydrogen';
+import { ReadonlyCustomerSessionManager, WritableCustomerSessionManager, CustomerSession } from '@shopify/hydrogen/customer-account';
+import './transport-Chh09xIP.js';
+import './client-CXCgpFGa.js';
+
+/** For loaders and server components: a read-only session. */
+interface HydrogenReadContext {
+    sessionManager: ReadonlyCustomerSessionManager;
+    requestContext: ShopifyRequestContext;
+}
+/** For route handlers and actions: a session the response commits. */
+interface HydrogenWriteContext {
+    sessionManager: WritableCustomerSessionManager;
+    requestContext: ShopifyRequestContext;
+}
+interface CreateHydrogenBagsyOptions extends Omit<CreateBagsyServerOptions<HydrogenReadContext, HydrogenWriteContext>, 'customer'> {
+    /**
+     * Your `createCustomerSession()` result, so signed-in customers keep one
+     * wishlist across devices. Omit for a guest-only storefront.
+     */
+    customerSession?: Pick<CustomerSession, 'getAccessToken' | 'getOrRefreshAccessToken'>;
+    /** Numeric shop id, the same one you pass to `createCustomerSession()`. Required with `customerSession`. */
+    shopId?: string;
+    /** Fetch for Customer Account API calls (tests, custom runtimes). */
+    customerAccountFetch?: typeof globalThis.fetch;
+}
+/**
+ * Bagsy for Hydrogen 2026-10. Create once at module scope, register
+ * `bagsy.handlers` with `handleShopifyRoutes`, and call `bagsy.shopper()` in
+ * loaders.
+ */
+declare function createHydrogenBagsy(options: CreateHydrogenBagsyOptions): {
+    handlers: {
+        bagsyRelay: _shopify_hydrogen.CallableRouteHandler<HydrogenWriteContext & {
+            request: Request;
+        }, _shopify_hydrogen.ShopifyRouteHandlerResult, string, "POST">;
+    };
+    endpoint: string;
+    shopper: (context: HydrogenReadContext) => Promise<Shopper>;
+    writableShopper: (context: HydrogenWriteContext) => Promise<WritableShopper>;
+    relay: (request: Request, context: HydrogenWriteContext) => Promise<{
+        response: RelayResponse;
+    } | {
+        rejected: {
+            status: number;
+            code: string;
+            message: string;
+        };
+    }>;
+    handle: (request: Request, context: HydrogenWriteContext) => Promise<Response | null>;
+};
+/** `handleShopifyRoutes` handlers for the relay endpoint `@umxr/bagsy/react` calls. */
+declare function bagsyRouteHandlers(server: BagsyServer<HydrogenReadContext, HydrogenWriteContext>): {
+    bagsyRelay: _shopify_hydrogen.CallableRouteHandler<HydrogenWriteContext & {
+        request: Request;
+    }, _shopify_hydrogen.ShopifyRouteHandlerResult, string, "POST">;
+};
+/**
+ * Who is signed in, from Hydrogen's customer session. Reads never refresh
+ * tokens or write the session; writes may refresh, and cache the customer id
+ * against the token so the Customer Account API is asked once per sign-in.
+ */
+declare function hydrogenCustomerId({ customerSession, shopId, fetch, }: {
+    customerSession: Pick<CustomerSession, 'getAccessToken' | 'getOrRefreshAccessToken'>;
+    shopId: string;
+    fetch?: typeof globalThis.fetch | undefined;
+}): CustomerResolver<HydrogenReadContext, HydrogenWriteContext>;
+
+export { Shopper, WritableShopper, bagsyRouteHandlers, createHydrogenBagsy, hydrogenCustomerId };
+export type { CreateHydrogenBagsyOptions, HydrogenReadContext, HydrogenWriteContext };

package/dist/hydrogen.js

@@ -0,0 +1,89 @@
+import {
+  createBagsyServer,
+  remember,
+  trackWrites,
+  warnIfNotPersisted
+} from "./chunk-CJV4SIV7.js";
+import "./chunk-QV3JPND6.js";
+
+// ../hydrogen/src/hydrogen.ts
+import { createShopifyRouteHandler } from "@shopify/hydrogen";
+import {
+  createCustomerAccountClient,
+  gql
+} from "@shopify/hydrogen/customer-account";
+function createHydrogenBagsy(options) {
+  const { customerSession, shopId, customerAccountFetch, ...rest } = options;
+  if (customerSession && !shopId) throw new TypeError("createHydrogenBagsy: `shopId` is required with `customerSession`.");
+  const server = createBagsyServer({
+    ...rest,
+    ...customerSession && shopId && { customer: hydrogenCustomerId({ customerSession, shopId, fetch: customerAccountFetch }) }
+  });
+  return { ...server, handlers: bagsyRouteHandlers(server) };
+}
+function bagsyRouteHandlers(server) {
+  return {
+    bagsyRelay: createShopifyRouteHandler(
+      server.endpoint,
+      "POST",
+      async (context) => {
+        const tracked = trackWrites(context.sessionManager);
+        const result = await server.relay(context.request, { ...context, sessionManager: tracked.sessionManager });
+        let headers;
+        if (tracked.dirty()) {
+          headers = await context.sessionManager.commit?.() ?? void 0;
+          warnIfNotPersisted(new Headers(headers));
+        }
+        if ("rejected" in result) {
+          const { status, code, message } = result.rejected;
+          return { type: "error", status, error: { code, message }, ...headers && { headers } };
+        }
+        return { type: "json", data: result.response, ...headers && { headers } };
+      }
+    )
+  };
+}
+var CUSTOMER_ID_QUERY = gql(`query BagsyCustomerId { customer { id } }`);
+var CACHE_KEY = "bagsy:customer";
+var customerIds = /* @__PURE__ */ new Map();
+function hydrogenCustomerId({
+  customerSession,
+  shopId,
+  fetch
+}) {
+  async function lookup(accessToken, { sessionManager, requestContext }) {
+    const token = await fingerprint(accessToken);
+    const cached = await sessionManager.getSessionItem(CACHE_KEY);
+    if (cached?.token === token && cached.id) return { id: cached.id, token, cached: true };
+    const known = customerIds.get(`${shopId}|${token}`);
+    if (known) return { id: known, token, cached: false };
+    const client = createCustomerAccountClient({ shopId, requestContext, ...fetch && { fetch } });
+    const result = await client.graphql(CUSTOMER_ID_QUERY, { accessToken });
+    const id = result.errors ? void 0 : result.data?.customer?.id ?? void 0;
+    if (id) remember(customerIds, `${shopId}|${token}`, id);
+    return { id, token, cached: false };
+  }
+  return {
+    async read(context) {
+      const accessToken = await customerSession.getAccessToken(context.sessionManager, context.requestContext);
+      return accessToken ? (await lookup(accessToken, context)).id : void 0;
+    },
+    async write(context) {
+      const accessToken = await customerSession.getOrRefreshAccessToken(context.sessionManager, context.requestContext);
+      if (!accessToken) return void 0;
+      const { id, token, cached } = await lookup(accessToken, context);
+      if (id && !cached) await context.sessionManager.setSessionItem(CACHE_KEY, { token, id });
+      return id;
+    }
+  };
+}
+async function fingerprint(token) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(token));
+  return [...new Uint8Array(digest).slice(0, 16)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export {
+  bagsyRouteHandlers,
+  createHydrogenBagsy,
+  hydrogenCustomerId
+};
+//# sourceMappingURL=hydrogen.js.map

package/dist/hydrogen.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../hydrogen/src/hydrogen.ts"],"sourcesContent":["import { createShopifyRouteHandler, type ShopifyRequestContext } from '@shopify/hydrogen';\nimport {\n  createCustomerAccountClient,\n  gql,\n  type CustomerSession,\n  type ReadonlyCustomerSessionManager,\n  type WritableCustomerSessionManager,\n} from '@shopify/hydrogen/customer-account';\nimport {\n  createBagsyServer,\n  remember,\n  trackWrites,\n  warnIfNotPersisted,\n  type BagsyServer,\n  type CreateBagsyServerOptions,\n  type CustomerResolver,\n} from './server.js';\n\n/** For loaders and server components: a read-only session. */\nexport interface HydrogenReadContext {\n  sessionManager: ReadonlyCustomerSessionManager;\n  requestContext: ShopifyRequestContext;\n}\n\n/** For route handlers and actions: a session the response commits. */\nexport interface HydrogenWriteContext {\n  sessionManager: WritableCustomerSessionManager;\n  requestContext: ShopifyRequestContext;\n}\n\nexport interface CreateHydrogenBagsyOptions\n  extends Omit<CreateBagsyServerOptions<HydrogenReadContext, HydrogenWriteContext>, 'customer'> {\n  /**\n   * Your `createCustomerSession()` result, so signed-in customers keep one\n   * wishlist across devices. Omit for a guest-only storefront.\n   */\n  customerSession?: Pick<CustomerSession, 'getAccessToken' | 'getOrRefreshAccessToken'>;\n  /** Numeric shop id, the same one you pass to `createCustomerSession()`. Required with `customerSession`. */\n  shopId?: string;\n  /** Fetch for Customer Account API calls (tests, custom runtimes). */\n  customerAccountFetch?: typeof globalThis.fetch;\n}\n\n/**\n * Bagsy for Hydrogen 2026-10. Create once at module scope, register\n * `bagsy.handlers` with `handleShopifyRoutes`, and call `bagsy.shopper()` in\n * loaders.\n */\nexport function createHydrogenBagsy(options: CreateHydrogenBagsyOptions) {\n  const { customerSession, shopId, customerAccountFetch, ...rest } = options;\n  if (customerSession && !shopId) throw new TypeError('createHydrogenBagsy: `shopId` is required with `customerSession`.');\n\n  const server = createBagsyServer<HydrogenReadContext, HydrogenWriteContext>({\n    ...rest,\n    ...(customerSession && shopId && { customer: hydrogenCustomerId({ customerSession, shopId, fetch: customerAccountFetch }) }),\n  });\n\n  return { ...server, handlers: bagsyRouteHandlers(server) };\n}\n\n/** `handleShopifyRoutes` handlers for the relay endpoint `@umxr/bagsy/react` calls. */\nexport function bagsyRouteHandlers(server: BagsyServer<HydrogenReadContext, HydrogenWriteContext>) {\n  return {\n    bagsyRelay: createShopifyRouteHandler(\n      server.endpoint,\n      'POST',\n      async (context: HydrogenWriteContext & { request: Request }) => {\n        // Matched Shopify routes skip your app's response boundary, so commit here.\n        const tracked = trackWrites(context.sessionManager);\n        const result = await server.relay(context.request, { ...context, sessionManager: tracked.sessionManager });\n        let headers: HeadersInit | undefined;\n        if (tracked.dirty()) {\n          headers = (await context.sessionManager.commit?.()) ?? undefined;\n          warnIfNotPersisted(new Headers(headers));\n        }\n        if ('rejected' in result) {\n          const { status, code, message } = result.rejected;\n          return { type: 'error' as const, status, error: { code, message }, ...(headers && { headers }) };\n        }\n        return { type: 'json' as const, data: result.response, ...(headers && { headers }) };\n      },\n    ),\n  };\n}\n\nconst CUSTOMER_ID_QUERY = gql(`query BagsyCustomerId { customer { id } }`);\nconst CACHE_KEY = 'bagsy:customer';\n/** Customer ids by token fingerprint, so read-only loaders don't ask the Customer Account API every request. */\nconst customerIds = new Map<string, string>();\n\n/**\n * Who is signed in, from Hydrogen's customer session. Reads never refresh\n * tokens or write the session; writes may refresh, and cache the customer id\n * against the token so the Customer Account API is asked once per sign-in.\n */\nexport function hydrogenCustomerId({\n  customerSession,\n  shopId,\n  fetch,\n}: {\n  customerSession: Pick<CustomerSession, 'getAccessToken' | 'getOrRefreshAccessToken'>;\n  shopId: string;\n  fetch?: typeof globalThis.fetch | undefined;\n}): CustomerResolver<HydrogenReadContext, HydrogenWriteContext> {\n  async function lookup(accessToken: string, { sessionManager, requestContext }: HydrogenReadContext) {\n    const token = await fingerprint(accessToken);\n    const cached = (await sessionManager.getSessionItem(CACHE_KEY)) as { token?: string; id?: string } | undefined;\n    if (cached?.token === token && cached.id) return { id: cached.id, token, cached: true };\n    const known = customerIds.get(`${shopId}|${token}`);\n    if (known) return { id: known, token, cached: false };\n    const client = createCustomerAccountClient({ shopId, requestContext, ...(fetch && { fetch }) });\n    const result = await client.graphql(CUSTOMER_ID_QUERY, { accessToken });\n    const id = result.errors ? undefined : (result.data?.customer?.id ?? undefined);\n    if (id) remember(customerIds, `${shopId}|${token}`, id);\n    return { id, token, cached: false };\n  }\n\n  return {\n    async read(context) {\n      const accessToken = await customerSession.getAccessToken(context.sessionManager, context.requestContext);\n      return accessToken ? (await lookup(accessToken, context)).id : undefined;\n    },\n    async write(context) {\n      const accessToken = await customerSession.getOrRefreshAccessToken(context.sessionManager, context.requestContext);\n      if (!accessToken) return undefined;\n      const { id, token, cached } = await lookup(accessToken, context);\n      if (id && !cached) await context.sessionManager.setSessionItem(CACHE_KEY, { token, id });\n      return id;\n    },\n  };\n}\n\n/** A short hash of the token, so the session never holds a second copy of it. */\nasync function fingerprint(token: string) {\n  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(token));\n  return [...new Uint8Array(digest).slice(0, 16)].map((b) => b.toString(16).padStart(2, '0')).join('');\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+export { B as Bagsy, c as createBagsy, a as createRelayClient } from './client-CXCgpFGa.js';
+import { A as AccountOptions, T as Transport, a as ProductRef, I as ItemOptions, d as Item, e as List, L as ListRef, P as PageOptions, f as SharedList, g as ItemPage, S as SavedLookup, M as MergeResult, h as TopProduct, V as VariantRef, c as components } from './transport-Chh09xIP.js';
+export { B as BagsyOptions, C as CustomerRef, O as Owner, i as ProxyOptions, R as RelayOptions, b as SavedEntry, j as ServerOptions, k as createTransport, l as customerGid, o as operations, p as paths, m as productGid, v as variantGid } from './transport-Chh09xIP.js';
+export { a as RelayRequest, R as RelayResponse, c as createRelayTransport } from './relay-0l6VcQp9.js';
+
+/**
+ * Transport for customer account UI extensions: every request carries a
+ * current Shopify session token. Kept separate from createTransport so
+ * storefront bundles that never use it don't pay for it.
+ */
+declare function createAccountTransport({ sessionToken, baseUrl, fetch: fetchImpl, ...rest }: AccountOptions): Transport;
+
+/** The owner's lists, default first. */
+declare const listLists: (t: Transport) => Promise<List[]>;
+declare const getList: (t: Transport, listId?: ListRef, { includeItems }?: {
+    includeItems?: boolean | undefined;
+}) => Promise<List>;
+declare const createList: (t: Transport, name: string) => Promise<List>;
+declare const renameList: (t: Transport, listId: ListRef, name: string) => Promise<List>;
+declare const deleteList: (t: Transport, listId: ListRef) => Promise<void>;
+/**
+ * The list's share token, creating it on first share. Stable across calls, so
+ * links already sent keep working; `rotate: true` issues a new one.
+ */
+declare const shareList: (t: Transport, listId?: ListRef, { rotate }?: {
+    rotate?: boolean;
+}) => Promise<string>;
+declare const unshareList: (t: Transport, listId?: ListRef) => Promise<void>;
+declare const listItems: (t: Transport, listId?: ListRef, page?: PageOptions) => Promise<ItemPage>;
+/** Every item in a list, fetched page by page. */
+declare function iterateItems(t: Transport, listId?: ListRef, { limit }?: {
+    limit?: number;
+}): AsyncGenerator<Item>;
+/** Save a product. Saving it again returns the existing item. */
+declare const addItem: (t: Transport, product: ProductRef, { listId, variantId, quantity, note }?: ItemOptions & {
+    quantity?: number;
+    note?: string;
+}) => Promise<Item>;
+/** Unsave by product, without knowing the item id. No-op if not saved. */
+declare const removeProduct: (t: Transport, product: ProductRef, { listId, variantId }?: ItemOptions) => Promise<void>;
+/** Save if unsaved, unsave if saved. Built for heart buttons. */
+declare function toggleItem(t: Transport, product: ProductRef, { listId, variantId }?: ItemOptions): Promise<{
+    saved: boolean;
+}>;
+declare const updateItem: (t: Transport, itemId: string, patch: {
+    variantId?: VariantRef | null;
+    quantity?: number;
+    note?: string | null;
+}, { listId }?: {
+    listId?: ListRef;
+}) => Promise<Item>;
+declare const removeItem: (t: Transport, itemId: string, { listId }?: {
+    listId?: ListRef;
+}) => Promise<void>;
+/**
+ * Saved state for a set of products across all of the owner's lists.
+ * Accepts any number of products; batches of 100 are fetched in parallel.
+ */
+declare function lookupSaved(t: Transport, products: Iterable<ProductRef>): Promise<SavedLookup>;
+/**
+ * Fold a guest's lists into the logged-in customer's. Call once after
+ * login; safe to retry. Defaults to the transport's `visitorId`.
+ */
+declare function mergeVisitor(t: Transport, visitorId?: string | undefined): Promise<MergeResult>;
+/** Public, read-only view of a shared list. */
+declare const getSharedList: (t: Transport, shareToken: string, page?: PageOptions) => Promise<SharedList>;
+/** Most-saved products. Server key only. */
+declare function topProducts(t: Transport, query?: {
+    since?: Date | string;
+    limit?: number;
+}): Promise<TopProduct[]>;
+
+type Problem = components['schemas']['Problem'];
+type BagsyErrorCode = Problem['code'] | 'unexpected_response';
+/** Thrown for any non-2xx response. Switch on `code`, never on `message`. */
+declare class BagsyError extends Error {
+    readonly name = "BagsyError";
+    readonly status: number;
+    readonly code: BagsyErrorCode;
+    readonly problem?: Problem;
+    constructor(status: number, problem: unknown);
+}
+
+/** The slice of Web Storage this module uses; `localStorage` satisfies it. */
+interface VisitorStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * Returns this browser's guest identity, creating it on first call.
+ *
+ * Persisted in localStorage. Falls back to an in-memory ID (for the page's
+ * lifetime) when storage is blocked, e.g. in private windows or iframes.
+ */
+declare function getVisitorId(storage?: Pick<VisitorStorage, 'getItem' | 'setItem'> | undefined): string;
+/** The guest identity if one exists, without creating it. Use to decide whether to merge on login. */
+declare function peekVisitorId(storage?: Pick<VisitorStorage, 'getItem'> | undefined): string | undefined;
+/** Forget the guest identity, e.g. after a successful merge on login. */
+declare function clearVisitorId(storage?: Pick<VisitorStorage, 'removeItem'> | undefined): void;
+
+export { AccountOptions, BagsyError, Item, ItemOptions, ItemPage, List, ListRef, MergeResult, PageOptions, ProductRef, SavedLookup, SharedList, TopProduct, Transport, VariantRef, addItem, clearVisitorId, components, createAccountTransport, createList, deleteList, getList, getSharedList, getVisitorId, iterateItems, listItems, listLists, lookupSaved, mergeVisitor, peekVisitorId, removeItem, removeProduct, renameList, shareList, toggleItem, topProducts, unshareList, updateItem };
+export type { BagsyErrorCode, Problem, VisitorStorage };

package/dist/index.js

@@ -0,0 +1,65 @@
+import {
+  BagsyError,
+  addItem,
+  clearVisitorId,
+  createAccountTransport,
+  createBagsy,
+  createList,
+  createRelayClient,
+  createRelayTransport,
+  createTransport,
+  customerGid,
+  deleteList,
+  getList,
+  getSharedList,
+  getVisitorId,
+  iterateItems,
+  listItems,
+  listLists,
+  lookupSaved,
+  mergeVisitor,
+  peekVisitorId,
+  productGid,
+  removeItem,
+  removeProduct,
+  renameList,
+  shareList,
+  toggleItem,
+  topProducts,
+  unshareList,
+  updateItem,
+  variantGid
+} from "./chunk-QV3JPND6.js";
+export {
+  BagsyError,
+  addItem,
+  clearVisitorId,
+  createAccountTransport,
+  createBagsy,
+  createList,
+  createRelayClient,
+  createRelayTransport,
+  createTransport,
+  customerGid,
+  deleteList,
+  getList,
+  getSharedList,
+  getVisitorId,
+  iterateItems,
+  listItems,
+  listLists,
+  lookupSaved,
+  mergeVisitor,
+  peekVisitorId,
+  productGid,
+  removeItem,
+  removeProduct,
+  renameList,
+  shareList,
+  toggleItem,
+  topProducts,
+  unshareList,
+  updateItem,
+  variantGid
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/react.d.ts

@@ -0,0 +1,174 @@
+import * as react from 'react';
+import { ReactNode, ButtonHTMLAttributes } from 'react';
+import { Bagsy } from './index.js';
+import { SavedEntry, ProductRef, VariantRef, ListRef, Item } from './index.js';
+
+interface SavedState {
+    /**
+     * Saved in any list. With a variant: that variant, or the product without a
+     * variant (which means "any variant"). False until known.
+     */
+    saved: boolean;
+    /** True once the server has answered (or the state was server-rendered). */
+    ready: boolean;
+    /** A toggle is in flight. */
+    pending: boolean;
+}
+interface StoreEvents {
+    /** A toggle was confirmed by the server. */
+    onChange?: (change: {
+        productId: string;
+        variantId?: string;
+        saved: boolean;
+    }) => void;
+    /** Any failed request. Toggles have already been rolled back. */
+    onError?: (error: unknown) => void;
+}
+type Listener = () => void;
+/**
+ * Saved state for one shopper, shared by every component under a provider.
+ * Plain TypeScript, so it can be used without React (and tested in Node).
+ *
+ * - Lookups for products not seen before are batched: every component that
+ *   mounts in the same tick shares one `/saved` request.
+ * - Toggles are optimistic and roll back on failure.
+ * - Server-rendered state can be seeded, so the first render is already right.
+ */
+declare class BagsyStore {
+    readonly client: Bagsy;
+    private events;
+    private saved;
+    private pendingToggles;
+    private queued;
+    private flushing?;
+    private productListeners;
+    private countListeners;
+    private snapshots;
+    private count?;
+    private countRequest?;
+    constructor(client: Bagsy, events?: StoreEvents);
+    setEvents(events: StoreEvents): void;
+    /**
+     * Server-rendered saved state, e.g. `shopper.saved(ids).byProduct`. Never
+     * overwrites state the client already has. Returns the products it filled
+     * in; pass `notify: false` while rendering and call `notify()` after.
+     */
+    seed(byProduct: Readonly<Record<string, SavedEntry[]>> | undefined, { notify }?: {
+        notify?: boolean | undefined;
+    }): string[];
+    /**
+     * Server-rendered count. Later values (e.g. a root loader revalidating after
+     * navigation) replace it, unless a toggle is in flight.
+     */
+    seedCount(count: number | undefined, { notify }?: {
+        notify?: boolean | undefined;
+    }): void;
+    /** Current state. Stable object identity until it changes, for useSyncExternalStore. */
+    getState(product: ProductRef, variant?: VariantRef): SavedState;
+    /** Subscribe to one product. Loads its state (batched) if unknown. */
+    subscribe(product: ProductRef, listener: Listener): () => void;
+    /**
+     * Save if unsaved, unsave if saved. The UI updates before the server answers.
+     *
+     * - Without a variant: saves the product; unsaving removes every saved
+     *   variant of it.
+     * - With a variant: saves that variant; unsaving removes that variant and
+     *   any product-level save (which covers all variants).
+     *
+     * A second tap while the first is in flight is ignored.
+     */
+    toggle(product: ProductRef, variant?: VariantRef): Promise<boolean>;
+    private unsave;
+    /** Record an item removed elsewhere (e.g. the wishlist page), so hearts update without a request. */
+    forget(product: ProductRef, itemId: string): void;
+    getCount(): number | undefined;
+    subscribeCount(listener: Listener): () => void;
+    /** Loads the default list's item count once; later calls share it. */
+    ensureCount(): Promise<number>;
+    private refreshCount;
+    private loadCount;
+    private adjustCount;
+    private queue;
+    /** Tell subscribers of these products their state may have changed. */
+    notify(...ids: string[]): void;
+}
+
+interface BagsyProviderProps extends StoreEvents {
+    /**
+     * Your server's relay endpoint (see `@umxr/bagsy/hydrogen`).
+     * @default '/api/bagsy'
+     */
+    endpoint?: string;
+    /** Or bring your own client, e.g. `createBagsy({ mode: 'proxy', visitorId: getVisitorId() })` for React in a Liquid theme. */
+    client?: Bagsy;
+    /** Server-rendered saved state: `(await shopper.saved(ids)).byProduct`. */
+    initialSaved?: Readonly<Record<string, SavedEntry[]>>;
+    /** Server-rendered count: `await shopper.count()`. */
+    initialCount?: number;
+    children?: ReactNode;
+}
+/** One per app. Every Bagsy hook and component below it shares one store. */
+declare function BagsyProvider({ endpoint, client, initialSaved, initialCount, onChange, onError, children, }: BagsyProviderProps): react.JSX.Element;
+/** The provider's store and client, for anything the hooks don't cover. */
+declare function useBagsy(): {
+    store: BagsyStore;
+    client: Bagsy;
+};
+/**
+ * Seed saved state from a route's loader, e.g. a collection page that
+ * returns `saved: (await shopper.saved(productIds)).byProduct`.
+ */
+declare function useSeedSaved(byProduct: Readonly<Record<string, SavedEntry[]>> | undefined): void;
+interface UseSavedResult extends SavedState {
+    /** Save if unsaved, unsave if saved. Resolves to the new state; rejects (after rolling back) on failure. */
+    toggle(): Promise<boolean>;
+}
+/** Saved state for one product, or one variant of it. */
+declare function useSaved(product: ProductRef, options?: {
+    variantId?: VariantRef | undefined;
+}): UseSavedResult;
+/** Number of items in the shopper's default list, for a header badge. Undefined until known. */
+declare function useWishlistCount(): number | undefined;
+interface UseWishlistOptions {
+    /** @default 'default' */
+    listId?: ListRef;
+    /** Items per page. @default 24 */
+    pageSize?: number;
+    /** Server-rendered first page: `await (await bagsy.shopper(context)).items({ limit })`. */
+    initial?: {
+        data: Item[];
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor?: string | null;
+        };
+    };
+}
+interface UseWishlistResult {
+    items: Item[];
+    status: 'loading' | 'ready' | 'error';
+    error: unknown;
+    hasNextPage: boolean;
+    loadingMore: boolean;
+    loadMore(): Promise<void>;
+    /** Remove an item. Optimistic; restores it on failure. Hearts elsewhere update too. */
+    remove(item: Item): Promise<void>;
+    refresh(): Promise<void>;
+}
+/** The items in a list, newest first, page by page. */
+declare function useWishlist({ listId, pageSize, initial }?: UseWishlistOptions): UseWishlistResult;
+interface WishlistButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'onToggle' | 'onError'> {
+    productId: ProductRef;
+    variantId?: VariantRef | undefined;
+    /** Content, or a function of the saved state. Defaults to "Save" / "Saved". */
+    children?: ReactNode | ((state: SavedState) => ReactNode);
+    onToggle?: (saved: boolean) => void;
+    onError?: (error: unknown) => void;
+}
+/**
+ * An accessible save toggle. Unstyled: style it with `[data-saved]`,
+ * `[data-pending]` and `[aria-pressed]`. Safe inside product-card links.
+ */
+declare function WishlistButton({ productId, variantId, children, onToggle, onError, onClick, ...rest }: WishlistButtonProps): react.JSX.Element;
+
+export { BagsyProvider, BagsyStore, WishlistButton, useBagsy, useSaved, useSeedSaved, useWishlist, useWishlistCount };
+export type { BagsyProviderProps, SavedState, StoreEvents, UseSavedResult, UseWishlistOptions, UseWishlistResult, WishlistButtonProps };