@maccesar/titools 2.0.7 → 2.2.1

package/skills/ti-expert/references/theming.md

@@ -0,0 +1,394 @@
+# Theming & Dark Mode
+
+## Alloy Theme System
+
+Alloy has a built-in theme system via the `app/themes/` folder. Themes override views, styles, and assets without modifying originals.
+
+### Theme Folder Structure
+
+```
+app/
+├── themes/
+│   ├── light/                   # Light theme (or default)
+│   │   ├── styles/
+│   │   │   └── app.tss          # Overrides app/styles/app.tss
+│   │   └── assets/
+│   │       └── images/
+│   │           └── logo.png     # Overrides app/assets/images/logo.png
+│   └── dark/                    # Dark theme
+│       ├── styles/
+│       │   └── app.tss          # Dark overrides
+│       └── assets/
+│           └── images/
+│               └── logo.png     # Dark version of logo
+├── styles/
+│   └── app.tss                  # Base styles (used when no theme active)
+├── config.json
+```
+
+### Activating a Theme
+
+Set the theme in `config.json`:
+
+```json
+{
+  "global": {
+    "theme": "light"
+  },
+  "env:development": {
+    "theme": "light"
+  }
+}
+```
+
+:::warning Theme is compile-time only
+Alloy themes are applied at **build time**. You cannot switch themes at runtime using this system alone. For runtime switching, use the Dynamic Theming approach below.
+:::
+
+### Theme Cascade
+
+When a theme is active, Alloy merges files in this order:
+1. `app/styles/app.tss` (base)
+2. `app/themes/<theme>/styles/app.tss` (theme override)
+3. `app/styles/<controller>.tss` (controller-specific)
+4. `app/themes/<theme>/styles/<controller>.tss` (theme + controller override)
+
+Theme files **merge** with base files — you only need to include properties you want to override.
+
+---
+
+## Dynamic Theming with Alloy.Globals
+
+For runtime theme switching (including Dark Mode), use `Alloy.Globals` as a centralized color palette.
+
+### Step 1: Define Color Palette
+
+```javascript
+// alloy.js
+const themes = {
+  light: {
+    bg: '#ffffff',
+    bgSecondary: '#f3f4f6',
+    text: '#111827',
+    textSecondary: '#6b7280',
+    primary: '#2563eb',
+    primaryText: '#ffffff',
+    border: '#e5e7eb',
+    card: '#ffffff',
+    danger: '#ef4444',
+    success: '#22c55e'
+  },
+  dark: {
+    bg: '#111827',
+    bgSecondary: '#1f2937',
+    text: '#f9fafb',
+    textSecondary: '#9ca3af',
+    primary: '#3b82f6',
+    primaryText: '#ffffff',
+    border: '#374151',
+    card: '#1f2937',
+    danger: '#f87171',
+    success: '#4ade80'
+  }
+}
+
+// Load saved preference or default to light
+const savedTheme = Ti.App.Properties.getString('app:theme', 'light')
+Alloy.Globals.theme = themes[savedTheme]
+Alloy.Globals.themeName = savedTheme
+```
+
+### Step 2: Use in TSS with Alloy.Globals
+
+```tss
+/* app.tss - Global base styles using theme colors */
+"Window": {
+  backgroundColor: Alloy.Globals.theme.bg
+}
+
+"Label": {
+  color: Alloy.Globals.theme.text
+}
+
+".card": {
+  backgroundColor: Alloy.Globals.theme.card,
+  borderWidth: 1,
+  borderColor: Alloy.Globals.theme.border,
+  borderRadius: 12
+}
+
+".btn-primary": {
+  backgroundColor: Alloy.Globals.theme.primary,
+  color: Alloy.Globals.theme.primaryText,
+  height: 48,
+  borderRadius: 8,
+  font: { fontWeight: 'bold' }
+}
+
+".text-secondary": {
+  color: Alloy.Globals.theme.textSecondary
+}
+
+".bg-secondary": {
+  backgroundColor: Alloy.Globals.theme.bgSecondary
+}
+```
+
+### Step 3: Theme Switching Service
+
+```javascript
+// lib/services/themeService.js
+const EventBus = require('services/eventBus')
+
+const themes = {
+  light: { /* ... same as alloy.js ... */ },
+  dark: { /* ... same as alloy.js ... */ }
+}
+
+exports.ThemeService = {
+  getCurrentTheme() {
+    return Alloy.Globals.themeName
+  },
+
+  setTheme(name) {
+    if (!themes[name]) return
+
+    Alloy.Globals.theme = themes[name]
+    Alloy.Globals.themeName = name
+    Ti.App.Properties.setString('app:theme', name)
+
+    // Notify all listeners
+    EventBus.trigger('theme:changed', { theme: name })
+  },
+
+  toggle() {
+    const next = Alloy.Globals.themeName === 'light' ? 'dark' : 'light'
+    this.setTheme(next)
+  },
+
+  // Follow system Dark Mode (iOS 13+, Android 10+)
+  followSystem() {
+    if (Ti.UI.semanticColorType !== undefined) {
+      const isDark = Ti.UI.semanticColorType === Ti.UI.SEMANTIC_COLOR_TYPE_DARK
+      this.setTheme(isDark ? 'dark' : 'light')
+    }
+  }
+}
+```
+
+### Step 4: Respond to Theme Changes in Controllers
+
+:::warning Theme change requires UI rebuild
+Since TSS is applied at controller creation time, changing `Alloy.Globals.theme` does NOT retroactively update already-rendered views. You must manually update visible elements or restart the root controller.
+:::
+
+**Approach A: Rebuild root controller (simplest)**
+
+```javascript
+// controllers/settings.js
+const { ThemeService } = require('services/themeService')
+
+function onToggleTheme() {
+  ThemeService.toggle()
+
+  // Restart app from root controller
+  const root = Alloy.createController('index')
+  root.getView().open()
+
+  // Close current window tree
+  $.getView().close()
+}
+```
+
+**Approach B: Update visible elements in-place (smoother)**
+
+```javascript
+// controllers/settings.js
+const EventBus = require('services/eventBus')
+const { ThemeService } = require('services/themeService')
+
+function init() {
+  EventBus.on('theme:changed', applyTheme)
+}
+
+function applyTheme() {
+  const t = Alloy.Globals.theme
+
+  $.settingsWindow.applyProperties({ backgroundColor: t.bg })
+  $.titleLabel.applyProperties({ color: t.text })
+  $.themeToggle.applyProperties({ backgroundColor: t.bgSecondary })
+}
+
+function onToggleTheme() {
+  ThemeService.toggle()
+}
+
+function cleanup() {
+  EventBus.off('theme:changed', applyTheme)
+  $.destroy()
+}
+
+$.cleanup = cleanup
+```
+
+---
+
+## System Dark Mode Detection
+
+### iOS 13+ / Android 10+
+
+```javascript
+// lib/services/themeService.js (add to existing service)
+
+exports.ThemeService = {
+  // ... existing methods ...
+
+  // Initialize system theme listener
+  initSystemListener() {
+    // Detect current system theme
+    this.followSystem()
+
+    // Listen for system theme changes
+    Ti.App.addEventListener('significantTimeChange', () => {
+      this.followSystem()
+    })
+
+    // iOS: userInterfaceStyle change
+    if (OS_IOS) {
+      Ti.App.addEventListener('traitCollectionChange', () => {
+        this.followSystem()
+      })
+    }
+  }
+}
+```
+
+### Semantic Colors (iOS)
+
+Titanium supports iOS semantic colors that automatically adapt to Dark Mode:
+
+```tss
+/* These colors automatically switch in Dark Mode */
+"#label": {
+  color: Ti.UI.fetchSemanticColor('label')
+}
+
+"#bg": {
+  backgroundColor: Ti.UI.fetchSemanticColor('systemBackground')
+}
+```
+
+Available semantic colors: `label`, `secondaryLabel`, `systemBackground`, `secondarySystemBackground`, `separator`, `systemFill`, etc.
+
+:::tip When to use Semantic Colors vs Alloy.Globals
+- **Semantic Colors**: Quick adaptation for iOS only. No Android support.
+- **Alloy.Globals palette**: Cross-platform, full control, consistent behavior on both platforms. **Recommended.**
+:::
+
+---
+
+## Reusable Style Classes Pattern
+
+Define a library of reusable TSS classes in `app.tss` for consistency across the app:
+
+```tss
+/* app.tss - Design System */
+
+/* === Layout === */
+".row": { layout: 'horizontal', width: Ti.UI.FILL, height: Ti.UI.SIZE }
+".col": { layout: 'vertical', width: Ti.UI.FILL, height: Ti.UI.SIZE }
+".centered": { width: Ti.UI.SIZE, height: Ti.UI.SIZE }
+
+/* === Cards === */
+".card": {
+  backgroundColor: Alloy.Globals.theme.card,
+  borderRadius: 12,
+  borderWidth: 1,
+  borderColor: Alloy.Globals.theme.border,
+  width: Ti.UI.FILL,
+  height: Ti.UI.SIZE
+}
+
+/* === Buttons === */
+".btn-primary": {
+  backgroundColor: Alloy.Globals.theme.primary,
+  color: Alloy.Globals.theme.primaryText,
+  height: 48,
+  width: Ti.UI.FILL,
+  borderRadius: 8,
+  font: { fontSize: 16, fontWeight: 'bold' }
+}
+
+".btn-secondary": {
+  backgroundColor: 'transparent',
+  color: Alloy.Globals.theme.primary,
+  height: 48,
+  width: Ti.UI.FILL,
+  borderRadius: 8,
+  borderWidth: 1,
+  borderColor: Alloy.Globals.theme.primary,
+  font: { fontSize: 16, fontWeight: 'bold' }
+}
+
+".btn-danger": {
+  backgroundColor: Alloy.Globals.theme.danger,
+  color: '#ffffff',
+  height: 48,
+  width: Ti.UI.FILL,
+  borderRadius: 8,
+  font: { fontSize: 16, fontWeight: 'bold' }
+}
+
+/* === Typography === */
+".text-title": { font: { fontSize: 24, fontWeight: 'bold' }, color: Alloy.Globals.theme.text }
+".text-subtitle": { font: { fontSize: 18, fontWeight: 'semibold' }, color: Alloy.Globals.theme.text }
+".text-body": { font: { fontSize: 16 }, color: Alloy.Globals.theme.text }
+".text-caption": { font: { fontSize: 14 }, color: Alloy.Globals.theme.textSecondary }
+".text-small": { font: { fontSize: 12 }, color: Alloy.Globals.theme.textSecondary }
+
+/* === Inputs === */
+".input": {
+  height: 48,
+  width: Ti.UI.FILL,
+  borderRadius: 8,
+  borderWidth: 1,
+  borderColor: Alloy.Globals.theme.border,
+  backgroundColor: Alloy.Globals.theme.bg,
+  color: Alloy.Globals.theme.text,
+  paddingLeft: 12,
+  font: { fontSize: 16 }
+}
+
+/* === Spacing (applied via class in XML) === */
+".mt-sm": { top: 8 }
+".mt-md": { top: 16 }
+".mt-lg": { top: 24 }
+".mt-xl": { top: 32 }
+".mx-md": { left: 16, right: 16 }
+".mx-lg": { left: 24, right: 24 }
+```
+
+### Using Style Classes in Views
+
+```xml
+<Alloy>
+  <Window>
+    <View class="col mx-md">
+      <Label class="text-title mt-lg" text="L('settings')" />
+
+      <View class="card mt-md">
+        <Label class="text-body mx-md mt-md" text="L('appearance')" />
+        <Button class="btn-secondary mx-md mt-md" title="L('toggle_theme')" onClick="onToggleTheme" />
+      </View>
+
+      <Button class="btn-danger mt-xl mx-md" title="L('logout')" onClick="onLogout" />
+    </View>
+  </Window>
+</Alloy>
+```
+
+This approach gives you:
+- Consistent spacing and typography across the entire app
+- Theme-aware colors that change with `Alloy.Globals.theme`
+- Clean XML views without inline styles
+- A single place to update design decisions (`app.tss`)

package/skills/ti-guides/SKILL.md

@@ -28,19 +28,6 @@ This skill automatically detects Titanium projects when invoked and provides SDK
 - **Not detected** → Indicates this is for Titanium projects only
 :::
 
-## Table of Contents
-
-- [Titanium SDK Guide Expert](#titanium-sdk-guide-expert)
-  - [Project Detection](#project-detection)
-  - [Table of Contents](#table-of-contents)
-  - [Core Workflow](#core-workflow)
-  - [Procedural Rules (Low Freedom)](#procedural-rules-low-freedom)
-  - [Reference Guides (Progressive Disclosure)](#reference-guides-progressive-disclosure)
-  - [Related Skills](#related-skills)
-  - [Response Format](#response-format)
-
----
-
 ## Core Workflow
 
 1.  **Architecture Check**: Validate that the project follows a modular pattern (CommonJS or Alloy).
@@ -82,7 +69,7 @@ For tasks beyond SDK fundamentals, use these complementary skills:
 
 | Task                                     | Use This Skill |
 | ---------------------------------------- | -------------- |
-| Project architecture, services, patterns | `alloy-expert` |
+| Project architecture, services, patterns | `ti-expert`    |
 | Native features (location, push, media)  | `ti-howtos`    |
 | Alloy CLI, configuration, debugging      | `alloy-howtos` |
 | UI layouts, ListViews, gestures          | `ti-ui`        |

package/skills/ti-guides/references/advanced-data-and-images.md

@@ -1,19 +1,135 @@
 # Advanced Database and Image Best Practices
 
 ## 1. SQLite Optimization
-- **Close Everything**: Always `resultSet.close()` and `db.close()` after each operation to avoid locks and memory bloat.
-- **Transactions**: Use `BEGIN` and `COMMIT` for batch inserts. It is significantly faster.
+
+- **Close Everything**: Always `resultSet.close()` and `db.close()` after each operation to avoid locks and memory bloat. SQLite enforces sequential write-access — if you don't close after `INSERT` or `UPDATE`, you may receive **DatabaseObjectNotClosed** exceptions on the next write attempt.
+- **Transactions**: Use `BEGIN` and `COMMIT` for batch inserts. It is significantly faster. Note: if any update within the transaction fails, the **entire batch is rolled back** (atomicity).
   ```javascript
+  const db = Ti.Database.open('myDatabase');
   db.execute('BEGIN');
-  // loop inserts
+  for (const item of playlist) {
+    db.execute('INSERT INTO albums (disc, artist, rating) VALUES (?, ?, ?)', item.disc, item.artist, item.rating);
+  }
   db.execute('COMMIT');
+  db.close();
   ```
-- **Database Skeleton**: Do not ship large pre-populated databases. Ship a "skeleton" and download data on first boot to reduce IPA/APK size.
+- **Database Skeleton**: Do not ship large pre-populated databases. Ship a "skeleton" and download data on first boot to reduce IPA/APK size. The `Resources` directory is read-only, so installing a database copies it to `applicationDataDirectory`, resulting in two copies on the device.
+  - **Android note**: In Android 2.2 and earlier, the installer could not uncompress assets over 1 MB. Workaround: rename the file with a `.mp3` extension to prevent `aapt` compression.
+
+### Database Version Management
+
+Store a version number in your database to detect which version is installed and take action (create tables, alter columns) on upgrades. If you lack a version table, use `PRAGMA TABLE_INFO` to detect column presence:
+
+```javascript
+const addColumn = (dbname, tblName, newFieldName, colSpec) => {
+  const db = Ti.Database.open(dbname);
+  let fieldExists = false;
+  const resultSet = db.execute(`PRAGMA TABLE_INFO(${tblName})`);
+  while (resultSet.isValidRow()) {
+    if (resultSet.field(1) === newFieldName) {
+      fieldExists = true;
+    }
+    resultSet.next();
+  }
+  resultSet.close();
+  if (!fieldExists) {
+    db.execute(`ALTER TABLE ${tblName} ADD COLUMN ${newFieldName} ${colSpec}`);
+  }
+  db.close();
+};
+```
+
+---
+
+## 2. Image Format Selection
+
+Choose the right format for each use case:
+
+| Format | Compression | Best For | Avoid For |
+| ------ | ----------- | -------- | --------- |
+| **PNG** | Lossless | Icons, text, line-art, buttons | Photos (file size) |
+| **JPG** | Lossy | Photographs | Text, icons, line drawings (artifacts) |
+| **GIF** | Lossless (256 colors) | Rarely appropriate | Almost everything — limited colors, proprietary, animated GIF not supported on all platforms |
 
-## 2. Image Memory Management
-- **Memory Footprint**: A JPG is tiny on disk but consumes `width * height * 3 bytes` in RAM.
+**For flip-book animations**: Use `ImageView.images` property with an array of PNG or optimized JPG files instead of animated GIFs.
+
+---
+
+## 3. Image Memory Management
+
+- **Memory Footprint**: A JPG is small on disk but consumes `width * height * 3 bytes` in RAM when decompressed. Each pixel uses 24 bits (8 bits per R/G/B channel).
+  - Example: `(640 × 480 × 3) / 1024 = 900 KB` in memory for a single image
+  - Device RAM available to your app can be as low as 12 MB, shared with your code and the Titanium framework
 - **Unloading**:
-  - `view.remove(imageView)` to help the OS free memory.
-  - Set `imageView = null` to release the native proxy.
-- **Resizing**: Always resize images to their display dimensions via `imageAsResized` before setting the `image` property.
-- **Caching**: iOS caches remote images automatically, but you should manually cache critical assets in `applicationDataDirectory` for predictability.
+  - `view.remove(imageView)` — removes from view hierarchy, helps OS free memory
+  - `imageView = null` — releases the native proxy object
+- **Resizing**: Always resize images to their display dimensions via `imageAsResized` or `imageAsCropped` (both on `Ti.Blob`) before setting the `image` property. Don't display a 1024×768 image on a 640×480 screen.
+- **Placeholder**: Set the `defaultImage` property on ImageView to show a local placeholder while a remote image downloads:
+  ```javascript
+  const imageView = Ti.UI.createImageView({
+    image: 'https://example.com/photo.jpg',
+    defaultImage: '/images/placeholder.png',
+    width: 300,
+    height: 200
+  });
+  ```
+
+---
+
+## 4. Image Optimization Tools
+
+Resize and compress images before including them in your app to minimize IPA/APK size and network usage.
+
+| Platform | File Types | Tool |
+| -------- | ---------- | ---- |
+| Mac | PNG, JPG, GIF | ImageOptim |
+| Mac, Windows, Linux | PNG, JPG, GIF | ImageMagick |
+| Windows/DOS | PNG | PNGCrush |
+| Windows | JPG | Nikkho |
+
+---
+
+## 5. Caching Remote Images
+
+Remote images are cached automatically on iOS, Android, and Windows.
+
+**Platform differences:**
+- **Android**: Cache limited to **25 MB**, persists for the lifetime of the app (while installed)
+- **iOS**: Cache size not predetermined (no guaranteed size), cleared by iOS when device needs storage
+
+To manually clean the cache, delete files in `applicationCacheDirectory`.
+
+**Android 6+ requirement**: Call `Ti.Filesystem.requestStoragePermissions()` before loading remote images (runtime permissions).
+
+### Manual Caching Utility
+
+For critical assets, cache manually in `applicationDataDirectory` for predictability:
+
+```javascript
+const CacheUtils = {
+  getExtension: (fn) => {
+    const match = /(?:\.([^.]+))?$/.exec(fn);
+    return match[1] || '';
+  },
+
+  createCachedImageView: (options) => {
+    const md5 = Ti.Utils.md5HexDigest(options.image) + CacheUtils.getExtension(options.image);
+    const savedFile = Ti.Filesystem.getFile(Ti.Filesystem.applicationDataDirectory, md5);
+
+    if (savedFile.exists()) {
+      options.image = savedFile;
+      return Ti.UI.createImageView(options);
+    }
+
+    const imageView = Ti.UI.createImageView(options);
+    const saveImage = () => {
+      imageView.removeEventListener('load', saveImage);
+      savedFile.write(
+        Ti.UI.createImageView({ image: imageView.image, width: Ti.UI.FILL, height: Ti.UI.FILL }).toImage()
+      );
+    };
+    imageView.addEventListener('load', saveImage);
+    return imageView;
+  }
+};
+```

package/skills/ti-guides/references/app-distribution.md

@@ -39,7 +39,7 @@ ti build -p android -T dist-playstore -K ~/android.keystore -P secret -L foo -O
 
 **Output files:**
 - `.apk` - Legacy format (still supported)
-- `.aab` - Android App Bundle (preferred, smaller downloads)
+- `.aab` - Android App Bundle (preferred, smaller downloads). Requires Titanium 9.0.0+. An AAB file cannot be installed directly on a device; it is a publishing format for Google Play only. Once uploaded, Google Play generates multiple device-specific APKs split by CPU architecture and image density, allowing smaller downloads.
 
 ### 4. Verify APK Signing
 
@@ -81,7 +81,7 @@ adb uninstall com.your.appid
 </android>
 ```
 
-- `versionCode`: Integer, must increment for each update
+- `versionCode`: Must be a 32-bit integer (whole number), must increment for each update. Cannot be a floating point number.
 - `versionName`: String, any format you prefer
 
 ### 7. SD Card Installation
@@ -100,13 +100,18 @@ Values: `preferExternal`, `auto`, `internalOnly`
 
 ### 1. Distribution Types
 
-- **App Store**: Public distribution via iTunes Store
-- **Ad Hoc**: Limited testing (max 100 devices)
+- **App Store**: Public distribution via App Store (formerly known as iTunes Connect, now App Store Connect)
+- **Ad Hoc**: Limited testing (max 100 devices per year; devices cannot be removed once registered, so use care when registering)
 - **In House**: Enterprise distribution for employees (Enterprise program only)
 
 ### 2. Create Distribution Certificate
 
-1. Log in to [Apple Developer Member Center](https://developer.apple.com/membercenter/)
+**Certificate types:**
+- **Development certificate**: Each developer on the team can have their own, used for building test versions.
+- **Distribution certificate**: A single certificate for the entire team. Only the Team Agent (the account owner who oversees final distribution) can create it. This ensures developers cannot publish the final app without authorization.
+
+**Steps:**
+1. Log in to [Apple Developer Member Center](https://developer.apple.com/membercenter/) as Team Agent or Admin
 2. Go to **Certificates, Identifiers & Profiles** > **Certificates**
 3. Click **+** > **App Store and Ad Hoc**
 4. Create a CSR (Certificate Signing Request) in Keychain Access
@@ -124,9 +129,11 @@ Values: `preferExternal`, `auto`, `internalOnly`
 6. Name profile (include "distribution" or "ad hoc")
 7. Download `.mobileprovision` and install (drag to Xcode icon)
 
-### 4. Create App ID on iTunes Connect
+### 4. Create App ID on App Store Connect
+
+App Store Connect (formerly iTunes Connect) is the app distribution management portal.
 
-1. Log in to [iTunes Connect](https://itunesconnect.apple.com)
+1. Log in to App Store Connect
 2. **Manage Your Apps** > **Add New App**
 3. Provide:
    - App name
@@ -172,11 +179,11 @@ ti build -p ios -T dist-appstore -R "Pseudo, Inc." -P "AAAAAAAA-0000-9999-8888-7
 
 The CLI installs the package to Xcode's Organizer.
 
-### 6. Upload to iTunes Connect
+### 6. Upload to App Store Connect
 
 1. Open Xcode > **Window** > **Organizer**
 2. Select your app archive
-3. Click **Verify** (validates against iTunes Connect app definition)
+3. Click **Verify** (validates against App Store Connect app definition)
 4. Click **Submit** (uploads app)
 5. Status changes to **Waiting for Review**
 
@@ -192,7 +199,38 @@ Testers need:
 3. Select device > **Installed Apps** > **+**
 4. Select IPA file
 
-### 8. App Store Requirements
+### 8. App Thinning (iOS)
+
+App Thinning optimizes your application by reducing its installed size on devices.
+
+**Slicing (Asset Catalog):**
+- Installs only the assets needed for the specific device (e.g., @2x images for non-Plus iPhones, @3x for Plus/Pro models)
+- When enabled, Titanium automatically adds all PNG and JPEG images to an Asset Catalog
+- Images with matching suffixes (@2x, @3x, etc.) are grouped into one imageset
+- **Important limitation**: When slicing is enabled, you cannot access images from the filesystem using `Ti.Filesystem` or path/URL-based access. Only use image names (without path) in ImageView and similar APIs.
+- Icons and launch images are always added to the Asset Catalog
+
+**Enable slicing in tiapp.xml:**
+```xml
+<ti:app>
+  <ios>
+    <use-app-thinning>true</use-app-thinning>
+  </ios>
+</ti:app>
+```
+
+By default, slicing is disabled.
+
+**Bitcode:**
+- Submits partially compiled code to App Store Connect, which then optimizes and compiles for specific architectures
+- Currently disabled in Titanium because all frameworks (including third-party modules) must have bitcode enabled
+
+**On-Demand Resources:**
+- Resources tagged into groups, stored on Apple servers, downloaded when needed by the app
+- iOS purges on-demand resources when device disk space is low
+- Titanium SDK does not currently provide a way to tag on-demand resources
+
+### 9. App Store Requirements
 
 Apple's guidelines include:
 - Apps must be useful, well-designed, and error-free