@pumped-fn/lite 1.3.0 → 1.4.0

package/README.md

@@ -4,655 +4,228 @@ A lightweight effect system for TypeScript with managed lifecycles and minimal r
 
 **Zero dependencies** · **<17KB bundle** · **Full TypeScript support**
 
-## What is an Effect System?
-
-An effect system manages **how** and **when** computations run, handling:
-- **Resource lifecycle** - acquire, use, release
-- **Computation ordering** - what depends on what
-- **Side effect isolation** - controlled execution boundaries
-- **State transitions** - idle → resolving → resolved → failed
-
-## Installation
-
-```bash
-npm install @pumped-fn/lite
-# or
-pnpm add @pumped-fn/lite
-# or
-yarn add @pumped-fn/lite
-```
-
-## Quick Start
-
-```typescript
-import { atom, flow, createScope, tag, tags, controller } from '@pumped-fn/lite'
-
-// 1. Define atoms (long-lived, cached dependencies)
-const configAtom = atom({
-  factory: () => ({ apiUrl: 'https://api.example.com', timeout: 5000 })
-})
-
-const apiClientAtom = atom({
-  deps: { config: configAtom },
-  factory: (ctx, { config }) => {
-    const client = new ApiClient(config.apiUrl, config.timeout)
-    ctx.cleanup(() => client.disconnect())
-    return client
-  }
-})
-
-// 2. Define flows (short-lived request handlers)
-const fetchUserFlow = flow({
-  deps: { api: apiClientAtom },
-  factory: async (ctx, { api }) => {
-    const userId = ctx.input as string
-    return api.getUser(userId)
-  }
-})
-
-// 3. Create scope and execute
-const scope = createScope()
-await scope.ready
-
-const context = scope.createContext()
-const user = await context.exec({ flow: fetchUserFlow, input: 'user-123' })
-await context.close()
-
-// 4. Cleanup when done
-await scope.dispose()
-```
-
-## Core Concepts
+## How It Works
 
 ```mermaid
-graph TB
-    subgraph Scope["Scope (long-lived execution boundary)"]
-        A1["Atom (effect)"] --- A2["Atom (effect)"]
-        A2 --- A3["Atom (effect)"]
-        A1 --> EC
-        A3 --> EC
-        EC["ExecutionContext<br/>(short-lived operation with input, tags, cleanup)"]
-    end
-```
-
-| Concept | Purpose |
-|---------|---------|
-| **Scope** | Long-lived boundary that manages atom lifecycles |
-| **Atom** | A managed effect with lifecycle (create, cache, cleanup, recreate) |
-| **Flow** | Template for short-lived operations with input/output |
-| **ExecutionContext** | Short-lived context for running flows with input and tags |
-| **Controller** | Handle for observing and controlling an atom's state |
-| **Tag** | Contextual value passed through execution |
-
-## Atoms
-
-Atoms are long-lived dependencies that are cached within a scope.
+sequenceDiagram
+    participant User
+    participant Scope
+    participant Atom
 
-```mermaid
-flowchart TB
-    subgraph Scope
-        Config["configAtom"] --> API["apiClientAtom"]
-        DB["dbAtom"] --> Repo["userRepoAtom"]
-        API --> Service["userServiceAtom"]
-        Repo --> Service
+    User->>Scope: createScope(options?)
+    Scope-->>User: scope
+    User->>Scope: await scope.ready
+
+    User->>Scope: scope.resolve(atom)
+    alt preset exists
+        Scope-->>User: preset value (factory skipped)
+    else no preset
+        Scope->>Atom: factory(ctx, deps)
+        Atom-->>Scope: value (cached)
+        Scope-->>User: value
     end
-```
-
-### Basic Atom
 
-```typescript
-const dbAtom = atom({
-  factory: async (ctx) => {
-    const connection = await createConnection()
-    ctx.cleanup(() => connection.close())
-    return connection
-  }
-})
-```
-
-### Atom with Dependencies
-
-```typescript
-const userRepoAtom = atom({
-  deps: { db: dbAtom },
-  factory: (ctx, { db }) => new UserRepository(db)
-})
-```
-
-### Self-Invalidating Atom
-
-```typescript
-const configAtom = atom({
-  factory: async (ctx) => {
-    const config = await fetchConfig()
-
-    // Re-fetch every 60 seconds
-    const interval = setInterval(() => ctx.invalidate(), 60_000)
-    ctx.cleanup(() => clearInterval(interval))
-
-    return config
-  }
-})
+    User->>Scope: scope.dispose()
+    Scope->>Atom: run cleanups, release all
 ```
 
-### Per-Atom Private Storage
-
-Use `ctx.data` to store data that survives invalidation:
+## Invalidation & Data Retention
 
-```typescript
-const prevDataTag = tag<Data>({ label: 'prevData' })
-
-const pollingAtom = atom({
-  factory: async (ctx) => {
-    const prev = ctx.data.get(prevDataTag)  // Data | undefined
-    const current = await fetchData()
-
-    if (prev && hasChanged(prev, current)) {
-      notifyChanges(prev, current)
-    }
-
-    ctx.data.set(prevDataTag, current)
-    setTimeout(() => ctx.invalidate(), 5000)
-    return current
-  }
-})
-```
-
-With default values:
+```mermaid
+sequenceDiagram
+    participant User
+    participant Controller
+    participant Atom
+    participant DataStore as ctx.data
 
-```typescript
-const countTag = tag<number>({ label: 'count', default: 0 })
+    Note over DataStore: persists across invalidations
 
-const counterAtom = atom({
-  factory: (ctx) => {
-    const count = ctx.data.get(countTag)  // number (guaranteed!)
-    ctx.data.set(countTag, count + 1)
-    return count
-  }
-})
+    User->>Controller: ctrl.invalidate()
+    Controller->>Atom: run cleanups (LIFO)
+    Note over DataStore: retained
+    Controller->>Atom: state = resolving
+    Controller->>Atom: factory(ctx, deps)
+    Note right of Atom: ctx.data still has previous values
+    Atom-->>Controller: new value
+    Controller->>Atom: state = resolved
+    Controller-->>User: listeners notified
 ```
 
-## Flows
-
-Flows are templates for short-lived operations.
+## Flow Execution
 
 ```mermaid
 sequenceDiagram
-    participant Client
+    participant User
+    participant Scope
     participant Context as ExecutionContext
     participant Flow
-    participant Atoms
-
-    Client->>Context: exec({ flow, input })
-    Context->>Atoms: resolve dependencies
-    Atoms-->>Context: deps
-    Context->>Flow: factory(ctx, deps)
-    Flow-->>Context: result
-    Context-->>Client: result
-    Client->>Context: close()
-```
-
-### Basic Flow
-
-```typescript
-const createUserFlow = flow({
-  deps: { repo: userRepoAtom },
-  factory: async (ctx, { repo }) => {
-    const input = ctx.input as CreateUserInput
-    return repo.create(input)
-  }
-})
-```
-
-### Flow with Parse Validation
-
-```typescript
-const createUserFlow = flow({
-  name: 'createUser',
-  parse: (raw) => {
-    const obj = raw as Record<string, unknown>
-    if (typeof obj.name !== 'string') throw new Error('name required')
-    if (typeof obj.email !== 'string') throw new Error('email required')
-    return { name: obj.name, email: obj.email }
-  },
-  deps: { repo: userRepoAtom },
-  factory: async (ctx, { repo }) => {
-    // ctx.input is typed as { name: string; email: string }
-    return repo.create(ctx.input)
-  }
-})
-```
-
-Parse runs before the factory, and `ctx.input` type is inferred from the parse return type. On validation failure, throws `ParseError` with phase `'flow-input'`.
-
-### Executing Flows
 
-```typescript
-const context = scope.createContext()
-const user = await context.exec({
-  flow: createUserFlow,
-  input: { name: 'Alice', email: 'alice@example.com' }
-})
-await context.close()
-```
+    User->>Scope: scope.createContext(options?)
+    Scope-->>User: context
 
-### Flow with Tags
+    User->>Context: ctx.exec({ flow, input, tags? })
+    Context->>Flow: parse(input)
+    Context->>Context: resolve flow deps
+    Context->>Flow: factory(ctx, deps)
+    Flow-->>Context: output
+    Context-->>User: output
 
-```typescript
-const requestIdTag = tag<string>({ label: 'requestId' })
-
-const loggingFlow = flow({
-  deps: { requestId: tags.required(requestIdTag) },
-  factory: (ctx, { requestId }) => {
-    console.log(`[${requestId}] Processing request`)
-    return processRequest(ctx.input)
-  }
-})
-
-// Pass tags at execution time
-const context = scope.createContext()
-await context.exec({
-  flow: loggingFlow,
-  input: data,
-  tags: [requestIdTag('req-abc-123')]
-})
+    User->>Context: ctx.close()
+    Context->>Context: run onClose cleanups (LIFO)
 ```
 
-## Controllers
-
-Controllers provide reactive access to atom state.
+## Tag Inheritance
 
 ```mermaid
-flowchart LR
-    subgraph Controller
-        State["state: idle|resolving|resolved|failed"]
-        Get["get()"]
-        Inv["invalidate()"]
+flowchart TD
+    subgraph Scope["Scope: tags=[tenantId('t1')]"]
+        subgraph Context["Context: tags=[requestId('r1')]"]
+            subgraph Flow["Flow deps:"]
+                T1["tags.required(tenantId) → 't1'"]
+                T2["tags.required(requestId) → 'r1'"]
+            end
+        end
     end
 
-    App -->|subscribe| Controller
-    Controller -->|on 'resolved'| App
-    Controller -->|on 'resolving'| App
-```
-
-### Basic Usage
-
-```typescript
-const ctrl = scope.controller(configAtom)
-
-ctrl.state              // 'idle' | 'resolving' | 'resolved' | 'failed'
-ctrl.get()              // value (throws if not resolved)
-await ctrl.resolve()    // resolve and wait
-ctrl.invalidate()       // trigger re-resolution
+    Note["Inner inherits from outer. Override by passing same tag at inner level."]
 ```
 
-### Subscribing to Changes
-
-```typescript
-ctrl.on('resolved', () => console.log('Updated:', ctrl.get()))
-ctrl.on('resolving', () => console.log('Refreshing...'))
-ctrl.on('*', () => console.log('State:', ctrl.state))
-```
-
-### Controller as Dependency
-
-Use `controller()` to receive a Controller instead of the resolved value:
-
-```typescript
-const appAtom = atom({
-  deps: { config: controller(configAtom) },
-  factory: (ctx, { config }) => {
-    config.on('resolved', () => ctx.invalidate())
-    return new App(config.get())
-  }
-})
-```
-
-### Fine-Grained Reactivity
-
-Use `select()` to subscribe only when a derived value changes:
-
-```typescript
-const portSelect = scope.select(configAtom, (c) => c.port)
-portSelect.subscribe(() => console.log('Port changed:', portSelect.get()))
-```
-
-## Tags
-
-Tags pass contextual values through execution without explicit wiring.
+## Controller Reactivity
 
 ```mermaid
-flowchart LR
-    subgraph Definition
-        T["tag({ label: 'tenantId' })"]
-    end
-
-    subgraph Usage
-        R["tags.required(tag)"] --> |"throws if missing"| V1["string"]
-        O["tags.optional(tag)"] --> |"undefined if missing"| V2["string | undefined"]
-        A["tags.all(tag)"] --> |"collects all"| V3["string[]"]
-    end
-```
+sequenceDiagram
+    participant User
+    participant Controller
+    participant Atom
 
-### Creating Tags
+    User->>Controller: scope.controller(atom)
+    User->>Controller: ctrl.on('resolved', listener)
+    Controller-->>User: unsubscribe fn
 
-```typescript
-const tenantIdTag = tag<string>({ label: 'tenantId' })
-const userRolesTag = tag<string[]>({ label: 'userRoles', default: [] })
-
-// With parse validation
-const userId = tag({
-  label: 'userId',
-  parse: (raw) => {
-    if (typeof raw !== 'string') throw new Error('Must be string')
-    return raw
-  }
-})
-
-userId('abc-123')  // OK
-userId(123)        // Throws ParseError
-```
+    Note over Controller: atom invalidated elsewhere
 
-### Using Tags as Dependencies
+    Controller->>Atom: state = resolving
+    Controller-->>User: 'resolving' listeners fire
+    Atom-->>Controller: new value
+    Controller->>Atom: state = resolved
+    Controller-->>User: 'resolved' listeners fire
 
-```typescript
-// Required - throws if not found
-const tenantAtom = atom({
-  deps: { tenantId: tags.required(tenantIdTag) },
-  factory: (ctx, { tenantId }) => loadTenantData(tenantId)
-})
-
-// Optional - undefined if not found
-const optionalAtom = atom({
-  deps: { tenantId: tags.optional(tenantIdTag) },
-  factory: (ctx, { tenantId }) => {
-    if (tenantId) {
-      return loadTenantData(tenantId)
-    }
-    return loadDefaultData()
-  }
-})
-
-// Collect all - returns array of all matching tags
-const multiAtom = atom({
-  deps: { roles: tags.all(userRolesTag) },
-  factory: (ctx, { roles }) => roles.flat()  // string[][]
-})
+    User->>Controller: ctrl.get()
+    Controller-->>User: current value
 ```
 
-### Passing Tags
+## Primitives
 
-Tags can be passed at different levels, with inner levels inheriting from outer:
+### Scope
 
-```mermaid
-flowchart LR
-    subgraph Scope["createScope()"]
-        ST["tenantId: 'tenant-123'"]
-        subgraph Context["createContext()"]
-            CT["userRoles: ['admin']"]
-            subgraph Exec["exec()"]
-                ET["requestId: 'req-456'"]
-            end
-        end
-    end
+Entry point. Manages atom lifecycles, caching, and cleanup orchestration.
 
-    ST -.->|inherited| CT
-    CT -.->|inherited| ET
-```
+- `createScope(options?)` — create with optional extensions, presets, tags
+- `scope.ready` — wait for extension initialization
+- `scope.resolve(atom)` — resolve and cache
+- `scope.controller(atom)` — get reactive handle
+- `scope.release(atom)` — run cleanups, remove from cache
+- `scope.dispose()` — release all, cleanup extensions
+- `scope.createContext(options?)` — create execution context for flows
+- `scope.select(atom, selector)` — fine-grained reactivity
+- `scope.flush()` — wait for pending invalidations
 
-All three tag levels are available during flow execution.
+### Atom
 
-### Direct Tag Methods
+Long-lived cached dependency with lifecycle.
 
-```typescript
-const tags = [tenantIdTag('tenant-123'), userRolesTag(['admin'])]
+- Dependencies on other atoms via `deps`
+- `ctx.cleanup(fn)` — runs on invalidate and release (LIFO order)
+- `ctx.invalidate()` — schedule re-resolution
+- `ctx.data` — storage that survives invalidation (cleared on release)
+- `ctx.data.getOrSet(tag, defaultValue)` — initialize and retrieve in one call
 
-// Get (throws if not found for tags without default)
-const tenantId = tenantIdTag.get(tags)
+### Flow
 
-// Find (returns undefined if not found)
-const roles = userRolesTag.find(tags)
+Short-lived operation with input/output.
 
-// Collect all matching values
-const allRoles = userRolesTag.collect(tags)
-```
+- `parse` — validate/transform input before factory (throws `ParseError` on failure)
+- `typed<T>()` — type marker without runtime parsing
+- Dependencies on atoms via `deps`
+- `ctx.input` — typed input access
+- `ctx.onClose(fn)` — cleanup when context closes
 
-## Presets
+### Tag
 
-Presets inject or redirect atom values, useful for testing.
+Contextual value passed through execution without explicit wiring.
 
-```mermaid
-flowchart LR
-    subgraph Normal["Normal Resolution"]
-        A1[resolve dbAtom] --> F1[factory]
-        F1 --> V1[real connection]
-    end
+- `tag({ label, default?, parse? })` — define with optional default and validation
+- `tags.required(tag)` — dependency that throws if missing
+- `tags.optional(tag)` — dependency that returns undefined if missing
+- `tags.all(tag)` — collects all values from inheritance chain
+- Tags inherit: Scope → Context → exec call
 
-    subgraph Preset["With Preset"]
-        A2[resolve dbAtom] --> P[preset check]
-        P -->|value| V2[mockDb]
-        P -->|atom| F2[testAtom.factory]
-    end
-```
+### Controller
 
-**Value injection** bypasses the factory entirely:
-```typescript
-const scope = createScope({
-  presets: [preset(dbAtom, mockDb)]
-})
-```
+Reactive handle for observing and controlling atom state.
 
-**Atom redirection** uses another atom's factory:
-```typescript
-const scope = createScope({
-  presets: [preset(configAtom, testConfigAtom)]
-})
-```
+- `ctrl.state` — sync access: `'idle' | 'resolving' | 'resolved' | 'failed'`
+- `ctrl.get()` — sync value access (throws if not resolved, returns stale during resolving)
+- `ctrl.resolve()` — async resolution
+- `ctrl.invalidate()` — trigger re-resolution (runs factory)
+- `ctrl.set(value)` — replace value directly (skips factory)
+- `ctrl.update(fn)` — transform value: `fn(currentValue) → newValue` (skips factory)
+- `ctrl.on(event, listener)` — subscribe to `'resolved' | 'resolving' | '*'`
+- Use `controller(atom)` in deps for reactive dependency (unresolved, you control timing)
 
-## Extensions
+### Preset
 
-Extensions provide cross-cutting behavior via AOP-style hooks.
+Value injection for testing. Bypasses factory entirely.
 
-```mermaid
-sequenceDiagram
-    participant App
-    participant Ext1 as Extension 1
-    participant Ext2 as Extension 2
-    participant Core as Core Logic
-
-    App->>Ext1: resolve(atom)
-    Ext1->>Ext1: before logic
-    Ext1->>Ext2: next()
-    Ext2->>Ext2: before logic
-    Ext2->>Core: next()
-    Core-->>Ext2: value
-    Ext2->>Ext2: after logic
-    Ext2-->>Ext1: value
-    Ext1->>Ext1: after logic
-    Ext1-->>App: value
-```
+- `preset(atom, value)` — inject direct value
+- `preset(atom, otherAtom)` — redirect to another atom's factory
+- Pass via `createScope({ presets: [...] })`
 
-### Extension Interface
+### Extension
 
-```typescript
-interface Extension {
-  readonly name: string
-  init?(scope: Scope): MaybePromise<void>
-  wrapResolve?<T>(next: () => Promise<T>, atom: Atom<T>, scope: Scope): Promise<T>
-  wrapExec?<T>(next: () => Promise<T>, target: Flow | Function, ctx: ExecutionContext): Promise<T>
-  dispose?(scope: Scope): MaybePromise<void>
-}
-```
+AOP-style middleware for cross-cutting concerns.
 
-### Example: Timing Extension
+- `init(scope)` — setup when scope created
+- `wrapResolve(next, atom, scope)` — intercept atom resolution
+- `wrapExec(next, target, ctx)` — intercept flow execution
+- `dispose(scope)` — cleanup when scope disposed
+- Pass via `createScope({ extensions: [...] })`
 
-```typescript
-const timingExtension: Lite.Extension = {
-  name: 'timing',
-
-  wrapResolve: async (next, atom, scope) => {
-    const start = performance.now()
-    const result = await next()
-    console.log(`Resolved in ${performance.now() - start}ms`)
-    return result
-  }
-}
-
-const scope = createScope({ extensions: [timingExtension] })
-```
+## Full API
 
-## Lifecycle
+See [`dist/index.d.mts`](./dist/index.d.mts) for complete type definitions.
 
-### Effect Lifecycle
+All types available under the `Lite` namespace:
 
-```mermaid
-stateDiagram-v2
-    [*] --> idle
-    idle --> resolving: resolve()
-    resolving --> resolved: success
-    resolving --> failed: error
-    resolved --> resolving: invalidate()
-    failed --> resolving: invalidate()
-    resolved --> idle: release()
-    failed --> idle: release()
+```typescript
+import type { Lite } from '@pumped-fn/lite'
 ```
 
-### Resolution Flow
+## Edge Cases
 
-```mermaid
-sequenceDiagram
-    participant App
-    participant Scope
-    participant Atom
-    participant Factory
-
-    App->>Scope: resolve(atom)
-    Scope->>Atom: check state
-
-    alt idle
-        Scope->>Atom: state = resolving
-        Scope->>Factory: factory(ctx, deps)
-        Factory-->>Scope: value
-        Scope->>Atom: state = resolved
-    else resolved
-        Atom-->>App: cached value
-    end
+### Controller.set() / update()
 
-    Atom-->>App: value
-```
+| State | Behavior |
+|-------|----------|
+| `idle` | Throws "Atom not resolved" |
+| `resolving` | Queues, applies after resolution completes |
+| `resolved` | Queues normally |
+| `failed` | Throws the stored error |
 
-### Invalidation Flow
+Both run cleanups before applying the new value.
 
-```mermaid
-sequenceDiagram
-    participant App
-    participant Controller
-    participant Scope
-    participant Queue
-    participant Factory
-
-    App->>Controller: invalidate()
-    Controller->>Scope: queue invalidation
-    Scope->>Queue: add atom
-
-    Note over Queue: queueMicrotask (batched)
-
-    Queue->>Scope: flush
-    Scope->>Scope: run cleanups (LIFO)
-    Scope->>Scope: state = resolving
-    Scope->>Factory: factory(ctx, deps)
-    Factory-->>Scope: new value
-    Scope->>Scope: state = resolved
-    Scope->>Scope: notify listeners
-```
+### DataStore.get()
 
-## API Reference
-
-### Factory Functions
-
-| Function | Description |
-|----------|-------------|
-| `createScope(options?)` | Create DI container (returns Scope with `ready` promise) |
-| `atom(config)` | Define long-lived cached dependency |
-| `flow(config)` | Define short-lived operation template (optional `name`, `parse`) |
-| `tag(config)` | Define contextual value (optional `parse` for validation) |
-| `controller(atom)` | Create controller dependency helper |
-| `preset(atom, value)` | Create value injection preset |
-
-### Scope Methods
-
-| Method | Description |
-|--------|-------------|
-| `scope.ready` | Promise that resolves when extensions are initialized |
-| `scope.resolve(atom)` | Resolve atom and return cached value |
-| `scope.controller(atom)` | Get Controller for atom |
-| `scope.select(atom, selector, options?)` | Create fine-grained subscription |
-| `scope.release(atom)` | Release atom (run cleanups, remove from cache) |
-| `scope.dispose()` | Dispose scope (release all atoms, cleanup extensions) |
-| `scope.createContext(options?)` | Create ExecutionContext for flows |
-| `scope.on(event, atom, listener)` | Subscribe to atom state changes |
-
-### Controller Methods
-
-| Method | Description |
-|--------|-------------|
-| `ctrl.state` | Current state: `'idle'` \| `'resolving'` \| `'resolved'` \| `'failed'` |
-| `ctrl.get()` | Get resolved value (throws if not resolved) |
-| `ctrl.resolve()` | Resolve and return value |
-| `ctrl.release()` | Release atom |
-| `ctrl.invalidate()` | Trigger re-resolution |
-| `ctrl.on(event, listener)` | Subscribe: `'resolved'` \| `'resolving'` \| `'*'` |
-
-### ExecutionContext Methods
-
-| Method | Description |
-|--------|-------------|
-| `ctx.input` | Current execution input |
-| `ctx.scope` | Parent scope |
-| `ctx.exec(options)` | Execute flow or function |
-| `ctx.onClose(fn)` | Register cleanup for context close |
-| `ctx.close()` | Close context and run cleanups |
-
-### ResolveContext Methods
-
-| Method | Description |
-|--------|-------------|
-| `ctx.cleanup(fn)` | Register cleanup for atom invalidation/release |
-| `ctx.invalidate()` | Schedule self-invalidation |
-| `ctx.scope` | Parent scope |
-| `ctx.data` | Per-atom DataStore (survives invalidation) |
-
-### Type Guards
-
-| Function | Description |
-|----------|-------------|
-| `isAtom(value)` | Check if value is Atom |
-| `isFlow(value)` | Check if value is Flow |
-| `isTag(value)` | Check if value is Tag |
-| `isTagged(value)` | Check if value is Tagged |
-| `isPreset(value)` | Check if value is Preset |
-| `isControllerDep(value)` | Check if value is ControllerDep |
-
-### Types
-
-All types are available under the `Lite` namespace:
+`ctx.data.get(tag)` always returns `T | undefined` (Map-like semantics). Use `getOrSet(tag)` when you need the tag's default value.
 
 ```typescript
-import type { Lite } from '@pumped-fn/lite'
+const countTag = tag<number>({ label: 'count', default: 0 })
 
-const myAtom: Lite.Atom<Config> = atom({ factory: () => loadConfig() })
-const myController: Lite.Controller<Config> = scope.controller(myAtom)
-const myTag: Lite.Tag<string> = tag({ label: 'myTag' })
+ctx.data.get(countTag)       // undefined (not stored)
+ctx.data.getOrSet(countTag)  // 0 (uses default, now stored)
+ctx.data.get(countTag)       // 0 (now stored)
 ```
 
-## Design Principles
-
-1. **Minimal API** - Every export is expensive to learn
-2. **Zero dependencies** - No runtime dependencies
-3. **Explicit lifecycle** - No magic, clear state transitions
-4. **Composable** - Effects compose through deps
-5. **Type-safe** - Full TypeScript inference
-
 ## License
 
 MIT