lanka 1.3.0 → 2.0.0

package/skills/lanka-core/reference.md

@@ -1,10 +1,10 @@
 <!-- Generated from core/GUIDE.md by scripts/skills.mjs. Edit the guide. -->
 
-> **`lanka@1.3.0`** — this document describes that version.
+> **`lanka@2.0.0`** — this document describes that version.
 >
-> Install: `npm install lanka react zustand` (the peers are not optional; only npm adds a missing one for you).
+> Install: `npm install lanka zustand` (the peers are not optional; only npm adds a missing one for you).
 >
-> Complete code, compiled and run in CI: [core/_playground/playground.test.tsx](https://github.com/lankajs/lanka/blob/main/core/_playground/playground.test.tsx)
+> Complete code, compiled and run in CI: [core/_playground/playground.test.ts](https://github.com/lankajs/lanka/blob/main/core/_playground/playground.test.ts)
 
 # lanka — user guide
 
@@ -27,8 +27,31 @@ If you want to know _why_ the framework is shaped this way, read
 > required: [ARCHITECTURE.md](https://github.com/lankajs/lanka/blob/main/ARCHITECTURE.md) separates the five things the
 > machine checks from the many that are advice you can take or leave.
 
+## When to reach for this
+
+Every other package here is adopted one at a time; this one is the framework, so
+the question is the other way round. Reach for lanka when an application has
+SERVER STATE that several screens care about — a list one screen changes and
+another shows, a session two screens read, a fact that has to travel without one
+screen importing another. That is what the gateway, the ViewModel and the
+scenario bus are for, and it is the shape that gets expensive when it is left to
+grow by itself.
+
+Do not reach for it for a form, a landing page, or a screen that loads once and
+sits still: a `useState` and a `fetch` are the right size for those, and this
+framework would be four layers around nothing.
+
+It is not an application shell either. Your host framework — Next, React Router,
+TanStack Start, Astro, Expo — keeps routing, rendering and caching;
+[ARCHITECTURE.md](https://github.com/lankajs/lanka/blob/main/ARCHITECTURE.md#inside-another-framework) draws the line.
+
+It binds no UI framework of its own: core imports no UI library at all, and
+reading a ViewModel from a screen is one of the five packages in
+`modules/bindings/`.
+
 ## Contents
 
+- [When to reach for this](#when-to-reach-for-this)
 - [Install](#install)
 - [Your first application](#your-first-application)
 - [The layers, and which way imports go](#the-layers-and-which-way-imports-go)
@@ -60,16 +83,28 @@ If you want to know _why_ the framework is shaped this way, read
 ## Install
 
 ```bash
-npm  install lanka react react-dom zustand
-pnpm add     lanka react react-dom zustand
-yarn add     lanka react react-dom zustand
-bun  add     lanka react react-dom zustand
+npm  install lanka zustand
+pnpm add     lanka zustand
+yarn add     lanka zustand
+bun  add     lanka zustand
 ```
 
-**The peers are listed on purpose.** `react` 19 and `zustand` 5 are peer
-dependencies, and only npm installs those for you. Under pnpm, yarn or bun a
-missing peer is a warning at install time and a resolution error at build time —
-name them once and the question never comes up.
+**The peer is listed on purpose.** `zustand` 5 is core's one peer dependency,
+and only npm installs a missing peer for you. Under pnpm, yarn or bun it is a
+warning at install time and a resolution error at build time — name it once and
+the question never comes up.
+
+**No UI framework is in that line, and that is not an omission.** Core imports no
+UI library at all: a ViewModel is a store, a gateway is a function, and neither
+knows what renders. Reading a ViewModel from a screen is one package more, the
+one for your framework:
+
+```bash
+npm install @lankajs/react   # or @lankajs/vue, @lankajs/svelte, @lankajs/solid, @lankajs/angular
+```
+
+All five publish the same name — `useLankaVM` — so the guide you read for one
+is the guide for the next.
 
 > [!NOTE]
 > Any package manager works, and nothing in the framework knows which one you
@@ -599,16 +634,16 @@ more protected member, `toLifecycleHooks`, is the framework's own reading of
 
 ### Config reference
 
-| Field                              | Meaning                                             |
-| ---------------------------------- | --------------------------------------------------- |
-| `name`                             | Shown in logs and devtools. Required                |
-| `states`                           | The initial state. Omit for a stateless ViewModel   |
-| `createActions`                    | Receives the context, returns the actions           |
-| `gateways` / `services`            | An object or a factory; reachable as `gateways.x`   |
-| `scenarioHandlers`                 | `{ scenario, handler }` pairs, bound at bootstrap   |
-| `enhancers`                        | Store enhancers, zustand style                      |
+| Field                              | Meaning                                                                                                                                                                                                      |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `name`                             | Shown in logs and devtools. Required                                                                                                                                                                         |
+| `states`                           | The initial state. Omit for a stateless ViewModel                                                                                                                                                            |
+| `createActions`                    | Receives the context, returns the actions                                                                                                                                                                    |
+| `gateways` / `services`            | An object or a factory; reachable as `gateways.x`                                                                                                                                                            |
+| `scenarioHandlers`                 | `{ scenario, handler }` pairs, bound at bootstrap                                                                                                                                                            |
+| `enhancers`                        | Store enhancers, zustand style                                                                                                                                                                               |
 | `onInit` / `onReset`               | Lifecycle hooks over the same context. Declaring either enrols the ViewModel with scenario bootstrap: `onInit` runs when bootstrap binds it, `onReset` when the instance — or a lazy ViewModel — is disposed |
-| `enableAccessTrackingOptimization` | Default on; see [common mistakes](#common-mistakes) |
+| `enableAccessTrackingOptimization` | Default on; see [common mistakes](#common-mistakes)                                                                                                                                                          |
 
 ### Using one in a component
 
@@ -626,6 +661,48 @@ The hook re-renders a component only for the keys it actually **read**. That is
 usually free performance, and it has one blind spot, described at the end of this
 guide.
 
+### A selector that builds its answer
+
+Every binding also takes a selector, and then the selector decides instead of
+the tracking. A selector that **builds** what it answers has a trap in it:
+
+```ts
+useLankaVM(missionVM, (state) => ({ title: state.title, status: state.status }));
+```
+
+That object is new on every call, so it is never identical to the previous one,
+and a binding compares selections by identity. The reader is therefore woken by
+every change in the ViewModel — including the keys the selector exists to
+ignore. A selector answering a **primitive** never has the problem, which is what
+makes this quiet: the shape that is free and the shape that repaints on
+everything look the same on the page.
+
+`createLankaShallowHold` is the comparison that fixes it. It answers the
+**previous** object while nothing in the selection moved, one level deep — own
+keys, same count, `Object.is` on each value, arrays included:
+
+```ts
+import { createLankaShallowHold } from "lanka/viewmodel";
+
+const hold = createLankaShallowHold<{ title: string; status: string }>();
+
+const view = useLankaVM(missionVM, (state) => hold({ title: state.title, status: state.status }));
+```
+
+One hold per reader, created once beside the ViewModel read — never shared
+between two components, because the answer it holds belongs to whoever selected
+it.
+
+> [!NOTE]
+> In React, write `useLankaShallow` from `@lankajs/react` instead. It is the same
+> comparison as a hook, and React needs one: a component re-runs the hook on
+> every render, so the holding has to survive a render while the selector stays
+> the current one.
+
+A selection with a **nested** object wants a selector that picks the leaves.
+Comparing deeper would mean walking a state of unknown size on every read, which
+is the cost a selector was taken to avoid.
+
 ## Choosing a coordination tool
 
 When "A must affect B", one question decides it: **do A and B co-own a thing, or
@@ -788,15 +865,15 @@ Things worth knowing:
 - **A failing handler cannot take the dispatch down**, and that holds for an
   async one too. A handler is typed `(data) => void`, but TypeScript assigns a
   `Promise<void>` to a void return position — so `async () => { await refetch();
-  }` compiles with nothing to warn about, and "refetch when the stream
+}` compiles with nothing to warn about, and "refetch when the stream
   reconnects" is the ordinary shape rather than an exotic one. Its rejection is
   caught and written to the scenario log, not left to surface as an unhandled
   rejection in whatever ran next.
 
-  What the framework cannot do is decide what the failure MEANT. A log line is a
-  diagnostic, not a retry and not a message on a screen — so an action called
-  from a handler should still own its own failure, because the handler returns
-  `void` and has nowhere to put one.
+    What the framework cannot do is decide what the failure MEANT. A log line is a
+    diagnostic, not a retry and not a message on a screen — so an action called
+    from a handler should still own its own failure, because the handler returns
+    `void` and has nowhere to put one.
 
 - **Middleware returns a decision** — `"pass"` or `{ stop: reason }` — never
   `next()`. A middleware that forgot to call `next()` would make the event vanish
@@ -838,28 +915,28 @@ the whole cost a form library exists to remove — and here you get it for free.
 
 ### Add a form library when the form grows its own behaviour
 
-| Reach for one when                                       | Why the ViewModel stops being enough                 |
-| -------------------------------------------------------- | ---------------------------------------------------- |
-| a field ARRAY — rows the user adds and removes           | rows force nesting, and nesting is not tracked        |
-| validation on every keystroke                            | the whole object re-checked per character             |
-| one field's validity depends on another's value          | written by hand, it drifts                            |
-| `touched` / `dirty` / blur as behaviour, not decoration  | three booleans per input in a screen's state          |
-| the screen is server-rendered WITH values                | see the warning at the end of this section            |
+| Reach for one when                                      | Why the ViewModel stops being enough           |
+| ------------------------------------------------------- | ---------------------------------------------- |
+| a field ARRAY — rows the user adds and removes          | rows force nesting, and nesting is not tracked |
+| validation on every keystroke                           | the whole object re-checked per character      |
+| one field's validity depends on another's value         | written by hand, it drifts                     |
+| `touched` / `dirty` / blur as behaviour, not decoration | three booleans per input in a screen's state   |
+| the screen is server-rendered WITH values               | see the warning at the end of this section     |
 
 Not on the list: how many forms the application has. A big application of flat
 forms needs nothing; one wizard with dynamic rows does.
 
 ### The boundary
 
-| | Owner |
-| --- | --- |
-| values, `touched`/`dirty`, focus, per-input messages | the **form** |
-| `isSubmitting` | the form — unless it is visible outside the form (a global overlay) |
-| `defaultValues` | the ViewModel: the server's version, held as `server` |
-| calling the gateway, `trigger`, clearing a draft, navigating | the **ViewModel** |
-| an input's ASYNCHRONOUS check | a ViewModel action — a resolver may not call a gateway |
-| failures with an address | pass through the ViewModel to the form |
-| failures without one | the ViewModel's own state |
+|                                                              | Owner                                                               |
+| ------------------------------------------------------------ | ------------------------------------------------------------------- |
+| values, `touched`/`dirty`, focus, per-input messages         | the **form**                                                        |
+| `isSubmitting`                                               | the form — unless it is visible outside the form (a global overlay) |
+| `defaultValues`                                              | the ViewModel: the server's version, held as `server`               |
+| calling the gateway, `trigger`, clearing a draft, navigating | the **ViewModel**                                                   |
+| an input's ASYNCHRONOUS check                                | a ViewModel action — a resolver may not call a gateway              |
+| failures with an address                                     | pass through the ViewModel to the form                              |
+| failures without one                                         | the ViewModel's own state                                           |
 
 The last row is the interesting one, and the two before it are why a form cannot
 be left to talk to the network itself.
@@ -874,11 +951,11 @@ no adapter to write and nothing declared twice.
 Keep the INPUT schema apart from the response ones. A form given the response
 schema asks for an `id` and an `updatedAt` the user does not have:
 
-| Schema        | Read by                          | Changes when         |
-| ------------- | -------------------------------- | -------------------- |
-| `orderWire`   | the gateway, on the way in       | the backend changes  |
-| `order`       | the gateway, the domain check    | the application does |
-| `orderInput`  | **the form's resolver AND the gateway's payload check** | what a person may type changes |
+| Schema       | Read by                                                 | Changes when                   |
+| ------------ | ------------------------------------------------------- | ------------------------------ |
+| `orderWire`  | the gateway, on the way in                              | the backend changes            |
+| `order`      | the gateway, the domain check                           | the application does           |
+| `orderInput` | **the form's resolver AND the gateway's payload check** | what a person may type changes |
 
 ### A failure that knows which input it belongs to
 
@@ -937,9 +1014,9 @@ your decision, not a framework's.
 const order = await gateways.orderGateway.update(id, values);
 
 set({ server: order, serverChangedAt: null }); // 1. mark your own write
-trigger(orderUpdated, { order });              // 2. announce it, WITH the data
-services.cache?.write(["order", id], order);   // 3. tell a cache, if you have one
-return { ok: true, data: order };              // 4. the form is still mounted here
+trigger(orderUpdated, { order }); // 2. announce it, WITH the data
+services.cache?.write(["order", id], order); // 3. tell a cache, if you have one
+return { ok: true, data: order }; // 4. the form is still mounted here
 // 5. navigate — after this returns
 ```
 
@@ -1053,14 +1130,14 @@ lanka at all: a Standard Schema in, `ILankaFieldError[]` out.
 the wire is server-sent events, a WebSocket, a GraphQL subscription or a gRPC
 server stream.
 
-| Name                              | What it is                                                      |
-| --------------------------------- | ---------------------------------------------------------------- |
+| Name                              | What it is                                                            |
+| --------------------------------- | --------------------------------------------------------------------- |
 | `ILankaServerEventTransport`      | the port: `isSupported`, `connect`, `disconnect`, `on`, `onReconnect` |
-| `ALankaStreamBridge`              | a wire event → one of your scenarios                            |
-| `createLankaStreamBridge`         | the same, written by calling                                     |
-| `createLankaStreamTriggerContext` | the "this came from outside" marker                              |
-| `ALankaStreamTransport`           | the base a transport extends: dispatch, and the reconnect ladder |
-| `lankaStream`                     | the plugin: bridges attached, lifetime owned                     |
+| `ALankaStreamBridge`              | a wire event → one of your scenarios                                  |
+| `createLankaStreamBridge`         | the same, written by calling                                          |
+| `createLankaStreamTriggerContext` | the "this came from outside" marker                                   |
+| `ALankaStreamTransport`           | the base a transport extends: dispatch, and the reconnect ladder      |
+| `lankaStream`                     | the plugin: bridges attached, lifetime owned                          |
 
 You normally reach these through a protocol package —
 [`@lankajs/plugin-sse`](https://github.com/lankajs/lanka/blob/main/plugins/sse/GUIDE.md),
@@ -1103,7 +1180,7 @@ the backoff ladder with its attempt ceiling and one auth refresh, and
 `onReconnect`. A subclass writes `open` and `close`, and reports through three
 handlers — `opened`, `received`, `lost`. Nothing else, and deliberately: the bug
 this shape is prone to is resetting the attempt counter where reconnection
-*starts* rather than where it *succeeds*, after which the ceiling exists, reads
+_starts_ rather than where it _succeeds_, after which the ceiling exists, reads
 as a guard, and can never fire.
 
 ## The locator
@@ -1310,7 +1387,7 @@ npx lanka-skills sync
 
 ### The modules and plugins
 
-Twenty-one more packages solve problems you may or may not have — four wire
+Thirty-seven more packages solve problems you may or may not have — four wire
 protocols, retry policy, optimistic updates, list handling, storage,
 prefetching. The table of
 "add it when" is in [ARCHITECTURE.md](https://github.com/lankajs/lanka/blob/main/ARCHITECTURE.md#adopting-the-packages),

package/skills/lanka-packages/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: lanka-packages
-description: Choose which lanka package solves a problem, and find its skill. Use when a lanka application needs a capability it does not have yet — storage, realtime, caching, prefetching, optimistic updates, list handling, validation, cookies, start-up stages or a devtool — or when deciding whether something belongs in application code at all.
+description: Choose which lanka package solves a problem, and find its skill. Use when a lanka application needs a capability it does not have yet — reading a ViewModel from a React, Vue, Svelte, Solid or Angular screen, storage and its engine, realtime over SSE or WebSocket, GraphQL or gRPC-Web, a read cache, response validation, prefetching, optimistic updates, list handling, cookies, start-up stages, a devtool, or living inside Next, Nuxt, SvelteKit or Expo — or when deciding whether something belongs in application code at all.
 license: MIT
 metadata:
     author: lankajs
     package: lanka
-    version: "1.3.0"
+    version: "2.0.0"
 ---
 
 # lanka — which package, and what it costs
@@ -19,24 +19,91 @@ has a skill of its own with the detail.
 
 ## By the problem
 
-| The problem                                             | The package                     | Its skill                    |
-| ------------------------------------------------------- | ------------------------------- | ---------------------------- |
-| screens, data, state, events                            | `lanka`                         | `lanka-core`                 |
-| stale data after several refreshes; bursts; polling     | `@lankajs/async`                  | `lanka-async`                |
-| a button that must not double-fire; instant feedback    | `@lankajs/optimistic`             | `lanka-optimistic`           |
-| a table: sort, filter, paginate, stop re-rendering rows | `@lankajs/collection`             | `lanka-collection`           |
-| localStorage, IndexedDB, encryption, persisted state    | `@lankajs/storage`                | `lanka-storage`              |
-| avatars and thumbnails that reload or flicker           | `@lankajs/blob-cache`             | `lanka-blob-cache`           |
-| cookies; stale caches after a new build shipped         | `@lankajs/browser`                | `lanka-browser`              |
-| validating responses with zod / valibot                 | `@lankajs/zod`, `@lankajs/valibot`  | `lanka-zod`, `lanka-valibot` |
-| retry, idempotency, timeouts, auth refresh, CSRF        | `@lankajs/plugin-http`            | `lanka-http`                 |
-| realtime updates pushed by the server                   | `@lankajs/plugin-sse`             | `lanka-sse`                  |
-| warming data or route code before the user asks         | `@lankajs/plugin-prefetch`        | `lanka-prefetch`             |
-| ordered start-up stages that can redirect               | `@lankajs/plugin-bootstrap-steps` | `lanka-bootstrap-steps`      |
-| seeing what the bus and the logger did                  | `@lankajs/plugin-devtools`        | `lanka-devtools`             |
-| the `@lanka_di` wiring and its build-time check         | `@lankajs/tool-di`                | `lanka-di`                   |
-| architectural boundaries as lint rules                  | `@lankajs/tool-eslint`            | `lanka-eslint`               |
-| testing, and benchmarking                               | `@lankajs/tool-testing`           | `lanka-testing`              |
+| The problem                                             | The package           | Its skill          |
+| ------------------------------------------------------- | --------------------- | ------------------ |
+| screens, data, state, events                            | `lanka`               | `lanka-core`       |
+| stale data after several refreshes; bursts; polling     | `@lankajs/async`      | `lanka-async`      |
+| a button that must not double-fire; instant feedback    | `@lankajs/optimistic` | `lanka-optimistic` |
+| a table: sort, filter, paginate, stop re-rendering rows | `@lankajs/collection` | `lanka-collection` |
+| localStorage, IndexedDB, encryption, persisted state    | `@lankajs/storage`    | `lanka-storage`    |
+| avatars and thumbnails that reload or flicker           | `@lankajs/blob-cache` | `lanka-blob-cache` |
+| cookies; stale caches after a new build shipped         | `@lankajs/browser`    | `lanka-browser`    |
+| Next, React Router, TanStack Start or Expo around lanka | `@lankajs/host`       | `lanka-host`       |
+
+## Reading a ViewModel from a screen
+
+Core imports no UI library, so this is the one package a rendering application
+always adds. Install the one for its framework and no other — they are
+alternatives, not layers:
+
+| The framework       | The package        | Its skill       |
+| ------------------- | ------------------ | --------------- |
+| React, React Native | `@lankajs/react`   | `lanka-react`   |
+| Vue, Nuxt           | `@lankajs/vue`     | `lanka-vue`     |
+| Svelte, SvelteKit   | `@lankajs/svelte`  | `lanka-svelte`  |
+| Solid               | `@lankajs/solid`   | `lanka-solid`   |
+| Angular             | `@lankajs/angular` | `lanka-angular` |
+
+All five publish `useLankaVM`, and the access tracking is core's rather than
+each binding's — so what a screen re-renders for is the same answer in every
+framework. What differs is what the call ANSWERS: the state itself in React, a
+`ShallowRef` in Vue, getters in Svelte, an `Accessor` in Solid, a `Signal` in
+Angular.
+
+Nothing else needs one. Gateways, scenarios, the locator and
+`viewModel.getState()` are plain calls with no view in them, and they run on a
+server unchanged.
+
+## What goes on the wire
+
+Everything here is a plugin: core declares the extension point, and the plugin is
+registered with `lanka.use(...)`.
+
+| The problem                                       | The package                       | Its skill               |
+| ------------------------------------------------- | --------------------------------- | ----------------------- |
+| retry, idempotency, timeouts, auth refresh, CSRF  | `@lankajs/plugin-http`            | `lanka-http`            |
+| the server pushes updates, one way                | `@lankajs/plugin-sse`             | `lanka-sse`             |
+| the wire has to carry traffic BOTH ways           | `@lankajs/plugin-websocket`       | `lanka-websocket`       |
+| the API is GraphQL, with or without subscriptions | `@lankajs/plugin-graphql`         | `lanka-graphql`         |
+| the API is gRPC and the client is a browser       | `@lankajs/plugin-grpc`            | `lanka-grpc`            |
+| warming data or route code before the user asks   | `@lankajs/plugin-prefetch`        | `lanka-prefetch`        |
+| ordered start-up stages that can redirect         | `@lankajs/plugin-bootstrap-steps` | `lanka-bootstrap-steps` |
+| seeing what the bus and the logger did            | `@lankajs/plugin-devtools`        | `lanka-devtools`        |
+
+SSE and WebSocket sit behind the SAME port, so the choice is one line in bootstrap
+and not a rewrite. Take SSE unless the client has to SEND on the same connection.
+
+## Pick exactly one from a family
+
+Four decisions where the framework refuses to choose for you, because the right
+answer is whichever library your application already has. Each family binds one
+port, so every member publishes the same surface under a different vendor name.
+
+| The decision                                | The members                                                                                                   | Its skill                                        |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
+| which schema library validates responses    | `@lankajs/zod`, `@lankajs/valibot`, `@lankajs/arktype`, `@lankajs/yup`, `@lankajs/typebox`, `@lankajs/effect` | `lanka-zod`, `lanka-valibot`, …                  |
+| …and the app ended up with two of them      | `@lankajs/any-schema`                                                                                         | `lanka-any-schema`                               |
+| which read cache sits under the ViewModels  | `@lankajs/tanstack-query`, `@lankajs/nanostores-query`                                                        | `lanka-tanstack-query`, `lanka-nanostores-query` |
+| where `@lankajs/storage` writes off the web | `@lankajs/mmkv`, `@lankajs/react-native-async-storage`, `@lankajs/secure-store`, `@lankajs/unstorage`         | `lanka-mmkv`, `lanka-secure-store`, …            |
+| which UI framework reads the ViewModels     | `@lankajs/react`, `@lankajs/vue`, `@lankajs/svelte`, `@lankajs/solid`, `@lankajs/angular`                     | `lanka-react`, `lanka-vue`, …                    |
+
+The recommended member, when there is one: `@lankajs/zod` for schemas, and
+`@lankajs/tanstack-query` for the read cache. Take another only for a reason you
+can name — usually that the library is already in the application.
+
+A storage engine is the one family you can skip entirely: in a browser
+`@lankajs/storage` brings its own adapters. Install one when the app runs on a
+device (`@lankajs/mmkv`, or `@lankajs/secure-store` for a token) or on a server
+(`@lankajs/unstorage`).
+
+## Build-time and test-time
+
+| The problem                                            | The package             | Its skill       |
+| ------------------------------------------------------ | ----------------------- | --------------- |
+| the `@lanka_di` wiring and its build-time check        | `@lankajs/tool-di`      | `lanka-di`      |
+| architectural boundaries as lint rules                 | `@lankajs/tool-eslint`  | `lanka-eslint`  |
+| testing, and benchmarking                              | `@lankajs/tool-testing` | `lanka-testing` |
+| keeping these skills matched to the installed versions | `@lankajs/tool-skills`  | `lanka-skills`  |
 
 ## Module or plugin, and why you should care
 
@@ -49,11 +116,16 @@ has a skill of its own with the detail.
 
 ## What NOT to install
 
-- Both `@lankajs/zod` and `@lankajs/valibot`. Pick one; the point is that the choice
-  is visible in your dependency list.
+- Two members of one family. Pick one; the point is that the choice is visible in
+  your dependency list. `@lankajs/any-schema` is the exception, and only for an
+  application that already carries two schema libraries.
+- A second view binding. One application renders with one UI framework, and
+  installing two puts two copies of `useLankaVM` in the import list.
 - `@lankajs/plugin-prefetch` before the app is measurably slow somewhere. It is
   three tiers of machinery for a problem you may not have.
 - `@lankajs/blob-cache` for images whose URL can change. It never checks freshness.
+- A read cache before two screens read the same resource. One screen with its own
+  ViewModel already has everywhere it needs to keep that data.
 
 ## Getting the skills