WIP: rename sample app to Folio (#20)

* refactor: rename examples/sample-app to examples/folio

Directory-level rename and path references in Go tests, bundle-check,
top-level README, and getting-started docs. Package declarations,
Gradle config, iOS bundle IDs, and class names follow in later commits.

* refactor(folio): rename Kotlin package dev.uatu.sample to app.folio

Moves source dirs and sqldelight schema from dev/uatu/sample to
app/folio, updates package declarations and imports, and switches
Android namespace/applicationId, iOS binaryOption bundleId, and
sqldelight database packageName to the new identifier.

* refactor(folio): rename SampleApplication to FolioApplication

Android manifest now points at .FolioApplication with label 'Folio'
instead of 'Uatu Sample'.

* refactor(folio): set iOS bundle id and display name to Folio

bundleIdPrefix + PRODUCT_BUNDLE_IDENTIFIER -> app.folio.
CFBundleName + CFBundleDisplayName -> 'Folio'.

* refactor(folio): update demo email to [email protected]

* refactor(folio): point justfile at app.folio bundle id

Updates xcrun simctl launch target, uatu test --bundle-id, and the
build/uninstall comments to reference folio instead of sample.

* test: update fixture package ids to app.folio

Sidecar activity-resolver test and verifier spec-integration XML
fixtures referenced the old dev.uatu.sample Android package. Updates
them to match the folio app's real package id so the tests stay
representative of what the CLI sees on-device.

* test(verifier): rename SampleApp identifiers to Folio

Renames TestSampleAppSpec* functions, bundleSampleAppSpec helper, and
sampleAppHierarchyXML const (now loginHierarchyXML for consistency with
the other per-screen fixtures). Updates trailing sample-app mentions in
comments and assertion messages.

* refactor(folio): rename Gradle/npm/wasm project identifiers to folio

settings.gradle.kts rootProject.name, package.json + package-lock.json
name, and the WasmJS index.html <title> all still read 'uatu-sample' /
'Uatu Sample'. Realigns them with the Folio brand.

* docs(folio): rewrite README title + getting-started bundle id

examples/folio/README.md is now titled 'Folio' with the Kotlin source
paths corrected to app/folio. Getting-started example uses --bundle-id
app.folio. Harness launch message is now generic ('app under test')
since uatu-sample-harness is not specific to folio.

* chore(folio): drop trailing 'sample' reference in gradle.properties

* refactor(folio): rename LoginPage composable to LoginScreen

Align with KMP/Android industry convention (NowInAndroid, Cash App,
JetBrains samples use Screen, not Page).

* refactor(folio): rename HomePage composable to HomeScreen

* refactor(folio): rename AddAccountPage composable to AddAccountScreen

* refactor(folio): rename LedgerPage composable to LedgerScreen

* refactor(folio): rename AddTransactionPage composable to AddTransactionScreen

* refactor(folio): split Models.kt into app.folio.data package

Account, Transaction (with TxnType), and Session move into their own
files under app.folio.data, matching NowInAndroid-style per-type
organization.

* refactor(folio): move data layer into app.folio.data package

Repository, LedgerStore (expect + interface), SqlLedgerStore,
WebLedgerStore, DriverFactory (expect + actuals), AndroidLedgerContext,
and Snapshot move into app.folio.data. Update all consumer imports.

* refactor(folio): move Navigation into app.folio.navigation package

Split the former Navigation.kt into Route.kt (sealed interface) and
Navigator.kt (singleton). Update consumer imports across screens,
App.kt, and FolioApplication.

* refactor(folio): move Platform and Format into app.folio.platform

Both files carry expect declarations (Platform object, formatDate);
grouping them into a dedicated platform package makes the KMP seam
obvious and mirrors the structure used by JetBrains samples.

* refactor(folio): move login into feature/auth package

Create app.folio.feature.auth with LoginScreen + LoginUiState. Inline
the former Auth.kt (DEMO_EMAIL, DEMO_PASSWORD, checkCredentials) into
LoginScreen since it is the sole caller.

* refactor(folio): move HomeScreen into feature/home package

* refactor(folio): move account creation into feature/account package

AddAccountScreen gets its own AddAccountUiState colocated with the
screen, replacing the shared UiState.addAccountError.

* refactor(folio): move ledger screens into feature/ledger package

LedgerScreen and AddTransactionScreen move into app.folio.feature.ledger
with AddTransactionUiState (txnError, txnFormType) colocated. The
former catch-all UiState.kt is removed now that each screen owns its
state alongside its UI.

* refactor(folio): split Theme.kt; move theme and icons to subpackages

Theme split into Theme.kt (tokens, layout dims, LedgerTheme) and
Type.kt (typography) under app.folio.ui.theme. Icons moves to
app.folio.ui.icon. Update every consumer's imports to match.

* refactor(folio): split ui components into per-file under ui/component

Former Widgets.kt and Components.kt become 10 focused files: AppButton,
Card, EmptyState, ErrorText, FieldLabel, Header, IconButton (w/
BackButton), Screen, Segmented, TextInput. Matches NowInAndroid style
of one composable per file in a designsystem/component package.

* chore(folio): consolidate uatu testing files under uatu/ folder

Move spec.ts, package.json, package-lock.json into examples/folio/uatu
so all uatu-specific testing artifacts live in one place. runs/ and
node_modules/ follow the same convention (both remain gitignored).
Update justfile, README, and the two Go consumers (bundle-check tool +
verifier/trace tests) that referenced the old path.

* refactor(trace): drop folio path in writer test

Round-trip only needs a non-empty string; neutralize to keep the
library free of folio references.

* refactor(sidecar): neutralize ResolveActivity test fixtures

Swap app.folio for com.example.app in the fixture strings so the
sidecar tests don't reference the example app by name.

* refactor(bundle-check): take spec path as argument

Previously the tool hardcoded examples/folio/uatu/spec.ts. Accept a
positional spec path instead so the tool works for any example and
leaves no folio reference in the library surface.

* test(verifier): add neutral integration spec and hierarchy fixtures

Adds testdata/integration_spec.ts with two routes ("list", "form"),
an InputText on text_field, a Tap on primary/secondary_action, a
safety property (itemCountNonNegative), and a liveness property
(submitEventually). Adds hierarchies_test.go with matching XML
fixtures. Constants intentionally go in a _test.go at package root
rather than testdata/hierarchies.go because go skips .go files
under testdata/.

* refactor(verifier): replace folio integration tests with neutral ones

Renames bundleFolioSpec -> bundleIntegrationSpec and the three Test*
entry points to TestIntegrationSpec*. Uses the synthetic spec and
hierarchies added in the previous commit so the library's test suite
no longer references examples/folio at all.

Folio-specific coverage remains covered by examples/folio/justfile's
'just test' which exercises the real spec on device/emulator.

* chore: remove cmd/uatu-sample-harness

Not referenced by Makefile, docs, CI, or any script. Duplicates the
adb reverse helpers already in cmd/uatu/test_run.go, and its name
implies ownership by the sample app which violates the library/
example decoupling. If a bare-protocol debugging tool is later
needed it belongs inside cmd/uatu/.

* docs(folio): drop Layout section and KMP layout paragraph; fix AVD override syntax

The directory-tree Layout section rots faster than the code and
duplicates what ls shows for free. The expect/actual paragraph in
Stack was the same kind of filler. The README also claimed 'just
AVD=Pixel_7 test' but the justfile reads AVD as an env var via
env_var_or_default, so the correct invocation is 'AVD=Pixel_7
just test'.

examples/folio/composeApp/src/androidMain/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:name=".FolioApplication"
+        android:label="Folio"
+        android:allowBackup="false"
+        android:theme="@android:style/Theme.Material.Light.NoActionBar">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:configChanges="orientation|screenSize|screenLayout|keyboardHidden|uiMode|fontScale">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

examples/folio/composeApp/src/androidMain/kotlin/app/folio/FolioApplication.kt

@@ -0,0 +1,93 @@
+package app.folio
+
+import android.app.Application
+import app.folio.data.AndroidLedgerContext
+import app.folio.data.Repository
+import app.folio.data.TxnType
+import app.folio.feature.account.AddAccountUiState
+import app.folio.feature.auth.LoginUiState
+import app.folio.feature.ledger.AddTransactionUiState
+import app.folio.navigation.Navigator
+import app.folio.navigation.Route
+import app.folio.platform.balanceOf
+import app.folio.platform.signedAmount
+import dev.uatu.sdk.Uatu
+
+class FolioApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        AndroidLedgerContext.context = applicationContext
+        Repository.init()
+        Uatu.start(this)
+        Uatu.extract("logged_in") { Repository.session.value != null }
+        Uatu.extract("account_count") { Repository.accounts.value.size }
+        Uatu.extract("total_balance") { balanceOf(Repository.transactions.value) }
+        Uatu.extract("route") {
+            when (Navigator.current.value) {
+                Route.Login -> "login"
+                Route.Home -> "home"
+                Route.AddAccount -> "add-account"
+                is Route.Ledger -> "ledger"
+                is Route.AddTransaction -> "add-transaction"
+            }
+        }
+        Uatu.extract("auth_status") {
+            if (Repository.session.value != null) "logged-in" else "logged-out"
+        }
+        Uatu.extract("accounts") {
+            val txns = Repository.transactions.value
+            Repository.accounts.value.map { a ->
+                val rows = txns.filter { it.accountId == a.id }
+                mapOf(
+                    "id" to a.id,
+                    "name" to a.name,
+                    "balance" to balanceOf(rows),
+                    "txnCount" to rows.size,
+                )
+            }
+        }
+        Uatu.extract("active_account_id") {
+            when (val r = Navigator.current.value) {
+                is Route.Ledger -> r.accountId
+                is Route.AddTransaction -> r.accountId
+                else -> null
+            }
+        }
+        Uatu.extract("ledger_rows") {
+            val active = when (val r = Navigator.current.value) {
+                is Route.Ledger -> r.accountId
+                is Route.AddTransaction -> r.accountId
+                else -> null
+            }
+            if (active == null) emptyList()
+            else Repository.transactions.value
+                .filter { it.accountId == active }
+                .map {
+                    mapOf(
+                        "id" to it.id,
+                        "accountId" to it.accountId,
+                        "type" to if (it.type == TxnType.credit) "credit" else "debit",
+                        "amount" to it.amount,
+                        "signed" to signedAmount(it),
+                    )
+                }
+        }
+        Uatu.extract("ledger_balance") {
+            val active = when (val r = Navigator.current.value) {
+                is Route.Ledger -> r.accountId
+                is Route.AddTransaction -> r.accountId
+                else -> null
+            }
+            if (active == null) 0L
+            else balanceOf(Repository.transactions.value.filter { it.accountId == active })
+        }
+        Uatu.extract("focused_input") { FocusTracker.current.value }
+        Uatu.extract("txn_form_type") { AddTransactionUiState.txnFormType.value }
+        Uatu.extract("txn_form_account_id") {
+            (Navigator.current.value as? Route.AddTransaction)?.accountId
+        }
+        Uatu.extract("login_error") { LoginUiState.loginError.value }
+        Uatu.extract("add_account_error") { AddAccountUiState.addAccountError.value }
+        Uatu.extract("txn_error") { AddTransactionUiState.txnError.value }
+    }
+}

examples/folio/composeApp/src/androidMain/kotlin/app/folio/MainActivity.kt

@@ -0,0 +1,12 @@
+package app.folio
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent { App() }
+    }
+}

examples/folio/composeApp/src/androidMain/kotlin/app/folio/data/DriverFactory.android.kt

@@ -0,0 +1,11 @@
+package app.folio.data
+
+import android.content.Context
+import app.cash.sqldelight.db.SqlDriver
+import app.cash.sqldelight.driver.android.AndroidSqliteDriver
+import app.folio.db.LedgerDatabase
+
+actual class DriverFactory(private val context: Context) {
+    actual fun create(): SqlDriver =
+        AndroidSqliteDriver(LedgerDatabase.Schema, context, "ledger.db")
+}

examples/folio/composeApp/src/androidMain/kotlin/app/folio/data/LedgerStore.android.kt

@@ -0,0 +1,10 @@
+package app.folio.data
+
+import android.content.Context
+
+object AndroidLedgerContext {
+    lateinit var context: Context
+}
+
+actual fun createLedgerStore(): LedgerStore =
+    SqlLedgerStore(DriverFactory(AndroidLedgerContext.context))

examples/folio/composeApp/src/androidMain/kotlin/app/folio/platform/Format.android.kt

@@ -0,0 +1,9 @@
+package app.folio.platform
+
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+private val DATE_FMT = SimpleDateFormat("MMM d, h:mm a", Locale.US)
+
+actual fun formatDate(epochMillis: Long): String = DATE_FMT.format(Date(epochMillis))

examples/folio/composeApp/src/androidMain/kotlin/app/folio/platform/Platform.android.kt

@@ -0,0 +1,8 @@
+package app.folio.platform
+
+import java.util.UUID
+
+actual object Platform {
+    actual fun now(): Long = System.currentTimeMillis()
+    actual fun makeId(): String = UUID.randomUUID().toString()
+}

examples/folio/composeApp/src/androidMain/kotlin/app/folio/ui/BackHandler.android.kt

@@ -0,0 +1,7 @@
+package app.folio.ui
+
+import androidx.compose.runtime.Composable
+import androidx.activity.compose.BackHandler as AndroidBackHandler
+
+@Composable
+actual fun BackHandler(onBack: () -> Unit) = AndroidBackHandler(onBack = onBack)