@classytic/commerce-client 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## 0.1.0 — 2026-10-20
+
+First publish.
+
+Expose storefront tag/collection/sale/price/sort queries and public taxonomy/compare-at prices; type merchant taxonomy and compare-at writes.
+
+Add typed category trees, hierarchy choices, parent/description/image fields and category image uploads. Category updates exclude immutable slugs.
+
+API-key lifetime options expose optional non-expiry support; creation accepts explicit `expiresInDays: null`.
+
+Delivery quote inputs include destination country; the storefront sends it when requesting prices.
+
+Add a bounded store sales overview and tenant-scoped delivery settings. Public storefront clients can load delivery districts/areas and request server-priced delivery quotes without merchant credentials.
+
+Typed store profiles, catalog reads, guest checkout with explicit retry keys, and private order tracking.
+
+The isolated `/management` entry supports merchant catalog/media, order commands
+and cash collection, store settings, Telegram connections and delivery history,
+plus API-key options, creation, rotation and revocation.

package/LICENSE

@@ -0,0 +1,75 @@
+Classytic Source-Available License (Community & Commercial), Version 1.0
+
+Copyright (c) 2026 Classytic LLC. All rights reserved.
+
+This software is source-available, not open source. Please read this License
+before using it.
+
+1. DEFINITIONS
+   "Software" means the contents of this package and any accompanying source
+   code, object code, or documentation, in any form.
+   "Licensor" means Classytic LLC, a limited liability company organized in the
+   United States.
+   "You" means the individual or legal entity exercising rights under this
+   License.
+   "Evaluation Use" means use for evaluation, development, testing,
+   experimentation, or internal non-commercial purposes only.
+   "Production Use" means any use of the Software that is live, commercial,
+   revenue-generating, or customer-facing, or any use other than Evaluation Use.
+   "Commercial License" means a separate written agreement executed with
+   Licensor that grants Production Use rights.
+
+2. OWNERSHIP
+   The Software is licensed, not sold. Licensor retains all right, title, and
+   interest in and to the Software, including all intellectual property rights.
+   All rights not expressly granted in this License are reserved by Licensor.
+
+3. EVALUATION GRANT
+   Subject to Your compliance with this License, Licensor grants You a
+   worldwide, royalty-free, non-exclusive, non-transferable, revocable license
+   to download, install, run, and modify the Software solely for Evaluation Use.
+
+4. PRODUCTION USE REQUIRES A COMMERCIAL LICENSE
+   Production Use of the Software is NOT permitted under this License and
+   requires a Commercial License from Licensor. A Commercial License may be
+   granted at Licensor's discretion, with or without a fee, and may confer
+   perpetual, irrevocable, and transferable Production Use rights as set out in
+   that agreement. Contact licensing@classytic.com to obtain one.
+
+5. RESTRICTIONS
+   You may not:
+   (a) make any Production Use of the Software without a Commercial License;
+   (b) redistribute, resell, rent, sublicense, or otherwise make the Software
+       (in whole or in part, original or modified) available to third parties as
+       a stand-alone product, framework, library, or hosted/managed service that
+       competes with the Software or with Licensor;
+   (c) remove, obscure, or alter any copyright, license, or attribution notice.
+
+6. FEEDBACK AND CONTRIBUTIONS
+   Any feedback, suggestions, or contributions You provide relating to the
+   Software may be used by Licensor for any purpose without obligation to You.
+
+7. TERMINATION
+   This License and the Evaluation Grant terminate automatically if You breach
+   any term. Upon termination You must cease all use of the Software and destroy
+   all copies in Your possession. Rights under a Commercial License are governed
+   by that agreement's own terms and survive termination of this License to the
+   extent stated there.
+
+8. DISCLAIMER OF WARRANTY
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+9. LIMITATION OF LIABILITY
+   TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL LICENSOR BE LIABLE
+   FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+   TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE
+   OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+10. GOVERNING LAW
+   This License is governed by the laws of the State of Delaware, United States,
+   without regard to its conflict-of-laws principles. (Adjust to Your LLC's state
+   of formation.)
+
+For commercial licensing, contact: licensing@classytic.com

package/README.md

@@ -1,3 +1,130 @@
-# Temporary Holding Version
+# @classytic/commerce-client
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@classytic/commerce-client` calls the shared Spine storefront resources.
+It exposes profile, catalog, guest checkout and order tracking. The backend must
+compose those resources, as Classytic Commerce does; the ERP's older checkout endpoints have
+a different contract.
+
+Install with `npm install @classytic/commerce-client`.
+
+Use Arc Next 0.17 or later. This entry uses its server-safe client/API subpaths;
+it imports no React hooks, Next.js APIs, merchant credentials or server kernels.
+
+```ts
+import { createStorefrontClient } from '@classytic/commerce-client';
+import type { GuestCheckoutInput } from '@classytic/commerce-client/types';
+
+const shop = createStorefrontClient({
+  apiUrl: 'http://localhost:4140/api/v1', // Full API mount, including its prefix.
+  store: 'store-alpha',
+});
+const profile = await shop.profile();
+const page = await shop.products({ limit: 20, category: 'mugs' });
+const next = page.next ? await shop.products({ after: page.next, limit: 20, category: 'mugs' }) : null;
+const categories = await shop.categories();
+// category=clothing includes products assigned to its descendants.
+const product = await shop.product('blue-mug');
+```
+
+Each instance captures its API mount and store. Dashboard `configureClient` and
+`configureAuth` settings cannot change its routing or add credentials. Cookies
+are omitted. Construct separate instances for separate stores or SSR requests.
+
+## Checkout from a frontend cart
+
+```ts
+const input: GuestCheckoutInput = {
+  lines: [{ productId: product.id, quantity: 2 }],
+  customer: { name: 'Buyer', phone: '01712345678' },
+  shippingAddress: { line1: 'Road 4', city: 'Dhaka', country: 'BD' },
+};
+// Create once for this attempt, outside any retry handler.
+const idempotencyKey = crypto.randomUUID();
+const placed = await shop.checkout(input, { idempotencyKey });
+const status = await shop.orderStatus(placed);
+```
+
+Keep the input and key unchanged when retrying a lost response. Use a new key
+when the buyer intentionally starts another order. The SDK does not generate a
+fallback key. The server resolves prices, publication, variants, delivery charges
+and totals. Multiple active variants require `variantSku` on each relevant line.
+Do not send prices or lifecycle/payment state.
+
+Money stays in integer minor units. Display it using the primitives money helpers;
+do not assume every currency has two decimal places. This client does no pricing
+arithmetic and stores no cart.
+
+The checkout result includes an access token bound to that store and order. Keep
+it privately for the buyer; the SDK puts it in `x-order-access`, never the URL.
+It does not persist tokens or place them in logs. Status reads use `no-store` and
+omit buyer contact/address. Shipment and delivery are fulfillment facts; delivery
+alone does not establish COD collection.
+
+## Requests and errors
+
+Read methods accept an optional `{ signal }`; checkout takes it alongside its
+required `idempotencyKey`. The client timeout defaults to 15 seconds and can be
+configured with `timeoutMs`. A custom `fetch` transport is available for embedding
+and tests; ordinary browser/Node consumers use the runtime's fetch.
+
+```ts
+import { isArcApiError } from '@classytic/arc-next/client';
+
+try {
+  await shop.checkout(input, { idempotencyKey });
+} catch (error) {
+  if (isArcApiError(error)) {
+    // Inspect status/code/fieldErrors; preserve the attempt key for a retry.
+    console.error(error.code, error.fieldErrors);
+  }
+}
+```
+
+Arc Next owns HTTP parsing, timeouts and the canonical error contract. Category
+reads return the data array; product pages retain their cursor metadata.
+The server remains the authority for validation;
+unknown filters and extra checkout fields fail there.
+
+Products use bounded cursor pages. Categories currently return at most 100 active
+entries. Merchant catalog/order CRUD, integrations, key management and React hooks
+are outside this public client.
+
+`products({ q, category, limit, after })` searches product names literally,
+case-insensitively, inside the selected store’s published catalog. Search terms
+are limited to 100 characters. Pagination preserves the same search/category
+filters; `next: null` marks the final page.
+
+## Merchant dashboard and backend clients
+
+Use the separate [`/management` entry](management.md) for authenticated products,
+categories, media, order commands, store settings, Telegram connections,
+notification delivery history and API keys. The root entry remains isolated for
+public storefronts.
+
+Delivery quotes accept `country` alongside `lines` and `areaId`. Send the destination
+country when known so the preview applies the same country restriction as checkout.
+
+`/category-tree` exports framework-independent `categoryNavigation` and
+`categoryChoices` helpers. Public categories include `parent`, `parentPath`,
+`description`, `image` and `displayOrder`; navigation omits children whose parents
+are absent from the public category list.
+
+## Storefront product filters
+
+```ts
+const featured = await shop.products({ collection: 'featured', limit: 8 });
+const summerSale = await shop.products({ tag: 'summer', onSale: true, limit: 8 });
+const affordable = await shop.products({ category: 'clothing', minPrice: 0, maxPrice: 100000, sort: 'price-asc' });
+```
+
+Filters combine with AND. A tag or collection matches its exact stored name.
+`category` includes descendants; `q` searches product names literally. Price bounds
+are inclusive integer minor units on the product's base price; variant adjustments
+are not part of that range. Sort values are `newest` (default), `price-asc` and
+`price-desc`. Price sorting includes products with a numeric base price.
+
+`next` is an opaque Mongokit cursor: pass it back as `after` with the same filters
+and sort. Restart pagination when filters change. Public calls always enforce the
+resolved store and published/priced visibility, and reject unknown query fields.
+Merchant `products.getAll({ params })` continues to use Arc's normal allowed query
+syntax, including tags, collections and base-price bracket filters.

package/dist/category-tree.d.ts

@@ -0,0 +1,20 @@
+//#region src/category-tree.d.ts
+export interface CategoryBranch {
+  name: string;
+  slug: string;
+  children?: readonly CategoryBranch[];
+}
+export interface CategoryChoice {
+  value: string;
+  label: string;
+  depth: number;
+}
+/** Flatten a category tree into breadcrumb choices, excluding a complete subtree when editing its parent. */
+export declare function categoryChoices(nodes: readonly CategoryBranch[], excludeSlug?: string): CategoryChoice[];
+/** Group the public flat projection into a navigation tree; children of missing parents stay unlisted. */
+export declare function categoryNavigation(rows: readonly {
+  name: string;
+  slug: string;
+  parent?: string | null;
+}[]): CategoryBranch[];
+//#endregion

package/dist/category-tree.js

@@ -0,0 +1,39 @@
+//#region src/category-tree.ts
+/** Flatten a category tree into breadcrumb choices, excluding a complete subtree when editing its parent. */
+function categoryChoices(nodes, excludeSlug) {
+	function visit(items, path, seen) {
+		return items.flatMap((item) => {
+			if (item.slug === excludeSlug) return [];
+			if (seen.has(item.slug) || path.length > 20) throw new Error("Invalid category hierarchy.");
+			const branch = [...path, item.name];
+			return [{
+				value: item.slug,
+				label: branch.join(" / "),
+				depth: path.length
+			}, ...visit(item.children ?? [], branch, /* @__PURE__ */ new Set([...seen, item.slug]))];
+		});
+	}
+	return visit(nodes, [], /* @__PURE__ */ new Set());
+}
+/** Group the public flat projection into a navigation tree; children of missing parents stay unlisted. */
+function categoryNavigation(rows) {
+	const nodes = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (nodes.has(row.slug)) throw new Error("Duplicate category slug.");
+		nodes.set(row.slug, {
+			name: row.name,
+			slug: row.slug,
+			children: []
+		});
+	}
+	const roots = [];
+	for (const row of rows) {
+		const node = nodes.get(row.slug);
+		if (!node) throw new Error("Category navigation is incomplete.");
+		if (row.parent) nodes.get(row.parent)?.children.push(node);
+		else roots.push(node);
+	}
+	return roots;
+}
+//#endregion
+export { categoryChoices, categoryNavigation };

package/dist/delivery-types.d.ts

@@ -0,0 +1,48 @@
+//#region src/delivery-types.d.ts
+export interface DeliveryRules {
+  mode: 'flat' | 'zones';
+  zones: Array<{
+    name: string;
+    chargeMinor: number;
+    districts: string[];
+  }>;
+  freeOverMinor: number | null;
+}
+export interface DeliverySettings {
+  deliveryChargeMinor: number;
+  deliveryRules: DeliveryRules;
+  version: number | null;
+}
+export interface DeliverySettingsUpdate {
+  deliveryChargeMinor: number;
+  deliveryRules: DeliveryRules;
+  expectedVersion: number | null;
+}
+export interface DeliveryDistrict {
+  id: string;
+  name: string;
+  divisionId: string;
+  divisionName: string;
+}
+export interface DeliveryArea {
+  id: number;
+  name: string;
+  districtName: string;
+}
+export interface DeliveryQuoteInput {
+  lines: Array<{
+    productId: string;
+    variantSku?: string;
+    quantity: number;
+  }>;
+  areaId?: number;
+  country?: string;
+}
+export interface DeliveryQuote {
+  subtotalMinor: number;
+  deliveryChargeMinor: number;
+  currency: string;
+  zone?: string;
+  freeDelivery?: boolean;
+}
+//#endregion

package/dist/delivery-types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { DeliveryArea, DeliveryDistrict, DeliveryQuote, DeliveryQuoteInput } from "./delivery-types.js";
+import { a as StorefrontCategory, c as StorefrontProductPage, d as StorefrontRequestOptions, i as GuestOrderAccess, l as StorefrontProductQuery, n as GuestCheckoutOptions, o as StorefrontOrder, r as GuestCheckoutResult, s as StorefrontProduct, t as GuestCheckoutInput, u as StorefrontProfile } from "./types-C0cSi6Pk.js";
+import { ArcClientConfig } from "@classytic/arc-next/client";
+//#region src/index.d.ts
+export interface StorefrontClientOptions {
+  /** Full API mount, for example https://api.example.com/api/v1. */
+  apiUrl: string;
+  store: string;
+  timeoutMs?: number;
+  fetch?: ArcClientConfig['fetch'];
+}
+/** Build an isolated guest client; never inherit dashboard credentials or global routing. */
+export declare function createStorefrontClient(options: StorefrontClientOptions): {
+  profile: (request?: StorefrontRequestOptions) => Promise<StorefrontProfile>;
+  products: (query?: StorefrontProductQuery, request?: StorefrontRequestOptions) => Promise<StorefrontProductPage>;
+  product: (slug: string, request?: StorefrontRequestOptions) => Promise<StorefrontProduct>;
+  categories: (request?: StorefrontRequestOptions) => Promise<StorefrontCategory[]>;
+  deliveryDistricts: (request?: StorefrontRequestOptions) => Promise<{
+    requiresArea: boolean;
+    data: DeliveryDistrict[];
+  }>;
+  deliveryAreas: (district: string, request?: StorefrontRequestOptions) => Promise<{
+    data: DeliveryArea[];
+  }>;
+  quoteDelivery: (input: DeliveryQuoteInput, request?: StorefrontRequestOptions) => Promise<DeliveryQuote>;
+  checkout: (input: GuestCheckoutInput, request: GuestCheckoutOptions) => Promise<GuestCheckoutResult>;
+  orderStatus: (access: GuestOrderAccess, request?: StorefrontRequestOptions) => Promise<StorefrontOrder>;
+};
+export type StorefrontClient = ReturnType<typeof createStorefrontClient>;
+//#endregion

package/dist/index.js

@@ -0,0 +1,66 @@
+import { BaseApi } from "@classytic/arc-next/api";
+import { createClient } from "@classytic/arc-next/client";
+//#region src/index.ts
+function segment(value) {
+	if (!value || value === "." || value === "..") throw new Error("A nonempty resource identifier is required.");
+	return encodeURIComponent(value);
+}
+/** Build an isolated guest client; never inherit dashboard credentials or global routing. */
+function createStorefrontClient(options) {
+	const store = options.store;
+	const url = new URL(options.apiUrl);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("apiUrl must be an HTTP(S) API mount without credentials, query or fragment.");
+	if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(store)) throw new Error("A valid store slug is required.");
+	const config = {
+		client: createClient({
+			baseUrl: url.href.replace(/\/+$/, ""),
+			getToken: () => null,
+			getOrgId: () => null,
+			credentials: "omit",
+			autoIdempotency: false,
+			timeoutMs: options.timeoutMs ?? 15e3,
+			...options.fetch ? { fetch: options.fetch } : {}
+		}),
+		basePath: "",
+		cache: "no-store"
+	};
+	const catalog = new BaseApi(`storefront/${segment(store)}`, config);
+	const profiles = new BaseApi("stores", config);
+	return {
+		profile: (request = {}) => profiles.request("GET", `${profiles.baseUrl}/${segment(store)}`, { options: request }),
+		products: (query = {}, request = {}) => catalog.request("GET", `${catalog.baseUrl}/products`, {
+			params: { ...query },
+			options: request
+		}),
+		product: (slug, request = {}) => catalog.request("GET", `${catalog.baseUrl}/products/${segment(slug)}`, { options: request }),
+		categories: async (request = {}) => {
+			return (await catalog.request("GET", `${catalog.baseUrl}/categories`, { options: request })).data;
+		},
+		deliveryDistricts: (request = {}) => catalog.request("GET", `${catalog.baseUrl}/delivery/districts`, { options: request }),
+		deliveryAreas: (district, request = {}) => catalog.request("GET", `${catalog.baseUrl}/delivery/areas`, {
+			params: { district },
+			options: request
+		}),
+		quoteDelivery: (input, request = {}) => catalog.request("POST", `${catalog.baseUrl}/orders/quote`, {
+			data: input,
+			options: request
+		}),
+		checkout: (input, request) => {
+			if (!request?.idempotencyKey?.trim()) throw new Error("idempotencyKey is required; preserve it for retries.");
+			return catalog.request("POST", `${catalog.baseUrl}/orders`, {
+				data: input,
+				options: {
+					signal: request.signal,
+					headerOptions: { "Idempotency-Key": request.idempotencyKey }
+				}
+			});
+		},
+		orderStatus: (access, request = {}) => catalog.request("GET", `${catalog.baseUrl}/orders/${segment(access.orderNumber)}/status`, { options: {
+			signal: request.signal,
+			cache: "no-store",
+			headerOptions: { "x-order-access": access.accessToken }
+		} })
+	};
+}
+//#endregion
+export { createStorefrontClient };

package/dist/management-types.d.ts

@@ -0,0 +1,225 @@
+import { o as StorefrontOrder, s as StorefrontProduct } from "./types-C0cSi6Pk.js";
+import { Address } from "@classytic/primitives/address";
+import { Money } from "@classytic/primitives/money";
+//#region src/management-types.d.ts
+export interface ProductInput {
+  name: string;
+  slug: string;
+  productType: 'physical';
+  status: 'draft' | 'active' | 'archived';
+  description?: string;
+  categorySlug?: string;
+  tags?: string[];
+  collections?: string[];
+  images?: StorefrontProduct['images'];
+  defaultMonetization: {
+    type: 'one_time';
+    pricing: {
+      basePrice: Money;
+      currency: string;
+      compareAtPrice?: Money;
+    };
+  };
+  variationAttributes?: Array<{
+    code: string;
+    name: string;
+    values: Array<{
+      code: string;
+      label: string;
+    }>;
+  }>;
+  variants?: Array<{
+    sku: string;
+    attributes: Record<string, string>;
+    priceModifier: number;
+    isActive: boolean;
+  }>;
+}
+export interface MerchantProduct extends ProductInput {
+  _id: string;
+  updatedAt: string;
+}
+export interface CategoryInput {
+  name: string;
+  /** Omit on create to generate from the name. Slugs are immutable after creation. */
+  slug?: string;
+  parent?: string | null;
+  description?: string;
+  image?: {
+    url: string;
+    alt?: string;
+  } | null;
+  isActive?: boolean;
+  displayOrder?: number;
+}
+export type CategoryUpdate = Partial<Omit<CategoryInput, 'slug'>>;
+export interface MerchantCategory extends CategoryInput {
+  _id: string;
+  slug: string;
+  parentPath?: string;
+  productCount?: number;
+}
+export interface MerchantCategoryTree extends MerchantCategory {
+  children: MerchantCategoryTree[];
+  totalProductCount: number;
+}
+export interface MerchantOrder extends StorefrontOrder {
+  _id: string;
+  customerSnapshot?: {
+    name: string;
+    phone?: string;
+    email?: string;
+  };
+  shippingAddress?: Address;
+  lines: Array<{
+    lineId: string;
+    quantity: number;
+    snapshot: {
+      name?: string;
+      sku?: string;
+    };
+    lineTotal?: Money;
+  }>;
+  paymentState?: {
+    chargeStatus: string;
+    totalCharged?: Money;
+  };
+}
+export type OrderCommand = {
+  action: 'confirm' | 'start_processing' | 'ship' | 'deliver';
+} | {
+  action: 'cancel';
+  reason: string;
+};
+export interface StoreSettings {
+  version: number | null;
+  currency: string;
+  deliveryChargeMinor: number;
+}
+export interface MerchantMedia {
+  _id: string;
+  url: string;
+  filename: string;
+  mimeType?: string;
+  width?: number;
+  height?: number;
+  variants?: Array<{
+    name: string;
+    url: string;
+    width: number;
+    height: number;
+    mimeType: string;
+    size: number;
+  }>;
+}
+export interface IntegrationProvider {
+  service: string;
+  provider: string;
+  label: string;
+  oauth: boolean;
+  credentialFields: Array<{
+    name: string;
+    label: string;
+    type: 'text' | 'password' | 'number' | 'boolean' | 'select';
+    required: boolean;
+    secret?: boolean;
+    placeholder?: string;
+    help?: string;
+    options?: Array<{
+      label: string;
+      value: string;
+    }>;
+  }>;
+}
+export interface MerchantIntegration {
+  _id: string;
+  service: string;
+  provider: string;
+  label?: string;
+  enabled: boolean;
+  status: 'connected' | 'disabled' | 'error';
+  config: Record<string, unknown>;
+  secretsSet: Record<string, boolean>;
+  lastTestedAt?: string | null;
+  lastTestStatus?: 'ok' | 'failed' | 'skipped';
+}
+export interface NotificationDelivery {
+  _id: string;
+  timestamp: string;
+  event: string;
+  status: 'delivered' | 'partial' | 'failed' | 'skipped';
+  subject?: {
+    sourceModel: string;
+    sourceId: string;
+  };
+}
+export interface MerchantApiKey {
+  id: string;
+  kind: 'user' | 'service';
+  name: string;
+  prefix: string;
+  ownerId: string;
+  scopes: string[];
+  status: 'active' | 'expired' | 'revoked';
+  expiresAt: string | null;
+  lastUsedAt: string | null;
+  ceilingRole: string | null;
+}
+export interface ApiKeyOptions {
+  scopes: Array<{
+    scope: string;
+    requires: string[];
+    grantable: boolean;
+  }>;
+  ceilingRoles: Array<{
+    role: string;
+    scopes: string[];
+  }>;
+  can: {
+    own: boolean;
+    createService: boolean;
+    readBranch: boolean;
+    updateService: boolean;
+    deleteOthers: boolean;
+  };
+  lifetime: {
+    defaultDays: number;
+    maxDays: number;
+    allowNeverExpires?: boolean;
+  };
+}
+export interface ApiKeyInput {
+  kind: 'user' | 'service';
+  name: string;
+  scopes: string[];
+  /** Null explicitly requests a key that does not expire. */
+  expiresInDays: number | null;
+  ceilingRole?: string;
+}
+export interface IssuedApiKey {
+  key: string;
+  record: MerchantApiKey;
+}
+/** Inclusive start and exclusive end as ISO timestamps, at most 92 days apart. */
+export interface AnalyticsWindow {
+  from: string;
+  to: string;
+}
+/** Order values include delivery charges and are independent of payment collection. */
+export interface MerchantOverview {
+  summary: {
+    totalOrders: number;
+    totalOrderValue: number;
+    fulfilledOrders: number;
+    fulfilledOrderValue: number;
+    canceledOrders: number;
+    canceledOrderValue: number;
+    averageOrderValue: number;
+  };
+  statuses: Array<{
+    status: string;
+    count: number;
+    orderValue: number;
+  }>;
+}
+//#endregion

package/dist/management-types.js

@@ -0,0 +1 @@
+export {};

package/dist/management.d.ts

@@ -0,0 +1,94 @@
+import { DeliveryDistrict, DeliverySettings, DeliverySettingsUpdate } from "./delivery-types.js";
+import { AnalyticsWindow, ApiKeyInput, ApiKeyOptions, CategoryInput, IntegrationProvider, IssuedApiKey, MerchantApiKey, MerchantCategory, MerchantCategoryTree, MerchantIntegration, MerchantMedia, MerchantOrder, MerchantOverview, MerchantProduct, NotificationDelivery, OrderCommand, ProductInput, StoreSettings } from "./management-types.js";
+import { BaseApi } from "@classytic/arc-next/api";
+import { ArcClientConfig } from "@classytic/arc-next/client";
+//#region src/management.d.ts
+export interface MerchantClientOptions {
+  apiUrl: string;
+  token: string;
+  organizationId: string;
+  fetch?: ArcClientConfig['fetch'];
+}
+/** Capture one authenticated store; callers create a new instance when switching stores. */
+export declare function createMerchantClient(options: MerchantClientOptions): {
+  integrations: {
+    catalog: (signal?: AbortSignal) => Promise<IntegrationProvider[]>;
+    list: (signal?: AbortSignal) => Promise<MerchantIntegration[]>;
+    connect: (data: {
+      service: string;
+      provider: string;
+      label: string;
+      credentials: Record<string, unknown>;
+      enable: boolean;
+    }) => Promise<MerchantIntegration>;
+    command: (id: string, action: 'test' | 'enable' | 'disable') => Promise<MerchantIntegration>;
+    remove: (id: string) => Promise<null>;
+  };
+  notifications: {
+    list: ({ token, organizationId, params, options }?: {
+      token?: string | null;
+      organizationId?: string | null;
+      params?: import("@classytic/arc-next/api").QueryParams;
+      options?: Omit<import("@classytic/arc-next/api").RequestOptions, "token" | "organizationId">;
+    }) => Promise<import("@classytic/repo-core/pagination").PaginatedResult<NotificationDelivery>>;
+  };
+  apiKeys: {
+    options: (signal?: AbortSignal) => Promise<ApiKeyOptions>;
+    list: (owner: 'me' | 'branch', signal?: AbortSignal) => Promise<MerchantApiKey[]>;
+    create: (data: ApiKeyInput) => Promise<IssuedApiKey>;
+    rotate: (id: string) => Promise<IssuedApiKey>;
+    revoke: (id: string) => Promise<MerchantApiKey>;
+  };
+  delivery: {
+    read: (signal?: AbortSignal) => Promise<DeliverySettings>;
+    update: (data: DeliverySettingsUpdate) => Promise<DeliverySettings>;
+    districts(signal?: AbortSignal): Promise<DeliveryDistrict[]>;
+  };
+  products: BaseApi<MerchantProduct, ProductInput, Partial<ProductInput>>;
+  categories: BaseApi<MerchantCategory, CategoryInput, Partial<Omit<CategoryInput, "slug">>> & {
+    tree: (options?: {
+      signal?: AbortSignal;
+    }) => Promise<MerchantCategoryTree[]>;
+  };
+  analytics: {
+    overview(window: AnalyticsWindow, options?: {
+      signal?: AbortSignal;
+    }): Promise<MerchantOverview>;
+  };
+  orders: {
+    collect(id: string, amount: number, idempotencyKey: string): Promise<{
+      outstanding: number;
+      settled: boolean;
+      transactionId?: string;
+    }>;
+    list: ({ token, organizationId, params, options }?: {
+      token?: string | null;
+      organizationId?: string | null;
+      params?: import("@classytic/arc-next/api").QueryParams;
+      options?: Omit<import("@classytic/arc-next/api").RequestOptions, "token" | "organizationId">;
+    }) => Promise<import("@classytic/repo-core/pagination").PaginatedResult<MerchantOrder>>;
+    detail: (orderNumber: string, options?: {
+      signal?: AbortSignal;
+    }) => Promise<MerchantOrder>;
+    command(id: string, command: OrderCommand, idempotencyKey: string): Promise<MerchantOrder>;
+  };
+  settings: {
+    get: () => Promise<StoreSettings>;
+    update: (data: {
+      expectedVersion: number | null;
+      deliveryChargeMinor: number;
+    }) => Promise<StoreSettings>;
+  };
+  media: {
+    list: ({ token, organizationId, params, options }?: {
+      token?: string | null;
+      organizationId?: string | null;
+      params?: import("@classytic/arc-next/api").QueryParams;
+      options?: Omit<import("@classytic/arc-next/api").RequestOptions, "token" | "organizationId">;
+    }) => Promise<import("@classytic/repo-core/pagination").PaginatedResult<MerchantMedia>>;
+    upload: (file: File, folder?: 'products' | 'categories') => Promise<MerchantMedia>;
+    uploadImage(file: File, folder?: 'products' | 'categories'): Promise<MerchantMedia>;
+  };
+};
+export type MerchantClient = ReturnType<typeof createMerchantClient>;
+//#endregion

package/dist/management.js

@@ -0,0 +1,261 @@
+import { BaseApi } from "@classytic/arc-next/api";
+import { createClient } from "@classytic/arc-next/client";
+//#region src/management-delivery.ts
+function createMerchantDelivery(client) {
+	const api = new BaseApi("stores/delivery", {
+		client,
+		basePath: "",
+		cache: "no-store"
+	});
+	return { delivery: {
+		read: (signal) => api.request("GET", `${api.baseUrl}/current`, { options: { signal } }),
+		update: (data) => api.request("PATCH", `${api.baseUrl}/current`, { data }),
+		async districts(signal) {
+			return (await api.request("GET", `${api.baseUrl}/districts`, { options: { signal } })).data;
+		}
+	} };
+}
+//#endregion
+//#region src/management-access.ts
+function key(value) {
+	if (!value || value === "." || value === "..") throw new Error("An identifier is required.");
+	return encodeURIComponent(value);
+}
+function createMerchantAccess(client) {
+	const config = {
+		client,
+		basePath: "",
+		cache: "no-store"
+	};
+	const integrations = new BaseApi("integrations", config);
+	const apiKeys = new BaseApi("auth/api-keys", config);
+	const deliveries = new BaseApi("notifications/delivery-log", config);
+	return {
+		integrations: {
+			catalog: (signal) => integrations.request("GET", `${integrations.baseUrl}/catalog`, { options: { signal } }),
+			list: (signal) => integrations.request("GET", integrations.baseUrl, { options: { signal } }),
+			connect: (data) => integrations.request("POST", integrations.baseUrl, { data }),
+			command: (id, action) => integrations.dispatchAction({
+				id: key(id),
+				action
+			}),
+			remove: (id) => integrations.request("DELETE", `${integrations.baseUrl}/${key(id)}`)
+		},
+		notifications: { list: deliveries.getAll.bind(deliveries) },
+		apiKeys: {
+			options: (signal) => apiKeys.request("GET", `${apiKeys.baseUrl}/options`, { options: { signal } }),
+			list: (owner, signal) => apiKeys.request("GET", apiKeys.baseUrl, {
+				params: { owner },
+				options: { signal }
+			}),
+			create: (data) => apiKeys.request("POST", apiKeys.baseUrl, { data }),
+			rotate: (id) => apiKeys.dispatchAction({
+				id: key(id),
+				action: "rotate"
+			}),
+			revoke: (id) => apiKeys.dispatchAction({
+				id: key(id),
+				action: "revoke"
+			})
+		}
+	};
+}
+//#endregion
+//#region src/management-media.ts
+function createMerchantMedia(client, fetcher) {
+	const media = new BaseApi("media", {
+		client,
+		basePath: "",
+		cache: "no-store"
+	});
+	async function put(target, blob) {
+		const headers = new Headers(target.headers);
+		if (!headers.has("content-type")) headers.set("content-type", blob.type);
+		if (!(await (fetcher ?? fetch)(target.uploadUrl, {
+			method: "PUT",
+			credentials: "omit",
+			headers,
+			signal: AbortSignal.timeout(6e4),
+			body: blob
+		})).ok) throw new Error("Image upload failed. Please retry.");
+	}
+	async function upload(file, folder, processed, originalFilename) {
+		const derivatives = processed?.derivatives ?? [];
+		const started = await media.request("POST", `${media.baseUrl}/start-write`, { data: {
+			filename: file.name,
+			contentType: file.type,
+			size: file.size,
+			folder,
+			...derivatives.length ? { derivatives: derivatives.map((item) => ({
+				name: item.name,
+				contentType: item.blob.type,
+				size: item.bytes
+			})) } : {}
+		} });
+		if (started.kind === "dedup") return started.media;
+		if (started.kind !== "presigned") throw new Error("Choose a smaller product image for direct upload.");
+		const targets = derivatives.map((derivative) => {
+			const target = started.derivativeUploads?.find((item) => item.name === derivative.name)?.upload;
+			if (!target) throw new Error("The server did not provide every requested image size. Please retry.");
+			return {
+				derivative,
+				target
+			};
+		});
+		await put(started.upload, file);
+		await Promise.all(targets.map(({ derivative, target }) => put(target, derivative.blob)));
+		const hints = processed ? (await import("@classytic/media-transform/image/uploadHints")).toUploadHints(processed) : {};
+		return media.request("POST", `${media.baseUrl}/complete-write`, { data: {
+			key: started.upload.key,
+			filename: file.name,
+			mimeType: file.type,
+			size: file.size,
+			...originalFilename ? { originalFilename } : {},
+			...hints,
+			...targets.length ? { variants: targets.map(({ derivative, target }) => ({
+				name: derivative.name,
+				key: target.key,
+				mimeType: derivative.blob.type,
+				size: derivative.bytes,
+				width: derivative.width,
+				height: derivative.height
+			})) } : {}
+		} });
+	}
+	return {
+		list: media.getAll.bind(media),
+		upload: (file, folder = "products") => upload(file, folder),
+		async uploadImage(file, folder = "products") {
+			const policy = await media.request("GET", `${media.baseUrl}/transform-policy`);
+			const { resolveTransformPlan } = await import("@classytic/media-transform/policy");
+			const plan = resolveTransformPlan({
+				folder,
+				mimeType: file.type,
+				bytes: file.size
+			}, policy);
+			if (!plan.transform) {
+				if (plan.outcome === "preserve") return upload(file, folder);
+				throw new Error("The image processing policy is unsupported. Refresh the dashboard before uploading.");
+			}
+			const [{ createBrowserImageAdapter }, { compressImageSet }, { storedFilename }] = await Promise.all([
+				import("@classytic/media-transform/image/BrowserImageAdapter"),
+				import("@classytic/media-transform/image/compressImageSet"),
+				import("@classytic/media-transform/image/uploadHints")
+			]);
+			const result = await compressImageSet(await createBrowserImageAdapter(), file, plan.options);
+			return upload(new File([result.blob], storedFilename(file.name, result.format), { type: result.blob.type }), folder, result, file.name);
+		}
+	};
+}
+//#endregion
+//#region src/management.ts
+function orderKey(value) {
+	if (!value || value === "." || value === "..") throw new Error("An order number is required.");
+	return encodeURIComponent(value);
+}
+/** Capture one authenticated store; callers create a new instance when switching stores. */
+function createMerchantClient(options) {
+	const { token, organizationId, fetch: fetcher } = options;
+	const url = new URL(options.apiUrl);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) throw new Error("A valid HTTP(S) API mount is required.");
+	if (!token.trim() || !organizationId.trim()) throw new Error("A bearer token and organizationId are required.");
+	const client = createClient({
+		baseUrl: url.href.replace(/\/+$/, ""),
+		getToken: () => token,
+		getOrgId: () => organizationId,
+		credentials: "omit",
+		autoIdempotency: false,
+		timeoutMs: 15e3,
+		...fetcher ? { fetch: fetcher } : {}
+	});
+	const config = {
+		client,
+		basePath: "",
+		cache: "no-store"
+	};
+	const products = new BaseApi("products", config);
+	const categories = new BaseApi("categories", config);
+	const orders = new BaseApi("orders", config);
+	const stores = new BaseApi("stores", config);
+	return {
+		...createMerchantAccess(client),
+		...createMerchantDelivery(client),
+		products,
+		categories: Object.assign(categories, { tree: (options = {}) => categories.request("GET", `${categories.baseUrl}/tree`, { options }) }),
+		analytics: { async overview(window, options = {}) {
+			const from = new Date(window.from);
+			const to = new Date(window.to);
+			if (!Number.isFinite(from.getTime()) || !Number.isFinite(to.getTime()) || to <= from || to.getTime() - from.getTime() > 79488e5) throw new Error("Choose a valid analytics window of at most 92 days.");
+			const statuses = (await orders.request("GET", `${orders.baseUrl}/aggregations/revenueByStatus`, {
+				params: {
+					"createdAt[gte]": from.toISOString(),
+					"createdAt[lt]": to.toISOString()
+				},
+				options
+			})).rows.map(({ status, count, revenue }) => ({
+				status,
+				count,
+				orderValue: revenue
+			}));
+			const summary = {
+				totalOrders: 0,
+				totalOrderValue: 0,
+				fulfilledOrders: 0,
+				fulfilledOrderValue: 0,
+				canceledOrders: 0,
+				canceledOrderValue: 0,
+				averageOrderValue: 0
+			};
+			for (const row of statuses) {
+				summary.totalOrders += row.count;
+				summary.totalOrderValue += row.orderValue;
+				if (row.status === "fulfilled" || row.status === "completed") {
+					summary.fulfilledOrders += row.count;
+					summary.fulfilledOrderValue += row.orderValue;
+				}
+				if (row.status === "canceled") {
+					summary.canceledOrders += row.count;
+					summary.canceledOrderValue += row.orderValue;
+				}
+			}
+			summary.averageOrderValue = summary.totalOrders ? Math.round(summary.totalOrderValue / summary.totalOrders) : 0;
+			return {
+				summary,
+				statuses
+			};
+		} },
+		orders: {
+			collect(id, amount, idempotencyKey) {
+				if (!idempotencyKey.trim()) throw new Error("Preserve an explicit idempotencyKey for collection retries.");
+				return orders.dispatchAction({
+					id: orderKey(id),
+					action: "collect_payment",
+					data: { amount },
+					options: { headerOptions: { "Idempotency-Key": idempotencyKey } }
+				});
+			},
+			list: orders.getAll.bind(orders),
+			detail: (orderNumber, options = {}) => orders.getById({
+				id: orderKey(orderNumber),
+				options
+			}),
+			command(id, command, idempotencyKey) {
+				if (!idempotencyKey.trim()) throw new Error("Preserve an explicit idempotencyKey for command retries.");
+				const { action, ...data } = command;
+				return orders.dispatchAction({
+					id: orderKey(id),
+					action,
+					data,
+					options: { headerOptions: { "Idempotency-Key": idempotencyKey } }
+				});
+			}
+		},
+		settings: {
+			get: () => stores.request("GET", `${stores.baseUrl}/settings/current`),
+			update: (data) => stores.request("PATCH", `${stores.baseUrl}/settings/current`, { data })
+		},
+		media: createMerchantMedia(client, fetcher)
+	};
+}
+//#endregion
+export { createMerchantClient };

package/dist/types-C0cSi6Pk.d.ts

@@ -0,0 +1,128 @@
+import { Address } from "@classytic/primitives/address";
+import { Money } from "@classytic/primitives/money";
+//#region src/types.d.ts
+/** Public wire projections; merchant-only catalog and buyer fields are absent. */
+interface StorefrontProduct {
+  id: string;
+  name: string;
+  slug: string;
+  description?: string;
+  categorySlug?: string;
+  tags?: string[];
+  collections?: string[];
+  onSale?: boolean;
+  images?: Array<{
+    url: string;
+    alt?: string;
+    order?: number;
+    isFeatured?: boolean;
+    variants?: {
+      thumbnail?: string;
+      medium?: string;
+    };
+  }>;
+  monetization?: {
+    type: 'one_time';
+    basePrice: Money;
+    compareAtPrice?: Money;
+  };
+  variants?: Array<{
+    sku: string;
+    attributes: Record<string, string>;
+    priceModifier: number;
+  }>;
+}
+interface StorefrontCategory {
+  id: string;
+  name: string;
+  slug: string;
+  parent?: string | null;
+  parentPath?: string;
+  description?: string;
+  image?: {
+    url: string;
+    alt?: string;
+  } | null;
+  displayOrder?: number;
+}
+interface StorefrontProductPage {
+  data: StorefrontProduct[];
+  next: string | null;
+}
+interface StorefrontProductQuery {
+  limit?: number;
+  /** Opaque cursor returned by the preceding page; keep filters and sort unchanged. */
+  after?: string;
+  category?: string;
+  q?: string;
+  tag?: string;
+  collection?: string;
+  onSale?: boolean;
+  /** Inclusive base-price bounds in the store currency's integer minor units. */
+  minPrice?: number;
+  maxPrice?: number;
+  sort?: 'newest' | 'price-asc' | 'price-desc';
+}
+interface StorefrontProfile {
+  organizationId: string;
+  name: string;
+  slug: string;
+  status: 'active';
+  currency: string;
+  deliveryChargeMinor: number;
+}
+interface GuestCheckoutInput {
+  lines: Array<{
+    productId: string;
+    variantSku?: string;
+    quantity: number;
+  }>;
+  customer: {
+    name: string;
+    phone: string;
+    email?: string;
+  };
+  shippingAddress: Address & {
+    areaId?: number;
+  };
+}
+interface StorefrontOrder {
+  orderNumber: string;
+  status: string;
+  fulfillmentStatus?: 'unfulfilled' | 'partial' | 'fulfilled' | 'returned';
+  fulfillmentSummary?: {
+    total: number;
+    fulfilled: number;
+    shipped: number;
+    delivered: number;
+    returned: number;
+  };
+  paymentTerm?: 'prepaid' | 'collect_on_delivery';
+  currency: string;
+  totals: {
+    subtotal: Money;
+    discount: Money;
+    tax: Money;
+    shipping: Money;
+    grandTotal: Money;
+    taxBasis?: 'inclusive' | 'exclusive';
+  };
+  createdAt: string;
+  updatedAt: string;
+}
+type GuestCheckoutResult = StorefrontOrder & {
+  accessToken: string;
+};
+interface GuestOrderAccess {
+  orderNumber: string;
+  accessToken: string;
+}
+interface StorefrontRequestOptions {
+  signal?: AbortSignal;
+}
+interface GuestCheckoutOptions extends StorefrontRequestOptions {
+  /** Create once per checkout attempt; preserve across retries and lost responses. */
+  idempotencyKey: string;
+}
+//#endregion
+export { StorefrontCategory as a, StorefrontProductPage as c, StorefrontRequestOptions as d, GuestOrderAccess as i, StorefrontProductQuery as l, GuestCheckoutOptions as n, StorefrontOrder as o, GuestCheckoutResult as r, StorefrontProduct as s, GuestCheckoutInput as t, StorefrontProfile as u };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { a as StorefrontCategory, c as StorefrontProductPage, d as StorefrontRequestOptions, i as GuestOrderAccess, l as StorefrontProductQuery, n as GuestCheckoutOptions, o as StorefrontOrder, r as GuestCheckoutResult, s as StorefrontProduct, t as GuestCheckoutInput, u as StorefrontProfile } from "./types-C0cSi6Pk.js";
+export { GuestCheckoutInput, GuestCheckoutOptions, GuestCheckoutResult, GuestOrderAccess, StorefrontCategory, StorefrontOrder, StorefrontProduct, StorefrontProductPage, StorefrontProductQuery, StorefrontProfile, StorefrontRequestOptions };

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/management.md

@@ -0,0 +1,88 @@
+# Merchant client
+
+Import `createMerchantClient` from `@classytic/commerce-client/management`.
+Its contracts live in `/management/types`. The guest-only root entry imports
+none of this authenticated surface.
+
+```ts
+import { createMerchantClient } from '@classytic/commerce-client/management';
+
+const merchant = createMerchantClient({
+  apiUrl: 'https://api.example.com/api/v1',
+  token: merchantSessionToken,
+  organizationId: selectedStoreId,
+});
+const products = await merchant.products.getAll({ params: { page: 1, limit: 20 } });
+const categories = await merchant.categories.tree();
+const orders = await merchant.orders.list();
+```
+
+Each instance captures one bearer credential and store. Create another instance
+on session or store changes. Cookies and automatic command keys are disabled.
+The server authorizes every operation; choosing a store ID grants no access.
+
+Product/category APIs use Arc Next's typed CRUD methods. Order writes expose
+only supported commands (`confirm`, `start_processing`, `ship`, `deliver`,
+`cancel`) and cash collection. Generate a key once per command attempt and keep
+it, its amount and its body unchanged across retries.
+
+```ts
+const key = crypto.randomUUID();
+await merchant.orders.command(orderNumber, { action: 'confirm' }, key);
+
+// After complete delivery and actual receipt of cash, with the collect permission:
+const collectionKey = crypto.randomUUID();
+await merchant.orders.collect(orderNumber, amountMinor, collectionKey);
+```
+
+`media.upload(file)` uses the shared start-write → storage PUT → complete-write
+protocol. Merchant authorization goes to the API; the storage PUT receives only
+its presigned headers and file bytes. A failed PUT does not confirm an upload.
+Settings updates carry `expectedVersion`; refetch after a conflict before saving.
+
+`integrations.catalog()` describes enabled providers and credential fields.
+`integrations.connect()` stores/tests a connection for the authenticated store;
+`command(id, 'test' | 'enable' | 'disable')` controls it and `remove(id)` disconnects
+it. `notifications.list()` reads paginated delivery evidence. These routes may be
+absent when the deployment has no notification credential encryption key.
+
+`apiKeys.options()` returns live scope grants, ownership permissions and lifetime
+bounds. Use them to construct `apiKeys.create(input)`. `apiKeys.list('me' | 'branch')`
+returns safe records; `rotate(id)` returns a replacement secret and `revoke(id)`
+disables one. Creation/rotation require a fresh bearer session. Store the returned
+secret on your server: it is shown once, cannot be read later and should never be
+placed in query caches or browser storage. These mutations have no automatic
+retry; refresh the key list after an uncertain outcome before retrying.
+
+`analytics.overview({ from, to }, { signal })` reads one store-scoped order
+aggregation. Supply ISO timestamps for an inclusive start and exclusive end,
+at most 92 days apart. Read the configured currency through `settings.get()`.
+Amounts are integer minor units; the rounded average uses the same unit.
+
+The summary reports order count/value, fulfilled count/value, canceled
+count/value and average order value, alongside the individual status rows.
+Total order value includes every status and delivery charges. Fulfilled combines
+`fulfilled` and `completed`: shipment can fulfill an order before delivery.
+Refunded remains a separate status. These metrics do not measure received cash
+or prove delivery. Order-read permission is required, including `read:orders`
+for API keys; organization IDs in query parameters cannot widen the store scope.
+
+## Category hierarchy
+
+`categories.tree({ signal })` returns nested categories with `children` and
+`totalProductCount`. `parent` is the parent category's slug; `null` moves a category
+to the top level. Slugs are permanent after creation. Omit a blank create slug to
+generate it from the name; update names without resending a slug.
+
+Import `categoryChoices` from `@classytic/commerce-client/category-tree` for
+breadcrumb labels. Pass the edited slug as its second argument to exclude that
+category and all its descendants from parent choices.
+
+`media.uploadImage(file, 'categories')` optimizes a category image using the
+category-folder policy. Send `image: null` to clear its reference; detached-media
+cleanup follows the server's normal governance policy.
+
+Product writes also accept `tags`, `collections` and
+`defaultMonetization.pricing.compareAtPrice`. The catalog derives `onSale`; clients
+never set it. Tags and collections use the existing catalog arrays, with no
+additional collection-management service.

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@classytic/commerce-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Typed storefront and merchant clients for the Classytic Commerce API",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./management": {
+      "types": "./dist/management.d.ts",
+      "default": "./dist/management.js"
+    },
+    "./management/types": {
+      "types": "./dist/management-types.d.ts",
+      "default": "./dist/management-types.js"
+    },
+    "./delivery-types": {
+      "types": "./dist/delivery-types.d.ts",
+      "default": "./dist/delivery-types.js"
+    },
+    "./category-tree": {
+      "types": "./dist/category-tree.d.ts",
+      "default": "./dist/category-tree.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "management.md"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "push": "classytic-push",
+    "release:tag": "node -e \"require('child_process').execSync('npm run push -- v'+require('./package.json').version,{stdio:'inherit'})\"",
+    "release": "npm run push -- main && npm run release:tag && npm publish"
+  },
+  "dependencies": {
+    "@classytic/arc-next": "^0.18.0",
+    "@classytic/media-transform": "^0.3.0",
+    "@classytic/primitives": "^0.34.0"
+  },
+  "devDependencies": {
+    "@classytic/dev-tools": "^0.2.1",
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.1",
+    "publint": "^0.3.25",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/classytic/commerce-client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/classytic/commerce-client/issues"
+  },
+  "homepage": "https://github.com/classytic/commerce-client#readme"
+}