@vtex/faststore 0.0.1

package/dist/sdk/actions/cart-action-provider.d.ts

@@ -0,0 +1,19 @@
+import { ActionProviderProps } from "./inject-actions.js";
+import { ReactNode } from "react";
+//#region src/sdk/actions/cart-action-provider.d.ts
+export type CartActionProviderProps = ActionProviderProps;
+/**
+ * Compiler-emitted runtime wrapper for the `cart` action namespace — the write-side mirror of
+ * `ReactiveDataProvider`. The compiler wraps every element whose definition declares
+ * `actions: { cart: [...] }` with `<CartActionProvider methods={[...]}>`, calls `useCartActions`
+ * once, narrows the surface to the declared `methods`, and threads it into the single child via
+ * `$actions.cart` (merging with any outer namespace provider). A namespace a component does not
+ * declare is never wrapped, so its hook is never called (specs/actions.md FR-6).
+ *
+ * It injects `$actions` as a prop (cloneElement) rather than a context so the contract matches
+ * `$data`: components destructure `$actions` from props and stay directly testable with `mockAction`.
+ * That makes the child's shape load-bearing — see `injectActions`.
+ */
+export declare function CartActionProvider(props: CartActionProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=cart-action-provider.d.ts.map

package/dist/sdk/actions/cart-action-provider.js

@@ -0,0 +1,23 @@
+"use client";
+import { useCartActions } from "../cart/use-cart-actions.js";
+import { injectActions } from "./inject-actions.js";
+//#region src/sdk/actions/cart-action-provider.tsx
+/**
+* Compiler-emitted runtime wrapper for the `cart` action namespace — the write-side mirror of
+* `ReactiveDataProvider`. The compiler wraps every element whose definition declares
+* `actions: { cart: [...] }` with `<CartActionProvider methods={[...]}>`, calls `useCartActions`
+* once, narrows the surface to the declared `methods`, and threads it into the single child via
+* `$actions.cart` (merging with any outer namespace provider). A namespace a component does not
+* declare is never wrapped, so its hook is never called (specs/actions.md FR-6).
+*
+* It injects `$actions` as a prop (cloneElement) rather than a context so the contract matches
+* `$data`: components destructure `$actions` from props and stay directly testable with `mockAction`.
+* That makes the child's shape load-bearing — see `injectActions`.
+*/
+function CartActionProvider(props) {
+	return injectActions("cart", useCartActions(), props);
+}
+//#endregion
+export { CartActionProvider };
+
+//# sourceMappingURL=cart-action-provider.js.map

package/dist/sdk/actions/cart-action-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cart-action-provider.js","names":[],"sources":["../../../src/sdk/actions/cart-action-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { ReactNode } from 'react';\nimport { useCartActions } from '../cart/use-cart-actions.js';\nimport { type ActionProviderProps, injectActions } from './inject-actions.js';\n\nexport type CartActionProviderProps = ActionProviderProps;\n\n/**\n * Compiler-emitted runtime wrapper for the `cart` action namespace — the write-side mirror of\n * `ReactiveDataProvider`. The compiler wraps every element whose definition declares\n * `actions: { cart: [...] }` with `<CartActionProvider methods={[...]}>`, calls `useCartActions`\n * once, narrows the surface to the declared `methods`, and threads it into the single child via\n * `$actions.cart` (merging with any outer namespace provider). A namespace a component does not\n * declare is never wrapped, so its hook is never called (specs/actions.md FR-6).\n *\n * It injects `$actions` as a prop (cloneElement) rather than a context so the contract matches\n * `$data`: components destructure `$actions` from props and stay directly testable with `mockAction`.\n * That makes the child's shape load-bearing — see `injectActions`.\n */\nexport function CartActionProvider(props: CartActionProviderProps): ReactNode {\n  return injectActions('cart', useCartActions(), props);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,SAAgB,mBAAmB,OAA2C;CAC5E,OAAO,cAAc,QAAQ,eAAe,GAAG,KAAK;AACtD"}

package/dist/sdk/actions/identity-action-provider.d.ts

@@ -0,0 +1,15 @@
+import { ActionProviderProps } from "./inject-actions.js";
+import { ReactNode } from "react";
+//#region src/sdk/actions/identity-action-provider.d.ts
+export type IdentityActionProviderProps = ActionProviderProps;
+/**
+ * Compiler-emitted runtime wrapper for the `identity` action namespace — the write-side mirror of
+ * `ReactiveDataProvider`, structurally identical to `CartActionProvider`. The compiler wraps every
+ * element whose definition declares `actions: { identity: [...] }` with
+ * `<IdentityActionProvider methods={[...]}>`, calls `useIdentityActions` once, narrows the surface to
+ * the declared `methods`, and threads it into the single child via `$actions.identity` (merging with
+ * any outer namespace provider).
+ */
+export declare function IdentityActionProvider(props: IdentityActionProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=identity-action-provider.d.ts.map

package/dist/sdk/actions/identity-action-provider.js

@@ -0,0 +1,19 @@
+"use client";
+import { injectActions } from "./inject-actions.js";
+import { useIdentityActions } from "../identity/use-identity-actions.js";
+//#region src/sdk/actions/identity-action-provider.tsx
+/**
+* Compiler-emitted runtime wrapper for the `identity` action namespace — the write-side mirror of
+* `ReactiveDataProvider`, structurally identical to `CartActionProvider`. The compiler wraps every
+* element whose definition declares `actions: { identity: [...] }` with
+* `<IdentityActionProvider methods={[...]}>`, calls `useIdentityActions` once, narrows the surface to
+* the declared `methods`, and threads it into the single child via `$actions.identity` (merging with
+* any outer namespace provider).
+*/
+function IdentityActionProvider(props) {
+	return injectActions("identity", useIdentityActions(), props);
+}
+//#endregion
+export { IdentityActionProvider };
+
+//# sourceMappingURL=identity-action-provider.js.map

package/dist/sdk/actions/identity-action-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-action-provider.js","names":[],"sources":["../../../src/sdk/actions/identity-action-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { ReactNode } from 'react';\nimport { useIdentityActions } from '../identity/use-identity-actions.js';\nimport { type ActionProviderProps, injectActions } from './inject-actions.js';\n\nexport type IdentityActionProviderProps = ActionProviderProps;\n\n/**\n * Compiler-emitted runtime wrapper for the `identity` action namespace — the write-side mirror of\n * `ReactiveDataProvider`, structurally identical to `CartActionProvider`. The compiler wraps every\n * element whose definition declares `actions: { identity: [...] }` with\n * `<IdentityActionProvider methods={[...]}>`, calls `useIdentityActions` once, narrows the surface to\n * the declared `methods`, and threads it into the single child via `$actions.identity` (merging with\n * any outer namespace provider).\n */\nexport function IdentityActionProvider(props: IdentityActionProviderProps): ReactNode {\n  return injectActions('identity', useIdentityActions(), props);\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,uBAAuB,OAA+C;CACpF,OAAO,cAAc,YAAY,mBAAmB,GAAG,KAAK;AAC9D"}

package/dist/sdk/actions/index.d.ts

@@ -0,0 +1,7 @@
+import { ComponentActions } from "./types.js";
+import { CartActionProvider, CartActionProviderProps } from "./cart-action-provider.js";
+import { IdentityActionProvider, IdentityActionProviderProps } from "./identity-action-provider.js";
+import { RegionActionProvider, RegionActionProviderProps } from "./region-action-provider.js";
+import { SessionActionProvider, SessionActionProviderProps } from "./session-action-provider.js";
+import { ShippingActionProvider, ShippingActionProviderProps } from "./shipping-action-provider.js";
+export { CartActionProvider, type CartActionProviderProps, IdentityActionProvider, type IdentityActionProviderProps, RegionActionProvider, type RegionActionProviderProps, SessionActionProvider, type SessionActionProviderProps, ShippingActionProvider, type ShippingActionProviderProps };

package/dist/sdk/actions/index.js

@@ -0,0 +1,6 @@
+import { CartActionProvider } from "./cart-action-provider.js";
+import { IdentityActionProvider } from "./identity-action-provider.js";
+import { RegionActionProvider } from "./region-action-provider.js";
+import { SessionActionProvider } from "./session-action-provider.js";
+import { ShippingActionProvider } from "./shipping-action-provider.js";
+export { CartActionProvider, IdentityActionProvider, RegionActionProvider, SessionActionProvider, ShippingActionProvider };

package/dist/sdk/actions/inject-actions.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+//#region src/sdk/actions/inject-actions.d.ts
+/** Props every compiler-emitted action provider takes, plus whatever an outer wrapper injected. */
+export type ActionProviderProps = Readonly<{
+  /** Method names the consuming component declared under `actions: { <namespace>: [...] }`. */
+  methods: readonly string[];
+  children: ReactNode;
+  /** Injected by the content boundary when the consumer also declares a content model. */
+  $content?: Record<string, unknown>;
+  /** Injected by another namespace's provider when the consumer declares more than one. */
+  $actions?: Record<string, Record<string, unknown>>;
+}>;
+//#endregion
+//# sourceMappingURL=inject-actions.d.ts.map

package/dist/sdk/actions/inject-actions.js

@@ -0,0 +1,36 @@
+"use client";
+import { cloneElement, isValidElement } from "react";
+//#region src/sdk/actions/inject-actions.tsx
+/**
+* The shared body of every action provider: narrow the namespace surface to the declared `methods`
+* and clone it onto the single child as `$actions.<namespace>`.
+*
+* A provider is transparent, so it forwards what an outer wrapper injected onto *it* rather than
+* consuming it: `$content` from the content boundary, and the namespaces of an outer provider when
+* the consumer declares more than one. Reading `$actions` off the child as well keeps a child that
+* already carries some (a hand-authored tree, `mockAction` in a test) working.
+*/
+function injectActions(namespace, surface, { methods, children, $content, $actions }) {
+	if (!isValidElement(children)) return children;
+	const selected = {};
+	for (const method of methods) {
+		const handler = surface[method];
+		if (typeof handler === "function") selected[method] = handler;
+	}
+	const child = children;
+	const inherited = {
+		...child.props.$actions,
+		...$actions
+	};
+	return cloneElement(child, {
+		...$content === void 0 ? {} : { $content },
+		$actions: {
+			...inherited,
+			[namespace]: selected
+		}
+	});
+}
+//#endregion
+export { injectActions };
+
+//# sourceMappingURL=inject-actions.js.map

package/dist/sdk/actions/inject-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-actions.js","names":[],"sources":["../../../src/sdk/actions/inject-actions.tsx"],"sourcesContent":["'use client';\n\nimport { cloneElement, isValidElement, type ReactElement, type ReactNode } from 'react';\n\n/** Props every compiler-emitted action provider takes, plus whatever an outer wrapper injected. */\nexport type ActionProviderProps = Readonly<{\n  /** Method names the consuming component declared under `actions: { <namespace>: [...] }`. */\n  methods: readonly string[];\n  children: ReactNode;\n  /** Injected by the content boundary when the consumer also declares a content model. */\n  $content?: Record<string, unknown>;\n  /** Injected by another namespace's provider when the consumer declares more than one. */\n  $actions?: Record<string, Record<string, unknown>>;\n}>;\n\ntype InjectedProps = Pick<ActionProviderProps, '$content' | '$actions'>;\n\n/**\n * The shared body of every action provider: narrow the namespace surface to the declared `methods`\n * and clone it onto the single child as `$actions.<namespace>`.\n *\n * A provider is transparent, so it forwards what an outer wrapper injected onto *it* rather than\n * consuming it: `$content` from the content boundary, and the namespaces of an outer provider when\n * the consumer declares more than one. Reading `$actions` off the child as well keeps a child that\n * already carries some (a hand-authored tree, `mockAction` in a test) working.\n */\nexport function injectActions(\n  namespace: string,\n  surface: Record<string, unknown>,\n  { methods, children, $content, $actions }: ActionProviderProps,\n): ReactNode {\n  if (!isValidElement(children)) return children;\n\n  const selected: Record<string, unknown> = {};\n  for (const method of methods) {\n    const handler = surface[method];\n    if (typeof handler === 'function') selected[method] = handler;\n  }\n\n  const child = children as ReactElement<InjectedProps>;\n  const inherited = { ...child.props.$actions, ...$actions };\n  return cloneElement(child, {\n    ...($content === undefined ? {} : { $content }),\n    $actions: { ...inherited, [namespace]: selected },\n  });\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,cACd,WACA,SACA,EAAE,SAAS,UAAU,UAAU,YACpB;CACX,IAAI,CAAC,eAAe,QAAQ,GAAG,OAAO;CAEtC,MAAM,WAAoC,CAAC;CAC3C,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,UAAU,QAAQ;EACxB,IAAI,OAAO,YAAY,YAAY,SAAS,UAAU;CACxD;CAEA,MAAM,QAAQ;CACd,MAAM,YAAY;EAAE,GAAG,MAAM,MAAM;EAAU,GAAG;CAAS;CACzD,OAAO,aAAa,OAAO;EACzB,GAAI,aAAa,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS;EAC7C,UAAU;GAAE,GAAG;IAAY,YAAY;EAAS;CAClD,CAAC;AACH"}

package/dist/sdk/actions/region-action-provider.d.ts

@@ -0,0 +1,15 @@
+import { ActionProviderProps } from "./inject-actions.js";
+import { ReactNode } from "react";
+//#region src/sdk/actions/region-action-provider.d.ts
+export type RegionActionProviderProps = ActionProviderProps;
+/**
+ * Compiler-emitted runtime wrapper for the `region` action namespace — a line-for-line mirror of
+ * `SessionActionProvider`. The compiler wraps every element whose definition declares
+ * `actions: { region: [...] }` with `<RegionActionProvider methods={[...]}>`, calls `useRegionActions`
+ * once, narrows the surface to the declared `methods`, and threads it into the single child via
+ * `$actions.region` (merging with any outer namespace provider). A namespace a component does not
+ * declare is never wrapped, so its hook is never called.
+ */
+export declare function RegionActionProvider(props: RegionActionProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=region-action-provider.d.ts.map

package/dist/sdk/actions/region-action-provider.js

@@ -0,0 +1,19 @@
+"use client";
+import { injectActions } from "./inject-actions.js";
+import { useRegionActions } from "../region/use-region-actions.js";
+//#region src/sdk/actions/region-action-provider.tsx
+/**
+* Compiler-emitted runtime wrapper for the `region` action namespace — a line-for-line mirror of
+* `SessionActionProvider`. The compiler wraps every element whose definition declares
+* `actions: { region: [...] }` with `<RegionActionProvider methods={[...]}>`, calls `useRegionActions`
+* once, narrows the surface to the declared `methods`, and threads it into the single child via
+* `$actions.region` (merging with any outer namespace provider). A namespace a component does not
+* declare is never wrapped, so its hook is never called.
+*/
+function RegionActionProvider(props) {
+	return injectActions("region", useRegionActions(), props);
+}
+//#endregion
+export { RegionActionProvider };
+
+//# sourceMappingURL=region-action-provider.js.map

package/dist/sdk/actions/region-action-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"region-action-provider.js","names":[],"sources":["../../../src/sdk/actions/region-action-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { ReactNode } from 'react';\nimport { useRegionActions } from '../region/use-region-actions.js';\nimport { type ActionProviderProps, injectActions } from './inject-actions.js';\n\nexport type RegionActionProviderProps = ActionProviderProps;\n\n/**\n * Compiler-emitted runtime wrapper for the `region` action namespace — a line-for-line mirror of\n * `SessionActionProvider`. The compiler wraps every element whose definition declares\n * `actions: { region: [...] }` with `<RegionActionProvider methods={[...]}>`, calls `useRegionActions`\n * once, narrows the surface to the declared `methods`, and threads it into the single child via\n * `$actions.region` (merging with any outer namespace provider). A namespace a component does not\n * declare is never wrapped, so its hook is never called.\n */\nexport function RegionActionProvider(props: RegionActionProviderProps): ReactNode {\n  return injectActions('region', useRegionActions(), props);\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,qBAAqB,OAA6C;CAChF,OAAO,cAAc,UAAU,iBAAiB,GAAG,KAAK;AAC1D"}

package/dist/sdk/actions/session-action-provider.d.ts

@@ -0,0 +1,15 @@
+import { ActionProviderProps } from "./inject-actions.js";
+import { ReactNode } from "react";
+//#region src/sdk/actions/session-action-provider.d.ts
+export type SessionActionProviderProps = ActionProviderProps;
+/**
+ * Compiler-emitted runtime wrapper for the `session` action namespace — a line-for-line mirror of
+ * `CartActionProvider`. The compiler wraps every element whose definition declares
+ * `actions: { session: [...] }` with `<SessionActionProvider methods={[...]}>`, calls
+ * `useSessionActions` once, narrows the surface to the declared `methods`, and threads it into the
+ * single child via `$actions.session` (merging with any outer namespace provider). A namespace a
+ * component does not declare is never wrapped, so its hook is never called (specs/actions.md FR-6).
+ */
+export declare function SessionActionProvider(props: SessionActionProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=session-action-provider.d.ts.map

package/dist/sdk/actions/session-action-provider.js

@@ -0,0 +1,19 @@
+"use client";
+import { injectActions } from "./inject-actions.js";
+import { useSessionActions } from "../session/use-session-actions.js";
+//#region src/sdk/actions/session-action-provider.tsx
+/**
+* Compiler-emitted runtime wrapper for the `session` action namespace — a line-for-line mirror of
+* `CartActionProvider`. The compiler wraps every element whose definition declares
+* `actions: { session: [...] }` with `<SessionActionProvider methods={[...]}>`, calls
+* `useSessionActions` once, narrows the surface to the declared `methods`, and threads it into the
+* single child via `$actions.session` (merging with any outer namespace provider). A namespace a
+* component does not declare is never wrapped, so its hook is never called (specs/actions.md FR-6).
+*/
+function SessionActionProvider(props) {
+	return injectActions("session", useSessionActions(), props);
+}
+//#endregion
+export { SessionActionProvider };
+
+//# sourceMappingURL=session-action-provider.js.map

package/dist/sdk/actions/session-action-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-action-provider.js","names":[],"sources":["../../../src/sdk/actions/session-action-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { ReactNode } from 'react';\nimport { useSessionActions } from '../session/use-session-actions.js';\nimport { type ActionProviderProps, injectActions } from './inject-actions.js';\n\nexport type SessionActionProviderProps = ActionProviderProps;\n\n/**\n * Compiler-emitted runtime wrapper for the `session` action namespace — a line-for-line mirror of\n * `CartActionProvider`. The compiler wraps every element whose definition declares\n * `actions: { session: [...] }` with `<SessionActionProvider methods={[...]}>`, calls\n * `useSessionActions` once, narrows the surface to the declared `methods`, and threads it into the\n * single child via `$actions.session` (merging with any outer namespace provider). A namespace a\n * component does not declare is never wrapped, so its hook is never called (specs/actions.md FR-6).\n */\nexport function SessionActionProvider(props: SessionActionProviderProps): ReactNode {\n  return injectActions('session', useSessionActions(), props);\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,sBAAsB,OAA8C;CAClF,OAAO,cAAc,WAAW,kBAAkB,GAAG,KAAK;AAC5D"}

package/dist/sdk/actions/shipping-action-provider.d.ts

@@ -0,0 +1,15 @@
+import { ActionProviderProps } from "./inject-actions.js";
+import { ReactNode } from "react";
+//#region src/sdk/actions/shipping-action-provider.d.ts
+export type ShippingActionProviderProps = ActionProviderProps;
+/**
+ * Compiler-emitted runtime wrapper for the `shipping` action namespace — a line-for-line mirror of
+ * `SessionActionProvider`. The compiler wraps every element whose definition declares
+ * `actions: { shipping: [...] }` with `<ShippingActionProvider methods={[...]}>`, calls
+ * `useShippingActions` once, narrows the surface to the declared `methods`, and threads it into the
+ * single child via `$actions.shipping` (merging with any outer namespace provider). A namespace a
+ * component does not declare is never wrapped, so its hook is never called (specs/actions.md FR-6).
+ */
+export declare function ShippingActionProvider(props: ShippingActionProviderProps): ReactNode;
+//#endregion
+//# sourceMappingURL=shipping-action-provider.d.ts.map

package/dist/sdk/actions/shipping-action-provider.js

@@ -0,0 +1,19 @@
+"use client";
+import { injectActions } from "./inject-actions.js";
+import { useShippingActions } from "../shipping/use-shipping-actions.js";
+//#region src/sdk/actions/shipping-action-provider.tsx
+/**
+* Compiler-emitted runtime wrapper for the `shipping` action namespace — a line-for-line mirror of
+* `SessionActionProvider`. The compiler wraps every element whose definition declares
+* `actions: { shipping: [...] }` with `<ShippingActionProvider methods={[...]}>`, calls
+* `useShippingActions` once, narrows the surface to the declared `methods`, and threads it into the
+* single child via `$actions.shipping` (merging with any outer namespace provider). A namespace a
+* component does not declare is never wrapped, so its hook is never called (specs/actions.md FR-6).
+*/
+function ShippingActionProvider(props) {
+	return injectActions("shipping", useShippingActions(), props);
+}
+//#endregion
+export { ShippingActionProvider };
+
+//# sourceMappingURL=shipping-action-provider.js.map

package/dist/sdk/actions/shipping-action-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shipping-action-provider.js","names":[],"sources":["../../../src/sdk/actions/shipping-action-provider.tsx"],"sourcesContent":["'use client';\n\nimport type { ReactNode } from 'react';\nimport { useShippingActions } from '../shipping/use-shipping-actions.js';\nimport { type ActionProviderProps, injectActions } from './inject-actions.js';\n\nexport type ShippingActionProviderProps = ActionProviderProps;\n\n/**\n * Compiler-emitted runtime wrapper for the `shipping` action namespace — a line-for-line mirror of\n * `SessionActionProvider`. The compiler wraps every element whose definition declares\n * `actions: { shipping: [...] }` with `<ShippingActionProvider methods={[...]}>`, calls\n * `useShippingActions` once, narrows the surface to the declared `methods`, and threads it into the\n * single child via `$actions.shipping` (merging with any outer namespace provider). A namespace a\n * component does not declare is never wrapped, so its hook is never called (specs/actions.md FR-6).\n */\nexport function ShippingActionProvider(props: ShippingActionProviderProps): ReactNode {\n  return injectActions('shipping', useShippingActions(), props);\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,uBAAuB,OAA+C;CACpF,OAAO,cAAc,YAAY,mBAAmB,GAAG,KAAK;AAC9D"}

package/dist/sdk/actions/types.d.ts

@@ -0,0 +1,21 @@
+import { CartActions } from "../cart/use-cart-actions.js";
+import { IdentityActions } from "../identity/use-identity-actions.js";
+import { RegionActions } from "../region/use-region-actions.js";
+import { SessionActions } from "../session/use-session-actions.js";
+import { ShippingActions } from "../shipping/use-shipping-actions.js";
+//#region src/sdk/actions/types.d.ts
+/**
+ * The `$actions` prop the compiler injects (and `mockAction` builds for tests). Each namespace is
+ * optional and each method is optional within it, because a component only receives the methods it
+ * declared under `actions: { ... }`. Ships the `cart`, `identity`, `region`, `session`, and
+ * `shipping` namespaces.
+ */
+export type ComponentActions = {
+  cart?: Partial<CartActions>;
+  identity?: Partial<IdentityActions>;
+  region?: Partial<RegionActions>;
+  session?: Partial<SessionActions>;
+  shipping?: Partial<ShippingActions>;
+};
+//#endregion
+//# sourceMappingURL=types.d.ts.map

package/dist/sdk/cache/storefront-cache.js

@@ -0,0 +1,35 @@
+import { possibleTypes } from "../generated/fragment-types.js";
+import { InMemoryCache } from "@apollo/client";
+//#region src/sdk/cache/storefront-cache.ts
+/**
+* Per-entity normalization and field-merge rules for the Storefront cache.
+*
+* Empty in T1. Domain entries (Product, Cart, OrderForm, …) arrive with the
+* particles that need them — see specs/shared-apollo-sdk-surface.md,
+* "Out of Scope".
+*/
+const typePolicies = {};
+/**
+* The single source of truth for InMemoryCache configuration. Both the
+* server-side `createClient` and the client-side `StorefrontProvider`
+* consume this so SSR and CSR normalize entities identically.
+*/
+function getCacheConfig() {
+	return {
+		typePolicies,
+		possibleTypes
+	};
+}
+/**
+* The only place an `InMemoryCache` is constructed on the server path.
+* The client-side provider builds its cache from `getCacheConfig()` so the
+* config is shared verbatim without coupling to a specific InMemoryCache
+* subclass (the Next.js integration ships its own SSR-aware variant).
+*/
+function buildCache() {
+	return new InMemoryCache(getCacheConfig());
+}
+//#endregion
+export { buildCache, getCacheConfig, possibleTypes, typePolicies };
+
+//# sourceMappingURL=storefront-cache.js.map

package/dist/sdk/cache/storefront-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storefront-cache.js","names":[],"sources":["../../../src/sdk/cache/storefront-cache.ts"],"sourcesContent":["import { InMemoryCache, type InMemoryCacheConfig, type TypePolicies } from '@apollo/client';\nimport { possibleTypes } from '../generated/fragment-types.js';\n\n/**\n * Per-entity normalization and field-merge rules for the Storefront cache.\n *\n * Empty in T1. Domain entries (Product, Cart, OrderForm, …) arrive with the\n * particles that need them — see specs/shared-apollo-sdk-surface.md,\n * \"Out of Scope\".\n */\nexport const typePolicies: TypePolicies = {};\n\nexport { possibleTypes };\n\n/**\n * The single source of truth for InMemoryCache configuration. Both the\n * server-side `createClient` and the client-side `StorefrontProvider`\n * consume this so SSR and CSR normalize entities identically.\n */\nexport function getCacheConfig(): InMemoryCacheConfig {\n  return {\n    typePolicies,\n    possibleTypes,\n  };\n}\n\n/**\n * The only place an `InMemoryCache` is constructed on the server path.\n * The client-side provider builds its cache from `getCacheConfig()` so the\n * config is shared verbatim without coupling to a specific InMemoryCache\n * subclass (the Next.js integration ships its own SSR-aware variant).\n */\nexport function buildCache(): InMemoryCache {\n  return new InMemoryCache(getCacheConfig());\n}\n"],"mappings":";;;;;;;;;;AAUA,MAAa,eAA6B,CAAC;;;;;;AAS3C,SAAgB,iBAAsC;CACpD,OAAO;EACL;EACA;CACF;AACF;;;;;;;AAQA,SAAgB,aAA4B;CAC1C,OAAO,IAAI,cAAc,eAAe,CAAC;AAC3C"}

package/dist/sdk/cart/operations.d.ts

@@ -0,0 +1,31 @@
+import { CartFragmentFragment, CartItemFragmentFragment, CartItemQuantityDecreaseMutation, CartItemQuantityIncreaseMutation, CartItemRemoveMutation, MoneyFragmentFragment } from "../generated/graphql.js";
+import "./operations.js";
+import { TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/cart/operations.d.ts
+/**
+ * Cart-related GraphQL operations and shared fragments (T6 / specs/mutation-contract.md).
+ *
+ * The `CartFragment` is the canonical Cart selection set: every mutation operation spreads it so
+ * the cache normalisation reaches every reactive subscriber (CartTotal, CartCount, CartItems, …)
+ * through a single response. The contract regression test (`contract.test.ts`) parses these
+ * documents and asserts the spread is present — see specs/mutation-contract.md AD-D3 / AD-8.
+ *
+ * T7 ([specs/graphql-codegen-pipeline.md][T7]) routes the domain types and the operation factory
+ * through @graphql-codegen. Public type names (`CartEntity`, `CartItemEntity`, `Money`, payload
+ * + input aliases) are preserved as re-exports / aliases so consumer call sites do not change.
+ *
+ * [T7]: ../../../../../specs/graphql-codegen-pipeline.md
+ */
+export type Money = MoneyFragmentFragment;
+export type CartItemEntity = CartItemFragmentFragment;
+export type CartEntity = CartFragmentFragment;
+export type CartTotalizer = CartFragmentFragment['totalizers'][number];
+export type CartUserError = Readonly<{
+  code: string;
+  message: string;
+}>;
+export type CartItemRemovePayload = CartItemRemoveMutation['cartItemRemove'];
+export type CartItemQuantityIncreasePayload = CartItemQuantityIncreaseMutation['cartItemQuantityIncrease'];
+export type CartItemQuantityDecreasePayload = CartItemQuantityDecreaseMutation['cartItemQuantityDecrease'];
+//#endregion
+//# sourceMappingURL=operations.d.ts.map

package/dist/sdk/cart/operations.js

@@ -0,0 +1,215 @@
+import { graphql } from "../generated/gql.js";
+graphql(`
+  fragment MoneyFragment on Money {
+    __typename
+    amount
+    currencyCode
+  }
+`);
+graphql(`
+  fragment CartItemFragment on CartItem {
+    __typename
+    id
+    quantity
+    price {
+      ...MoneyFragment
+    }
+    listPrice {
+      ...MoneyFragment
+    }
+    sellingPrice {
+      ...MoneyFragment
+    }
+    gift
+    ownTotal {
+      ...MoneyFragment
+    }
+    total {
+      ...MoneyFragment
+    }
+    variant {
+      __typename
+      variantId
+      sku
+      name
+      image {
+        url
+        altText
+      }
+      availability
+    }
+    product {
+      __typename
+      productId
+      title
+      detailUrl
+      categories {
+        categoryId
+        name
+      }
+      brand {
+        brandId
+        name
+      }
+    }
+  }
+`);
+/**
+* Canonical Cart selection set. Every cart mutation MUST spread this fragment so the cache
+* receives the entity slices that all subscribers depend on (id + items + totalizers + total +
+* messages). The regression test in contract.test.ts enforces this.
+*/
+const CartFragment = graphql(`
+  fragment CartFragment on Cart {
+    __typename
+    id
+    items {
+      ...CartItemFragment
+    }
+    totalizers {
+      __typename
+      id
+      name
+      value {
+        ...MoneyFragment
+      }
+    }
+    total {
+      ...MoneyFragment
+    }
+    messages {
+      __typename
+      code
+      text
+      status
+    }
+    appliedCoupons {
+      code
+      isUnmatchedCondition
+    }
+  }
+`);
+const CART_ITEM_ADD = graphql(`
+  mutation CartItemAdd($input: CartItemAddInput!) {
+    cartItemAdd(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+const CART_ITEM_REMOVE = graphql(`
+  mutation CartItemRemove($input: CartItemRemoveInput!) {
+    cartItemRemove(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+const CART_ITEMS_REMOVE = graphql(`
+  mutation CartItemsRemove($input: CartItemsRemoveInput!) {
+    cartItemsRemove(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+const CART_ITEM_QUANTITY_INCREASE = graphql(`
+  mutation CartItemQuantityIncrease($input: CartItemQuantityIncreaseInput!) {
+    cartItemQuantityIncrease(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+const CART_ITEM_QUANTITY_DECREASE = graphql(`
+  mutation CartItemQuantityDecrease($input: CartItemQuantityDecreaseInput!) {
+    cartItemQuantityDecrease(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+const CART_COUPON_APPLY = graphql(`
+  mutation CartCouponApply($input: CartCouponApplyInput!) {
+    cartCouponApply(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+const CART_COUPON_REMOVE = graphql(`
+  mutation CartCouponRemove($input: CartCouponRemoveInput!) {
+    cartCouponRemove(input: $input) {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+/**
+* Re-check the active cart against the platform and adopt corrected availability. Read-only upstream
+* (specs/mini-cart-validate-operation.md): the payload is the cart with each line's
+* `variant.availability` refreshed, shaped like every other cart mutation so the correction lands in
+* the normalized cache. Takes no arguments — the cart resolves from the request context. Spreading
+* `CartFragment` is what makes the guard, the per-line alert, and the badge re-render as subscribers,
+* so T13 needs no fragment or codegen change beyond registering this document.
+*/
+const CART_VALIDATE = graphql(`
+  mutation CartValidate {
+    cartValidate {
+      __typename
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+//#endregion
+export { CART_COUPON_APPLY, CART_COUPON_REMOVE, CART_ITEMS_REMOVE, CART_ITEM_ADD, CART_ITEM_QUANTITY_DECREASE, CART_ITEM_QUANTITY_INCREASE, CART_ITEM_REMOVE, CART_VALIDATE, CartFragment };
+
+//# sourceMappingURL=operations.js.map

package/dist/sdk/cart/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","names":[],"sources":["../../../src/sdk/cart/operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { graphql } from '../generated/gql.js';\nimport type {\n  CartCouponApplyMutation,\n  CartCouponApplyMutationVariables,\n  CartCouponRemoveMutation,\n  CartCouponRemoveMutationVariables,\n  CartFragmentFragment,\n  CartItemAddMutation,\n  CartItemAddMutationVariables,\n  CartItemFragmentFragment,\n  CartItemQuantityDecreaseMutation,\n  CartItemQuantityDecreaseMutationVariables,\n  CartItemQuantityIncreaseMutation,\n  CartItemQuantityIncreaseMutationVariables,\n  CartItemRemoveMutation,\n  CartItemRemoveMutationVariables,\n  CartItemsRemoveMutation,\n  CartItemsRemoveMutationVariables,\n  CartValidateMutation,\n  CartValidateMutationVariables,\n  MoneyFragmentFragment,\n} from '../generated/graphql.js';\n\n/**\n * Cart-related GraphQL operations and shared fragments (T6 / specs/mutation-contract.md).\n *\n * The `CartFragment` is the canonical Cart selection set: every mutation operation spreads it so\n * the cache normalisation reaches every reactive subscriber (CartTotal, CartCount, CartItems, …)\n * through a single response. The contract regression test (`contract.test.ts`) parses these\n * documents and asserts the spread is present — see specs/mutation-contract.md AD-D3 / AD-8.\n *\n * T7 ([specs/graphql-codegen-pipeline.md][T7]) routes the domain types and the operation factory\n * through @graphql-codegen. Public type names (`CartEntity`, `CartItemEntity`, `Money`, payload\n * + input aliases) are preserved as re-exports / aliases so consumer call sites do not change.\n *\n * [T7]: ../../../../../specs/graphql-codegen-pipeline.md\n */\n\n// ---------------------------------------------------------------------------\n// Domain type aliases — re-exports from codegen artifacts (T7)\n// ---------------------------------------------------------------------------\n\nexport type Money = MoneyFragmentFragment;\nexport type CartItemEntity = CartItemFragmentFragment;\nexport type CartEntity = CartFragmentFragment;\nexport type CartTotalizer = CartFragmentFragment['totalizers'][number];\nexport type CartMessage = CartFragmentFragment['messages'][number];\nexport type AppliedCoupon = CartFragmentFragment['appliedCoupons'][number];\n\nexport type CartUserError = Readonly<{ code: string; message: string }>;\n\n// ---------------------------------------------------------------------------\n// Mutation input types — direct re-exports from codegen\n// ---------------------------------------------------------------------------\n\nexport type {\n  CartCouponApplyInput,\n  CartCouponRemoveInput,\n  CartItemAddInput,\n  CartItemQuantityDecreaseInput,\n  CartItemQuantityIncreaseInput,\n  CartItemRemoveInput,\n  CartItemsRemoveInput,\n} from '../generated/graphql.js';\n\n// ---------------------------------------------------------------------------\n// Mutation payload types — derived from operation result types\n// ---------------------------------------------------------------------------\n\nexport type CartItemAddPayload = CartItemAddMutation['cartItemAdd'];\nexport type CartItemRemovePayload = CartItemRemoveMutation['cartItemRemove'];\nexport type CartItemsRemovePayload = CartItemsRemoveMutation['cartItemsRemove'];\nexport type CartItemQuantityIncreasePayload = CartItemQuantityIncreaseMutation['cartItemQuantityIncrease'];\nexport type CartItemQuantityDecreasePayload = CartItemQuantityDecreaseMutation['cartItemQuantityDecrease'];\nexport type CartCouponApplyPayload = CartCouponApplyMutation['cartCouponApply'];\nexport type CartCouponRemovePayload = CartCouponRemoveMutation['cartCouponRemove'];\nexport type CartValidatePayload = CartValidateMutation['cartValidate'];\n\n// ---------------------------------------------------------------------------\n// Shared fragments — authored via the codegen `graphql()` factory so codegen can scan and type\n// every operation that spreads them.\n// ---------------------------------------------------------------------------\n\nexport const MoneyFragment: TypedDocumentNode<MoneyFragmentFragment, never> = graphql(`\n  fragment MoneyFragment on Money {\n    __typename\n    amount\n    currencyCode\n  }\n`);\n\nexport const CartItemFragment: TypedDocumentNode<CartItemFragmentFragment, never> = graphql(`\n  fragment CartItemFragment on CartItem {\n    __typename\n    id\n    quantity\n    price {\n      ...MoneyFragment\n    }\n    listPrice {\n      ...MoneyFragment\n    }\n    sellingPrice {\n      ...MoneyFragment\n    }\n    gift\n    ownTotal {\n      ...MoneyFragment\n    }\n    total {\n      ...MoneyFragment\n    }\n    variant {\n      __typename\n      variantId\n      sku\n      name\n      image {\n        url\n        altText\n      }\n      availability\n    }\n    product {\n      __typename\n      productId\n      title\n      detailUrl\n      categories {\n        categoryId\n        name\n      }\n      brand {\n        brandId\n        name\n      }\n    }\n  }\n`);\n\n/**\n * Canonical Cart selection set. Every cart mutation MUST spread this fragment so the cache\n * receives the entity slices that all subscribers depend on (id + items + totalizers + total +\n * messages). The regression test in contract.test.ts enforces this.\n */\nexport const CartFragment: TypedDocumentNode<CartFragmentFragment, never> = graphql(`\n  fragment CartFragment on Cart {\n    __typename\n    id\n    items {\n      ...CartItemFragment\n    }\n    totalizers {\n      __typename\n      id\n      name\n      value {\n        ...MoneyFragment\n      }\n    }\n    total {\n      ...MoneyFragment\n    }\n    messages {\n      __typename\n      code\n      text\n      status\n    }\n    appliedCoupons {\n      code\n      isUnmatchedCondition\n    }\n  }\n`);\n\n// ---------------------------------------------------------------------------\n// Mutation operations — authored via `graphql()`, typed via the codegen-derived\n// TypedDocumentNode generic so Apollo's `useMutation` infers TData / TVariables correctly.\n// ---------------------------------------------------------------------------\n\nexport const CART_ITEM_ADD: TypedDocumentNode<CartItemAddMutation, CartItemAddMutationVariables> = graphql(`\n  mutation CartItemAdd($input: CartItemAddInput!) {\n    cartItemAdd(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\nexport const CART_ITEM_REMOVE: TypedDocumentNode<CartItemRemoveMutation, CartItemRemoveMutationVariables> = graphql(`\n  mutation CartItemRemove($input: CartItemRemoveInput!) {\n    cartItemRemove(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\nexport const CART_ITEMS_REMOVE: TypedDocumentNode<CartItemsRemoveMutation, CartItemsRemoveMutationVariables> = graphql(`\n  mutation CartItemsRemove($input: CartItemsRemoveInput!) {\n    cartItemsRemove(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\nexport const CART_ITEM_QUANTITY_INCREASE: TypedDocumentNode<\n  CartItemQuantityIncreaseMutation,\n  CartItemQuantityIncreaseMutationVariables\n> = graphql(`\n  mutation CartItemQuantityIncrease($input: CartItemQuantityIncreaseInput!) {\n    cartItemQuantityIncrease(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\nexport const CART_ITEM_QUANTITY_DECREASE: TypedDocumentNode<\n  CartItemQuantityDecreaseMutation,\n  CartItemQuantityDecreaseMutationVariables\n> = graphql(`\n  mutation CartItemQuantityDecrease($input: CartItemQuantityDecreaseInput!) {\n    cartItemQuantityDecrease(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\nexport const CART_COUPON_APPLY: TypedDocumentNode<CartCouponApplyMutation, CartCouponApplyMutationVariables> = graphql(`\n  mutation CartCouponApply($input: CartCouponApplyInput!) {\n    cartCouponApply(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\nexport const CART_COUPON_REMOVE: TypedDocumentNode<CartCouponRemoveMutation, CartCouponRemoveMutationVariables> =\n  graphql(`\n  mutation CartCouponRemove($input: CartCouponRemoveInput!) {\n    cartCouponRemove(input: $input) {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\n/**\n * Re-check the active cart against the platform and adopt corrected availability. Read-only upstream\n * (specs/mini-cart-validate-operation.md): the payload is the cart with each line's\n * `variant.availability` refreshed, shaped like every other cart mutation so the correction lands in\n * the normalized cache. Takes no arguments — the cart resolves from the request context. Spreading\n * `CartFragment` is what makes the guard, the per-line alert, and the badge re-render as subscribers,\n * so T13 needs no fragment or codegen change beyond registering this document.\n */\nexport const CART_VALIDATE: TypedDocumentNode<CartValidateMutation, CartValidateMutationVariables> = graphql(`\n  mutation CartValidate {\n    cartValidate {\n      __typename\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n\n/**\n * Canonical list of cart mutation documents. Used by the contract regression test to iterate\n * over every shipped operation without hard-coding names.\n */\nexport const CART_MUTATIONS = [\n  { name: 'CartItemAdd', document: CART_ITEM_ADD },\n  { name: 'CartItemRemove', document: CART_ITEM_REMOVE },\n  { name: 'CartItemsRemove', document: CART_ITEMS_REMOVE },\n  { name: 'CartItemQuantityIncrease', document: CART_ITEM_QUANTITY_INCREASE },\n  { name: 'CartItemQuantityDecrease', document: CART_ITEM_QUANTITY_DECREASE },\n  { name: 'CartCouponApply', document: CART_COUPON_APPLY },\n  { name: 'CartCouponRemove', document: CART_COUPON_REMOVE },\n  { name: 'CartValidate', document: CART_VALIDATE },\n] as const;\n"],"mappings":";AAoF8E,QAAQ;;;;;;CAMrF;AAEmF,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C3F;;;;;;AAOD,MAAa,eAA+D,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BnF;AAOD,MAAa,gBAAsF,QAAQ;;;;;;;;;;;;;CAa1G;AAED,MAAa,mBAA+F,QAAQ;;;;;;;;;;;;;CAanH;AAED,MAAa,oBAAkG,QAAQ;;;;;;;;;;;;;CAatH;AAED,MAAa,8BAGT,QAAQ;;;;;;;;;;;;;CAaX;AAED,MAAa,8BAGT,QAAQ;;;;;;;;;;;;;CAaX;AAED,MAAa,oBAAkG,QAAQ;;;;;;;;;;;;;CAatH;AAED,MAAa,qBACX,QAAQ;;;;;;;;;;;;;CAaT;;;;;;;;;AAUD,MAAa,gBAAwF,QAAQ;;;;;;;;;;;;;CAa5G"}