@series-inc/venus-sdk 2.4.1 → 2.6.2

package/README.md

@@ -17,21 +17,203 @@ 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
+const profile = await VenusAPI.profile.getCurrentProfile()
+console.log(profile.name, profile.username)
+```
+---
 
-// Create Host (false = remote, true = mock)
-const host = createHost(venusApi, false)
-await host.initialize()
+### 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
+}
 ```
 
-## API Reference
+`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()
+
+// 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
+}
+```
+---
+
+### Haptics API
+
+```typescript
+// Trigger haptic feedback
+await VenusAPI.haptics.trigger('success')
+await VenusAPI.haptics.trigger('warning')
+await VenusApi.haptics.trigger('light')
+await VenusApi.haptics.trigger('medium')
+await VenusAPI.haptics.trigger('heavy')
+
+```
+---
+
+### Local Notifications API
+
+```typescript
+  // Schedule a delayed notification
+  const id = await VenusApi.notifications.scheduleAsync({
+    title: 'Notification Title',
+    body: 'Notification Body',
+    trigger: {
+      type: 'timeInterval',
+      seconds: 60 // Delay in seconds (required)
+    },
+  })
+  
+  // 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({
+    productId: 'yourProductID',
+    amount: '3',
+    options?: {
+      screenname: 'yourScreenName'
+    },
+  })
+  // 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 +223,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,34 +236,34 @@ 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({
+const requirements = await VenusAPI.simulation.getRecipeRequirementsAsync({
   recipeId: 'craft_sword',
   entity: 'player',
   amount: 1
@@ -89,13 +271,13 @@ const requirements = await host.simulation.getRecipeRequirementsAsync({
 // Returns: { canAfford, costs, rewards }
 
 // Batch check multiple recipes
-const results = await host.simulation.getBatchRecipeRequirementsAsync([
+const results = await VenusAPI.simulation.getBatchRecipeRequirementsAsync([
   { recipeId: 'craft_sword', amount: 1 },
   { recipeId: 'craft_shield', amount: 2 }
 ])
 
 // Get available recipes
-const recipes = await host.simulation.getAvailableRecipesAsync({
+const recipes = await VenusAPI.simulation.getAvailableRecipesAsync({
   roomId: 'room_123',
   includeActorRecipes: true
 })
@@ -107,24 +289,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 +314,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 +322,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 +333,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,15 +363,15 @@ 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.set('lastUserId', '12345')
+const userId = await VenusAPI.deviceCache.get('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.set('highScore', 1000)
+await VenusAPI.appStorage.set('playerData', { level: 5, gold: 1000 })
 
 // Global Storage - shared across all apps for the user
-await host.globalStorage.set('preferences', { theme: 'dark' })
+await VenusAPI.globalStorage.set('preferences', { theme: 'dark' })
 
 // All storage APIs support:
 const value = await storage.get(key, defaultValue?)
@@ -201,47 +384,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,21 +391,21 @@ 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({
+await VenusAPI.popups.showAlert({
   title: 'Warning',
   message: 'This action cannot be undone',
   buttonText: 'OK'
 })
 
 // Confirm dialog
-const confirmed = await host.popups.showConfirm({
+const confirmed = await VenusAPI.popups.showConfirm({
   title: 'Delete Item',
   message: 'Are you sure you want to delete this item?',
   confirmText: 'Delete',
@@ -275,7 +417,7 @@ if (confirmed) {
 }
 
 // Action sheet
-const selected = await host.popups.showActionSheet({
+const selected = await VenusAPI.popups.showActionSheet({
   title: 'Choose Action',
   options: [
     { id: 'edit', label: 'Edit', variant: 'default' },
@@ -298,17 +440,17 @@ Stack-based navigation system:
 
 ```typescript
 // Get current stack information
-const stack = await host.navigation.getStackInfo()
+const stack = await VenusAPI.navigation.getStackInfo()
 // Returns: { depth, currentApp, history }
 
 // Push new app to stack
-await host.navigation.push({
+await VenusAPI.navigation.push({
   appId: 'bird-flap',
   context: { level: 5, difficulty: 'hard' }
 })
 
 // Pop from stack (returns to previous app)
-await host.navigation.pop()
+await VenusAPI.navigation.pop()
 ```
 
 ---
@@ -319,20 +461,20 @@ Social interaction APIs for posts:
 
 ```typescript
 // Get post interaction data
-const interactions = await host.post.getInteractions()
+const interactions = await VenusAPI.post.getInteractions()
 // Returns: { postId, isLiked, isFollowing, likeCount, commentCount }
 
 // Toggle like
-await host.post.toggleLike()
+await VenusAPI.post.toggleLike()
 
 // Toggle follow
-await host.post.toggleFollow()
+await VenusAPI.post.toggleFollow()
 
 // Open comments UI
-await host.post.openComments()
+await VenusAPI.post.openComments()
 
 // Share post
-await host.post.share({
+await VenusAPI.post.share({
   message: 'Check this out!',
   recipientIds: ['user1', 'user2']
 })
@@ -340,43 +482,18 @@ await host.post.share({
 
 ---
 
-### 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)
-```
-
----
-
 ### Analytics API
 
 ```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')
 ```
 
 ---
@@ -385,10 +502,10 @@ await host.analytics.setUserProperty('vip_status', 'gold')
 
 ```typescript
 // Get current avatar configuration
-const avatar = await host.avatar3d.get()
+const avatar = await VenusAPI.avatar3d.get()
 
 // Show avatar editor
-const result = await host.avatar3d.showEditor({
+const result = await VenusAPI.avatar3d.showEditor({
   allowSave: true,
   enableSharing: true
 })
@@ -398,13 +515,13 @@ if (result.saved) {
 }
 
 // Delete avatar
-await host.avatar3d.delete()
+await VenusAPI.avatar3d.delete()
 
 // Get shared avatar
-const sharedAvatar = await host.avatar3d.getSharedAvatar('avatar_123')
+const sharedAvatar = await VenusAPI.avatar3d.getSharedAvatar('avatar_123')
 
 // Download avatar manifest
-const manifest = await host.avatar3d.downloadManifest('avatar_123')
+const manifest = await VenusAPI.avatar3d.downloadManifest('avatar_123')
 ```
 
 ---
@@ -415,17 +532,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,51 +550,23 @@ 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()
+const serverTime = await VenusAPI.time.getServerTime()
 // Returns: { timestamp, timezone, formatted }
 
 // Format time with locale
-const formatted = host.time.format(Date.now(), {
+const formatted = VenusAPI.time.format(Date.now(), {
   locale: 'en-US',
   format: 'full' // 'full', 'long', 'medium', 'short'
 })
 
 // Format number with locale
-const formatted = host.time.formatNumber(1234567.89, {
+const formatted = VenusAPI.time.formatNumber(1234567.89, {
   locale: 'en-US',
   style: 'currency',
   currency: 'USD'
@@ -490,10 +579,10 @@ const formatted = host.time.formatNumber(1234567.89, {
 
 ```typescript
 // Get CDN URL for an asset
-const url = await host.cdn.getAssetUrl('images/logo.png')
+const url = await VenusAPI.cdn.getAssetUrl('images/logo.png')
 
 // Upload to CDN
-const uploadUrl = await host.cdn.upload(file)
+const uploadUrl = await VenusAPI.cdn.upload(file)
 ```
 
 ---
@@ -504,77 +593,52 @@ Feature flags, experiments, and A/B testing:
 
 ```typescript
 // Get feature flag value
-const enabled = await host.features.getFeatureFlag('new_ui_enabled')
+const enabled = await VenusAPI.features.getFeatureFlag('new_ui_enabled')
 
 // Get feature gate (boolean flag)
-const canAccess = await host.features.getFeatureGate('beta_features')
+const canAccess = await VenusAPI.features.getFeatureGate('beta_features')
 
 // Get experiment variant
-const experiment = await host.features.getExperiment('checkout_flow')
+const experiment = await VenusAPI.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)
-})
-```
-
----
-
 ### 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 +647,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 +659,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' }