ketoy-dev 0.1.0

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "ketoy-dev",
+  "version": "0.1.0",
+  "description": "AI-powered CLI for Ketoy — scaffold, write, migrate, diagnose, and build .ktx bundles for Android. BYO API key (Anthropic, OpenAI, Google, Mistral, Groq, xAI, OpenRouter, or local Ollama).",
+  "type": "module",
+  "bin": {
+    "ketoy": "./dist/ketoy.js"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "templates",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/ketoy.js",
+    "prepack": "node scripts/prepack-skills.mjs",
+    "postpack": "node scripts/postpack-skills.mjs",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^1.0.0",
+    "@ai-sdk/google": "^1.0.0",
+    "@ai-sdk/groq": "^1.0.0",
+    "@ai-sdk/mistral": "^1.0.0",
+    "@ai-sdk/openai": "^1.0.0",
+    "@ai-sdk/xai": "^1.0.0",
+    "@inquirer/prompts": "^8.4.3",
+    "@openrouter/ai-sdk-provider": "^0.0.6",
+    "ai": "^4.0.0",
+    "commander": "^12.1.0",
+    "execa": "^9.4.0",
+    "fast-xml-parser": "^4.5.0",
+    "ollama-ai-provider": "^1.0.0",
+    "picocolors": "^1.1.0",
+    "tinyglobby": "^0.2.10",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": [
+    "ketoy",
+    "ketoyvm",
+    "kbc",
+    "android",
+    "compose",
+    "jetpack-compose",
+    "server-driven",
+    "cli",
+    "ai-agent",
+    "vercel-ai-sdk"
+  ],
+  "author": "Aditya Shinde",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/developerchunk/ketoy-extended.git",
+    "directory": "ketoy-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/developerchunk/ketoy-extended/issues"
+  },
+  "homepage": "https://ketoy.dev",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/skills/ketoy/README.md

@@ -0,0 +1,50 @@
+# Ketoy Skill
+
+Operational skill for an AI agent helping developers adopt Ketoy.
+
+**Entry point**: [SKILL.md](SKILL.md). Read this first.
+
+## Layout
+
+```
+skills/ketoy/
+├── SKILL.md                            # entry — frontmatter + operating rules
+├── reference/                          # ground truth for "is X supported"
+│   ├── supported-composables.md
+│   ├── supported-constructors.md
+│   ├── supported-modifiers.md
+│   ├── capabilities.md
+│   ├── forbidden-apis.md
+│   └── architecture-cheatsheet.md
+├── guides/                             # workflow playbooks
+│   ├── init-project.md
+│   ├── safe-edits.md                   # ← surgical-edits policy (READ FIRST)
+│   ├── migrate.md
+│   ├── diagnose-errors.md
+│   ├── build-and-analyze.md
+│   └── publish-deferred.md
+├── examples/                           # paste-ready Kotlin code
+│   ├── todo-screen.kt
+│   ├── capabilities-stubs.kt
+│   ├── hilt-config.kt
+│   └── no-hilt-config.kt
+└── templates/                          # static templates for `ketoy init`
+    ├── app-build.gradle.kts.tmpl
+    ├── ketoy-capabilities.json.tmpl
+    └── manifest-snippet.xml.tmpl
+```
+
+## When the skill applies
+
+The agent should load this skill whenever the user's task involves:
+
+- Adding Ketoy to an Android project
+- Writing `@KetoyComposable` / `@KetoyEntryPoint` / `@KetoyViewModel` / `@KetoyCapabilityStub`
+- Migrating an existing Compose screen to KBC
+- Diagnosing `KetoyBC:` errors, `.ktx` runtime errors
+- Building, analyzing, or shipping `.ktx` bundles
+- Working with `dev.ketoy.vm:*` Maven coordinates
+
+## Version this skill targets
+
+Ketoy **0.3.4-alpha** on Maven Central. Coordinates use group `dev.ketoy.vm`. Bundle wire format v2 with `minAppVersion` trailing field. Closure conversion via `KBCValue.ClosureRef` shipped. Phase 11E inline-source app bundle mode is the standard adoption path (one `.ktx` per app module, `bundleId = "main"`).

package/skills/ketoy/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: ketoy
+description: Operate the Ketoy CLI agent. Use for any task involving Ketoy/KetoyBC — scaffolding a Ketoy-enabled Android project, writing or migrating `@KetoyComposable` screens, defining `@KetoyCapabilityStub` declarations, wiring Hilt/non-Hilt configuration, diagnosing compiler-plugin errors, building `.ktx` bundles, inspecting bundle contents. Triggers on: "ketoy", "KBC", ".ktx", "Ketoy", "server-driven Compose", `@KetoyComposable`, `@KetoyCapabilityStub`, `dev.ketoy.vm:*` dependencies.
+---
+
+# Ketoy Skill — Operating Manual
+
+You are a Ketoy CLI agent. Your job is to help Android developers adopt Ketoy: a register-based VM that executes Compose UI from server-shipped `.ktx` bytecode bundles inside their app. The app is the OS; the server ships programs.
+
+You run inside the `@ketoy/cli` Node.js CLI built on Vercel AI SDK — the user picked their own AI provider (Anthropic / OpenAI / Google / Mistral / Groq / xAI / OpenRouter / Ollama). The tool surface (`readFile`, `writeFile`, `editFile`, `grep`, `glob`, `bash`, `analyzeKtx`) is identical across providers. See [/KETOY_CLI.md](../../KETOY_CLI.md) at the repo root for the full CLI design.
+
+## Truth sources, in priority order
+
+1. **The user's working directory** — read their actual `build.gradle.kts`, `AndroidManifest.xml`, KBC source. Never assume.
+2. **`reference/`** in this skill — the curated catalog of what Ketoy actually supports today. Treat as ground truth for "is X supported".
+3. **`KNOWN_ISSUES.md`** and **`CLAUDE.md`** at the repo root of the Ketoy project, if present. Read them when diagnosing weird behavior.
+4. **`docs/`** at the Ketoy repo or `ketoy.dev/docs` — secondary. Some pages still describe per-screen bundles; the actual ship state is **one `.ktx` per app module** (`bundleId = "main"`).
+
+## Hard rules (never violate)
+
+- **Never rewrite existing user files in full.** All edits to `build.gradle.kts`, `AndroidManifest.xml`, `MainActivity.kt`, `Application` subclasses, `settings.gradle.kts`, or any pre-existing user file MUST be surgical — single-line additions or single-block appends at well-identified anchors. Templates in `templates/` describe the *final shape*, not the *bytes to write*. See [guides/safe-edits.md](guides/safe-edits.md) for the per-file insertion strategy. Show a diff and confirm before touching anything the user is likely to have hand-tuned.
+- KBC source CANNOT call:
+  - Reflection (`kotlin.reflect.*`, `Class.get*`, `java.lang.reflect.*`)
+  - File I/O (`java.io.*`, `java.nio.*`, `kotlin.io.*`)
+  - Direct Android APIs (`android.*`, `androidx.*` outside the registered Compose surface)
+  - `GlobalScope`, `runBlocking`, `CoroutineScope(...)` factory
+- Every Android/system side-effect goes through a `@KetoyCapabilityStub` declared in the KBC module and registered in the host's `CapabilityRegistry`.
+- Every visible Compose composable must have a generated adapter — i.e. live in `adapter-scan-roots.txt` (or app-specific scan-roots). If it's not there, it's not callable.
+- KBC closures over outer-scope locals work for `val`/captured reads only (shipped via `KBCValue.ClosureRef`). Don't try clever capture patterns; keep lambdas small.
+
+## Workflow you offer
+
+### A. Bootstrap (`ketoy init`) — deterministic, no AI tokens
+
+When the user wants to add Ketoy to a project, **prefer running deterministic scaffolding over generating files**. The CLI's `init` command makes **surgical, additive edits** to existing files (never full rewrites — see [guides/safe-edits.md](guides/safe-edits.md)) and creates new files where none exist:
+
+1. Plugin + dependencies to `build.gradle.kts` (root + app)
+2. `Application` class (if Hilt: `@HiltAndroidApp`; else: plain `Application`)
+3. `MainActivity` wired with `KetoyScreen` host (Hilt vs non-Hilt variants)
+4. `AndroidManifest.xml` updated `android:name` for Application
+5. `app/ketoy-capabilities.json` skeleton
+6. `app/src/main/java/<pkg>/ketoyscreens/Capabilities.kt` with standard `NAV_*` / `VM_*` stubs
+7. The `ketoy { exportFromAppModule = true; bundleId = "main"; bundleVariant = "release" }` block
+8. `.gitignore` entry: `**/keys/*-private.key`
+
+Detect Hilt by grepping for `dagger.hilt.android` in any existing `build.gradle.kts` or `@HiltAndroidApp`. **Non-Hilt setup is the default first pass**; if the user later adds Hilt, run `ketoy init --hilt` to upgrade.
+
+See `templates/` for the canonical content.
+
+### B. Write a new `@KetoyComposable` screen
+
+Use [examples/todo-screen.kt](examples/todo-screen.kt) as the canonical pattern. Rules:
+
+- File goes under `app/src/main/.../ketoyscreens/`
+- Annotate with `@KetoyEntryPoint @KetoyComposable @Composable` if it's a screen-root.
+- Only call composables listed in [reference/supported-composables.md](reference/supported-composables.md).
+- Use `Modifier` chains only with the named-arg forms documented in [reference/supported-modifiers.md](reference/supported-modifiers.md).
+- For state, dispatch capabilities — `vmGetState(key)`, `vmSetState(key, value)`, `observeTodos()`, etc. — declared as `@KetoyCapabilityStub` in `ketoyscreens/Capabilities.kt`.
+
+### C. Migrate an existing Compose screen to KBC
+
+Per-file migration only. Never offer "migrate the whole project." Workflow:
+
+1. **Audit** the source: list every composable, every Android/Java API call, every state holder, every `LaunchedEffect` / `Flow.collect`.
+2. **Map each call site** to one of:
+   - A supported composable → leave it (verify in `reference/supported-composables.md`).
+   - A side effect → invent a capability ID at `0x4000+`, add a stub, add the host-side registration.
+   - A forbidden API → propose an alternative (Capability call, or "this can't be migrated; keep it native").
+3. **Rewrite the file** with `@KetoyComposable`-annotated public function(s) and any captured `val`s declared at the top of the function body (closure-converted to `KBCValue.ClosureRef`).
+4. **Show the user a diff** before writing — migrations frequently change semantics (e.g. `viewModel()` → `vmGetState`).
+5. **Run `./gradlew :app:ketoyBundle --rerun-tasks`** — surface the actual error if compilation fails.
+
+See [guides/migrate.md](guides/migrate.md) for the playbook.
+
+### D. Diagnose build / runtime errors
+
+Read `guides/diagnose-errors.md`. Common patterns:
+
+- `KetoyBC: Direct access to android.*` → host API call, route through capability.
+- `KetoyBC: Direct access to FontWeight.Companion.<get-X>` → token not in `ComposeTokenRegistry` — file a Ketoy issue OR replace with a supported one.
+- `KetoyBC: Reached via: X → Y → Z` → forbidden call in a transitive helper; fix at the leaf (Z), not the root (X).
+- `KetoyBundleMalformedException` at runtime → signature mismatch or stale `.ktx`. Re-run `./gradlew :app:ketoyBundle --rerun-tasks` and verify the public key matches.
+- `KBCEngineNotAvailableException` → `KetoyConfig.enableJIT` set but `dexCacheDir` missing, OR using suspend without `parentScope`.
+
+### E. Build & analyze
+
+- **Build**: `./gradlew :app:ketoyBundle --rerun-tasks` from project root, or `:app:assembleDebug` (which transitively triggers the bundle).
+- **Analyze**: use the CLI's `analyze <path-to-.ktx>` — wraps a JVM subprocess that calls `KtxReader.read` and prints function count, manifest entries, modifier table size, signature status, and string pool contents.
+
+### F. Publish (deferred)
+
+Don't write publishing code. If asked: explain that publishing requires written package-name confirmation (safety gate) and the Ketoy backend, which is not yet GA. Track the user's interest and stop there.
+
+## Tone & format
+
+- Be specific. "Add `dev.ketoy.vm:ketoy-runtime:0.3.4-alpha`" beats "add the runtime dependency."
+- Quote real symbol names from the user's tree. Don't paraphrase.
+- For multi-step migrations, show the plan, get acknowledgment, then execute step-by-step with intermediate verification (gradle compile after each meaningful change).
+- When suggesting an unsupported pattern, link to the alternative in `reference/`. Never say "use X" without saying "because Y is not supported in KBC."
+
+## Coordinates reference (current release: 0.3.4-alpha)
+
+```kotlin
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
+    id("dev.ketoy.compiler") version "0.3.4-alpha"
+}
+
+dependencies {
+    implementation(platform("dev.ketoy.vm:ketoy-bom:0.3.4-alpha"))
+    implementation("dev.ketoy.vm:ketoy-runtime")
+    implementation("dev.ketoy.vm:ketoy-annotations")
+    implementation("dev.ketoy.vm:ketoy-capabilities-core")
+    implementation("dev.ketoy.vm:ketoy-capabilities-navigation")
+    implementation("dev.ketoy.vm:ketoy-adapters-material3")
+    // Add `dev.ketoy.vm:ketoy-hilt` only if the host opts into Hilt.
+}
+
+ketoy {
+    exportFromAppModule.set(true)
+    bundleId.set("main")
+    bundleVariant.set("release")
+    capabilityRegistryFile.set(file("ketoy-capabilities.json"))
+    minAppVersion.set(0)
+    debugMode.set(true)
+    val signingKey = file("keys/release-private.key")
+    if (signingKey.exists()) {
+        signingKeyFile.set(signingKey)
+    }
+}
+```
+
+The `dev.ketoy.compiler` Gradle plugin auto-attaches the KetoyBC compiler plugin to `compile<bundleVariant>Kotlin`. `exportFromAppModule.set(true)` is ADR-0003 inline-source mode — the bundle is emitted at `app/src/main/assets/ketoy/<bundleId>.ktx`.
+
+The plugin must apply to the **module that owns `@KetoyComposable` declarations**, normally `:app`. Plugin version is declared inline on the `id(...) version "..."` line since the plugin is resolved through the Gradle Plugin Portal / Maven Central.
+
+## When to read sub-files
+
+- Asked "is X supported?" → `reference/supported-composables.md`, `reference/supported-constructors.md`, `reference/capabilities.md`.
+- Asked "what can't I do?" → `reference/forbidden-apis.md`.
+- Writing a screen → `examples/todo-screen.kt`.
+- Defining capabilities → `examples/capabilities-stubs.kt`.
+- Wiring Hilt → `examples/hilt-config.kt`.
+- Scaffolding from scratch → `templates/`.
+- Diagnosing a build error → `guides/diagnose-errors.md`.
+- Migrating a screen → `guides/migrate.md`.

package/skills/ketoy/examples/capabilities-stubs.kt

@@ -0,0 +1,60 @@
+// Canonical capability stubs for a KBC screen.
+//
+// Place this file at: app/src/main/kotlin/com/example/app/ketoyscreens/Capabilities.kt
+//
+// Every function below is a `@KetoyCapabilityStub` — the body throws because
+// at runtime the compiler plugin replaces calls to these with INVOKE_CAPABILITY
+// opcodes. The body is never executed.
+//
+// IDs in 0x07xx, 0x09xx, 0x0Axx are STANDARD LIBRARY — match exactly.
+// IDs at 0x4000+ are APP-SPECIFIC — pick freely, but pick once and never reuse.
+
+@file:Suppress("UnusedParameter")
+
+package com.example.app.ketoyscreens
+
+import dev.ketoy.annotations.KetoyCapabilityStub
+import kotlinx.coroutines.flow.Flow
+
+private const val STUB_MSG = "Ketoy capability stub — replaced by INVOKE_CAPABILITY at compile time"
+
+// ── Navigation (standard library) ────────────────────────────────
+
+@KetoyCapabilityStub(id = 0x0700, name = "NAV_PUSH")
+public fun navPush(route: String): Unit = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x0701, name = "NAV_POP")
+public fun navPop(): Unit = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x0702, name = "NAV_REPLACE")
+public fun navReplace(route: String): Unit = error(STUB_MSG)
+
+// ── ViewModel state bridge ───────────────────────────────────────
+
+@KetoyCapabilityStub(id = 0x0A00, name = "VM_GET_STATE")
+public fun vmGetState(key: String): Any? = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x0A01, name = "VM_SET_STATE")
+public fun vmSetState(key: String, value: Any?): Unit = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x0A02, name = "VM_OBSERVE_STATE")
+public fun vmObserveState(key: String): Flow<Any?> = error(STUB_MSG)
+
+// ── Platform (standard library) ──────────────────────────────────
+
+@KetoyCapabilityStub(id = 0x0901, name = "TOAST")
+public fun toast(message: String, duration: Int = 0): Unit = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x0900, name = "ANALYTICS_TRACK")
+public fun analyticsTrack(event: String, props: Map<String, Any?> = emptyMap()): Unit = error(STUB_MSG)
+
+// ── App-specific (0x4000+, define yours) ─────────────────────────
+
+@KetoyCapabilityStub(id = 0x4000, name = "OBSERVE_TODOS")
+public fun observeTodos(): Flow<List<Any?>> = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x4001, name = "ADD_TODO")
+public suspend fun addTodo(title: String): Long = error(STUB_MSG)
+
+@KetoyCapabilityStub(id = 0x4002, name = "SET_TODO_COMPLETED")
+public suspend fun setTodoCompleted(id: Long, completed: Boolean): Unit = error(STUB_MSG)

package/skills/ketoy/examples/hilt-config.kt

@@ -0,0 +1,192 @@
+// Hilt wiring for a Ketoy host APK.
+//
+// Three files in one — separate them in your project:
+//   1. AppCapabilityProvider.kt  (the KetoyCapabilityProvider impl)
+//   2. AppHiltModule.kt          (@Module with @Binds + @Provides)
+//   3. MainActivity.kt           (consumer wiring)
+
+// ════════════════════════════════════════════════════════════════════
+// File 1 — AppCapabilityProvider.kt
+// ════════════════════════════════════════════════════════════════════
+
+package com.example.app.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dev.ketoy.capabilities.core.KetoyHttpClient
+import dev.ketoy.capabilities.core.KBCRoomBridge
+import dev.ketoy.capabilities.core.registerCoreCapabilities
+import dev.ketoy.capabilities.core.registerStorageCapabilities
+import dev.ketoy.hilt.KetoyCapabilityProvider
+import dev.ketoy.runtime.capability.CapabilityRegistry
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+public class AppCapabilityProvider @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val dataStore: DataStore<Preferences>,
+    private val httpClient: KetoyHttpClient,
+    // Inject your domain repositories here (Room DAOs, HTTP clients, etc.)
+    // private val todoRepository: TodoRepository,
+) : KetoyCapabilityProvider {
+
+    override fun buildRegistry(): CapabilityRegistry {
+        val registry = CapabilityRegistry()
+
+        // Standard library: HTTP, KV storage, dispatchers, platform, navigation
+        registry.registerCoreCapabilities(context, httpClient = httpClient)
+        registry.registerStorageCapabilities(dataStore)
+
+        // App-specific (0x4000+) — registered via KBCRoomBridge for type-safe Room
+        KBCRoomBridge(registry).apply {
+            // observeList(0x4000) { args -> todoRepository.observeAll() }
+            // suspendCapability(0x4001) { args ->
+            //     val title = args[0] as String
+            //     todoRepository.add(title)
+            // }
+        }
+
+        return registry
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════
+// File 2 — AppHiltModule.kt
+// ════════════════════════════════════════════════════════════════════
+
+package com.example.app.di
+
+import android.content.Context
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.ui.text.font.Font
+import androidx.compose.ui.text.font.FontFamily
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import dagger.Binds
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dev.ketoy.adapters.material3.MaterialDrawableResolver
+import dev.ketoy.adapters.material3.MaterialFontFamilyResolver
+import dev.ketoy.adapters.material3.MaterialIconsResolver
+import dev.ketoy.adapters.material3.materialDrawableResolver
+import dev.ketoy.adapters.material3.materialFontFamilyResolver
+import dev.ketoy.adapters.material3.materialIconsResolver
+import dev.ketoy.hilt.KetoyCapabilityProvider
+import dev.ketoy.hilt.KetoyConfigCustomizer
+import dev.ketoy.runtime.security.KetoyKeystore
+import com.example.app.R
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+public abstract class AppHiltModule {
+
+    @Binds @Singleton
+    public abstract fun bindCapabilityProvider(impl: AppCapabilityProvider): KetoyCapabilityProvider
+
+    public companion object {
+        private const val PREFERENCES_NAME = "app_prefs"
+        private const val PUBLIC_KEY_ASSET = "ketoy/keys/sample-public.key"
+
+        @Provides @Singleton
+        public fun provideDataStore(
+            @ApplicationContext context: Context,
+        ): DataStore<Preferences> = PreferenceDataStoreFactory.create {
+            context.preferencesDataStoreFile(PREFERENCES_NAME)
+        }
+
+        @Provides @Singleton
+        public fun provideKetoyConfigCustomizer(
+            @ApplicationContext context: Context,
+            iconsResolver: MaterialIconsResolver,
+            fontResolver: MaterialFontFamilyResolver,
+            drawableResolver: MaterialDrawableResolver,
+        ): KetoyConfigCustomizer = KetoyConfigCustomizer { default ->
+            val publicKey = KetoyKeystore.loadFromAsset(context, PUBLIC_KEY_ASSET)
+            default.copy(
+                enableSignatureVerification = true,
+                publicKey = publicKey,
+                imageVectorResolver = iconsResolver,
+                fontFamilyResolver = fontResolver,
+                drawableResolver = drawableResolver,
+            )
+        }
+
+        @Provides @Singleton
+        public fun provideMaterialIconsResolver(): MaterialIconsResolver = materialIconsResolver {
+            registerFilled("Settings", Icons.Filled.Settings)
+            // Add additional icons here as KBC source consumes them.
+        }
+
+        @Provides @Singleton
+        public fun provideMaterialFontFamilyResolver(): MaterialFontFamilyResolver =
+            materialFontFamilyResolver {
+                // register("courgette_regular", FontFamily(Font(R.font.courgette_regular)))
+            }
+
+        @Provides @Singleton
+        public fun provideMaterialDrawableResolver(): MaterialDrawableResolver =
+            materialDrawableResolver {
+                // register("img", R.drawable.img)
+            }
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════
+// File 3 — MainActivity.kt
+// ════════════════════════════════════════════════════════════════════
+
+package com.example.app
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.Modifier
+import dagger.hilt.android.AndroidEntryPoint
+import dev.ketoy.hilt.KetoyHiltProvider
+import dev.ketoy.hilt.KetoyViewModelFactoryBuilder
+import dev.ketoy.runtime.KetoyRuntime
+import dev.ketoy.runtime.bundle.KetoyBundleLoader
+import dev.ketoy.runtime.bundle.KetoyBundleSource
+import dev.ketoy.runtime.compose.KetoyScreen
+import javax.inject.Inject
+
+@AndroidEntryPoint
+public class MainActivity : ComponentActivity() {
+    @Inject public lateinit var factoryBuilder: KetoyViewModelFactoryBuilder
+    @Inject public lateinit var runtime: KetoyRuntime
+    @Inject public lateinit var bundleLoader: KetoyBundleLoader
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            KetoyHiltProvider(
+                factoryBuilder = factoryBuilder,
+                bundleLoader = bundleLoader,
+                runtime = runtime,
+            ) {
+                KetoyScreen(
+                    entryPoint = "TodoListScreen",
+                    bundleSource = KetoyBundleSource.Asset("ketoy/main.ktx"),
+                    modifier = Modifier.fillMaxSize(),
+                    nativeFallback = {
+                        // Required: rendered when bundle is missing / incompatible / corrupt.
+                        // This should be the same screen the user would see WITHOUT Ketoy.
+                    },
+                )
+            }
+        }
+    }
+}

package/skills/ketoy/examples/no-hilt-config.kt

@@ -0,0 +1,101 @@
+// Non-Hilt Ketoy setup — the default first-pass for `ketoy init`.
+//
+// Two files:
+//   1. App.kt          (Application with manual singleton wiring)
+//   2. MainActivity.kt (consumer)
+
+// ════════════════════════════════════════════════════════════════════
+// File 1 — App.kt
+// ════════════════════════════════════════════════════════════════════
+
+package com.example.app
+
+import android.app.Application
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Settings
+import dev.ketoy.adapters.material3.materialDrawableResolver
+import dev.ketoy.adapters.material3.materialFontFamilyResolver
+import dev.ketoy.adapters.material3.materialIconsResolver
+import dev.ketoy.capabilities.core.KetoyHttpClient
+import dev.ketoy.capabilities.core.registerCoreCapabilities
+import dev.ketoy.runtime.KetoyConfig
+import dev.ketoy.runtime.KetoyRuntime
+import dev.ketoy.runtime.bundle.KetoyBundleLoader
+import dev.ketoy.runtime.capability.CapabilityRegistry
+import dev.ketoy.runtime.security.KetoyKeystore
+
+public class App : Application() {
+
+    public lateinit var ketoyRuntime: KetoyRuntime
+        private set
+
+    public lateinit var ketoyBundleLoader: KetoyBundleLoader
+        private set
+
+    override fun onCreate() {
+        super.onCreate()
+
+        val iconsResolver = materialIconsResolver {
+            registerFilled("Settings", Icons.Filled.Settings)
+        }
+        val fontResolver = materialFontFamilyResolver { /* register fonts */ }
+        val drawableResolver = materialDrawableResolver { /* register drawables */ }
+
+        val registry = CapabilityRegistry().apply {
+            registerCoreCapabilities(this@App, httpClient = KetoyHttpClient.build())
+            // app-specific capabilities here:
+            // registerSuspend(0x4001) { args -> ... }
+        }
+
+        val config = KetoyConfig(
+            enableSignatureVerification = true,
+            publicKey = KetoyKeystore.loadFromAsset(this, "ketoy/keys/sample-public.key"),
+            imageVectorResolver = iconsResolver,
+            fontFamilyResolver = fontResolver,
+            drawableResolver = drawableResolver,
+        )
+
+        ketoyRuntime = KetoyRuntime(config, registry)
+        ketoyBundleLoader = KetoyBundleLoader(ketoyRuntime, this)
+    }
+}
+
+// ════════════════════════════════════════════════════════════════════
+// File 2 — MainActivity.kt
+// ════════════════════════════════════════════════════════════════════
+
+package com.example.app
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.Modifier
+import dev.ketoy.runtime.bundle.KetoyBundleSource
+import dev.ketoy.runtime.compose.KetoyScreen
+
+public class MainActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val app = application as App
+
+        setContent {
+            KetoyScreen(
+                entryPoint = "TodoListScreen",
+                bundleSource = KetoyBundleSource.Asset("ketoy/main.ktx"),
+                modifier = Modifier.fillMaxSize(),
+                runtime = app.ketoyRuntime,
+                bundleLoader = app.ketoyBundleLoader,
+                nativeFallback = {
+                    // Required: rendered when bundle missing / incompatible / corrupt.
+                },
+            )
+        }
+    }
+}
+
+// Remember to register the Application in AndroidManifest.xml:
+//   <application
+//       android:name=".App"
+//       ... >