@maccesar/titools 4.0.0 → 4.3.0

package/skills/ti-api/references/api-ui-extras.md

@@ -1,5 +1,24 @@
 # Ti.UI Extras API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.Animation](#tiuianimation)
+- [Ti.UI.Matrix2D](#tiuimatrix2d)
+- [Ti.UI.Matrix3D](#tiuimatrix3d)
+- [Ti.UI.WebView](#tiuiwebview)
+- [Ti.UI.Toolbar](#tiuitoolbar)
+- [Ti.UI.ButtonBar](#tiuibuttonbar)
+- [Ti.UI.TabbedBar](#tiuitabbedbar)
+- [Ti.UI.OptionBar](#tiuioptionbar)
+- [Ti.UI.Shortcut](#tiuishortcut)
+- [Ti.UI.ShortcutItem](#tiuishortcutitem)
+- [Ti.UI.EmailDialog](#tiuiemaildialog)
+- [Ti.UI.DashboardView](#tiuidashboardview)
+- [Ti.UI.DashboardItem](#tiuidashboarditem)
+
+<!-- TOC-END -->
+
 ## Ti.UI.Animation
 > The `Animation` object defines an animation that can be applied to a view.
 > Extends Ti.Proxy
@@ -523,7 +542,6 @@ Google documents how to add static shortcuts
 [here](https://developer.android.com/guide/topics/ui/shortcuts/creating-shortcuts#static).
 
 In the `tiapp.xml` file, you will need to add a shortcuts `<meta-data/>` element to your main activity.
-``` xml
 
 ### Properties (unique: 6/9)
 | Property | Type | Default | Platform | Description |

package/skills/ti-api/references/api-ui-ios-animator.md

@@ -1,5 +1,19 @@
 # Ti.UI.iOS Animator & Physics API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.iOS.AnchorAttachmentBehavior](#tiuiiosanchorattachmentbehavior)
+- [Ti.UI.iOS.Animator](#tiuiiosanimator)
+- [Ti.UI.iOS.CollisionBehavior](#tiuiioscollisionbehavior)
+- [Ti.UI.iOS.DynamicItemBehavior](#tiuiiosdynamicitembehavior)
+- [Ti.UI.iOS.GravityBehavior](#tiuiiosgravitybehavior)
+- [Ti.UI.iOS.PushBehavior](#tiuiiospushbehavior)
+- [Ti.UI.iOS.SnapBehavior](#tiuiiossnapbehavior)
+- [Ti.UI.iOS.ViewAttachmentBehavior](#tiuiiosviewattachmentbehavior)
+
+<!-- TOC-END -->
+
 ## Ti.UI.iOS.AnchorAttachmentBehavior
 > Dynamic behavior to support connections between an anchor point and an item.
 > Extends Ti.Proxy

package/skills/ti-api/references/api-ui-ios.md

@@ -1,5 +1,47 @@
 # Ti.UI.iOS API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.iOS](#tiuiios)
+- [Ti.UI.iOS.AlertDialogStyle](#tiuiiosalertdialogstyle)
+- [Ti.UI.iOS.AnimationStyle](#tiuiiosanimationstyle)
+- [Ti.UI.iOS.ApplicationShortcuts](#tiuiiosapplicationshortcuts)
+- [Ti.UI.iOS.BlurView](#tiuiiosblurview)
+- [Ti.UI.iOS.ButtonConfiguration](#tiuiiosbuttonconfiguration)
+- [Ti.UI.iOS.CoverFlowView](#tiuiioscoverflowview)
+- [Ti.UI.iOS.DocumentViewer](#tiuiiosdocumentviewer)
+- [Ti.UI.iOS.FeedbackGenerator](#tiuiiosfeedbackgenerator)
+- [Ti.UI.iOS.ListViewCellSelectionStyle](#tiuiioslistviewcellselectionstyle)
+- [Ti.UI.iOS.ListViewScrollPosition](#tiuiioslistviewscrollposition)
+- [Ti.UI.iOS.ListViewStyle](#tiuiioslistviewstyle)
+- [Ti.UI.iOS.LivePhoto](#tiuiioslivephoto)
+- [Ti.UI.iOS.LivePhotoView](#tiuiioslivephotoview)
+- [Ti.UI.iOS.MenuPopup](#tiuiiosmenupopup)
+- [Ti.UI.iOS.NavigationWindow](#tiuiiosnavigationwindow)
+- [Ti.UI.iOS.PreviewAction](#tiuiiospreviewaction)
+- [Ti.UI.iOS.PreviewActionGroup](#tiuiiospreviewactiongroup)
+- [Ti.UI.iOS.PreviewContext](#tiuiiospreviewcontext)
+- [Ti.UI.iOS.ProgressBarStyle](#tiuiiosprogressbarstyle)
+- [Ti.UI.iOS.RowAnimationStyle](#tiuiiosrowanimationstyle)
+- [Ti.UI.iOS.ScrollIndicatorStyle](#tiuiiosscrollindicatorstyle)
+- [Ti.UI.iOS.SplitWindow](#tiuiiossplitwindow)
+- [Ti.UI.iOS.StatusBar](#tiuiiosstatusbar)
+- [Ti.UI.iOS.Stepper](#tiuiiosstepper)
+- [Ti.UI.iOS.SystemButton](#tiuiiossystembutton)
+- [Ti.UI.iOS.SystemIcon](#tiuiiossystemicon)
+- [Ti.UI.iOS.TabbedBar](#tiuiiostabbedbar)
+- [Ti.UI.iOS.TableViewCellSelectionStyle](#tiuiiostableviewcellselectionstyle)
+- [Ti.UI.iOS.TableViewScrollPosition](#tiuiiostableviewscrollposition)
+- [Ti.UI.iOS.TableViewStyle](#tiuiiostableviewstyle)
+- [Ti.UI.iOS.Toolbar](#tiuiiostoolbar)
+- [Ti.UI.iOS.TransitionAnimation](#tiuiiostransitionanimation)
+- [Ti.UI.iOS.WebViewConfiguration](#tiuiioswebviewconfiguration)
+- [Ti.UI.iOS.WebViewDecisionHandler](#tiuiioswebviewdecisionhandler)
+- [Ti.UI.iOS.WebViewProcessPool](#tiuiioswebviewprocesspool)
+
+<!-- TOC-END -->
+
 ## Ti.UI.iOS
 > Apple iOS specific UI capabilities.  All properties, methods and events in this namespace will only work on Apple iOS devices.
 > Extends Ti.Module

package/skills/ti-api/references/api-ui-lists.md

@@ -1,5 +1,19 @@
 # Ti.UI Lists & Tables API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.ListView](#tiuilistview)
+- [Ti.UI.ListItem](#tiuilistitem)
+- [Ti.UI.ListSection](#tiuilistsection)
+- [Ti.UI.ListViewScrollPosition](#tiuilistviewscrollposition)
+- [Ti.UI.TableView](#tiuitableview)
+- [Ti.UI.TableViewRow](#tiuitableviewrow)
+- [Ti.UI.TableViewSection](#tiuitableviewsection)
+- [Ti.UI.TableViewScrollPosition](#tiuitableviewscrollposition)
+
+<!-- TOC-END -->
+
 ## Ti.UI.ListView
 > A list view is used to present information, organized in to sections and items, in a vertically-scrolling view.
 > Extends Ti.UI.View
@@ -15,7 +29,6 @@ A `ListView` object is a container for [ListSection](Titanium.UI.ListSection)
 objects that are, in turn, containers for [ListItem](Titanium.UI.ListItem) objects. This is
 easily visualized as an Alloy view:
 
-``` xml
 
 ### Properties (unique: 54/122)
 | Property | Type | Default | Platform | Description |
@@ -155,7 +168,6 @@ Alloy applications can use **`<ListItem>`** elements to create `ListItem` object
 must be nested inside a **`<ListSection>`** element, which itself is nested in a `<ListView>` element,
 as shown below:
 
-``` xml
 
 ### Properties (unique: 26/28)
 | Property | Type | Default | Platform | Description |

package/skills/ti-api/references/api-ui-text-input.md

@@ -1,5 +1,20 @@
 # Ti.UI Text & Input API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.TextField](#tiuitextfield)
+- [Ti.UI.TextArea](#tiuitextarea)
+- [Ti.UI.SearchBar](#tiuisearchbar)
+- [Ti.UI.AttributedString](#tiuiattributedstring)
+- [Ti.UI.Color](#tiuicolor)
+- [Ti.UI.Clipboard](#tiuiclipboard)
+- [Ti.UI.Picker](#tiuipicker)
+- [Ti.UI.PickerColumn](#tiuipickercolumn)
+- [Ti.UI.PickerRow](#tiuipickerrow)
+
+<!-- TOC-END -->
+
 ## Ti.UI.TextField
 > A single line text field.
 > Extends Ti.UI.View

package/skills/ti-api/references/api-ui-views.md

@@ -1,5 +1,24 @@
 # Ti.UI Core Views API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.View](#tiuiview)
+- [Ti.UI.Label](#tiuilabel)
+- [Ti.UI.Button](#tiuibutton)
+- [Ti.UI.ImageView](#tiuiimageview)
+- [Ti.UI.ScrollView](#tiuiscrollview)
+- [Ti.UI.ScrollableView](#tiuiscrollableview)
+- [Ti.UI.ActivityIndicator](#tiuiactivityindicator)
+- [Ti.UI.ActivityIndicatorStyle](#tiuiactivityindicatorstyle)
+- [Ti.UI.ProgressBar](#tiuiprogressbar)
+- [Ti.UI.Slider](#tiuislider)
+- [Ti.UI.Switch](#tiuiswitch)
+- [Ti.UI.MaskedImage](#tiuimaskedimage)
+- [Ti.UI.RefreshControl](#tiuirefreshcontrol)
+
+<!-- TOC-END -->
+
 ## Ti.UI.View
 > An empty drawing surface or container
 > Extends Ti.Proxy

package/skills/ti-api/references/api-ui-windows-navigation.md

@@ -1,5 +1,18 @@
 # Ti.UI Windows & Navigation API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.UI.Window](#tiuiwindow)
+- [Ti.UI.NavigationWindow](#tiuinavigationwindow)
+- [Ti.UI.TabGroup](#tiuitabgroup)
+- [Ti.UI.Tab](#tiuitab)
+- [Ti.UI.AlertDialog](#tiuialertdialog)
+- [Ti.UI.OptionDialog](#tiuioptiondialog)
+- [Ti.UI.Notification](#tiuinotification)
+
+<!-- TOC-END -->
+
 ## Ti.UI.Window
 > The Window is an empty drawing surface or container.
 > Extends Ti.UI.View

package/skills/ti-api/references/api-xml-global.md

@@ -1,5 +1,36 @@
 # Ti.XML & Global API Reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Ti.XML](#tixml)
+- [Ti.XML.Attr](#tixmlattr)
+- [Ti.XML.CDATASection](#tixmlcdatasection)
+- [Ti.XML.CharacterData](#tixmlcharacterdata)
+- [Ti.XML.Comment](#tixmlcomment)
+- [Ti.XML.DOMImplementation](#tixmldomimplementation)
+- [Ti.XML.Document](#tixmldocument)
+- [Ti.XML.DocumentFragment](#tixmldocumentfragment)
+- [Ti.XML.DocumentType](#tixmldocumenttype)
+- [Ti.XML.Element](#tixmlelement)
+- [Ti.XML.Entity](#tixmlentity)
+- [Ti.XML.EntityReference](#tixmlentityreference)
+- [Ti.XML.NamedNodeMap](#tixmlnamednodemap)
+- [Ti.XML.Node](#tixmlnode)
+- [Ti.XML.NodeList](#tixmlnodelist)
+- [Ti.XML.Notation](#tixmlnotation)
+- [Ti.XML.ProcessingInstruction](#tixmlprocessinginstruction)
+- [Ti.XML.Text](#tixmltext)
+- [Global](#global)
+- [Global.Console](#globalconsole)
+- [Global.Intl](#globalintl)
+- [Global.Intl.Collator](#globalintlcollator)
+- [Global.Intl.DateTimeFormat](#globalintldatetimeformat)
+- [Global.Intl.NumberFormat](#globalintlnumberformat)
+- [Global.String](#globalstring)
+
+<!-- TOC-END -->
+
 ## Ti.XML
 > The top level XML module.  The XML module is used for parsing and processing XML-based content.
 > Extends Ti.Module

package/skills/ti-expert/SKILL.md

@@ -149,7 +149,7 @@ For the complete reference with examples, see [Alloy builtins and globals](refer
 - [Contracts & Communication](references/contracts.md)
 - [State Management](references/state-management.md)
 - [Anti-patterns to Avoid](references/anti-patterns.md)
-- [Adaptive Layouts](references/adaptive-layouts.md) (responsive breakpoints, tablet/foldable/desktop support, Android 17 resizability compliance)
+- [Adaptive Layouts](references/adaptive-layouts.md) (responsive breakpoints, tablet/foldable/desktop support, Android 16/17 resizability compliance, orientation locks and which Android activities they must cover)
 
 ### Implementation & API
 - [Alloy Builtins & Globals](references/alloy-builtins.md)

package/skills/ti-expert/references/adaptive-layouts.md

@@ -4,6 +4,20 @@ Patterns for building responsive Titanium apps that work across phones, tablets,
 
 This reference is NOT derived from official Titanium documentation. It addresses Google's Android 17 resizability requirements and provides reusable patterns for adaptive UI in Titanium/Alloy apps.
 
+<!-- TOC-START -->
+## Contents
+
+- [1. Context: Android 17 resizability requirements](#1-context-android-17-resizability-requirements)
+- [2. Detecting window size](#2-detecting-window-size)
+- [3. Layout strategy](#3-layout-strategy)
+- [4. Controller pattern](#4-controller-pattern)
+- [5. Grid simulation](#5-grid-simulation)
+- [6. Anti-patterns](#6-anti-patterns)
+- [7. tiapp.xml configuration](#7-tiappxml-configuration)
+- [8. Quick reference](#8-quick-reference)
+
+<!-- TOC-END -->
+
 ## 1. Context: Android 17 resizability requirements
 
 Starting with Android 17 (API 37), on devices with screens >= 600dp (tablets, foldables, desktop mode), Google ignores these manifest attributes:
@@ -19,6 +33,26 @@ Scope: Only affects screens >= 600dp. Phones (< 600dp) and games (`android:appCa
 
 What this means: portrait-only apps will be forced into landscape/resized on large screens. If the UI doesn't support it, it will break.
 
+### It already started in Android 16 (API 36)
+
+This is usually described as an API 37 change, but it lands one release earlier: an app
+targeting **API 36** already has `android:screenOrientation` ignored on >= 600dp displays
+running Android 16. The difference is that API 36 still ships an opt-out:
+
+```xml
+<!-- inside <application>, or on an individual <activity> -->
+<property
+  android:name="android.window.PROPERTY_COMPAT_ALLOW_RESTRICTED_RESIZABILITY"
+  android:value="true"/>
+```
+
+The opt-out stops working the moment you target API 37, so treat it as a bridge while the
+layout is made adaptive — not as a fix. Source: [Android 16 behavior changes](https://developer.android.com/about/versions/16/behavior-changes-16).
+
+Worth knowing when debugging: this only kicks in at >= 600dp. If a **phone** is rotating
+despite a portrait lock, the cause is in the app, not in Android — see the orientation
+debugging recipe in section 7.
+
 ### Related: edge-to-edge (API 36)
 
 Before the resizability requirement (API 37), Android SDK 36 removes the opt-out for edge-to-edge rendering, causing Titanium layouts to overlap system navigation bars. The Titanium core team has a PR to handle this at the SDK level: tidev/titanium-sdk#14399 — adds an `EdgeToEdgeHelper` with correct padding so existing apps work without code changes.
@@ -343,6 +377,24 @@ const dpWidth = $.win.size.width / density  // WRONG: halves the value
 Ti.Gesture.isPortrait()   // TypeError!
 Ti.Gesture.portrait       // correct — boolean property
 
+// ❌ Setting orientation imperatively — silently overrides the manifest
+$.win.activity.requestedOrientation = Ti.Android.SCREEN_ORIENTATION_PORTRAIT
+// The manifest value is applied in onCreate; this runs afterwards and always wins.
+// Nothing in tiapp.xml can beat it, which makes it invisible when debugging.
+// Declare `orientationModes` on the window instead (see section 7).
+
+// ❌ Detecting tablets with a pixel threshold
+Math.min(displayCaps.platformWidth, displayCaps.platformHeight) >= 600
+// platformWidth returns PIXELS on Android. A 720x1604 @xhdpi phone is 360dp wide,
+// but 720 >= 600 reports "tablet". Use Alloy.isTablet / the formFactor query, which
+// read Ti.Platform.Android.physicalSizeCategory instead of raw pixels.
+
+// ❌ Passing an empty orientationModes array to mean "no preference"
+orientationModes: []
+// An empty array maps to SCREEN_ORIENTATION_SENSOR (TiWindowProxy.setOrientationModes),
+// so it doesn't clear the setting — it actively unlocks rotation, overriding the manifest.
+// To leave orientation alone, don't set the property at all.
+
 // ❌ Using gap property — does NOT exist in Titanium
 { layout: 'horizontal', gap: 10 }
 
@@ -373,7 +425,129 @@ Titanium generates the main activity name as `<app-id>.<Appname>Activity`. For e
 </android>
 ```
 
-To verify the exact generated activity name, check `build/android/AndroidManifest.xml` after a build.
+To verify the exact generated activity name, check `build/android/app/src/main/AndroidManifest.xml` after a build.
+
+### Which activities a lock has to cover
+
+`android:screenOrientation` is per-activity — it is not inherited from `<application>`. Every
+window the app opens runs inside one of a small, fixed set of activities declared by the
+Titanium AAR, so read the canonical list from the SDK instead of memorising it:
+
+```bash
+cat ~/.gradle/caches/*/transforms/*/transformed/jetified-titanium-*/AndroidManifest.xml
+```
+
+As of 13.4.0 there are exactly six, and `android:name` takes the fully-qualified form:
+
+```
+org.appcelerator.titanium.TiActivity
+org.appcelerator.titanium.TiTranslucentActivity
+ti.modules.titanium.media.TiCameraActivity
+ti.modules.titanium.media.TiCameraXActivity
+ti.modules.titanium.media.TiVideoActivity
+ti.modules.titanium.ui.android.TiPreferencesActivity
+```
+
+The seventh is the app's own root activity, generated from the `<name>` in tiapp.xml (see the
+derivation rule above). Which one hosts what:
+
+| What the app does | Activity |
+|---|---|
+| `Window.open()`, Tab, TabGroup, NavigationWindow | `org.appcelerator.titanium.TiActivity` |
+| Window with `modal:true`, `opacity`, or a `backgroundColor` with alpha < 255 | `org.appcelerator.titanium.TiTranslucentActivity` |
+| `showCamera({ overlay })` | `ti.modules.titanium.media.TiCameraActivity` (`TiCameraXActivity` when `useCameraX:true`) |
+| `showCamera()` with no overlay | none of yours — Titanium launches the system camera app |
+| VideoPlayer added to a regular Window | `org.appcelerator.titanium.TiActivity` |
+
+Two things are better left undeclared:
+
+- **`android:configChanges`.** The CLI strips it before the merge even happens — `_build.js`
+  keeps a list of the `TiBaseActivity`-derived activities and calls
+  `removeActivityAttribute(name, 'android:configChanges')` on each, with the reason spelled out
+  in the source: *"Most devs don't set this right, causing UI to disappear when a config change
+  occurs for a missing setting."* So a hand-written subset is not dangerous, just dead weight —
+  Titanium's full list always wins.
+- **A lock on `TiTranslucentActivity`.** Android 8–11 throws `IllegalStateException` ("Only
+  fullscreen opaque activities can request orientation") when a translucent activity requests a
+  fixed orientation. Declaring `orientationModes` on those windows is safer: the SDK applies it
+  inside a try/catch (`TiWindowProxy.setOrientationModes`), so the worst case is a modal that
+  rotates instead of an app that crashes.
+
+### Prefer orientationModes over the manifest
+
+`orientationModes` is defined on `TiWindowProxy`, so the same declaration works on `Window`,
+`TabGroup` and `NavigationWindow`. Being per-window it also composes with form-factor queries,
+which is what you usually want:
+
+```xml
+<!-- PurgeTSS -->
+<TabGroup class="handheld:portrait tablet:landscape">
+```
+
+```tss
+/* plain TSS equivalent */
+'#tabs[formFactor=handheld]': { orientationModes: [ Ti.UI.PORTRAIT ] }
+```
+
+Alloy resolves `formFactor` from `Ti.Platform.Android.physicalSizeCategory`, which is why this
+is more reliable than any width comparison you could write yourself.
+
+Keep the manifest for what Alloy cannot reach: the root activity, which shows the splash before
+any JS runs, and optionally `TiActivity` as a blanket fallback for windows that carry no class.
+
+A single Ti Element rule covers every window in the app without touching a single view, which
+is usually all an Alloy app needs:
+
+```javascript
+// purgetss/config.cjs
+module.exports = {
+  theme: { extend: {} },
+  'Window': { handheld: { apply: 'portrait' } }
+}
+```
+
+```tss
+/* generated — applies to every Window, including modal ones */
+'Window[formFactor=handheld]': { orientationModes: [ Ti.UI.PORTRAIT ] }
+```
+
+Note it matches `Window` only, so a `TabGroup` still needs its own class. And because the
+declaration is per-window, it does nothing for the splash — that one stays in the manifest.
+
+### Debugging a rotation that shouldn't happen
+
+Ask the system for the effective value instead of re-reading the manifest:
+
+```bash
+adb shell dumpsys activity activities | grep -E "topResumedActivity|requestedOrientation"
+```
+
+If `requestedOrientation` disagrees with what tiapp.xml declares, something overrode it at
+runtime — grep the app for `requestedOrientation` and `orientationModes` before touching the
+manifest again. Note that an *existing* `orientationModes` can be the bug rather than the fix:
+an empty array unlocks rotation (see the anti-patterns above).
+
+Before blaming the OS, let the SDK tell you. Titanium logs a warning when Android drops the
+request on a large screen, so this either hits or rules that cause out immediately:
+
+```bash
+adb logcat | grep "Orientation request will be ignored"
+# Fixed orientation is not supported on large screens (smallest width: <N>dp).
+# Orientation request will be ignored on Android 16+.
+```
+
+And to see the size bucket the device actually reports — `normal` means a phone, so the >= 600dp
+rule does not apply and the cause is in the app:
+
+```bash
+adb shell am get-config    # e.g. ...-sw360dp-w360dp-h802dp-normal-...
+```
+
+To confirm what actually shipped in the binary:
+
+```bash
+aapt2 dump xmltree --file AndroidManifest.xml <apk> | grep -A2 "E: activity"
+```
 
 ### iOS: support all orientations on iPad
 
@@ -405,6 +579,9 @@ To verify the exact generated activity name, check `build/android/AndroidManifes
 | Device screen size | `Ti.Platform.displayCaps.platformWidth` — pixels on Android, needs `/logicalDensityFactor` |
 | Orientation (boolean) | `Ti.Gesture.portrait`, `Ti.Gesture.landscape` — properties, not methods |
 | Orientation event | `Ti.Gesture.addEventListener('orientationchange', handler)` |
+| Lock orientation | `orientationModes` on the window — not `activity.requestedOrientation` |
+| Tablet detection | `Alloy.isTablet` / `[formFactor=tablet]` — never a pixel threshold |
+| Effective orientation at runtime | `adb shell dumpsys activity activities \| grep requestedOrientation` |
 | Window resize event | `$.win.addEventListener('postlayout', handler)` — fires on rotation, split-screen, resize |
 | Auto-size | `Ti.UI.SIZE` (fit content), `Ti.UI.FILL` (fill remaining) |
 | Percentages | `width: '50%'` relative to parent |

package/skills/ti-expert/references/alloy-builtins.md

@@ -1,5 +1,20 @@
 # Alloy builtins & globals
 
+<!-- TOC-START -->
+## Contents
+
+- [Compiler directives](#compiler-directives)
+- [Alloy.Globals](#alloyglobals)
+- [Alloy.CFG](#alloycfg)
+- [Alloy.isTablet / Alloy.isHandheld](#alloyistablet-alloyishandheld)
+- [$.args , controller arguments](#args-controller-arguments)
+- [Alloy.createController / Alloy.createWidget](#alloycreatecontroller-alloycreatewidget)
+- [Alloy.createModel / Alloy.createCollection](#alloycreatemodel-alloycreatecollection)
+- [Conditional code in XML](#conditional-code-in-xml)
+- [Quick reference](#quick-reference)
+
+<!-- TOC-END -->
+
 ## Compiler directives
 
 Alloy provides compile-time constants that are replaced with `true`/`false` during build. Use them for platform-specific code without runtime cost.

package/skills/ti-expert/references/alloy-structure.md

@@ -1,5 +1,20 @@
 # Alloy MVC structure reference
 
+<!-- TOC-START -->
+## Contents
+
+- [Standard project structure](#standard-project-structure)
+- [Organization strategy](#organization-strategy)
+- [lib/ folder and module require paths](#lib-folder-and-module-require-paths)
+- [Data layer: two approaches](#data-layer-two-approaches)
+- [Controller rules](#controller-rules)
+- [Navigation & cleanup pattern](#navigation-cleanup-pattern)
+- [i18n and accessibility rules](#i18n-and-accessibility-rules)
+- [Widget structure](#widget-structure)
+- [config.json reference](#configjson-reference)
+
+<!-- TOC-END -->
+
 ## Standard project structure
 
 ```

package/skills/ti-expert/references/code-conventions.md

@@ -1,5 +1,24 @@
 # TSS styling & code conventions
 
+<!-- TOC-START -->
+## Contents
+
+- [Module system: CommonJS (NOT ES6 modules)](#module-system-commonjs-not-es6-modules)
+- [ES6+ features (Non-Module)](#es6-features-non-module)
+- [No semicolons](#no-semicolons)
+- [Styling with TSS](#styling-with-tss)
+- [Platform & device modifiers](#platform-device-modifiers)
+- [applyProperties() pattern](#applyproperties-pattern)
+- [ListView templates](#listview-templates)
+- [Memory cleanup](#memory-cleanup)
+- [i18n and accessibility (a11y)](#i18n-and-accessibility-a11y)
+- [Percentage-based layouts](#percentage-based-layouts)
+- [Naming conventions](#naming-conventions)
+- [Import/Export patterns](#importexport-patterns)
+- [Async/Promise patterns](#asyncpromise-patterns)
+
+<!-- TOC-END -->
+
 ## Module system: CommonJS (NOT ES6 modules)
 
 Titanium uses **CommonJS** for modules. Do NOT use ES6 `import`/`export`:

package/skills/ti-expert/references/controller-patterns.md

@@ -1,5 +1,23 @@
 # Alloy controller patterns
 
+<!-- TOC-START -->
+## Contents
+
+- [Titanium layout rules](#titanium-layout-rules)
+- [Animation usage](#animation-usage)
+- [Dynamic styling](#dynamic-styling)
+- [Percentage-based layouts](#percentage-based-layouts)
+- [Controller lifecycle patterns](#controller-lifecycle-patterns)
+- [Form handling patterns](#form-handling-patterns)
+- [Loading state patterns](#loading-state-patterns)
+- [Modal and dialog patterns](#modal-and-dialog-patterns)
+- [Tabgroup pattern](#tabgroup-pattern)
+- [Navigationwindow pattern (iOS)](#navigationwindow-pattern-ios)
+- [Searchbar with ListView](#searchbar-with-listview)
+- [Pull-to-refresh pattern](#pull-to-refresh-pattern)
+
+<!-- TOC-END -->
+
 ## Titanium layout rules
 
 - Use `layout: 'horizontal'` for left-to-right

package/skills/ti-expert/references/error-handling.md

@@ -1,5 +1,21 @@
 # Error handling & logging guide
 
+<!-- TOC-START -->
+## Contents
+
+- [Apperror classes](#apperror-classes)
+- [Logger service](#logger-service)
+- [Error handler service](#error-handler-service)
+- [Using the logger](#using-the-logger)
+- [API client error handling](#api-client-error-handling)
+- [Controller error handling pattern](#controller-error-handling-pattern)
+- [Global error handler](#global-error-handler)
+- [Crash reporting integration](#crash-reporting-integration)
+- [Validation helper](#validation-helper)
+- [Logging best practices](#logging-best-practices)
+
+<!-- TOC-END -->
+
 ## Apperror classes
 
 ```javascript

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

@@ -1,5 +1,22 @@
 # Alloy implementation examples
 
+<!-- TOC-START -->
+## Contents
+
+- [API client service](#api-client-service)
+- [Native module wrapper service](#native-module-wrapper-service)
+- [i18n helper](#i18n-helper)
+- [Model with SQL adapter](#model-with-sql-adapter)
+- [Fully styled & accessible view](#fully-styled-accessible-view)
+- [Cleanup pattern in controller](#cleanup-pattern-in-controller)
+- [Animation usage](#animation-usage)
+- [Complete crud example](#complete-crud-example)
+- [ListView with search and filter](#listview-with-search-and-filter)
+- [Form with validation example](#form-with-validation-example)
+- [Tab-based navigation example](#tab-based-navigation-example)
+
+<!-- TOC-END -->
+
 ## API client service
 Standard logic for network requests.
 

package/skills/ti-expert/references/migration-patterns.md

@@ -1,5 +1,20 @@
 # Migration patterns for legacy Titanium apps
 
+<!-- TOC-START -->
+## Contents
+
+- [Assessment checklist](#assessment-checklist)
+- [Phase 1: TSS organization](#phase-1-tss-organization)
+- [Phase 2: service layer extraction](#phase-2-service-layer-extraction)
+- [Phase 3: event system migration](#phase-3-event-system-migration)
+- [Phase 4: navigation service](#phase-4-navigation-service)
+- [Phase 5: state management](#phase-5-state-management)
+- [Migration order](#migration-order)
+- [Rollback strategy](#rollback-strategy)
+- [Common migration pitfalls](#common-migration-pitfalls)
+
+<!-- TOC-END -->
+
 ## Assessment checklist
 
 Before migrating, evaluate the current codebase:

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

@@ -1,5 +1,20 @@
 # Architectural patterns for Titanium + Alloy
 
+<!-- TOC-START -->
+## Contents
+
+- [1. Native module abstraction (Wrapper)](#1-native-module-abstraction-wrapper)
+- [2. Repository pattern for data](#2-repository-pattern-for-data)
+- [3. Service layer pattern](#3-service-layer-pattern)
+- [4. Event bus for decoupling](#4-event-bus-for-decoupling)
+- [5. Factory pattern for dynamic views](#5-factory-pattern-for-dynamic-views)
+- [6. Navigation service pattern](#6-navigation-service-pattern)
+- [7. Collection binding pattern](#7-collection-binding-pattern)
+- [8. Cleanup pattern](#8-cleanup-pattern)
+- [9. Singleton service pattern](#9-singleton-service-pattern)
+
+<!-- TOC-END -->
+
 ## 1. Native module abstraction (Wrapper)
 
 **Use when:** Using native modules like Maps, Biometrics, or specialized Media players.
@@ -446,3 +461,4 @@ class AnalyticsService {
 }
 
 exports.Analytics = new AnalyticsService()
+```

package/skills/ti-expert/references/performance-optimization.md

@@ -1,5 +1,22 @@
 # Performance optimization: bridge, memory, animation & timing
 
+<!-- TOC-START -->
+## Contents
+
+- [Bridge optimization](#bridge-optimization)
+- [Memory management](#memory-management)
+- [Image memory management](#image-memory-management)
+- [Lazy loading pattern](#lazy-loading-pattern)
+- [Database performance](#database-performance)
+- [Performance monitoring](#performance-monitoring)
+- [Animation performance](#animation-performance)
+- [Hardware-accelerated properties](#hardware-accelerated-properties)
+- [Animation cleanup](#animation-cleanup)
+- [Debouncing and throttling](#debouncing-and-throttling)
+- [Performance checklist](#performance-checklist)
+
+<!-- TOC-END -->
+
 ## Bridge optimization
 
 ### Minimize bridge crossings