@goodz-core/sdk 0.2.0 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # @goodz-core/sdk
 
-Official SDK for **GoodZ.Core** — a type-safe API client for building GoodZ-powered applications. This package provides a zero-dependency HTTP client that speaks the tRPC wire protocol directly, along with OAuth helpers, Z-coin utilities, and full TypeScript type coverage.
+Official SDK for the **GoodZ** ecosystem — a unified, type-safe API client for building GoodZ-powered applications. One package covers all five products: Core, Commerce, Exchange, Alive, and Shops. Stripe-style namespaces route requests to the correct service transparently.
 
 ## Installation
 
@@ -10,7 +10,7 @@ npm install @goodz-core/sdk
 pnpm add @goodz-core/sdk
 ```
 
-The SDK has only one runtime dependency (`superjson`) and requires Node.js 18+. It works in any JavaScript runtime that supports the Fetch API (Node.js, Deno, Bun, Cloudflare Workers, browsers).
+Runtime dependency: `superjson` only. Works in Node.js 18+, Deno, Bun, Cloudflare Workers, and browsers (any runtime with Fetch API).
 
 ## Quick Start
 
@@ -21,11 +21,9 @@ const goodz = createGoodZClient({
   accessToken: "your-jwt-token",
 });
 
-// All methods are fully typed — IDE autocomplete works out of the box
+// Core — settlement
 const balance = await goodz.zcoin.getMyBalance();
-console.log(`Balance: ${balance.balance} hundredths`);
-
-const result = await goodz.zcoin.commercialTransfer({
+const trade = await goodz.zcoin.commercialTransfer({
   instanceId: 90447,
   buyerUserId: 1,
   sellerUserId: 2,
@@ -34,118 +32,271 @@ const result = await goodz.zcoin.commercialTransfer({
   referenceId: "order-abc-123",
   appClientId: "od_myapp",
 });
-console.log(`Trade ID: ${result.tradeId}`);
+
+// Commerce — create a shop and launch a campaign
+const shop = await goodz.commerce.createShop({ name: "Frostpeak Store" });
+const campaign = await goodz.commerce.launchCampaign({ shopId: shop.id, name: "Spring Drop" });
+const order = await goodz.commerce.executePurchase({ campaignId: campaign.id, quantity: 1 });
+
+// Exchange — list an item for sale
+const listing = await goodz.exchange.createListing({
+  instanceId: 42,
+  listingType: "fixed_price",
+  askPrice: 2000,
+});
+const data = await goodz.exchange.getMarketData({ coreGoodzId: 42 });
+
+// Alive — chat with a character
+const reply = await goodz.alive.sendMessage({
+  instanceId: 1,
+  userId: 1,
+  message: "What's your favorite memory?",
+});
 ```
 
 ## Architecture
 
-The SDK is designed around three principles:
+The SDK is built on three principles:
 
-**Zero tRPC dependency.** Unlike a typical tRPC client that requires `@trpc/client` and `@trpc/server` as peer dependencies (and transitively pulls in the entire server type tree), this SDK speaks the tRPC HTTP wire protocol directly using `fetch` + `superjson`. This means consumers never need to install tRPC packages, and the DTS bundle is fully self-contained.
+**One client, all services.** `createGoodZClient()` returns a single object with namespaces for every GoodZ product. Core uses tRPC HTTP wire protocol; sub-sites (Commerce, Exchange, Alive) use MCP JSON-RPC 2.0. The client handles routing transparently — developers never need to know which protocol a method uses.
 
-**Hand-crafted types as API contract.** All input/output types are defined inside the SDK itself (in `src/types.ts`), mirroring the Zod schemas on the Core server. This is the same approach used by the Stripe SDK — the types serve as both documentation and compile-time contract. When Core's API evolves, the SDK types are updated and a new version is published.
+**Hand-crafted types as API contract.** All input/output types are defined inside the SDK itself, mirroring the Zod schemas on Core and the MCP tool schemas on sub-sites. This is the same approach used by the Stripe SDK — types serve as both documentation and compile-time contract. When any service's API evolves, the SDK types are updated and a new version is published.
 
-**Namespace-based API surface.** Methods are organized into logical namespaces (`zcoin`, `inventory`, `collectible`, `user`, `auth`, `ip`) that mirror Core's tRPC router structure. Each namespace method is a thin wrapper around the transport layer, providing typed inputs and outputs.
+**Zero tRPC dependency.** The SDK speaks the tRPC wire protocol directly using `fetch` + `superjson`, and speaks MCP JSON-RPC natively. Consumers never need to install `@trpc/client`, `@trpc/server`, or any MCP client library.
 
-## API Reference
-
-### Client Configuration
+## Client Configuration
 
 ```ts
 interface GoodZClientConfig {
   coreUrl?: string;           // Default: "https://goodzcore.manus.space"
+  commerceUrl?: string;       // Default: "https://goodzcommerce.manus.space"
+  exchangeUrl?: string;       // Default: "https://goodzexchange.manus.space"
+  aliveUrl?: string;          // Default: "https://goodzalive.manus.space"
   accessToken?: string;       // Static JWT token
   getAccessToken?: () => string | Promise<string>;  // Dynamic token provider
   headers?: Record<string, string>;  // Custom headers for every request
 }
 ```
 
-The `getAccessToken` function takes precedence over `accessToken` when both are provided. Use it for auto-refresh scenarios.
+The `getAccessToken` function takes precedence over `accessToken` when both are provided. Use it for auto-refresh scenarios. Sub-site URLs default to production endpoints and rarely need to be changed.
 
-### Namespaces
+## API Reference — Core Namespaces
 
-#### `goodz.zcoin` — Z-coin Payment & Settlement
+Core namespaces communicate via tRPC HTTP wire protocol with `goodzcore.manus.space`.
 
-The Z-coin namespace handles all monetary operations. These are the primary APIs that Commerce and Exchange apps use to process purchases.
+### `goodz.zcoin` — Z-coin Payment & Settlement
 
 | Method | Type | Description |
 |--------|------|-------------|
-| `getMyBalance()` | Query | Get authenticated user's Z-coin balance |
-| `getMyHistory(input?)` | Query | Get Z-coin transaction history with pagination |
-| `getDepositPackages(input?)` | Query | List available deposit packages with pricing |
-| `createDepositOrder(input)` | Mutation | Create a Stripe checkout session for Z-coin deposit |
+| `getMyBalance()` | Query | Authenticated user's Z-coin balance |
+| `getMyHistory(input?)` | Query | Transaction history with pagination |
+| `getDepositPackages(input?)` | Query | Available deposit packages with pricing |
+| `createDepositOrder(input)` | Mutation | Create Stripe checkout for Z-coin deposit |
 | `getDepositStatus(input)` | Query | Check deposit checkout session status |
-| `commercialTransfer(input)` | Mutation | Atomic Z-coin payment + ownership transfer |
-| `mintAndCharge(input)` | Mutation | Mint new instance + charge buyer atomically |
-| `chargeUser(input)` | Mutation | Charge user's Z-coin for in-app purchases |
-| `createDirectPurchaseOrder(input)` | Mutation | Create fiat-to-Z-coin direct purchase checkout |
+| `commercialTransfer(input)` | Mutation | **Primary API for secondary market.** Atomic: debit buyer → credit seller → transfer ownership |
+| `mintAndCharge(input)` | Mutation | **Primary API for primary sales.** Atomic: mint instance → charge buyer |
+| `chargeUser(input)` | Mutation | Charge Z-coin for in-app purchases |
+| `createDirectPurchaseOrder(input)` | Mutation | Fiat-to-Z-coin direct purchase checkout |
 
-**Key method: `commercialTransfer`** is the primary API for all secondary market transactions. It atomically debits the buyer's Z-coin balance, credits the seller (minus platform fee), and transfers card instance ownership — all in a single database transaction. The `referenceId` parameter provides idempotency, so duplicate calls (e.g., from retries) return the same result.
+`commercialTransfer` is the most important method in the SDK. It atomically debits the buyer's Z-coin balance, credits the seller (minus platform fee), and transfers card instance ownership — all in a single database transaction. The `referenceId` parameter provides idempotency.
 
-**Key method: `mintAndCharge`** is the primary API for primary sales (gacha, direct-from-creator). It mints a new card instance and charges the buyer in one atomic operation. Requires prior mint authorization via `inventory.grantMintAuth`.
+`mintAndCharge` is the primary API for primary sales (gacha, direct-from-creator). It mints a new card instance and charges the buyer in one atomic operation. Requires prior mint authorization via `inventory.grantMintAuth`.
 
-#### `goodz.inventory` — Card Instance Management
+### `goodz.inventory` — Card Instance Management
 
 | Method | Type | Description |
 |--------|------|-------------|
-| `getUserInventory(input)` | Query | Get a user's owned card instances |
+| `getUserInventory(input)` | Query | User's owned card instances |
 | `confirmOwnership(input)` | Query | Check if user owns a specific card |
-| `mint(input)` | Mutation | Mint new card instances (requires authorization) |
-| `transfer(input)` | Mutation | Transfer a specific instance to another user |
-| `transferByCard(input)` | Mutation | Transfer instances by cardId (oldest first) |
-| `grantMintAuth(input)` | Mutation | Grant mint authorization to another user/app |
-| `transferHistory(input)` | Query | Get transfer/ownership history |
+| `mint(input)` | Mutation | Mint new instances (requires authorization) |
+| `transfer(input)` | Mutation | Transfer instance by instanceId |
+| `transferByCard(input)` | Mutation | Transfer by cardId (oldest first) |
+| `grantMintAuth(input)` | Mutation | Grant mint authorization to app/user |
+| `transferHistory(input)` | Query | Ownership/transfer history |
 
-For commercial transactions (purchases, trades), always use `zcoin.commercialTransfer` or `zcoin.mintAndCharge` instead of the raw `transfer`/`mint` methods. The raw methods are intended for administrative operations and gift transfers only.
+For commercial transactions, always use `zcoin.commercialTransfer` or `zcoin.mintAndCharge` instead of raw `transfer`/`mint`. The raw methods are for administrative operations and gift transfers only.
 
-#### `goodz.collectible` — Card & Instance Queries
+### `goodz.collectible` — Card & Instance Queries
 
 | Method | Type | Description |
 |--------|------|-------------|
-| `getInstanceById(input)` | Query | Get instance by numeric ID |
-| `getPublicInstance(input)` | Query | Get instance by instance code |
+| `getInstanceById(input)` | Query | Instance by numeric ID |
+| `getPublicInstance(input)` | Query | Instance by instance code |
 | `getPublicInstancesBatch(input)` | Query | Batch-fetch instances (max 100) |
-| `getCardProfile(input)` | Query | Get card metadata, rarity, series info |
-| `getShellImageUrl(input)` | Query | Get shell (packaging) image URL |
+| `getCardProfile(input)` | Query | Card metadata, rarity, series info |
+| `getShellImageUrl(input)` | Query | Shell (packaging) image URL |
 
-#### `goodz.user` — User Profiles
+### `goodz.ip` — IP Management (Franchise/Series/Card)
 
 | Method | Type | Description |
 |--------|------|-------------|
-| `getPublicProfile(input)` | Query | Get profile by openId |
-| `getPublicProfileById(input)` | Query | Get profile by internal userId |
+| `getFranchise(input)` | Query | Franchise by ID or slug |
+| `getSeries(input)` | Query | Series by ID or slug |
+| `listSeriesByFranchise(input)` | Query | All series in a franchise |
+| `getCard(input)` | Query | Card by ID |
+| `listCardsBySeries(input)` | Query | All cards in a series |
 
-#### `goodz.auth` — Authentication
+### `goodz.user` & `goodz.auth`
 
 | Method | Type | Description |
 |--------|------|-------------|
-| `me()` | Query | Get authenticated user's profile |
-| `getOAuthAppInfo(input)` | Query | Get OAuth app info by client ID |
+| `user.getPublicProfile(input)` | Query | Profile by openId |
+| `user.getPublicProfileById(input)` | Query | Profile by userId |
+| `auth.me()` | Query | Authenticated user's profile |
+| `auth.getOAuthAppInfo(input)` | Query | OAuth app info by clientId |
+
+## API Reference — Commerce Namespace
+
+Commerce methods communicate via MCP JSON-RPC with `goodzcommerce.manus.space`. This namespace covers shop management, product assembly, campaigns, purchases, wholesale, and settlement.
+
+### Shop & Product Assembly
+
+| Method | Description |
+|--------|-------------|
+| `createShop(input)` | Create a new shop |
+| `getShopDashboard()` | Shop dashboard with stats |
+| `createBatch(input)` | Create a product batch (fixed-price bundle) |
+| `createGachaPool(input)` | Create a gacha/blind-box pool with probability weights |
+
+### Campaign Lifecycle
+
+| Method | Description |
+|--------|-------------|
+| `launchCampaign(input)` | Launch a new sales campaign |
+| `activateCampaign(input)` | Activate a paused campaign |
+| `pauseCampaign(input)` | Pause an active campaign |
+| `endCampaign(input)` | End a campaign permanently |
+| `updateCampaign(input)` | Update campaign details |
+| `getCampaignInfo(input)` | Get campaign info |
+| `getCampaignItems(input)` | Get items in a campaign |
+
+### Purchase & Orders
+
+| Method | Description |
+|--------|-------------|
+| `executePurchase(input)` | Execute a purchase (direct or gacha draw) |
+| `getMyOrders()` | User's order history |
+
+### Wholesale
+
+| Method | Description |
+|--------|-------------|
+| `publishToWholesale(input)` | Publish batch to wholesale market |
+| `browseWholesale()` | Browse wholesale listings |
+| `procureBatch(input)` | Procure a wholesale batch for resale |
+
+### Inventory & Fulfillment
+
+| Method | Description |
+|--------|-------------|
+| `manageInventory(input)` | View/manage shop inventory |
+| `registerInstances(input)` | Register minted instances to shop |
+| `mintToInventory(input)` | Mint + register in one step |
+| `redeemPhysical(input)` | Redeem a physical item |
+
+### Settlement & Discovery
+
+| Method | Description |
+|--------|-------------|
+| `getSettlementReport()` | Revenue and settlement report |
+| `searchMarketplace(input)` | Search across all shops |
+| `getShopsByBlueprint(input)` | Find shops selling a specific card |
+
+### Webhooks & App Management
+
+| Method | Description |
+|--------|-------------|
+| `registerWebhook(input)` | Register event webhook |
+| `listWebhooks()` | List registered webhooks |
+| `testWebhook(input)` | Test a webhook endpoint |
+| `deleteWebhook(input)` | Delete a webhook |
+| `registerApp(input)` | Register an app on Commerce |
+| `updateApp(input)` | Update app details |
+| `listMyApps()` | List your registered apps |
+| `getAuthUrl()` | Get Commerce OAuth URL |
+
+### Commerce Escape Hatch
 
-#### `goodz.ip` — IP Management (Franchise/Series/Card)
+```ts
+// For MCP tools not yet in the typed API
+const result = await goodz.commerce.rawTool("some_new_tool", { key: "value" });
+```
 
-| Method | Type | Description |
-|--------|------|-------------|
-| `getFranchise(input)` | Query | Get franchise by ID or slug |
-| `getSeries(input)` | Query | Get series by ID or slug |
-| `listSeriesByFranchise(input)` | Query | List all series in a franchise |
-| `getCard(input)` | Query | Get card by ID |
-| `listCardsBySeries(input)` | Query | List all cards in a series |
+## API Reference — Exchange Namespace
 
-### Raw Escape Hatches
+Exchange methods communicate via MCP JSON-RPC with `goodzexchange.manus.space`. This namespace covers the secondary market: listings, auctions, want-to-buy requests, P2P trades, and market data.
 
-For routes not yet covered by the typed namespaces, use the raw methods:
+### Marketplace & Listings
+
+| Method | Description |
+|--------|-------------|
+| `browseMarketplace(input?)` | Browse active listings with filters |
+| `getListingDetail(input)` | Get listing details |
+| `createListing(input)` | Create listing (fixed_price or auction). Core locks the instance |
+| `cancelListing(input)` | Cancel listing. Core unlocks the instance |
+
+### Purchase & Bidding
+
+| Method | Description |
+|--------|-------------|
+| `buyListing(input)` | Buy a fixed-price listing. Z-coin debit + ownership transfer |
+| `placeBid(input)` | Bid on auction. If meets buy-now price → instant purchase |
+| `getBids(input)` | All bids for an auction (highest first) |
+
+### Want-to-Buy (WTB)
+
+| Method | Description |
+|--------|-------------|
+| `createWtb(input)` | Post a want-to-buy request |
+| `fulfillWtb(input)` | Fulfill a WTB by offering your item |
+| `cancelWtb(input)` | Cancel your WTB request |
+
+### P2P Trade
+
+| Method | Description |
+|--------|-------------|
+| `proposeTrade(input)` | Propose an item swap (optional Z-coin compensation) |
+| `respondToTrade(input)` | Accept/reject trade. If accepted → all items transfer atomically |
+
+### Watchlist & Market Data
+
+| Method | Description |
+|--------|-------------|
+| `getWatchlist()` | Your watchlist |
+| `addToWatchlist(input)` | Add to watchlist |
+| `removeFromWatchlist(input)` | Remove from watchlist |
+| `getMarketData(input)` | Price history, floor price, volume, trends |
+
+### Exchange Escape Hatch
 
 ```ts
-const data = await goodz.rawQuery("some.newRoute", { id: 123 });
-const result = await goodz.rawMutation("some.newMutation", { name: "test" });
+const result = await goodz.exchange.rawTool("some_new_tool", { key: "value" });
 ```
 
-## Authentication
+## API Reference — Alive Namespace
 
-### Server-to-Server with Static Token
+Alive methods communicate via MCP JSON-RPC with `goodzalive.manus.space`. This namespace powers AI companion interactions: memory, intimacy, context building, and conversation.
 
-The simplest approach for backend services:
+| Method | Description |
+|--------|-------------|
+| `storeMemory(input)` | Store a memory for a character-user pair |
+| `recallMemories(input)` | Semantic search for relevant memories |
+| `forgetMemory(input)` | Delete a specific memory |
+| `getIntimacy(input)` | Get intimacy/affection state between character and user |
+| `updateIntimacy(input)` | Update intimacy level after interaction |
+| `buildContext(input)` | Build full AI context (profile + memories + history + system prompt) |
+| `classifyIntent(input)` | Classify user message into intent category |
+| `sendMessage(input)` | Send message → get character response (includes memory/intimacy processing) |
+
+### Alive Escape Hatch
+
+```ts
+const result = await goodz.alive.rawTool("some_new_tool", { key: "value" });
+```
+
+## Authentication
+
+### Static Token (simplest)
 
 ```ts
 const goodz = createGoodZClient({
@@ -169,7 +320,6 @@ const tokenManager = new TokenManager({
     expiresAt: savedExpiresAt,
   },
   onTokenRefresh: async (tokens) => {
-    // Persist refreshed tokens to your database
     await db.update(appTokens).set({
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
@@ -198,7 +348,7 @@ const authUrl = buildAuthorizationUrl({
   state: crypto.randomUUID(),
 });
 
-// Step 2: Exchange code for tokens in your callback handler
+// Step 2: Exchange code for tokens
 const tokens = await exchangeCode({
   clientId: "od_myapp",
   clientSecret: process.env.CLIENT_SECRET,
@@ -214,7 +364,7 @@ const userGoodz = createGoodZClient({
 
 ## Z-coin Precision
 
-GoodZ.Core stores Z-coin amounts in **hundredths** (1/100th of a Z-coin). For example, 10.50 Z-coin is stored as `1050`. The SDK provides utility functions to convert between display values and hundredths:
+GoodZ stores Z-coin amounts in **hundredths** (1/100th of a Z-coin). For example, 10.50 Z-coin is stored as `1050`.
 
 ```ts
 import { toHundredths, toDisplay, formatZcoin } from "@goodz-core/sdk/zcoin";
@@ -224,7 +374,7 @@ toDisplay(1050);        // → 10.5
 formatZcoin(1050);      // → "10.50"
 ```
 
-Always use `toHundredths()` when constructing API inputs to avoid the off-by-100x error:
+Always use `toHundredths()` when constructing API inputs:
 
 ```ts
 // ✅ Correct
@@ -242,7 +392,7 @@ await goodz.zcoin.commercialTransfer({
 
 ## Error Handling
 
-All API errors are thrown as `GoodZApiError` instances with structured fields:
+All API errors are thrown as `GoodZApiError` instances:
 
 ```ts
 import { GoodZApiError } from "@goodz-core/sdk";
@@ -251,33 +401,67 @@ try {
   await goodz.zcoin.commercialTransfer({ /* ... */ });
 } catch (err) {
   if (err instanceof GoodZApiError) {
-    console.error(err.code);       // "BAD_REQUEST", "FORBIDDEN", "CONFLICT", etc.
-    console.error(err.httpStatus);  // 400, 403, 409, etc.
+    console.error(err.code);       // "BAD_REQUEST", "FORBIDDEN", etc.
+    console.error(err.httpStatus);  // 400, 403, etc.
     console.error(err.path);       // "zcoin.commercialTransfer"
-    console.error(err.message);    // Human-readable error message
-
-    // Zod validation errors (if input was malformed)
+    console.error(err.message);    // Human-readable message
     if (err.zodErrors) {
       for (const fieldErr of err.zodErrors) {
         console.error(`${fieldErr.path.join(".")}: ${fieldErr.message}`);
       }
     }
-
-    // Full detailed string for logging
-    console.error(err.toDetailedString());
   }
 }
 ```
 
-Common error codes and recommended handling:
+| Code | HTTP | Meaning | Action |
+|------|------|---------|--------|
+| `BAD_REQUEST` | 400 | Invalid input or insufficient balance | Check input values |
+| `UNAUTHORIZED` | 401 | Missing or invalid token | Refresh token or re-login |
+| `FORBIDDEN` | 403 | No permission | Show permission denied |
+| `NOT_FOUND` | 404 | Resource doesn't exist | Show 404 or fallback |
+| `CONFLICT` | 409 | Version conflict | Retry the operation |
+
+## UI Components (React)
+
+The SDK includes a React component for displaying GoodZ collectibles with full material effects and tilt interaction — the same experience used on GoodZ.Core itself.
+
+### GoodZCardFocus
+
+```tsx
+import { GoodZCardFocus } from "@goodz-core/sdk/ui";
+
+<GoodZCardFocus
+  imageUrl="https://goodzcore.manus.space/api/shell/42.png"
+  cardName="Luna"
+  rarity="SSR"
+  formFactor="trading_card"
+>
+  <img src={thumbnailUrl} alt="Luna" className="w-full rounded-lg" />
+</GoodZCardFocus>
+```
+
+Supports all 10 form factors with unique material effects:
+
+| Form Factor | Material Effect |
+|---|---|
+| `trading_card` | Holographic gradient + sparkle (intensity by rarity) |
+| `postcard` / `postcard_portrait` | Paper texture + subtle shadow |
+| `polaroid` | White border (thick bottom) + paper texture |
+| `laser_ticket` | Intense rainbow holographic + shimmer animation |
+| `badge_*` | Circular clip + metal frame + dome highlight |
+| `acrylic_stand_*` | Transparent glass + edge refraction + caustic |
 
-| Code | HTTP | Meaning | Recommended Action |
-|------|------|---------|--------------------|
-| `BAD_REQUEST` | 400 | Invalid input or insufficient balance | Check input values, show user-friendly message |
-| `UNAUTHORIZED` | 401 | Missing or invalid token | Redirect to login or refresh token |
-| `FORBIDDEN` | 403 | No permission (e.g., not the owner) | Show permission denied message |
-| `NOT_FOUND` | 404 | Resource doesn't exist | Show 404 page or fallback |
-| `CONFLICT` | 409 | Version conflict (optimistic locking) | Retry the operation |
+Interaction: desktop mouse tilt, mobile gyroscope (auto-detected), touch drag fallback, iOS permission prompt. React 18+ peer dependency. No CSS framework required.
+
+### Form Factor Utilities
+
+```ts
+import { FORM_FACTORS, getAspectRatioCSS, getFormFactorSpec } from "@goodz-core/sdk/ui";
+
+getAspectRatioCSS("trading_card");  // "5 / 7"
+getFormFactorSpec("polaroid");      // { key, label, aspectRatio: [3, 4], isCircle: false }
+```
 
 ## Subpath Imports
 
@@ -287,6 +471,10 @@ For tree-shaking, import from specific subpaths:
 import { createGoodZClient } from "@goodz-core/sdk/core";
 import { TokenManager } from "@goodz-core/sdk/auth";
 import { toHundredths } from "@goodz-core/sdk/zcoin";
+import { GoodZCardFocus } from "@goodz-core/sdk/ui";
+import { createCommerceNamespace } from "@goodz-core/sdk/commerce";
+import { createExchangeNamespace } from "@goodz-core/sdk/exchange";
+import { createAliveNamespace } from "@goodz-core/sdk/alive";
 ```
 
 The root import (`@goodz-core/sdk`) re-exports everything for convenience.