@series-inc/venus-sdk 2.4.1 → 3.0.0

package/README.md

@@ -17,21 +17,215 @@ The Venus SDK is built on a client-server RPC architecture:
 - **Mock Implementations** - Complete mock APIs for local development
 - **Venus API** - Low-level platform interface
 
-### Core Components
+### Usage
 
 ```typescript
-import { createHost, VenusAPI } from 'venus-sdk'
+import { default as VenusAPI } from '@series-inc/venus-sdk/api'
 
-// Create Venus API instance
-const venusApi = new VenusAPI()
-await venusApi.initializeAsync()
+// Initialize the API
+await VenusAPI.initializeAsync()
+```
+
+## API Overview
+
+### Profile API
+
+```typescript
+// Get current user profile (synchronous)
+const profile = VenusAPI.profile.getCurrentProfile()
+console.log(profile.name, profile.username)
+```
+---
+
+### Safe Area & HUD Insets
+
+```typescript
+// Static safe area from initialization (baseline padding)
+const safeArea = VenusAPI.config.ui.safeArea
+layout.style.paddingTop = `${safeArea.top}px`
+layout.style.paddingBottom = `${safeArea.bottom}px`
+
+// Dynamic HUD insets arrive with lifecycle events
+VenusAPI.lifecycle.onShow(({ hudInsets }) => {
+  applyInsets(hudInsets, 'preview')
+})
+
+VenusAPI.lifecycle.onPlay(({ hudInsets }) => {
+  applyInsets(hudInsets, 'fullscreen')
+})
+
+function applyInsets(insets, mode) {
+  // Use whichever inset is larger to avoid overlap with host UI
+  const top = Math.max(VenusAPI.config.ui.safeArea.top, insets.top)
+  canvas.style.paddingTop = `${top}px`
+  canvas.dataset.mode = mode
+}
+```
+
+`safeArea` provides a static baseline defined at initialization. `hudInsets` reflect the live host UI chrome and differ between preview (`onShow`) and fullscreen (`onPlay`) contexts.
+
+---
+
+### Ads API
+
+```typescript
+// Check if rewarded ad is ready
+const rewardedReady = await VenusAPI.ads.isRewardedAdReadyAsync()
 
-// Create Host (false = remote, true = mock)
-const host = createHost(venusApi, false)
-await host.initialize()
+// Show interstitial ad
+const interstitialShown = await VenusAPI.ads.showInterstitialAd()
+if (interstitialShown) {
+  // Interstitial ad was displayed
+}
+
+// Show rewarded video ad
+const rewardEarned = await VenusAPI.ads.showRewardedAdAsync()
+if (rewardEarned) {
+  // User watched the full video and earned reward
+}
 ```
+---
 
-## API Reference
+### Haptics API
+
+```typescript
+// Trigger haptic feedback
+await VenusAPI.haptics.triggerHapticAsync('success')
+await VenusAPI.haptics.triggerHapticAsync('warning')
+await VenusAPI.haptics.triggerHapticAsync('error')
+await VenusAPI.haptics.triggerHapticAsync('light')
+await VenusAPI.haptics.triggerHapticAsync('medium')
+await VenusAPI.haptics.triggerHapticAsync('heavy')
+```
+---
+
+### Local Notifications API
+
+```typescript
+  // Schedule a delayed notification (minimal - required params only)
+  const id = await VenusApi.notifications.scheduleAsync(
+    'Notification Title',
+    'Notification Body',
+    60 // Delay in seconds
+  )
+  
+  // Schedule with optional notification ID
+  const id = await VenusApi.notifications.scheduleAsync(
+    'Notification Title',
+    'Notification Body',
+    60,
+    'custom-notification-id'
+  )
+  
+  // Schedule with all optional settings
+  const id = await VenusApi.notifications.scheduleAsync(
+    'Notification Title',
+    'Notification Body',
+    60,
+    'custom-notification-id',
+    {
+      priority: 100,          // 0-100, default 50
+      groupId: 'reminders',   // Group related notifications
+      payload: { key: 'value' } // Custom data
+    }
+  )
+  
+  // Cancel a notification
+  await VenusApi.notifications.cancelNotification(notificationId)
+  
+  // Get all scheduled notifications
+  await VenusApi.notifications.getAllScheduledLocalNotifications()
+```
+---
+
+### Loader API
+
+The preloader is opt-in by default. In order to opt in, you must add 
+```typescript
+   await VenusAPI.initializeAsync({ usePreloader: true })
+```
+
+```typescript
+    // Activating and dismissing the preloader
+    await VenusApi.preloader.showLoadScreen()
+    await VenusApi.preloader.hideLoadScreen()
+```
+---
+
+### Custom Funnel Events API
+
+```typescript
+  // Record a custom analytics event
+  await VenusApi.analytics.recordCustomEvent('level_completed', {
+    level: 5,
+    score: 1250,
+    time: 45.2
+  })
+  
+  // Track funnel step with optional funnel name
+  await VenusApi.analytics.trackFunnelStep(1, 'tutorial_started', 'onboarding')
+  await VenusApi.analytics.trackFunnelStep(2, 'tutorial_completed', 'onboarding')
+```
+---
+
+### IAP API
+
+```typescript
+  // get VBucks/Hard Currency balance
+  await VenusApi.iap.getHardCurrencyBalance()
+  // Spend VBucks/Hard Currency
+  await VenusApi.iap.spendCurrency('yourProductID', 3)
+  // Open Venus Store
+  await VenusApi.iap.openStore()
+  // Get Currency Icon
+  await VenusApi.iap.getCurrencyIcon()
+```
+---
+
+### Saves API
+
+```typescript
+  // Get an item from storage
+  await VenusApi.storage.getItem('playerData')
+  // Set an item in storage
+  await VenusApi.storage.setItem('playerData', JSON.stringify({ level: 10 }))
+  // Remove an item from storage
+  await VenusApi.storage.removeItem('playerData')
+  // Get storage length
+  await VenusApi.storage.length()
+  // Get key at specific index
+  await VenusApi.storage.key(0)
+  // Clear all items from storage
+  await VenusApi.storage.clear()
+  // Set multiple items at once
+  await VenusApi.storage.setMultipleItems([
+    { key: 'playerData', value: JSON.stringify({ level: 10 }) },
+    { key: 'settings', value: JSON.stringify({ sound: true }) }
+  ])
+  // Remove multiple items at once
+  await VenusApi.storage.removeMultipleItems(['playerData', 'settings'])
+  // Get all items from storage
+  await VenusApi.storage.getAllItems()
+```
+---
+
+### LLM API
+
+```typescript
+  // Request chat completion from AI model
+  const response = await VenusApi.ai.requestChatCompletionAsync({
+    model: 'chatGPT',
+    messages: [
+      {
+        role: 'user',
+        content: 'What is the best strategy for this level?'
+      }
+    ]
+  })
+  
+  // Get available completion models
+  const models = await VenusApi.ai.getAvailableCompletionModels()
+```
 
 ### Simulation API
 
@@ -41,11 +235,11 @@ The Simulation API manages game state, recipe execution, and slot systems.
 
 ```typescript
 // Get current simulation state
-const state = await host.simulation.getStateAsync(roomId?)
+const state = await VenusAPI.simulation.getStateAsync(roomId?)
 // Returns: { entities, inventory, currencies, timers, etc. }
 
 // Get simulation configuration
-const config = await host.simulation.getConfigAsync(roomId?)
+const config = await VenusAPI.simulation.getConfigAsync(roomId?)
 ```
 
 #### Recipe Execution
@@ -54,51 +248,53 @@ Recipes are server-authoritative game actions (crafting, battles, upgrades, etc.
 
 ```typescript
 // Execute a recipe
-const result = await host.simulation.executeRecipeAsync(
+const result = await VenusAPI.simulation.executeRecipeAsync(
   'craft_sword',
   { materials: ['iron', 'wood'] },
   { skipNotification: false }
 )
 
 // Execute a scoped recipe (entity-specific)
-const result = await host.simulation.executeScopedRecipeAsync(
+const result = await VenusAPI.simulation.executeScopedRecipeAsync(
   'upgrade_weapon',
   'sword_123',
   { level: 5 }
 )
 
 // Get active recipe runs (for time-based recipes)
-const runs = await host.simulation.getActiveRunsAsync()
+const runs = await VenusAPI.simulation.getActiveRunsAsync()
 
 // Collect completed recipe
-const result = await host.simulation.collectRecipeAsync(runId)
+const result = await VenusAPI.simulation.collectRecipeAsync(runId)
 
 // Trigger recipe chain
-await host.simulation.triggerRecipeChainAsync('battle_complete')
+await VenusAPI.simulation.triggerRecipeChainAsync('battle_complete')
 ```
 
 #### Recipe Requirements
 
 ```typescript
 // Check requirements for a single recipe
-const requirements = await host.simulation.getRecipeRequirementsAsync({
-  recipeId: 'craft_sword',
-  entity: 'player',
-  amount: 1
-})
-// Returns: { canAfford, costs, rewards }
+const requirements = await VenusAPI.simulation.getRecipeRequirementsAsync(
+  'craft_sword',
+  'player',
+  1
+)
+// Returns: { recipeId, entity, amount?, inputs, canAfford, disabled }
 
 // Batch check multiple recipes
-const results = await host.simulation.getBatchRecipeRequirementsAsync([
-  { recipeId: 'craft_sword', amount: 1 },
-  { recipeId: 'craft_shield', amount: 2 }
+const results = await VenusAPI.simulation.getBatchRecipeRequirementsAsync([
+  { recipeId: 'craft_sword', batchAmount: 1 },
+  { recipeId: 'craft_shield', batchAmount: 2 }
 ])
+// Returns: { success, results, errors? }
 
 // Get available recipes
-const recipes = await host.simulation.getAvailableRecipesAsync({
+const recipes = await VenusAPI.simulation.getAvailableRecipesAsync({
   roomId: 'room_123',
   includeActorRecipes: true
 })
+// Returns: { success, recipes }
 ```
 
 #### Slot Management
@@ -107,24 +303,24 @@ Slots represent equipment, loadouts, teams, or any item container system:
 
 ```typescript
 // Get all slot containers
-const containers = await host.simulation.getSlotContainersAsync()
+const containers = await VenusAPI.simulation.getSlotContainersAsync()
 // Returns: [{ id: 'equipment', slots: [...] }, { id: 'team', slots: [...] }]
 
 // Get slot assignments for a container
-const assignments = await host.simulation.getSlotAssignmentsAsync('equipment')
+const assignments = await VenusAPI.simulation.getSlotAssignmentsAsync('equipment')
 // Returns: [{ slotId: 'weapon', itemId: 'sword_123' }, ...]
 
 // Assign item to slot
-await host.simulation.assignItemToSlotAsync('equipment', 'weapon', 'sword_123')
+await VenusAPI.simulation.assignItemToSlotAsync('equipment', 'weapon', 'sword_123')
 
 // Remove item from slot
-await host.simulation.removeItemFromSlotAsync('equipment', 'weapon')
+await VenusAPI.simulation.removeItemFromSlotAsync('equipment', 'weapon')
 
 // Get available items for a slot
-const items = await host.simulation.getAvailableItemsAsync('equipment', 'weapon')
+const items = await VenusAPI.simulation.getAvailableItemsAsync('equipment', 'weapon')
 
 // Preview power calculation before assignment
-const preview = await host.simulation.calculatePowerPreviewAsync(
+const preview = await VenusAPI.simulation.calculatePowerPreviewAsync(
   'equipment',
   'weapon',
   'sword_456'
@@ -132,7 +328,7 @@ const preview = await host.simulation.calculatePowerPreviewAsync(
 // Returns: { currentPower: 100, newPower: 150, delta: +50 }
 
 // Validate slot assignment
-const valid = await host.simulation.validateSlotAssignmentAsync(
+const valid = await VenusAPI.simulation.validateSlotAssignmentAsync(
   'equipment',
   'weapon',
   'shield_123' // Wrong type
@@ -140,7 +336,7 @@ const valid = await host.simulation.validateSlotAssignmentAsync(
 // Returns: { valid: false, reason: 'Type mismatch' }
 
 // Batch operations (atomic)
-await host.simulation.executeBatchOperationsAsync([
+await VenusAPI.simulation.executeBatchOperationsAsync([
   { type: 'assign', containerId: 'equipment', slotId: 'weapon', itemId: 'sword' },
   { type: 'assign', containerId: 'equipment', slotId: 'armor', itemId: 'plate' },
   { type: 'remove', containerId: 'equipment', slotId: 'boots' }
@@ -151,21 +347,22 @@ await host.simulation.executeBatchOperationsAsync([
 
 ```typescript
 // Resolve dynamic field values
-const value = await host.simulation.resolveFieldValueAsync(
+const value = await VenusAPI.simulation.resolveFieldValueAsync(
   'player_123',
   'stats.power',
   'player'
 )
 
 // Get entity metadata
-const metadata = await host.simulation.getEntityMetadataAsync('sword_123')
+const metadata = await VenusAPI.simulation.getEntityMetadataAsync('sword_123')
 ```
+---
 
 #### Utility Methods
 
 ```typescript
 // Sum stat contributions
-const totalPower = host.simulation.sumContributions(
+const totalPower = VenusAPI.simulation.sumContributions(
   [{ power: 10 }, { power: 20 }, { power: 15 }],
   'power'
 )
@@ -180,20 +377,20 @@ Three-tier storage system with different data scopes:
 
 ```typescript
 // Device Cache - persists across all apps for the device
-await host.deviceCache.set('lastUserId', '12345')
-const userId = await host.deviceCache.get('lastUserId')
+await VenusAPI.deviceCache.setItem('lastUserId', '12345')
+const userId = await VenusAPI.deviceCache.getItem('lastUserId')
 
 // App Storage - app-specific persistent storage
-await host.appStorage.set('highScore', 1000)
-await host.appStorage.set('playerData', { level: 5, gold: 1000 })
+await VenusAPI.appStorage.setItem('highScore', JSON.stringify(1000))
+await VenusAPI.appStorage.setItem('playerData', JSON.stringify({ level: 5, gold: 1000 }))
 
 // Global Storage - shared across all apps for the user
-await host.globalStorage.set('preferences', { theme: 'dark' })
+await VenusAPI.globalStorage.setItem('preferences', JSON.stringify({ theme: 'dark' }))
 
 // All storage APIs support:
-const value = await storage.get(key, defaultValue?)
-await storage.set(key, value)
-await storage.remove(key)
+const value = await storage.getItem(key)
+await storage.setItem(key, value)
+await storage.removeItem(key)
 await storage.clear()
 const count = await storage.length()
 const keyName = await storage.key(index)
@@ -201,47 +398,6 @@ const keyName = await storage.key(index)
 
 ---
 
-### Profile API
-
-```typescript
-// Get current user profile
-const profile = await host.profile.getCurrentProfile()
-// Returns: { id, name, username }
-```
-
----
-
-### Ads API
-
-```typescript
-// Check ad readiness
-const interstitialReady = await host.ads.isInterstitialReady()
-const rewardedReady = await host.ads.isRewardedReady()
-
-// Show interstitial ad
-await host.ads.showInterstitial()
-
-// Show rewarded video ad
-const watched = await host.ads.showRewarded()
-if (watched) {
-  // User watched the full video, grant reward
-}
-```
-
----
-
-### Haptics API
-
-Trigger haptic feedback on supported devices:
-
-```typescript
-// Available haptic types: 'light', 'medium', 'heavy', 'success', 'warning', 'error'
-await host.haptics.trigger('success')
-await host.haptics.trigger('warning')
-await host.haptics.trigger('heavy')
-```
-
----
 
 ### Popups API
 
@@ -249,41 +405,42 @@ Display native-style UI popups:
 
 ```typescript
 // Toast messages
-await host.popups.showToast('Game saved!', {
+await VenusAPI.popups.showToast('Game saved!', {
   duration: 3000,
   variant: 'success',
   action: { label: 'Undo' }
 })
 
 // Alert dialog
-await host.popups.showAlert({
-  title: 'Warning',
-  message: 'This action cannot be undone',
-  buttonText: 'OK'
-})
+await VenusAPI.popups.showAlert(
+  'Warning',
+  'This action cannot be undone',
+  { buttonText: 'OK' }
+)
 
 // Confirm dialog
-const confirmed = await host.popups.showConfirm({
-  title: 'Delete Item',
-  message: 'Are you sure you want to delete this item?',
-  confirmText: 'Delete',
-  cancelText: 'Cancel'
-})
+const confirmed = await VenusAPI.popups.showConfirm(
+  'Delete Item',
+  'Are you sure you want to delete this item?',
+  { confirmText: 'Delete', cancelText: 'Cancel' }
+)
 
 if (confirmed) {
   // User confirmed
 }
 
 // Action sheet
-const selected = await host.popups.showActionSheet({
-  title: 'Choose Action',
-  options: [
-    { id: 'edit', label: 'Edit', variant: 'default' },
-    { id: 'share', label: 'Share', variant: 'default' },
-    { id: 'delete', label: 'Delete', variant: 'destructive' }
+const selected = await VenusAPI.popups.showActionSheet(
+  [
+    { id: 'edit', label: 'Edit' },
+    { id: 'share', label: 'Share' },
+    { id: 'delete', label: 'Delete' }
   ],
-  cancelText: 'Cancel'
-})
+  {
+    title: 'Choose Action',
+    cancelButtonText: 'Cancel'
+  }
+)
 
 if (selected === 'delete') {
   // User selected delete
@@ -297,18 +454,17 @@ if (selected === 'delete') {
 Stack-based navigation system:
 
 ```typescript
-// Get current stack information
-const stack = await host.navigation.getStackInfo()
-// Returns: { depth, currentApp, history }
+// Get current stack information (synchronous)
+const stack = VenusAPI.navigation.getStackInfo()
+// Returns: { isInStack, stackPosition, isTopOfStack, stackDepth, parentInstanceId }
 
 // Push new app to stack
-await host.navigation.push({
-  appId: 'bird-flap',
-  context: { level: 5, difficulty: 'hard' }
+await VenusAPI.navigation.pushApp('bird-flap', {
+  contextData: { level: 5, difficulty: 'hard' }
 })
 
 // Pop from stack (returns to previous app)
-await host.navigation.pop()
+await VenusAPI.navigation.popApp()
 ```
 
 ---
@@ -319,48 +475,27 @@ Social interaction APIs for posts:
 
 ```typescript
 // Get post interaction data
-const interactions = await host.post.getInteractions()
-// Returns: { postId, isLiked, isFollowing, likeCount, commentCount }
+const postInfo = await VenusAPI.post.getPostInfo()
+// Returns: { isLiked, isFollowing, likesCount, commentsCount }
 
 // Toggle like
-await host.post.toggleLike()
+const likeResult = await VenusAPI.post.toggleLikeAsync()
+// Returns: { isLiked, likesCount, action: 'liked' | 'unliked' }
 
 // Toggle follow
-await host.post.toggleFollow()
+const followResult = await VenusAPI.post.toggleFollowAsync()
+// Returns: { isFollowing, action: 'followed' | 'unfollowed' }
 
 // Open comments UI
-await host.post.openComments()
+const commentsResult = await VenusAPI.post.openCommentsAsync()
+// Returns: { opened, commentsCount }
 
 // Share post
-await host.post.share({
+const shareResult = await VenusAPI.post.sharePostAsync({
   message: 'Check this out!',
-  recipientIds: ['user1', 'user2']
+  title: 'My Post'
 })
-```
-
----
-
-### AI API
-
-LLM integration for chat completions:
-
-```typescript
-// Get available models
-const models = await host.ai.getAvailableModels()
-// Returns: ['gpt-4', 'gpt-3.5-turbo', 'claude-3-opus', ...]
-
-// Chat completion
-const response = await host.ai.chatCompletion({
-  messages: [
-    { role: 'system', content: 'You are a helpful game assistant' },
-    { role: 'user', content: 'What is the best strategy for this level?' }
-  ],
-  model: 'gpt-4',
-  temperature: 0.7,
-  max_tokens: 500
-})
-
-console.log(response.choices[0].message.content)
+// Returns: { shared, platform, customMessage? }
 ```
 
 ---
@@ -369,14 +504,14 @@ console.log(response.choices[0].message.content)
 
 ```typescript
 // Log custom event
-await host.analytics.logEvent('level_complete', {
+await VenusAPI.analytics.logEvent('level_complete', {
   level: 5,
   score: 1000,
   timeElapsed: 120
 })
 
 // Set user properties
-await host.analytics.setUserProperty('vip_status', 'gold')
+await VenusAPI.analytics.setUserProperty('vip_status', 'gold')
 ```
 
 ---
@@ -384,27 +519,32 @@ await host.analytics.setUserProperty('vip_status', 'gold')
 ### Avatar 3D API
 
 ```typescript
-// Get current avatar configuration
-const avatar = await host.avatar3d.get()
+// Load current avatar configuration
+const avatar = await VenusAPI.avatar3d.loadAvatar()
+// Or load a specific avatar
+const avatarConfig = await VenusAPI.avatar3d.loadAvatar('avatar_123')
 
 // Show avatar editor
-const result = await host.avatar3d.showEditor({
-  allowSave: true,
-  enableSharing: true
+const result = await VenusAPI.avatar3d.showEditor({
+  currentAvatar: avatarConfig,
+  contextData: { source: 'settings' }
 })
 
-if (result.saved) {
-  console.log('Avatar updated:', result.avatarId)
+if (result.wasChanged && result.savedAvatarId) {
+  console.log('Avatar updated:', result.savedAvatarId)
 }
 
-// Delete avatar
-await host.avatar3d.delete()
+// Save avatar
+const avatarId = await VenusAPI.avatar3d.saveAvatar(avatarConfig)
 
-// Get shared avatar
-const sharedAvatar = await host.avatar3d.getSharedAvatar('avatar_123')
+// Delete avatar
+await VenusAPI.avatar3d.deleteAvatar()
 
 // Download avatar manifest
-const manifest = await host.avatar3d.downloadManifest('avatar_123')
+const manifest = await VenusAPI.avatar3d.downloadManifest()
+
+// Download asset paths
+const assetPaths = await VenusAPI.avatar3d.downloadAssetPaths()
 ```
 
 ---
@@ -415,17 +555,17 @@ Multi-user room management:
 
 ```typescript
 // Get current room
-const room = await host.rooms.getCurrentRoom()
+const room = await VenusAPI.rooms.getCurrentRoom()
 // Returns: { id, name, participants, metadata }
 
 // Join room
-await host.rooms.join('room_123')
+await VenusAPI.rooms.join('room_123')
 
 // Leave room
-await host.rooms.leave()
+await VenusAPI.rooms.leave()
 
 // Send room message
-await host.rooms.sendMessage({
+await VenusAPI.rooms.sendMessage({
   type: 'game_action',
   data: { action: 'move', x: 10, y: 20 }
 })
@@ -433,55 +573,34 @@ await host.rooms.sendMessage({
 
 ---
 
-### Notifications API
-
-Local push notifications:
-
-```typescript
-// Schedule notification
-await host.notifications.schedule({
-  id: 'energy_full',
-  title: 'Energy Restored!',
-  body: 'Your energy is now full. Come back to play!',
-  trigger: { type: 'time', seconds: 3600 } // 1 hour
-})
-
-// Cancel notification
-await host.notifications.cancel('energy_full')
-
-// Get all scheduled notifications
-const scheduled = await host.notifications.getAllScheduled()
-
-// Check if notifications are enabled
-const enabled = await host.notifications.isEnabled()
-
-// Enable/disable notifications
-await host.notifications.setEnabled(true)
-```
-
----
-
 ### Time API
 
 Server time synchronization and formatting:
 
 ```typescript
 // Get server time
-const serverTime = await host.time.getServerTime()
-// Returns: { timestamp, timezone, formatted }
+const serverTimeData = await VenusAPI.time.requestTimeAsync()
+// Returns: { serverTime, localTime, timezoneOffset, formattedTime, locale }
 
 // Format time with locale
-const formatted = host.time.format(Date.now(), {
+const formatted = VenusAPI.time.formatTime(Date.now(), {
   locale: 'en-US',
   format: 'full' // 'full', 'long', 'medium', 'short'
 })
 
 // Format number with locale
-const formatted = host.time.formatNumber(1234567.89, {
+const formattedNumber = VenusAPI.time.formatNumber(1234567.89, {
   locale: 'en-US',
   style: 'currency',
   currency: 'USD'
 })
+
+// Get future time
+const futureTime = await VenusAPI.time.getFutureTimeAsync({
+  days: 1,
+  hours: 2,
+  minutes: 30
+})
 ```
 
 ---
@@ -489,11 +608,17 @@ const formatted = host.time.formatNumber(1234567.89, {
 ### CDN API
 
 ```typescript
-// Get CDN URL for an asset
-const url = await host.cdn.getAssetUrl('images/logo.png')
+// Resolve asset URLs (synchronous)
+const assetUrl = VenusAPI.cdn.resolveAssetUrl('images/logo.png')
+const avatarUrl = VenusAPI.cdn.resolveAvatarAssetUrl('avatars/model.glb')
+const libUrl = VenusAPI.cdn.resolveSharedLibUrl('libs/helper.js')
+
+// Get CDN base URL
+const baseUrl = VenusAPI.cdn.getAssetCdnBaseUrl()
 
-// Upload to CDN
-const uploadUrl = await host.cdn.upload(file)
+// Fetch from CDN
+const response = await VenusAPI.cdn.fetchFromCdn('https://cdn.example.com/file.json')
+const blob = await VenusAPI.cdn.fetchBlob('path/to/asset.png')
 ```
 
 ---
@@ -503,78 +628,53 @@ const uploadUrl = await host.cdn.upload(file)
 Feature flags, experiments, and A/B testing:
 
 ```typescript
-// Get feature flag value
-const enabled = await host.features.getFeatureFlag('new_ui_enabled')
+// Get feature flag value (returns boolean)
+const enabled = await VenusAPI.features.getFeatureFlag('new_ui_enabled')
 
-// Get feature gate (boolean flag)
-const canAccess = await host.features.getFeatureGate('beta_features')
+// Get feature gate (returns boolean)
+const canAccess = await VenusAPI.features.getFeatureGate('beta_features')
 
 // Get experiment variant
-const experiment = await host.features.getExperiment('checkout_flow')
-// Returns: { variant: 'control' | 'variant_a' | 'variant_b', ... }
-```
-
----
-
-### IAP API
-
-In-app purchases and virtual currency:
-
-```typescript
-// Get wallet balance
-const wallet = await host.iap.getWallet()
-// Returns: { coins: 1000, gems: 50 }
-
-// Spend currency
-const result = await host.iap.spendCurrency('coins', 100)
-if (result.success) {
-  console.log('Purchase successful')
-}
-
-// Listen for wallet updates
-host.iap.onWalletUpdate((wallet) => {
-  console.log('Wallet updated:', wallet)
-})
+const experiment = await VenusAPI.features.getExperiment('checkout_flow')
+// Returns: { name, ruleID, value, groupName } | null
 ```
 
----
-
 ### Lifecycle API
 
 App lifecycle event handlers:
 
 ```typescript
 // Register lifecycle callbacks
-host.lifecycle.onReady(() => {
+VenusAPI.lifecycle.onReady(() => {
   console.log('App ready')
 })
 
-host.lifecycle.onShow((context) => {
+VenusAPI.lifecycle.onShow((context) => {
   console.log('App shown', context.hudInsets)
 })
 
-host.lifecycle.onPlay((context) => {
+VenusAPI.lifecycle.onPlay((context) => {
   console.log('App playing', context.hudInsets)
 })
 
-host.lifecycle.onPause(() => {
+VenusAPI.lifecycle.onPause(() => {
   console.log('App paused')
 })
 
-host.lifecycle.onResume(() => {
+VenusAPI.lifecycle.onResume(() => {
   console.log('App resumed')
 })
 
-host.lifecycle.onHidden(() => {
+VenusAPI.lifecycle.onHidden(() => {
   console.log('App hidden')
 })
 
-host.lifecycle.onQuit(() => {
+VenusAPI.lifecycle.onQuit(() => {
   console.log('App quitting')
 })
 
 // Quit the app
-await host.lifecycle.quit()
+await VenusAPI.lifecycle.quit()
 ```
 
 ---
@@ -583,9 +683,9 @@ await host.lifecycle.quit()
 
 ```typescript
 // Log messages
-host.logging.log('Info message', { data: 'value' })
-host.logging.error('Error message', error)
-host.logging.debug('Debug info')
+VenusAPI.logging.log('Info message', { data: 'value' })
+VenusAPI.logging.error('Error message', error)
+VenusAPI.logging.debug('Debug info')
 ```
 
 ---
@@ -595,22 +695,18 @@ host.logging.debug('Debug info')
 All APIs have complete mock implementations for local development:
 
 ```typescript
-import { createHost, VenusAPI } from 'venus-sdk'
-
-const venusApi = new VenusAPI()
-await venusApi.initializeAsync({ mock: true })
+import { default as VenusAPI } from '@series-inc/venus-sdk/api'
 
-const host = createHost(venusApi, true) // true = mock mode
-await host.initialize()
+await VenusAPI.initializeAsync({ mock: true })
 
 // All APIs work the same, but with simulated responses
-const state = await host.simulation.getStateAsync()
+const state = await VenusAPI.simulation.getStateAsync()
 ```
 
 ### Custom Mock Data
 
 ```typescript
-await venusApi.initializeAsync({
+await VenusAPI.initializeAsync({
   mock: {
     simulation: {
       state: { customData: 'value' }