@businessdash/sdk 0.9.60 → 0.9.80

package/dist/solid-compat.d.ts

@@ -0,0 +1,204 @@
+/**
+ * The slice of Solid this SDK uses, written so one binding works on **both**
+ * Solid 1 and Solid 2.
+ *
+ * ## Why this exists
+ *
+ * Solid 2 reorganised its public API. Measured against the published packages
+ * rather than assumed:
+ *
+ * | symbol | Solid 1 | Solid 2 |
+ * |---|---|---|
+ * | `createSignal` `createMemo` `createEffect` | `solid-js` | `solid-js` |
+ * | `createContext` `useContext` `onCleanup` | `solid-js` | `solid-js` |
+ * | `mapArray` `children` `untrack` | `solid-js` | `solid-js` |
+ * | `For` `Show` `Switch` `Match` | `solid-js` | **`@solidjs/web`** |
+ * | `onMount` `createUniqueId` `from` | `solid-js` | **gone** |
+ * | `Accessor` `JSX` (types) | `solid-js` | **gone** |
+ *
+ * A static import cannot branch on which version is installed, and the build
+ * here is plain `tsc` with no aliasing step — so the two-entry-point trick is
+ * not available either. What IS available is the intersection: every primitive
+ * in the first three rows exists, unchanged, in both versions.
+ *
+ * So this module rebuilds the missing pieces on top of that intersection. The
+ * binding then imports control flow from here instead of from `solid-js`, and
+ * the same compiled output runs on either version.
+ *
+ * ## Why not just use plain JSX instead
+ *
+ * `{items().map(...)}` would have been less code. It also throws away `For`'s
+ * keyed reconciliation — Solid re-creates every row when the array identity
+ * changes, instead of moving the DOM nodes it already has. That is a real
+ * performance characteristic of a form renderer with 200 fields, not sugar, so
+ * `For` here is built over `mapArray`, which is the same primitive Solid's own
+ * `For` uses and which exists in both versions.
+ *
+ * @module
+ */
+/**
+ * A reactive getter. `Accessor` in Solid 1; nothing in Solid 2, where it is
+ * spelled as the plain function type it always was.
+ */
+export type Accessor<T> = () => T;
+/**
+ * Anything Solid will render.
+ *
+ * Deliberately not `JSX.Element`: that type lives in `solid-js` on 1 and in
+ * `@solidjs/web` on 2, so naming it would reintroduce the split this module
+ * exists to remove. Written structurally instead, as the union both versions
+ * accept — measured from their `jsx.d.ts`:
+ *
+ *   Solid 1: `Node | ArrayElement | (string & {}) | number | boolean | null | undefined`
+ *   Solid 2: `SolidElement | Node | ArrayElement`
+ *
+ * The function arm matters: every component here returns a `createMemo`, and a
+ * memo is a function. Solid renders it lazily, which is what keeps unselected
+ * `Switch` branches from evaluating.
+ */
+export type SolidNode = unknown;
+/**
+ * Hand a `SolidNode` back to JSX.
+ *
+ * One cast, in one place, and it is unavoidable rather than lazy: the two
+ * versions disagree about what `JSX.Element` IS — Solid 2 adds a
+ * `RenderedElement` arm Solid 1 has never heard of — so no single named type
+ * is assignable in both directions. Accepting children permissively and
+ * narrowing once at the boundary is what Solid's own components do, and it
+ * keeps the cast auditable instead of scattering `as` through the render tree.
+ */
+export declare function renderNode(node: SolidNode): Node;
+/**
+ * What these components RETURN.
+ *
+ * `Node` rather than `SolidNode`, because TypeScript checks a component's
+ * return type against the installed version's `JSX.Element`, and `Node` is the
+ * only arm those two unions share:
+ *
+ *   Solid 1: `Node | ArrayElement | (string & {}) | number | boolean | null | undefined`
+ *   Solid 2: `SolidElement | Node | ArrayElement`
+ *
+ * The values really returned are memos — functions — which Solid renders
+ * lazily. Solid's own `For` does the same thing and casts for the same reason;
+ * the cast is at the JSX boundary only, and every value flowing THROUGH these
+ * components stays typed as `SolidNode`.
+ */
+/**
+ * An inline style object.
+ *
+ * `JSX.CSSProperties` lives in `solid-js` on Solid 1 and `@solidjs/web` on
+ * Solid 2, so naming it would reintroduce the split. Solid accepts a plain
+ * record of CSS property names to values, which is all these are.
+ */
+export type SolidStyle = Record<string, string | number | undefined>;
+/**
+ * Keyed list rendering.
+ *
+ * `mapArray` is the primitive under Solid's own `For` and is exported by both
+ * versions, so this keeps the reconciliation behaviour rather than degrading
+ * to a re-render on every array identity change.
+ */
+export declare function For<T>(props: {
+    each: readonly T[] | undefined | null;
+    children: (item: T, index: Accessor<number>) => SolidNode;
+}): Node;
+/**
+ * Conditional rendering.
+ *
+ * The children are only evaluated when the condition holds, which is the whole
+ * point — an eagerly-evaluated branch would run effects and fetches for UI
+ * nobody is looking at.
+ */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    fallback?: SolidNode;
+    children: (item: Accessor<NonNullable<T>>) => SolidNode;
+}): Node;
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    fallback?: SolidNode;
+    children: SolidNode;
+}): Node;
+/**
+ * One branch of a `Switch`.
+ *
+ * Returns a descriptor rather than DOM. `children` is a GETTER so the branch
+ * body is not evaluated unless `Switch` picks it — Solid's props are lazy, and
+ * forwarding that laziness is what keeps unselected branches inert.
+ */
+export declare function Match(props: {
+    when: unknown;
+    children: SolidNode;
+}): Node;
+/**
+ * First matching branch wins, else `fallback`.
+ *
+ * `children()` resolves the JSX children — which invokes each `Match` and
+ * yields its marker — and the memo re-picks whenever any `when` changes.
+ */
+export declare function Switch(props: {
+    fallback?: SolidNode;
+    children: SolidNode;
+}): Node;
+/**
+ * Run once, after the first render.
+ *
+ * Solid 2 dropped `onMount`; it was always `createEffect` with the body
+ * untracked and a guard. Written out rather than imported so the binding does
+ * not care which version it is on.
+ */
+export declare function onMount(fn: () => void): void;
+/**
+ * The provider component for a context, on either Solid version.
+ *
+ * Solid 1 hangs a `.Provider` off the context object. Solid 2 makes the
+ * context object **its own provider** — you write `<Ctx value={x}>` where you
+ * used to write `<Ctx.Provider value={x}>`.
+ *
+ * Unlike the import differences, this one CAN be resolved at runtime: the
+ * shape is inspectable. `.Provider` when it exists, the context itself
+ * otherwise.
+ */
+export declare function providerFor<T>(context: unknown): (props: {
+    value: T;
+    children: SolidNode;
+}) => Node;
+/**
+ * Build a `class` string from a base plus conditional modifiers.
+ *
+ * Replaces Solid 1's `classList={{ "mod": cond }}`, which Solid 2 removed —
+ * verified against both versions' `jsx.d.ts`, where `classList` is declared in
+ * 1 and absent in 2.
+ *
+ * A plain `class` string behaves identically on both, so this is the portable
+ * spelling rather than a workaround.
+ */
+export declare function cx(base: string | undefined, modifiers?: Record<string, boolean | undefined>): string;
+/**
+ * A stable id for `for`/`aria-*` pairs.
+ *
+ * Solid 2 dropped `createUniqueId`. A module-level counter is enough here
+ * because these ids are only ever used to link a label to its own input within
+ * one document — they are not persisted, sent anywhere, or compared across
+ * renders.
+ *
+ * The `biab-` prefix keeps them from colliding with ids the consumer's own
+ * page already uses.
+ */
+export declare function createUniqueId(): string;
+/**
+ * Bridge an external store into a signal.
+ *
+ * Replaces Solid 1's `from`, which Solid 2 dropped. The shape is exactly what
+ * every shared core exposes — `snapshot()` / `subscribe()` / `destroy()` — so
+ * this is the one seam where the framework-agnostic controllers meet Solid.
+ *
+ * `subscribe` does NOT replay, so the initial value is read separately. A
+ * bridge that waited for the first notification would render empty until
+ * something happened to change, which on a quiet screen is forever.
+ */
+export declare function fromStore<T>(store: {
+    snapshot: () => T;
+    subscribe: (listener: () => void) => () => void;
+}): Accessor<T>;
+//# sourceMappingURL=solid-compat.d.ts.map

package/dist/solid-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-compat.d.ts","sourceRoot":"","sources":["../src/solid-compat.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAWH;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AAElC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC;AAEhC;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAEhD;AAED;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;AAErE;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE;IAC7B,IAAI,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;IACtC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC;CAC1D,GAAG,IAAI,CAUP;AAED;;;;;;GAMG;AAKH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE;IAC9B,IAAI,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC;IACnC,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC;CACxD,GAAG,IAAI,CAAC;AACT,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE;IAC9B,IAAI,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC;IACnC,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;CACpB,GAAG,IAAI,CAAC;AAsCT;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAWzE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE;IAC7B,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;CACpB,GAAG,IAAI,CAUP;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAO5C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC5B,OAAO,EAAE,OAAO,GACd,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAA;CAAE,KAAK,IAAI,CAQpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,EAAE,CACjB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,GAC7C,MAAM,CAQR;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAGvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE;IACnC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAClB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAChD,GAAG,QAAQ,CAAC,CAAC,CAAC,CAqBd"}

package/dist/solid-compat.js

@@ -0,0 +1,221 @@
+/**
+ * The slice of Solid this SDK uses, written so one binding works on **both**
+ * Solid 1 and Solid 2.
+ *
+ * ## Why this exists
+ *
+ * Solid 2 reorganised its public API. Measured against the published packages
+ * rather than assumed:
+ *
+ * | symbol | Solid 1 | Solid 2 |
+ * |---|---|---|
+ * | `createSignal` `createMemo` `createEffect` | `solid-js` | `solid-js` |
+ * | `createContext` `useContext` `onCleanup` | `solid-js` | `solid-js` |
+ * | `mapArray` `children` `untrack` | `solid-js` | `solid-js` |
+ * | `For` `Show` `Switch` `Match` | `solid-js` | **`@solidjs/web`** |
+ * | `onMount` `createUniqueId` `from` | `solid-js` | **gone** |
+ * | `Accessor` `JSX` (types) | `solid-js` | **gone** |
+ *
+ * A static import cannot branch on which version is installed, and the build
+ * here is plain `tsc` with no aliasing step — so the two-entry-point trick is
+ * not available either. What IS available is the intersection: every primitive
+ * in the first three rows exists, unchanged, in both versions.
+ *
+ * So this module rebuilds the missing pieces on top of that intersection. The
+ * binding then imports control flow from here instead of from `solid-js`, and
+ * the same compiled output runs on either version.
+ *
+ * ## Why not just use plain JSX instead
+ *
+ * `{items().map(...)}` would have been less code. It also throws away `For`'s
+ * keyed reconciliation — Solid re-creates every row when the array identity
+ * changes, instead of moving the DOM nodes it already has. That is a real
+ * performance characteristic of a form renderer with 200 fields, not sugar, so
+ * `For` here is built over `mapArray`, which is the same primitive Solid's own
+ * `For` uses and which exists in both versions.
+ *
+ * @module
+ */
+import { children, createMemo, createSignal, mapArray, onCleanup, untrack, } from "solid-js";
+/**
+ * Hand a `SolidNode` back to JSX.
+ *
+ * One cast, in one place, and it is unavoidable rather than lazy: the two
+ * versions disagree about what `JSX.Element` IS — Solid 2 adds a
+ * `RenderedElement` arm Solid 1 has never heard of — so no single named type
+ * is assignable in both directions. Accepting children permissively and
+ * narrowing once at the boundary is what Solid's own components do, and it
+ * keeps the cast auditable instead of scattering `as` through the render tree.
+ */
+export function renderNode(node) {
+    return node;
+}
+/**
+ * Keyed list rendering.
+ *
+ * `mapArray` is the primitive under Solid's own `For` and is exported by both
+ * versions, so this keeps the reconciliation behaviour rather than degrading
+ * to a re-render on every array identity change.
+ */
+export function For(props) {
+    // `props.each` is read inside the memo so the list stays reactive; reading
+    // it here would snapshot it once and never update.
+    const mapped = createMemo(mapArray(() => props.each ?? [], (item, index) => props.children(item, index)));
+    return mapped;
+}
+export function Show(props) {
+    const condition = createMemo(() => props.when);
+    return createMemo(() => {
+        const value = condition();
+        if (!value)
+            return props.fallback;
+        const body = props.children;
+        if (typeof body !== "function")
+            return body;
+        // An accessor, matching Solid's own signature: the child is written as
+        // `{(item) => <b>{item()}</b>}` and calling it keeps the read tracked
+        // inside the child rather than at the boundary.
+        const accessor = () => condition();
+        return untrack(() => body(accessor));
+    });
+}
+function isMatchMarker(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.__biabMatch === true);
+}
+/**
+ * One branch of a `Switch`.
+ *
+ * Returns a descriptor rather than DOM. `children` is a GETTER so the branch
+ * body is not evaluated unless `Switch` picks it — Solid's props are lazy, and
+ * forwarding that laziness is what keeps unselected branches inert.
+ */
+export function Match(props) {
+    const marker = {
+        __biabMatch: true,
+        get when() {
+            return props.when;
+        },
+        get children() {
+            return props.children;
+        },
+    };
+    return marker;
+}
+/**
+ * First matching branch wins, else `fallback`.
+ *
+ * `children()` resolves the JSX children — which invokes each `Match` and
+ * yields its marker — and the memo re-picks whenever any `when` changes.
+ */
+export function Switch(props) {
+    const resolved = children(() => props.children);
+    return createMemo(() => {
+        const list = resolved.toArray();
+        for (const entry of list) {
+            if (!isMatchMarker(entry))
+                continue;
+            if (entry.when)
+                return entry.children;
+        }
+        return props.fallback;
+    });
+}
+/**
+ * Run once, after the first render.
+ *
+ * Solid 2 dropped `onMount`; it was always `createEffect` with the body
+ * untracked and a guard. Written out rather than imported so the binding does
+ * not care which version it is on.
+ */
+export function onMount(fn) {
+    const [mounted, setMounted] = createSignal(false);
+    createMemo(() => {
+        if (mounted())
+            return;
+        setMounted(true);
+        untrack(fn);
+    });
+}
+/**
+ * The provider component for a context, on either Solid version.
+ *
+ * Solid 1 hangs a `.Provider` off the context object. Solid 2 makes the
+ * context object **its own provider** — you write `<Ctx value={x}>` where you
+ * used to write `<Ctx.Provider value={x}>`.
+ *
+ * Unlike the import differences, this one CAN be resolved at runtime: the
+ * shape is inspectable. `.Provider` when it exists, the context itself
+ * otherwise.
+ */
+export function providerFor(context) {
+    const withProvider = context;
+    return (withProvider.Provider ??
+        context);
+}
+/**
+ * Build a `class` string from a base plus conditional modifiers.
+ *
+ * Replaces Solid 1's `classList={{ "mod": cond }}`, which Solid 2 removed —
+ * verified against both versions' `jsx.d.ts`, where `classList` is declared in
+ * 1 and absent in 2.
+ *
+ * A plain `class` string behaves identically on both, so this is the portable
+ * spelling rather than a workaround.
+ */
+export function cx(base, modifiers) {
+    const parts = base ? [base] : [];
+    if (modifiers) {
+        for (const [name, on] of Object.entries(modifiers)) {
+            if (on)
+                parts.push(name);
+        }
+    }
+    return parts.join(" ");
+}
+let uniqueIdCounter = 0;
+/**
+ * A stable id for `for`/`aria-*` pairs.
+ *
+ * Solid 2 dropped `createUniqueId`. A module-level counter is enough here
+ * because these ids are only ever used to link a label to its own input within
+ * one document — they are not persisted, sent anywhere, or compared across
+ * renders.
+ *
+ * The `biab-` prefix keeps them from colliding with ids the consumer's own
+ * page already uses.
+ */
+export function createUniqueId() {
+    uniqueIdCounter += 1;
+    return `biab-${uniqueIdCounter}`;
+}
+/**
+ * Bridge an external store into a signal.
+ *
+ * Replaces Solid 1's `from`, which Solid 2 dropped. The shape is exactly what
+ * every shared core exposes — `snapshot()` / `subscribe()` / `destroy()` — so
+ * this is the one seam where the framework-agnostic controllers meet Solid.
+ *
+ * `subscribe` does NOT replay, so the initial value is read separately. A
+ * bridge that waited for the first notification would render empty until
+ * something happened to change, which on a quiet screen is forever.
+ */
+export function fromStore(store) {
+    // Boxed, and not for tidiness: Solid 2 types the value overload of
+    // `createSignal` as `Exclude<T, Function>`, because a bare function
+    // argument is read as a compute function instead of a value. A snapshot
+    // type that could be callable is therefore rejected outright. A wrapper
+    // object is never a Function, so the same call compiles on both versions
+    // and cannot be mistaken for a computation.
+    const [box, setBox] = createSignal({ value: store.snapshot() }, {
+        // Snapshots are replaced wholesale, and two structurally-equal
+        // snapshots are still a real update to the controller. Comparing
+        // would drop legitimate notifications.
+        equals: false,
+    });
+    const unsubscribe = store.subscribe(() => setBox({ value: store.snapshot() }));
+    onCleanup(unsubscribe);
+    return () => box().value;
+}
+//# sourceMappingURL=solid-compat.js.map

package/dist/solid-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid-compat.js","sourceRoot":"","sources":["../src/solid-compat.tsx"],"names":[],"mappings":"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"}

package/dist/store-core/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * `@businessdash/sdk/store` — the headless storefront + cart controller.
+ *
+ * ## Why this exists
+ *
+ * Until now the only storefront the SDK offered was `<Storefront>`: a
+ * BusinessDash-hosted page in a sandboxed iframe. It works, and it ships fast,
+ * but it renders OUR markup inside YOUR app — your design system stops at the
+ * iframe boundary, and there is no way to put a product card in your own grid.
+ * That was true in every binding, React included.
+ *
+ * This is the native path. It owns all of the behaviour — pagination, category
+ * filtering, the cart, coupons, the product detail — and none of the markup.
+ * Exactly the split `createFormController` already uses for forms: one
+ * framework-agnostic controller, and a thin reactive view per framework.
+ *
+ * A binding subscribes to `snapshot()` and renders it. That is the whole
+ * contract, and it is why React, Solid, Vue, Svelte, Qwik, Angular and plain
+ * DOM can each expose a native storefront without any of them reimplementing
+ * what "add to cart" means.
+ *
+ * ## Money
+ *
+ * Every price crossing this boundary is an INTEGER of the currency's minor unit
+ * — cents for USD. The controller never divides, rounds or formats: it passes
+ * what the API sent straight to your renderer. Format at the edge, where you
+ * know the locale.
+ *
+ * @module
+ */
+import type { CartAddItemInput, CartSnapshot, StorefrontCategory, StorefrontProductDetail, StorefrontProductRow } from "../contracts.js";
+/**
+ * The client surface this controller needs. Declared structurally rather than
+ * importing `BiabDevClient`, so a consumer can hand in a same-origin proxy, a
+ * test double, or a narrowed client without the controller caring.
+ */
+export type StoreCoreClient = {
+    storefront: {
+        listProducts(input?: {
+            limit?: number;
+            cursor?: number | null;
+            categoryId?: string;
+        }): Promise<{
+            items: StorefrontProductRow[];
+            nextCursor: number | null;
+        }>;
+        listCategories(): Promise<{
+            items: StorefrontCategory[];
+        }>;
+        getProduct(productId: string): Promise<StorefrontProductDetail>;
+    };
+    cart: {
+        get(): Promise<CartSnapshot>;
+        addItem(input: CartAddItemInput): Promise<CartSnapshot>;
+        updateItem(itemId: string, input: {
+            quantity: number;
+        }): Promise<CartSnapshot>;
+        removeItem(itemId: string): Promise<CartSnapshot>;
+        applyCoupon(input: {
+            code: string;
+        }): Promise<CartSnapshot>;
+        removeCoupon(): Promise<CartSnapshot>;
+        clear(): Promise<CartSnapshot>;
+    };
+};
+export type StoreStatus = "idle" | "loading" | "ready" | "error";
+/**
+ * What a binding renders. Field names are STABLE and load-bearing for every
+ * framework binding — renaming one is a breaking change in eight places.
+ */
+export type StoreSnapshot = {
+    status: StoreStatus;
+    /** The current page of products, accumulated across `loadMore()`. */
+    products: readonly StorefrontProductRow[];
+    categories: readonly StorefrontCategory[];
+    /** `null` until the first cart read resolves. */
+    cart: CartSnapshot | null;
+    /** The product opened via `openProduct()`, if any. */
+    activeProduct: StorefrontProductDetail | null;
+    /** Active category filter, or `null` for everything. */
+    categoryId: string | null;
+    /** Whether `loadMore()` would fetch anything. */
+    hasMore: boolean;
+    /** Last failure. Cleared on the next successful action. */
+    error: Error | null;
+    /**
+     * In-flight work, so a binding can disable a button without inventing its
+     * own loading state. `cart` covers every mutation — add, update, remove,
+     * coupon, clear — because they all serialise onto the same cart.
+     */
+    pending: {
+        products: boolean;
+        categories: boolean;
+        product: boolean;
+        cart: boolean;
+    };
+    /** Convenience mirrors of `cart`, so a badge doesn't need a null check. */
+    itemCount: number;
+    subtotal: number;
+    currency: string | null;
+};
+export type StoreController = {
+    snapshot(): StoreSnapshot;
+    /**
+     * Subscribe to snapshot changes. Returns an unsubscribe function. The
+     * callback is NOT invoked on subscribe — read `snapshot()` for the initial
+     * value, the same contract `createFormController` uses.
+     */
+    subscribe(callback: (snapshot: StoreSnapshot) => void): () => void;
+    /** Fetch products, categories and the cart. Safe to call more than once. */
+    load(): Promise<void>;
+    /** Append the next page. No-op when `hasMore` is false or a page is in flight. */
+    loadMore(): Promise<void>;
+    /** Filter by category (or `null` for all) and reset pagination. */
+    filterByCategory(categoryId: string | null): Promise<void>;
+    /** Load one product's detail into `activeProduct`. */
+    openProduct(productId: string): Promise<void>;
+    closeProduct(): void;
+    addToCart(input: CartAddItemInput): Promise<void>;
+    /** Quantity 0 removes the line, matching the API's own semantics. */
+    updateQuantity(itemId: string, quantity: number): Promise<void>;
+    removeItem(itemId: string): Promise<void>;
+    applyCoupon(code: string): Promise<void>;
+    removeCoupon(): Promise<void>;
+    clearCart(): Promise<void>;
+    /** Re-read the cart without touching products. */
+    refreshCart(): Promise<void>;
+    /** Stop notifying and drop all subscribers. */
+    destroy(): void;
+};
+export type CreateStoreControllerOptions = {
+    client: StoreCoreClient;
+    /** Products per page. Default 24. */
+    pageSize?: number;
+    /** Start filtered to a category. */
+    categoryId?: string | null;
+    /** Called on every failure, in addition to landing in `snapshot().error`. */
+    onError?: (error: Error) => void;
+};
+export declare function createStoreController(options: CreateStoreControllerOptions): StoreController;
+//# sourceMappingURL=index.d.ts.map

package/dist/store-core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/store-core/index.ts"],"names":[],"mappings":"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"}