@pumped-fn/lite 1.10.0 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @pumped-fn/lite
 
+## 1.11.0
+
+### Minor Changes
+
+- 60604a2: Add automatic garbage collection for atoms
+
+  - Atoms are automatically released when they have no subscribers after a configurable grace period (default 3000ms)
+  - Cascading GC: dependencies are protected while dependents are mounted
+  - New `keepAlive: true` option on atoms to prevent auto-release
+  - New `gc: { enabled, graceMs }` option on `createScope()` to configure or disable GC
+  - React Strict Mode compatible via grace period (handles double-mount/unmount)
+  - Disable with `createScope({ gc: { enabled: false } })` to preserve pre-1.11 behavior
+
+- 06d527f: Add utility types for better DX and boundary types for extensions
+
+  - Add `Lite.Utils` namespace with type extraction utilities:
+    - `AtomValue<A>`, `FlowOutput<F>`, `FlowInput<F>`, `TagValue<T>`, `ControllerValue<C>`
+    - `DepsOf<T>`, `Simplify<T>`, `AtomType<T, D>`, `FlowType<O, I, D>`
+  - Add boundary types for passthrough extension code:
+    - `AnyAtom`, `AnyFlow`, `AnyController`
+  - Add `ExecTarget` and `ExecTargetFn` type aliases for cleaner extension signatures
+
+### Patch Changes
+
+- a017021: docs: add Flow Deps & Execution pattern and improve documentation
+
+  - Add "Flow Deps & Execution" section to PATTERNS.md covering:
+    - Deps resolution (atoms from Scope vs tags from context hierarchy)
+    - Service invocation via ctx.exec (observable by extensions)
+    - Cleanup pattern with ctx.onClose (pessimistic cleanup)
+  - Remove redundant patterns (Command, Interceptor) covered by composite patterns
+  - Remove verbose Error Boundary diagram, replaced with bullet point
+  - Add Documentation section to README linking PATTERNS.md and API reference
+
 ## 1.10.0
 
 ### Minor Changes

package/PATTERNS.md

@@ -44,7 +44,7 @@ sequenceDiagram
     Scope-->>Context: deps (cached in scope)
     Context->>Flow1: factory(childCtx, deps)
     Note over Flow1: childCtx.parent = ctx
-    Flow1->>Flow1: tags.required(userId) from merged tags
+    Flow1->>Flow1: tags.required(userIdTag) from merged tags
     Flow1-->>Context: validated
 
     App->>Context: ctx.exec({ flow: processFlow, input: validated })
@@ -70,46 +70,103 @@ sequenceDiagram
 - Each `exec()` creates child context with isolated `data` Map
 - `seekTag()` traverses parent chain for shared data (e.g., transaction)
 - `ctx.close()` runs all `onClose` cleanups (LIFO order)
+- On error: child context auto-closes, cleanups still run
 
-**Error Boundary (natural extension):**
+**Primitives:** `createScope()`, `scope.createContext()`, `ctx.exec()`, `ctx.data.setTag/seekTag()`, `ctx.onClose()`, `ctx.close()`
+
+---
+
+### Flow Deps & Execution
+
+**Combines:** Command + Composite + Resource Management
+
+| Concern | Primitive |
+|---------|-----------|
+| Dependency injection | `deps` (atoms from Scope, tags from context hierarchy) |
+| Service invocation | `ctx.exec({ fn, params })` (observable by extensions) |
+| Resource cleanup | `ctx.onClose()` (LIFO, runs on success or failure) |
+
+**Deps Resolution:**
+
+```mermaid
+flowchart TB
+    subgraph Flow["flow({ deps, factory })"]
+        Deps["deps: { db: dbAtom, userId: tags.required(userIdTag) }"]
+    end
+
+    subgraph Resolution
+        Deps --> AtomPath["Atom deps"]
+        Deps --> TagPath["Tag deps (TagExecutor)"]
+
+        AtomPath --> Scope["Scope.resolve()"]
+        Scope --> |"cached in scope"| ResolvedAtom["db instance"]
+
+        TagPath --> CtxHierarchy["ctx.data.seekTag()"]
+        CtxHierarchy --> |"traverses parent chain"| ResolvedTag["userId value"]
+    end
+
+    subgraph Factory["factory(ctx, { db, userId })"]
+        ResolvedAtom --> DepsObj["deps object"]
+        ResolvedTag --> DepsObj
+    end
+```
+
+**Service Invocation:**
 
 ```mermaid
 sequenceDiagram
-    participant App
-    participant Scope
-    participant Context as ExecutionContext
     participant Flow
+    participant Ctx as ExecutionContext
+    participant Ext as Extension.wrapExec
+    participant Fn as service.method
+
+    Note over Flow: ❌ Direct call
+    Flow->>Fn: service.method(ctx, data)
+    Note over Fn: Extensions cannot observe
+
+    Note over Flow: ✅ Via ctx.exec
+    Flow->>Ctx: ctx.exec({ fn: service.method, params: [data] })
+    Ctx->>Ctx: create childCtx (parent = ctx)
+    Ctx->>Ext: wrapExec(next, fn, childCtx)
+    Ext->>Fn: next()
+    Fn-->>Ext: result
+    Ext-->>Ctx: result
+    Ctx->>Ctx: childCtx.close()
+    Ctx-->>Flow: result
+```
 
-    App->>Scope: createContext({ tags: [requestId] })
-    Scope-->>App: ctx
-    App->>Context: ctx.onClose(() => releaseResources())
-
-    alt Success path
-        App->>Context: ctx.exec({ flow, input })
-        Context->>Scope: resolve flow deps
-        Scope-->>Context: deps (cached)
-        Context->>Flow: factory(childCtx, deps)
-        Flow-->>Context: result
-        Note over Context: childCtx auto-closes
-        Context-->>App: result
-        App->>Context: ctx.close()
-        Context->>Context: run onClose cleanups
-    else Error path
-        App->>Context: ctx.exec({ flow, input })
-        Context->>Scope: resolve flow deps
-        Scope-->>Context: deps (cached)
-        Context->>Flow: factory(childCtx, deps)
-        Flow-->>Flow: throws Error
-        Note over Context: childCtx auto-closes
-        Context-->>App: throws Error
-        App->>App: catch(error)
-        App->>Context: ctx.close()
-        Context->>Context: run onClose cleanups
-        App-->>App: return error response
+**Cleanup Pattern:**
+
+```mermaid
+sequenceDiagram
+    participant Flow
+    participant Ctx as ExecutionContext
+    participant Tx as Transaction
+
+    Flow->>Tx: beginTransaction()
+    Tx-->>Flow: tx
+    Flow->>Ctx: ctx.onClose(() => tx.rollback())
+
+    alt Success
+        Flow->>Flow: do work
+        Flow->>Tx: tx.commit()
+        Flow->>Ctx: return result
+        Ctx->>Ctx: close() → rollback() is no-op
+    else Error
+        Flow->>Flow: do work (throws)
+        Ctx->>Ctx: close() → rollback() executes
+        Ctx->>Tx: tx.rollback()
     end
 ```
 
-**Primitives:** `createScope()`, `scope.createContext()`, `ctx.exec()`, `ctx.data.setTag/seekTag()`, `ctx.onClose()`, `ctx.close()`
+**Characteristics:**
+- Atoms resolve via `Scope.resolve()` (cached, long-lived)
+- Tag deps resolve via `ctx.data.seekTag()` (traverses parent → grandparent → scope tags)
+- `ctx.exec({ fn, params })` creates child context with isolated `data` Map
+- Extensions intercept via `wrapExec(next, target, ctx)`
+- Register pessimistic cleanup via `ctx.onClose(fn)`, neutralize on success
+
+**Primitives:** `flow({ deps })`, `tags.required()`, `tags.optional()`, `tags.all()`, `ctx.exec()`, `ctx.onClose()`
 
 ---
 
@@ -272,45 +329,6 @@ stateDiagram-v2
 
 ---
 
-### Command
-
-**GoF:** Command Pattern
-
-```mermaid
-graph LR
-    Client -->|exec| Context[ExecutionContext]
-    Context -->|invoke| Flow
-    Flow -->|input| Factory
-    Factory -->|output| Context
-    Context -->|result| Client
-```
-
-**Primitives:** `flow()`, `ctx.exec()`, `ctx.input`, `parse`
-
-**Characteristics:** Encapsulated request/response, input validation via `parse`, nestable execution, auto-closing child contexts.
-
----
-
-### Interceptor
-
-**GoF:** Interceptor / Chain of Responsibility
-
-```mermaid
-graph LR
-    Request --> Ext1[Extension 1]
-    Ext1 -->|next| Ext2[Extension 2]
-    Ext2 -->|next| Target[Atom/Flow]
-    Target --> Ext2
-    Ext2 --> Ext1
-    Ext1 --> Response
-```
-
-**Primitives:** `Extension`, `wrapResolve()`, `wrapExec()`, `init()`, `dispose()`
-
-**Characteristics:** Wraps both atom resolution and flow execution, registration order determines nesting, access to scope and context.
-
----
-
 ### Context Object
 
 **GoF:** Context Object / Ambient Context

package/README.md

@@ -4,6 +4,13 @@ A lightweight effect system for TypeScript with managed lifecycles and minimal r
 
 **Zero dependencies** · **<17KB bundle** · **Full TypeScript support**
 
+## Documentation
+
+| Resource | Purpose |
+|----------|---------|
+| [PATTERNS.md](./PATTERNS.md) | Architecture patterns, flow design, deps resolution, cleanup strategies |
+| [dist/index.d.mts](./dist/index.d.mts) | API reference with TSDoc |
+
 ## How It Works
 
 ```mermaid
@@ -254,9 +261,7 @@ flowchart LR
 
 Use cases: metrics collection, debugging, documentation generation.
 
-## Full API
-
-See [`dist/index.d.mts`](./dist/index.d.mts) for complete type definitions.
+## Types
 
 All types available under the `Lite` namespace:
 
@@ -339,6 +344,100 @@ const handler = flow({
 | `deps: { x: tags.required(tag) }` | Once at start | Stable snapshot |
 | `ctx.data.seekTag(tag)` | Each call | Sees changes |
 
+## Automatic Garbage Collection
+
+Atoms are automatically released when they have no subscribers, preventing memory leaks in long-running applications.
+
+### How It Works
+
+```mermaid
+sequenceDiagram
+    participant Component
+    participant Controller
+    participant Scope
+    participant Timer
+
+    Component->>Controller: ctrl.on('resolved', callback)
+    Note over Controller: subscriberCount = 1
+    
+    Component->>Controller: unsubscribe()
+    Note over Controller: subscriberCount = 0
+    Controller->>Timer: schedule GC (3000ms)
+    
+    alt Resubscribe before timeout
+        Component->>Controller: ctrl.on('resolved', callback)
+        Controller->>Timer: cancel GC
+        Note over Controller: Atom stays alive
+    else Timeout fires
+        Timer->>Scope: release(atom)
+        Note over Scope: Cleanups run, cache cleared
+        Scope->>Scope: Check dependencies for cascading GC
+    end
+```
+
+### Configuration
+
+```typescript
+// Default: GC enabled with 3000ms grace period
+const scope = createScope()
+
+// Custom grace period (useful for tests)
+const scope = createScope({
+  gc: { graceMs: 100 }
+})
+
+// Disable GC entirely (preserves pre-1.11 behavior)
+const scope = createScope({
+  gc: { enabled: false }
+})
+```
+
+### Opt-Out with keepAlive
+
+Mark atoms that should never be automatically released:
+
+```typescript
+const configAtom = atom({
+  factory: () => loadConfig(),
+  keepAlive: true  // Never auto-released
+})
+```
+
+### Cascading Dependency Protection
+
+Dependencies are protected while dependents are mounted:
+
+```
+configAtom (keepAlive: true)
+    ↑
+dbAtom ←── userServiceAtom ←── [Component subscribes]
+```
+
+- `dbAtom` won't be GC'd while `userServiceAtom` is mounted
+- When component unmounts, `userServiceAtom` is GC'd after grace period
+- Then `dbAtom` becomes eligible for GC (no dependents)
+- `configAtom` stays alive due to `keepAlive: true`
+
+### React Strict Mode Compatibility
+
+The 3000ms default grace period handles React's double-mount behavior:
+
+```
+Mount (render 1):     subscribe    → count=1
+Unmount (cleanup 1):  unsubscribe  → count=0 → schedule GC
+Mount (render 2):     subscribe    → count=1 → CANCEL GC
+```
+
+The second mount always happens before the GC timer fires.
+
+### API Summary
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `gc.enabled` | `true` | Enable/disable automatic GC |
+| `gc.graceMs` | `3000` | Delay before releasing (ms) |
+| `atom.keepAlive` | `false` | Prevent auto-release for specific atoms |
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -235,7 +235,8 @@ function atom(config) {
 		[atomSymbol]: true,
 		factory: config.factory,
 		deps: config.deps,
-		tags: config.tags
+		tags: config.tags,
+		keepAlive: config.keepAlive
 	};
 	if (config.tags?.length) registerAtomToTags(atomInstance, config.tags);
 	return atomInstance;
@@ -535,6 +536,7 @@ var ScopeImpl = class {
 	chainPromise = null;
 	initialized = false;
 	controllers = /* @__PURE__ */ new Map();
+	gcOptions;
 	extensions;
 	tags;
 	ready;
@@ -580,6 +582,10 @@ var ScopeImpl = class {
 		this.extensions = options?.extensions ?? [];
 		this.tags = options?.tags ?? [];
 		for (const p of options?.presets ?? []) this.presets.set(p.atom, p.value);
+		this.gcOptions = {
+			enabled: options?.gc?.enabled ?? true,
+			graceMs: options?.gc?.graceMs ?? 3e3
+		};
 		this.ready = this.init();
 	}
 	async init() {
@@ -601,19 +607,68 @@ var ScopeImpl = class {
 					["resolved", /* @__PURE__ */ new Set()],
 					["*", /* @__PURE__ */ new Set()]
 				]),
-				pendingInvalidate: false
+				pendingInvalidate: false,
+				dependents: /* @__PURE__ */ new Set(),
+				gcScheduled: null
 			};
 			this.cache.set(atom$1, entry);
 		}
 		return entry;
 	}
 	addListener(atom$1, event, listener) {
+		this.cancelScheduledGC(atom$1);
 		const listeners = this.getOrCreateEntry(atom$1).listeners.get(event);
 		listeners.add(listener);
 		return () => {
 			listeners.delete(listener);
+			this.maybeScheduleGC(atom$1);
 		};
 	}
+	getSubscriberCount(atom$1) {
+		const entry = this.cache.get(atom$1);
+		if (!entry) return 0;
+		let count = 0;
+		for (const listeners of entry.listeners.values()) count += listeners.size;
+		return count;
+	}
+	maybeScheduleGC(atom$1) {
+		if (!this.gcOptions.enabled) return;
+		if (atom$1.keepAlive) return;
+		const entry = this.cache.get(atom$1);
+		if (!entry) return;
+		if (entry.state === "idle") return;
+		if (this.getSubscriberCount(atom$1) > 0) return;
+		if (entry.dependents.size > 0) return;
+		if (entry.gcScheduled) return;
+		entry.gcScheduled = setTimeout(() => {
+			this.executeGC(atom$1);
+		}, this.gcOptions.graceMs);
+	}
+	cancelScheduledGC(atom$1) {
+		const entry = this.cache.get(atom$1);
+		if (entry?.gcScheduled) {
+			clearTimeout(entry.gcScheduled);
+			entry.gcScheduled = null;
+		}
+	}
+	async executeGC(atom$1) {
+		const entry = this.cache.get(atom$1);
+		if (!entry) return;
+		entry.gcScheduled = null;
+		if (this.getSubscriberCount(atom$1) > 0) return;
+		if (entry.dependents.size > 0) return;
+		if (atom$1.keepAlive) return;
+		await this.release(atom$1);
+		if (atom$1.deps) for (const dep of Object.values(atom$1.deps)) {
+			const depAtom = isAtom(dep) ? dep : isControllerDep(dep) ? dep.atom : null;
+			if (!depAtom) continue;
+			const depEntry = this.cache.get(depAtom);
+			if (depEntry) {
+				depEntry.dependents.delete(atom$1);
+				this.maybeScheduleGC(depAtom);
+			}
+		}
+	}
 	notifyListeners(atom$1, event) {
 		const entry = this.cache.get(atom$1);
 		if (!entry) return;
@@ -692,7 +747,7 @@ var ScopeImpl = class {
 			this.emitStateChange("resolving", atom$1);
 			this.notifyListeners(atom$1, "resolving");
 		}
-		const resolvedDeps = await this.resolveDeps(atom$1.deps);
+		const resolvedDeps = await this.resolveDeps(atom$1.deps, void 0, atom$1);
 		const ctx = {
 			cleanup: (fn) => entry.cleanups.push(fn),
 			invalidate: () => {
@@ -752,14 +807,23 @@ var ScopeImpl = class {
 		}
 		return next();
 	}
-	async resolveDeps(deps, ctx) {
+	async resolveDeps(deps, ctx, dependentAtom) {
 		if (!deps) return {};
 		const result = {};
-		for (const [key, dep] of Object.entries(deps)) if (isAtom(dep)) result[key] = await this.resolve(dep);
-		else if (isControllerDep(dep)) {
+		for (const [key, dep] of Object.entries(deps)) if (isAtom(dep)) {
+			result[key] = await this.resolve(dep);
+			if (dependentAtom) {
+				const depEntry = this.getEntry(dep);
+				if (depEntry) depEntry.dependents.add(dependentAtom);
+			}
+		} else if (isControllerDep(dep)) {
 			const ctrl = new ControllerImpl(dep.atom, this);
 			if (dep.resolve) await ctrl.resolve();
 			result[key] = ctrl;
+			if (dependentAtom) {
+				const depEntry = this.getEntry(dep.atom);
+				if (depEntry) depEntry.dependents.add(dependentAtom);
+			}
 		} else if (tagExecutorSymbol in dep) {
 			const tagExecutor = dep;
 			switch (tagExecutor.mode) {
@@ -868,6 +932,10 @@ var ScopeImpl = class {
 	async release(atom$1) {
 		const entry = this.cache.get(atom$1);
 		if (!entry) return;
+		if (entry.gcScheduled) {
+			clearTimeout(entry.gcScheduled);
+			entry.gcScheduled = null;
+		}
 		for (let i = entry.cleanups.length - 1; i >= 0; i--) {
 			const cleanup = entry.cleanups[i];
 			if (cleanup) await cleanup();
@@ -877,6 +945,10 @@ var ScopeImpl = class {
 	}
 	async dispose() {
 		for (const ext of this.extensions) if (ext.dispose) await ext.dispose(this);
+		for (const entry of this.cache.values()) if (entry.gcScheduled) {
+			clearTimeout(entry.gcScheduled);
+			entry.gcScheduled = null;
+		}
 		const atoms = Array.from(this.cache.keys());
 		for (const atom$1 of atoms) await this.release(atom$1);
 	}

package/dist/index.d.cts

@@ -35,12 +35,20 @@ declare namespace Lite {
     extensions?: Extension[];
     tags?: Tagged<unknown>[];
     presets?: Preset<unknown>[];
+    gc?: GCOptions;
+  }
+  interface GCOptions {
+    /** Enable automatic garbage collection. Default: true */
+    enabled?: boolean;
+    /** Grace period before releasing (ms). Default: 3000 */
+    graceMs?: number;
   }
   interface Atom<T> {
     readonly [atomSymbol]: true;
     readonly factory: AtomFactory<T, Record<string, Dependency>>;
     readonly deps?: Record<string, Dependency>;
     readonly tags?: Tagged<unknown>[];
+    readonly keepAlive?: boolean;
   }
   interface Flow<TOutput, TInput = unknown> {
     readonly [flowSymbol]: true;
@@ -225,7 +233,7 @@ declare namespace Lite {
     readonly name: string;
     init?(scope: Scope): MaybePromise<void>;
     wrapResolve?(next: () => Promise<unknown>, atom: Atom<unknown>, scope: Scope): Promise<unknown>;
-    wrapExec?(next: () => Promise<unknown>, target: Flow<unknown, unknown> | ((ctx: ExecutionContext, ...args: unknown[]) => MaybePromise<unknown>), ctx: ExecutionContext): Promise<unknown>;
+    wrapExec?(next: () => Promise<unknown>, target: ExecTarget, ctx: ExecutionContext): Promise<unknown>;
     dispose?(scope: Scope): MaybePromise<void>;
   }
   type Dependency = Atom<unknown> | ControllerDep<unknown> | TagExecutor<unknown>;
@@ -239,6 +247,91 @@ declare namespace Lite {
   }, deps: InferDeps<D>) => MaybePromise<Output>;
   type ServiceMethod = (ctx: ExecutionContext, ...args: any[]) => unknown;
   type ServiceMethods = Record<string, ServiceMethod>;
+  /**
+   * Any atom regardless of value type.
+   * Useful for APIs that don't need the value type.
+   */
+  type AnyAtom = Atom<any>;
+  /**
+   * Any flow regardless of input/output types.
+   * Useful for APIs that don't need the type parameters.
+   */
+  type AnyFlow = Flow<any, any>;
+  /**
+   * Any controller regardless of value type.
+   */
+  type AnyController = Controller<any>;
+  /**
+   * Target type for wrapExec extension hook.
+   * Either a Flow or an inline function.
+   */
+  type ExecTarget = Flow<unknown, unknown> | ExecTargetFn;
+  /**
+   * Inline function that can be executed via ctx.exec.
+   */
+  type ExecTargetFn = (ctx: ExecutionContext, ...args: any[]) => MaybePromise<unknown>;
+  /**
+   * Utility types for type extraction and manipulation.
+   * @example
+   * type Config = Lite.Utils.AtomValue<typeof configAtom>
+   * type Result = Lite.Utils.FlowOutput<typeof processFlow>
+   */
+  namespace Utils {
+    /**
+     * Extract value type from an Atom.
+     * @example
+     * type Config = Lite.Utils.AtomValue<typeof configAtom> // string
+     */
+    type AtomValue<A> = A extends Atom<infer T> ? T : never;
+    /**
+     * Extract output type from a Flow.
+     * @example
+     * type Result = Lite.Utils.FlowOutput<typeof processFlow> // ProcessResult
+     */
+    type FlowOutput<F> = F extends Flow<infer O, unknown> ? O : never;
+    /**
+     * Extract input type from a Flow.
+     * @example
+     * type Input = Lite.Utils.FlowInput<typeof processFlow> // ProcessRequest
+     */
+    type FlowInput<F> = F extends Flow<unknown, infer I> ? I : never;
+    /**
+     * Extract value type from a Tag.
+     * @example
+     * type UserId = Lite.Utils.TagValue<typeof userIdTag> // string
+     */
+    type TagValue<T> = T extends Tag<infer V, boolean> ? V : never;
+    /**
+     * Extract dependencies record from an Atom or Flow.
+     * @example
+     * type Deps = Lite.Utils.DepsOf<typeof myAtom> // { db: DbAtom, cache: CacheAtom }
+     */
+    type DepsOf<T> = T extends Atom<unknown> ? T['deps'] : T extends Flow<unknown, unknown> ? T['deps'] : never;
+    /**
+     * Flatten complex intersection types for better IDE display.
+     */
+    type Simplify<T> = { [K in keyof T]: T[K] } & {};
+    /**
+     * Create an atom type with inferred value.
+     * Useful for declaring atom types without defining the atom.
+     */
+    type AtomType<T, D extends Record<string, Dependency> = Record<string, never>> = Atom<T> & {
+      readonly deps: D;
+    };
+    /**
+     * Create a flow type with inferred input/output.
+     * Useful for declaring flow types without defining the flow.
+     */
+    type FlowType<O, I = void, D extends Record<string, Dependency> = Record<string, never>> = Flow<O, I> & {
+      readonly deps: D;
+    };
+    /**
+     * Extract value type from a Controller.
+     * @example
+     * type Value = Lite.Utils.ControllerValue<typeof ctrl> // string
+     */
+    type ControllerValue<C> = C extends Controller<infer T> ? T : never;
+  }
 }
 //#endregion
 //#region src/tag.d.ts
@@ -405,6 +498,7 @@ declare function atom<T>(config: {
   deps?: undefined;
   factory: (ctx: Lite.ResolveContext) => MaybePromise<T>;
   tags?: Lite.Tagged<unknown>[];
+  keepAlive?: boolean;
 }): Lite.Atom<T>;
 declare function atom<T, const D extends Record<string, Lite.Atom<unknown> | Lite.ControllerDep<unknown> | {
   mode: string;
@@ -412,6 +506,7 @@ declare function atom<T, const D extends Record<string, Lite.Atom<unknown> | Lit
   deps: D;
   factory: (ctx: Lite.ResolveContext, deps: Lite.InferDeps<D>) => MaybePromise<T>;
   tags?: Lite.Tagged<unknown>[];
+  keepAlive?: boolean;
 }): Lite.Atom<T>;
 /**
  * Type guard to check if a value is an Atom.