@rhi-zone/rainbow 0.1.0 → 0.2.0-alpha.0

package/README.md

@@ -0,0 +1,51 @@
+# @rhi-zone/rainbow
+
+Optics-based reactivity for TypeScript. Seven composable primitives, no framework coupling, no magic.
+
+## What it is
+
+Rainbow gives you structured state management grounded in the algebra of optics. Instead of scattered reactive variables or a centralized store with action boilerplate, you get:
+
+- **Signals** — reactive cells with `get`, `set`, `subscribe`, and `map`.
+- **Lenses** — focus on a field of a record, composable and law-abiding.
+- **Prisms** — focus on a case of a sum type (discriminated unions, optionals).
+- **Traversals** — focus on zero or more values within a collection.
+- **Computed** — derive from multiple sources with an explicit dep list.
+- **Cond** — conditional propagation, composable like `&&`.
+- **Product** — pair two signals into one `Signal<[A, B]>`.
+
+Everything is a plain TypeScript value. No decorators, no global state, no framework requirement.
+
+## Install
+
+```sh
+npm install @rhi-zone/rainbow
+```
+
+## Quick example
+
+```ts
+import { signal, field, computed } from '@rhi-zone/rainbow'
+
+type State = { user: { name: string }; count: number }
+
+const state = signal<State>({ user: { name: 'Alice' }, count: 0 })
+
+// Focus on a nested field — reads and writes go through the lens
+const name = state.focus(field('user')).focus(field('name'))
+
+name.get()        // 'Alice'
+name.set('Bob')
+state.get()       // { user: { name: 'Bob' }, count: 0 }
+
+// Derive from multiple sources
+const summary = computed(
+  () => `${name.get()} has visited ${state.focus(field('count')).get()} times`,
+  [name, state],
+)
+summary.get()     // 'Bob has visited 0 times'
+```
+
+## Docs
+
+Full guides, API reference, and design notes are at the [Rainbow VitePress site](https://rhi.zone/rainbow/).

package/dist/async-data.d.ts

@@ -1,3 +1,4 @@
+import type { Signal, ReadonlySignal } from './signal.ts';
 /**
  * AsyncData<T, E> — the type of an asynchronous value.
  *
@@ -21,20 +22,28 @@ export type AsyncData<T, E = unknown> = {
     readonly status: 'success';
     readonly value: T;
 };
+/** Singleton for the "not yet requested" state. */
 export declare const notAsked: AsyncData<never, never>;
+/** Singleton for the "request in flight" state. */
 export declare const loading: AsyncData<never, never>;
+/** Construct a failure value. */
 export declare const failure: <E>(error: E) => AsyncData<never, E>;
+/** Construct a success value. */
 export declare const success: <T>(value: T) => AsyncData<T, never>;
+/** Narrowing guard for the `notAsked` state. */
 export declare const isNotAsked: <T, E>(ad: AsyncData<T, E>) => ad is {
     status: 'notAsked';
 };
+/** Narrowing guard for the `loading` state. */
 export declare const isLoading: <T, E>(ad: AsyncData<T, E>) => ad is {
     status: 'loading';
 };
+/** Narrowing guard for the `failure` state. */
 export declare const isFailure: <T, E>(ad: AsyncData<T, E>) => ad is {
     status: 'failure';
     error: E;
 };
+/** Narrowing guard for the `success` state. */
 export declare const isSuccess: <T, E>(ad: AsyncData<T, E>) => ad is {
     status: 'success';
     value: T;
@@ -45,12 +54,81 @@ export declare const map: <T, U, E>(ad: AsyncData<T, E>, f: (value: T) => U) =>
 export declare const mapError: <T, E, F>(ad: AsyncData<T, E>, f: (error: E) => F) => AsyncData<T, F>;
 /** Chain async operations — flatMap over the success case. */
 export declare const chain: <T, U, E>(ad: AsyncData<T, E>, f: (value: T) => AsyncData<U, E>) => AsyncData<U, E>;
-/** Unwrap with a fallback for non-success states. */
+/**
+ * Unwrap the success value, or return `fallback` for all other states.
+ * @param fallback - Value to return when not in the success state.
+ */
 export declare const getOrElse: <T, E>(ad: AsyncData<T, E>, fallback: T) => T;
-/** Fold over all four states. */
+/**
+ * Fold over all four states.
+ * @param cases - Handlers for each state; all four must be provided.
+ */
 export declare const fold: <T, E, R>(ad: AsyncData<T, E>, cases: {
     notAsked: () => R;
     loading: () => R;
     failure: (error: E) => R;
     success: (value: T) => R;
 }) => R;
+/**
+ * Wrap an already-in-flight promise as a `ReadonlySignal<AsyncData<T, E>>`.
+ * Starts in `loading`; transitions to `success` or `failure` when the promise
+ * settles. The signal is read-only — it can only be updated by the promise.
+ *
+ * @example
+ * const user = fromPromise(fetchUser(id))
+ * // user.get() === loading initially, then success({ ... }) or failure(e)
+ */
+export declare function fromPromise<T, E = unknown>(promise: Promise<T>): ReadonlySignal<AsyncData<T, E>>;
+/**
+ * Derive a `ReadonlySignal<AsyncData<T, E>>` that re-runs `fn` whenever
+ * `deps` changes. Each new run receives a fresh `AbortSignal`; the previous
+ * in-flight request is aborted before the next one starts. Starts in
+ * `loading` immediately.
+ *
+ * Returns `[signal, dispose]`. Call `dispose()` when done — it aborts any
+ * in-flight request and unsubscribes from `deps`. In a widget context, pass
+ * `dispose` to `register()` so it is called automatically on unmount.
+ *
+ * @example
+ * const [results, dispose] = fromAsync(querySignal, (q, abort) =>
+ *   fetch(`/api/search?q=${q}`, { signal: abort }).then(r => r.json())
+ * )
+ * register(dispose)  // clean up when widget unmounts
+ */
+export declare function fromAsync<D, T, E = unknown>(deps: ReadonlySignal<D>, fn: (deps: D, abort: AbortSignal) => Promise<T>): [ReadonlySignal<AsyncData<T, E>>, dispose: () => void];
+/**
+ * Create an imperatively-triggered async operation.
+ *
+ * Unlike `fromAsync`, this is not driven by a signal — you call `trigger(input)`
+ * manually (e.g. from a button handler). Concurrent calls abort the previous
+ * in-flight request via AbortSignal.
+ *
+ * @returns
+ *   `result`  — ReadonlySignal<AsyncData<T, E>> starting as notAsked()
+ *   `trigger` — Call with input to start the async operation
+ *   `dispose` — Cancel any in-flight request and stop updates
+ *
+ * @example
+ *   const { result, trigger, dispose } = fromAsyncImperative(
+ *     async (contact: Contact, signal) => await saveContact(contact, signal)
+ *   )
+ *   on(saveBtn, "click", () => trigger(formState.get().values))
+ *   register(dispose)
+ */
+export declare function fromAsyncImperative<I, T, E = unknown>(fn: (input: I, signal: AbortSignal) => Promise<T>): {
+    readonly result: ReadonlySignal<AsyncData<T, E>>;
+    readonly trigger: (input: I) => void;
+    readonly dispose: () => void;
+};
+/**
+ * Returns a Promise that resolves with the next value from `s` that satisfies
+ * `predicate`. If the current value already satisfies it, resolves immediately.
+ *
+ * Useful for bridging signal-based async results back to imperative await:
+ *
+ * @example
+ *   trigger(contact)
+ *   const result = await toNextValue(saveResult, r => !isLoading(r))
+ *   if (isSuccess(result)) ...
+ */
+export declare function toNextValue<T>(s: Signal<T> | ReadonlySignal<T>, predicate?: (v: T) => boolean): Promise<T>;

package/dist/computed.d.ts

@@ -2,7 +2,10 @@ import type { ReadonlySignal } from './signal.ts';
 /**
  * Derive a read-only signal from multiple source signals.
  *
- * Unlike signal.map (one source), computed accepts any number of sources
- * and recomputes when any of them change.
+ * Unlike `signal.map` (one source), `computed` accepts any number of sources
+ * and recomputes `fn` when any of them change.
+ *
+ * @param fn - Pure function that reads from one or more signals and returns the derived value.
+ * @param deps - Explicit dependency list; the signal re-evaluates when any dep changes.
  */
 export declare function computed<T>(fn: () => T, deps: ReadonlySignal<unknown>[]): ReadonlySignal<T>;

package/dist/cond.d.ts

@@ -1,6 +1,6 @@
 import type { ReadonlySignal } from './signal.ts';
 /**
- * Conditional signal — propagates the value when `pred` holds, undefined otherwise.
+ * Conditional signal — propagates the value when `pred` holds, `undefined` otherwise.
  *
  * Accepts both `ReadonlySignal<A>` and `ReadonlySignal<A | undefined>` so that
  * cond calls can be composed directly:
@@ -10,7 +10,7 @@ import type { ReadonlySignal } from './signal.ts';
  * When the source already carries `undefined` (from a prior `cond` or `narrow`),
  * undefined passes through unchanged — equivalent to short-circuit `&&`.
  *
- * Usage:
+ * @example
  *   const positiveCount = cond(n => n > 0, countSignal)
  *   const positiveEven  = cond(n => n % 2 === 0, positiveCount)
  */

package/dist/index.d.ts

@@ -1,7 +1,8 @@
+export type { Optic } from './optic.ts';
 export type { Lens } from './lens.ts';
-export { lens, composeLens, field, fst, snd, id } from './lens.ts';
+export { lens, composeLens, field, index, id, arrayOf, recordOf, mapOf } from './lens.ts';
 export type { Prism } from './prism.ts';
-export { prism, composePrism, some, iso } from './prism.ts';
+export { prism, composePrism, some, iso, guard, nullable, tagged } from './prism.ts';
 export type { Signal, ReadonlySignal } from './signal.ts';
 export { signal, batch } from './signal.ts';
 export { computed } from './computed.ts';
@@ -10,4 +11,4 @@ export { product, stateful } from './product.ts';
 export type { Traversal } from './traversal.ts';
 export { traversal, each, filtered, nth, composeWithLens, composeTraversal } from './traversal.ts';
 export type { AsyncData } from './async-data.ts';
-export { notAsked, loading, failure, success, isNotAsked, isLoading, isFailure, isSuccess, map as mapAsyncData, mapError, chain as chainAsyncData, getOrElse, fold, } from './async-data.ts';
+export { notAsked, loading, failure, success, isNotAsked, isLoading, isFailure, isSuccess, map as mapAsyncData, mapError, chain as chainAsyncData, getOrElse, fold, fromPromise, fromAsync, fromAsyncImperative, toNextValue, } from './async-data.ts';

package/dist/lens.d.ts

@@ -1,22 +1,60 @@
+import type { Optic } from './optic.ts';
 /**
  * A Lens<A, B> focuses on a field of type B within a structure of type A.
  *
  * Laws:
- *   get(set(a, b)) = b
- *   set(a, get(a)) = a
- *   set(set(a, b1), b2) = set(a, b2)
+ *   view(review(b, a)) = b
+ *   review(view(a), a) = a
+ *   review(b, review(b1, a)) = review(b, a)
  */
-export interface Lens<A, B> {
-    get(a: A): B;
-    set(a: A, b: B): A;
+export interface Lens<A, B> extends Optic<A, B> {
+    view(a: A): B;
+    review(b: B, a: A): A;
 }
-export declare function lens<A, B>(get: (a: A) => B, set: (a: A, b: B) => A): Lens<A, B>;
+/**
+ * Construct a lens from explicit view and review functions.
+ * @param view   - Extract B from A.
+ * @param review - Return a new A with B replaced.
+ */
+export declare function lens<A, B>(view: (a: A) => B, review: (b: B, a: A) => A): Lens<A, B>;
+/**
+ * Compose two lenses. If `ab` focuses on B within A, and `bc` focuses on C within B,
+ * the result focuses on C within A.
+ */
 export declare function composeLens<A, B, C>(ab: Lens<A, B>, bc: Lens<B, C>): Lens<A, C>;
-/** Lens into the first element of a tuple */
-export declare const fst: <A, B>() => Lens<[A, B], A>;
-/** Lens into the second element of a tuple */
-export declare const snd: <A, B>() => Lens<[A, B], B>;
-/** Lens into a record field */
+/** Lens into a tuple element by index. `index(0)` replaces `fst`, `index(1)` replaces `snd`. */
+export declare function index<T extends readonly unknown[], N extends number & keyof T>(n: N): Lens<T, T[N]>;
+/**
+ * Lens into a record field by key.
+ * @param key - The key of the field to focus on.
+ */
 export declare function field<A, K extends keyof A>(key: K): Lens<A, A[K]>;
-/** Identity lens */
+/** Identity lens — focuses on the whole value. */
 export declare function id<A>(): Lens<A, A>;
+/**
+ * Lift a `Lens<S, A>` to `Lens<S[], A[]>`, applying it pointwise over an array.
+ *
+ * Laws hold as long as the `A[]` written back has the same length as the `S[]`
+ * it came from — which is guaranteed when the only source of `A[]` values is
+ * `view` on the same array.
+ *
+ * Useful for two-way bindings over arrays of objects:
+ *   signal<User[]>.focus(arrayOf(field("name")))  // Signal<string[]>
+ */
+export declare function arrayOf<S, A>(l: Lens<S, A>): Lens<S[], A[]>;
+/**
+ * Lift a `Lens<S, A>` to `Lens<Record<K, S>, Record<K, A>>`, applying it to
+ * every value in the record.
+ *
+ * Useful for normalized state keyed by branded IDs:
+ *   signal<Record<UserId, User>>.focus(recordOf(field("name")))  // Signal<Record<UserId, string>>
+ */
+export declare function recordOf<K extends string, S, A>(l: Lens<S, A>): Lens<Record<K, S>, Record<K, A>>;
+/**
+ * Lift a `Lens<S, A>` to `Lens<Map<K, S>, Map<K, A>>`, applying it to every
+ * value in the map.
+ *
+ * Prefer this over `recordOf` when keys are arbitrary strings — `Map` avoids
+ * prototype-pollution footguns with special keys like `__proto__`.
+ */
+export declare function mapOf<K, S, A>(l: Lens<S, A>): Lens<Map<K, S>, Map<K, A>>;

package/dist/optic.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared supertype for Lens and Prism.
+ *
+ * - `view`   — extract B from A; may return undefined (Prism) or always
+ *              succeeds (Lens, which narrows the return to B, not B|undefined).
+ * - `review` — embed B back into A. Prism implements this as `(b) => A`,
+ *              satisfying the `(b, a) => A` signature because TypeScript
+ *              allows fewer parameters. Lens uses both `b` and `a` to
+ *              preserve surrounding structure.
+ *
+ * Use `Optic<A, B>` at call sites that accept either optic kind.
+ */
+export interface Optic<A, B> {
+    view(a: A): B | undefined;
+    review(b: B, a: A): A;
+}

package/dist/prism.d.ts

@@ -1,17 +1,63 @@
+import type { Optic } from './optic.ts';
 /**
  * A Prism<A, B> focuses on a case of type B within a sum type A.
  *
  * Laws:
- *   match(inject(b)) = b
- *   if match(a) = b then inject(b) = a
+ *   view(review(b)) = b
+ *   if view(a) = b then review(b) = a
  */
-export interface Prism<A, B> {
-    match(a: A): B | undefined;
-    inject(b: B): A;
+export interface Prism<A, B> extends Optic<A, B> {
+    view(a: A): B | undefined;
+    review(b: B): A;
 }
-export declare function prism<A, B>(match: (a: A) => B | undefined, inject: (b: B) => A): Prism<A, B>;
+/**
+ * Construct a prism from explicit view and review functions.
+ * @param view   - Extract B from A, or return undefined if the case doesn't apply.
+ * @param review - Construct an A from a B.
+ */
+export declare function prism<A, B>(view: (a: A) => B | undefined, review: (b: B) => A): Prism<A, B>;
+/**
+ * Compose two prisms. If `ab` focuses on B within A, and `bc` focuses on C within B,
+ * the result focuses on C within A.
+ */
 export declare function composePrism<A, B, C>(ab: Prism<A, B>, bc: Prism<B, C>): Prism<A, C>;
 /** Prism for the Some case of an optional value */
 export declare function some<A>(): Prism<A | undefined, A>;
-/** Prism that always matches (isomorphism) */
+/**
+ * Prism that always matches — models an isomorphism between A and B.
+ * @param to   - Convert A to B.
+ * @param from - Convert B back to A.
+ */
 export declare function iso<A, B>(to: (a: A) => B, from: (b: B) => A): Prism<A, B>;
+/**
+ * Prism from a type predicate. The most general constructor — `some` and
+ * `nullable` are both special cases.
+ *
+ * @example
+ *   const positive = guard((n: number): n is number => n > 0)
+ *   signal(signal.narrow(positive))  // Signal<number | undefined>
+ */
+export declare function guard<A, B extends A>(predicate: (a: A) => a is B): Prism<A, B>;
+/**
+ * Prism for the non-null case. Use `some` for `T | undefined`,
+ * `nullable` for `T | null`.
+ */
+export declare function nullable<A>(): Prism<A | null, A>;
+/**
+ * Prism for a specific variant of a discriminated union, matched by a tag field.
+ *
+ * `A` cannot be inferred from the key/value arguments alone — provide it
+ * explicitly when not in a `.narrow()` context where it can be inferred:
+ *
+ * @example
+ *   type Shape = { kind: "circle"; r: number } | { kind: "rect"; w: number; h: number }
+ *
+ *   // In a narrow() call — A inferred from the signal's type:
+ *   shapeSignal.narrow(tagged("kind", "circle"))
+ *   // Signal<{ kind: "circle"; r: number } | undefined>
+ *
+ *   // Standalone — provide A explicitly (K and V are inferred from the args):
+ *   const circle = tagged<Shape>("kind", "circle")
+ *   // Prism<Shape, { kind: "circle"; r: number }>
+ */
+export declare function tagged<A, K extends keyof A, V extends A[K]>(key: K, value: V): Prism<A, Extract<A, Record<K, V>>>;

package/dist/product.d.ts

@@ -1,19 +1,24 @@
 import type { Signal } from './signal.ts';
 /**
- * Create a signal over a pair [A, B] backed by two independent signals.
+ * Create a signal over a pair `[A, B]` backed by two independent signals.
+ * Writes to the product signal are atomically batched across both children.
+ *
+ * @param a - Signal for the first element.
+ * @param b - Signal for the second element.
  */
 export declare function product<A, B>(a: Signal<A>, b: Signal<B>): Signal<[A, B]>;
 /**
- * Encapsulate internal state S alongside external signal A.
+ * Attach a local state `S` to an external signal `A`, returning `Signal<[S, A]>`.
  *
- * The S state starts as `init` and lives locally — not accessible
- * from outside except via the returned signal's focus(fst()) / focus(snd()).
+ * The `S` state starts as `init` and lives locally — not observable
+ * from outside except via `.focus(index(0))` / `.focus(index(1))`.
  *
- * Unicorn equivalent: `stateful init widget`
+ * @param init - Initial value for the local state.
+ * @param outer - The external signal to pair with.
  *
- * Usage:
- *   const combined = stateful("", itemsSignal)  // Signal<[string, Item[]]>
- *   const draft = combined.focus(fst())          // Signal<string>  — local
- *   const items = combined.focus(snd())          // Signal<Item[]>  — external
+ * @example
+ *   const combined = stateful("", itemsSignal)    // Signal<[string, Item[]]>
+ *   const draft = combined.focus(index(0))        // Signal<string>  — local
+ *   const items = combined.focus(index(1))        // Signal<Item[]>  — external
  */
 export declare function stateful<S, A>(init: S, outer: Signal<A>): Signal<[S, A]>;

package/dist/rainbow.js

@@ -1,62 +1,107 @@
-var d = Object.defineProperty;
-var w = (s, t, e) => t in s ? d(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
-var u = (s, t, e) => w(s, typeof t != "symbol" ? t + "" : t, e);
-function _(s, t) {
-  return { get: s, set: t };
+var j = Object.defineProperty;
+var S = (e, t, s) => t in e ? j(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s;
+var u = (e, t, s) => S(e, typeof t != "symbol" ? t + "" : t, s);
+function a(e, t) {
+  return { view: e, review: t };
 }
-function P(s, t) {
+function F(e, t) {
   return {
-    get: (e) => t.get(s.get(e)),
-    set: (e, r) => s.set(e, t.set(s.get(e), r))
+    view: (s) => t.view(e.view(s)),
+    review: (s, r) => e.review(t.review(s, e.view(r)), r)
   };
 }
-const z = () => _(([s]) => s, ([, s], t) => [t, s]), C = () => _(([, s]) => s, ([s], t) => [s, t]);
-function F(s) {
-  return _(
-    (t) => t[s],
-    (t, e) => ({ ...t, [s]: e })
+function I(e) {
+  return a(
+    (t) => t[e],
+    (t, s) => {
+      const r = [...s];
+      return r[e] = t, r;
+    }
   );
 }
-function N() {
-  return _((s) => s, (s, t) => t);
+function R(e) {
+  return a(
+    (t) => t[e],
+    (t, s) => ({ ...s, [e]: t })
+  );
+}
+function T() {
+  return a((e) => e, (e) => e);
+}
+function V(e) {
+  return a(
+    (t) => t.map((s) => e.view(s)),
+    (t, s) => s.map((r, n) => e.review(t[n], r))
+  );
+}
+function W(e) {
+  return a(
+    (t) => Object.fromEntries(Object.entries(t).map(([s, r]) => [s, e.view(r)])),
+    (t, s) => Object.fromEntries(Object.entries(s).map(([r, n]) => [r, e.review(t[r], n)]))
+  );
 }
-function p(s, t) {
-  return { match: s, inject: t };
+function q(e) {
+  return a(
+    (t) => new Map([...t].map(([s, r]) => [s, e.view(r)])),
+    (t, s) => new Map([...s].map(([r, n]) => [r, e.review(t.get(r), n)]))
+  );
 }
-function R(s, t) {
+function f(e, t) {
+  return { view: e, review: t };
+}
+function B(e, t) {
   return {
-    match: (e) => {
-      const r = s.match(e);
-      return r !== void 0 ? t.match(r) : void 0;
+    view: (s) => {
+      const r = e.view(s);
+      return r !== void 0 ? t.view(r) : void 0;
     },
-    inject: (e) => s.inject(t.inject(e))
+    review: (s) => e.review(t.review(s))
   };
 }
-function T() {
-  return p(
-    (s) => s,
-    (s) => s
+function G() {
+  return f(
+    (e) => e,
+    (e) => e
+  );
+}
+function H(e, t) {
+  return f(e, t);
+}
+function J(e) {
+  return f(
+    (t) => e(t) ? t : void 0,
+    (t) => t
   );
 }
-function W(s, t) {
-  return p(s, t);
+function K() {
+  return f(
+    (e) => e !== null ? e : void 0,
+    (e) => e
+  );
+}
+function Q(e, t) {
+  return f(
+    (s) => s[e] === t ? s : void 0,
+    // Extract<A, Record<K,V>> extends A, so this upcast is safe
+    (s) => s
+  );
 }
-let l = 0;
-const f = /* @__PURE__ */ new Map();
-function v(s) {
-  l++;
+let p = 0;
+const _ = /* @__PURE__ */ new Map();
+function k(e) {
+  p++;
   try {
-    s();
+    e();
   } finally {
-    if (l--, l === 0)
-      for (; f.size > 0; ) {
-        const t = [...f.values()];
-        f.clear();
-        for (const e of t) e();
+    if (p--, p === 0)
+      for (; _.size > 0; ) {
+        const t = [..._.values()];
+        _.clear();
+        for (const s of t) s();
       }
   }
 }
-class A {
+class x {
   constructor(t) {
     u(this, "_value");
     u(this, "_subscribers", /* @__PURE__ */ new Set());
@@ -67,292 +112,356 @@ class A {
   }
   set(t) {
     if (!Object.is(this._value, t))
-      if (this._value = t, l > 0)
-        for (const e of this._subscribers)
-          f.set(e, () => e(this._value));
+      if (this._value = t, p > 0)
+        for (const s of this._subscribers)
+          _.set(s, () => s(this._value));
       else
-        for (const e of this._subscribers) e(t);
+        for (const s of this._subscribers) s(t);
   }
   subscribe(t) {
     return this._subscribers.add(t), () => this._subscribers.delete(t);
   }
   map(t) {
-    return new c(this, t);
+    return new h(this, t);
   }
   focus(t) {
-    return new o(this, t);
+    return new b(this, t);
   }
   narrow(t) {
-    return new a(this, t);
+    return new w(this, t);
   }
 }
-class c {
-  constructor(t, e) {
+class h {
+  constructor(t, s) {
     u(this, "_source");
     u(this, "_f");
-    this._source = t, this._f = e;
+    this._source = t, this._f = s;
   }
   get() {
     return this._f(this._source.get());
   }
   subscribe(t) {
-    let e = this.get();
+    let s = this.get();
     return this._source.subscribe(() => {
       const r = this.get();
-      Object.is(e, r) || (e = r, t(r));
+      Object.is(s, r) || (s = r, t(r));
     });
   }
   map(t) {
-    return new c(this, t);
+    return new h(this, t);
   }
 }
-class o {
-  constructor(t, e) {
+class b {
+  constructor(t, s) {
     u(this, "_source");
     u(this, "_lens");
-    this._source = t, this._lens = e;
+    this._source = t, this._lens = s;
   }
   get() {
-    return this._lens.get(this._source.get());
+    return this._lens.view(this._source.get());
   }
   set(t) {
-    this._source.set(this._lens.set(this._source.get(), t));
+    this._source.set(this._lens.review(t, this._source.get()));
   }
   subscribe(t) {
-    let e = this.get();
+    let s = this.get();
     return this._source.subscribe(() => {
       const r = this.get();
-      Object.is(e, r) || (e = r, t(r));
+      Object.is(s, r) || (s = r, t(r));
     });
   }
   map(t) {
-    return new c(this, t);
+    return new h(this, t);
   }
   focus(t) {
-    return new o(this, t);
+    return new b(this, t);
   }
   narrow(t) {
-    return new a(this, t);
+    return new w(this, t);
   }
 }
-class a {
-  constructor(t, e) {
+class w {
+  constructor(t, s) {
     u(this, "_source");
     u(this, "_prism");
-    this._source = t, this._prism = e;
+    this._source = t, this._prism = s;
   }
   get() {
-    return this._prism.match(this._source.get());
+    return this._prism.view(this._source.get());
   }
   set(t) {
-    t !== void 0 && this._source.set(this._prism.inject(t));
+    t !== void 0 && this._source.set(this._prism.review(t));
   }
   subscribe(t) {
-    let e = this.get();
+    let s = this.get();
     return this._source.subscribe(() => {
       const r = this.get();
-      Object.is(e, r) || (e = r, t(r));
+      Object.is(s, r) || (s = r, t(r));
     });
   }
   map(t) {
-    return new c(this, t);
+    return new h(this, t);
   }
   focus(t) {
-    return new o(this, t);
+    return new b(this, t);
   }
   narrow(t) {
-    return new a(this, t);
+    return new w(this, t);
   }
 }
-function m(s) {
-  return new A(s);
+function g(e) {
+  return new x(e);
 }
-function j(s, t) {
-  return new o(s, t);
+function E(e, t) {
+  return new b(e, t);
 }
-function k(s, t) {
-  return new a(s, t);
+function P(e, t) {
+  return new w(e, t);
 }
-function y(s, t) {
-  return new O(s, t);
+function C(e, t) {
+  return new M(e, t);
 }
-class O {
-  constructor(t, e) {
+class M {
+  constructor(t, s) {
     u(this, "_fn");
     u(this, "_deps");
-    this._fn = t, this._deps = e;
+    this._fn = t, this._deps = s;
   }
   get() {
     return this._fn();
   }
   subscribe(t) {
-    let e = this.get();
+    let s = this.get();
     const r = this._deps.map(
       (n) => n.subscribe(() => {
         const i = this.get();
-        Object.is(e, i) || (e = i, t(i));
+        Object.is(s, i) || (s = i, t(i));
       })
     );
     return () => r.forEach((n) => n());
   }
   map(t) {
-    return y(() => t(this.get()), [this]);
+    return C(() => t(this.get()), [this]);
   }
 }
-function q(s, t) {
-  return t.map((e) => e !== void 0 && s(e) ? e : void 0);
+function U(e, t) {
+  return t.map((s) => s !== void 0 && e(s) ? s : void 0);
 }
-class S {
-  constructor(t, e) {
-    this._a = t, this._b = e;
+class D {
+  constructor(t, s) {
+    this._a = t, this._b = s;
   }
   get() {
     return [this._a.get(), this._b.get()];
   }
-  set([t, e]) {
-    v(() => {
-      this._a.set(t), this._b.set(e);
+  set([t, s]) {
+    k(() => {
+      this._a.set(t), this._b.set(s);
     });
   }
   subscribe(t) {
-    const e = () => t(this.get()), r = this._a.subscribe(e), n = this._b.subscribe(e);
+    const s = () => t(this.get()), r = this._a.subscribe(s), n = this._b.subscribe(s);
     return () => {
       r(), n();
     };
   }
   map(t) {
-    let e = t(this.get());
-    const r = m(e);
+    let s = t(this.get());
+    const r = g(s);
     return this.subscribe((n) => {
       const i = t(n);
-      Object.is(e, i) || (e = i, r.set(i));
+      Object.is(s, i) || (s = i, r.set(i));
     }), r;
   }
   focus(t) {
-    return j(this, t);
+    return E(this, t);
   }
   narrow(t) {
-    return k(this, t);
+    return P(this, t);
   }
 }
-function x(s, t) {
-  return new S(s, t);
+function L(e, t) {
+  return new D(e, t);
 }
-function B(s, t) {
-  return x(m(s), t);
+function X(e, t) {
+  return L(g(e), t);
 }
-function h(s, t) {
-  return { getAll: s, modify: t };
+function v(e, t) {
+  return { getAll: e, modify: t };
 }
-function G() {
-  return h(
-    (s) => [...s],
-    (s, t) => s.map(t)
+function Y() {
+  return v(
+    (e) => [...e],
+    (e, t) => e.map(t)
   );
 }
-function H(s) {
-  return h(
-    (t) => t.filter(s),
-    (t, e) => t.map((r) => s(r) ? e(r) : r)
+function Z(e) {
+  return v(
+    (t) => t.filter(e),
+    (t, s) => t.map((r) => e(r) ? s(r) : r)
   );
 }
-function I(s) {
-  return h(
-    (t) => t.filter((e, r) => r === s),
-    (t, e) => t.map((r, n) => n === s ? e(r) : r)
+function $(e) {
+  return v(
+    (t) => t.filter((s, r) => r === e),
+    (t, s) => t.map((r, n) => n === e ? s(r) : r)
   );
 }
-function J(s, t) {
-  return h(
-    (e) => t.getAll(s.get(e)),
-    (e, r) => s.set(e, t.modify(s.get(e), r))
+function tt(e, t) {
+  return v(
+    (s) => t.getAll(e.view(s)),
+    (s, r) => e.review(t.modify(e.view(s), r), s)
   );
 }
-function K(s, t) {
-  return h(
-    (e) => s.getAll(e).flatMap((r) => t.getAll(r)),
-    (e, r) => s.modify(e, (n) => t.modify(n, r))
+function et(e, t) {
+  return v(
+    (s) => e.getAll(s).flatMap((r) => t.getAll(r)),
+    (s, r) => e.modify(s, (n) => t.modify(n, r))
   );
 }
-const g = { status: "notAsked" }, b = { status: "loading" }, D = (s) => ({ status: "failure", error: s }), E = (s) => ({ status: "success", value: s }), Q = (s) => s.status === "notAsked", U = (s) => s.status === "loading", V = (s) => s.status === "failure", L = (s) => s.status === "success", X = (s, t) => {
-  switch (s.status) {
+const d = { status: "notAsked" }, c = { status: "loading" }, m = (e) => ({ status: "failure", error: e }), A = (e) => ({ status: "success", value: e }), st = (e) => e.status === "notAsked", rt = (e) => e.status === "loading", nt = (e) => e.status === "failure", N = (e) => e.status === "success", it = (e, t) => {
+  switch (e.status) {
     case "success":
-      return E(t(s.value));
+      return A(t(e.value));
     case "failure":
-      return s;
+      return e;
     case "loading":
-      return b;
+      return c;
     case "notAsked":
-      return g;
+      return d;
   }
-}, Y = (s, t) => {
-  switch (s.status) {
+}, ut = (e, t) => {
+  switch (e.status) {
     case "failure":
-      return D(t(s.error));
+      return m(t(e.error));
     case "success":
-      return s;
+      return e;
     case "loading":
-      return b;
+      return c;
     case "notAsked":
-      return g;
+      return d;
   }
-}, Z = (s, t) => {
-  switch (s.status) {
+}, ot = (e, t) => {
+  switch (e.status) {
     case "success":
-      return t(s.value);
+      return t(e.value);
     case "failure":
-      return s;
+      return e;
     case "loading":
-      return b;
+      return c;
     case "notAsked":
-      return g;
+      return d;
   }
-}, $ = (s, t) => L(s) ? s.value : t, tt = (s, t) => {
-  switch (s.status) {
+}, ct = (e, t) => N(e) ? e.value : t, at = (e, t) => {
+  switch (e.status) {
     case "notAsked":
       return t.notAsked();
     case "loading":
       return t.loading();
     case "failure":
-      return t.failure(s.error);
+      return t.failure(e.error);
     case "success":
-      return t.success(s.value);
+      return t.success(e.value);
   }
 };
+function lt(e) {
+  const t = g(c);
+  return e.then(
+    (s) => t.set(A(s)),
+    (s) => t.set(m(s))
+  ), t;
+}
+function ft(e, t) {
+  const s = g(c);
+  let r = new AbortController();
+  const n = (l) => {
+    r.abort(), r = new AbortController(), s.set(c);
+    const { signal: o } = r;
+    t(l, o).then(
+      (O) => {
+        o.aborted || s.set(A(O));
+      },
+      (O) => {
+        o.aborted || s.set(m(O));
+      }
+    );
+  };
+  n(e.get());
+  const i = e.subscribe(n);
+  return [s, () => {
+    r.abort(), i();
+  }];
+}
+function ht(e) {
+  const t = g(d);
+  let s = null, r = !1;
+  return { result: t, trigger: (y) => {
+    if (r) return;
+    s !== null && s.abort(), s = new AbortController(), t.set(c);
+    const { signal: l } = s;
+    e(y, l).then(
+      (o) => {
+        !l.aborted && !r && t.set(A(o));
+      },
+      (o) => {
+        !l.aborted && !r && t.set(m(o));
+      }
+    );
+  }, dispose: () => {
+    r = !0, s !== null && (s.abort(), s = null);
+  } };
+}
+function bt(e, t) {
+  const s = e.get();
+  return t === void 0 || t(s) ? Promise.resolve(s) : new Promise((r) => {
+    const n = e.subscribe((i) => {
+      t(i) && (n(), r(i));
+    });
+  });
+}
 export {
-  v as batch,
-  Z as chainAsyncData,
-  P as composeLens,
-  R as composePrism,
-  K as composeTraversal,
-  J as composeWithLens,
-  y as computed,
-  q as cond,
-  G as each,
-  D as failure,
-  F as field,
-  H as filtered,
-  tt as fold,
-  z as fst,
-  $ as getOrElse,
-  N as id,
-  V as isFailure,
-  U as isLoading,
-  Q as isNotAsked,
-  L as isSuccess,
-  W as iso,
-  _ as lens,
-  b as loading,
-  X as mapAsyncData,
-  Y as mapError,
-  g as notAsked,
-  I as nth,
-  p as prism,
-  x as product,
-  m as signal,
-  C as snd,
-  T as some,
-  B as stateful,
-  E as success,
-  h as traversal
+  V as arrayOf,
+  k as batch,
+  ot as chainAsyncData,
+  F as composeLens,
+  B as composePrism,
+  et as composeTraversal,
+  tt as composeWithLens,
+  C as computed,
+  U as cond,
+  Y as each,
+  m as failure,
+  R as field,
+  Z as filtered,
+  at as fold,
+  ft as fromAsync,
+  ht as fromAsyncImperative,
+  lt as fromPromise,
+  ct as getOrElse,
+  J as guard,
+  T as id,
+  I as index,
+  nt as isFailure,
+  rt as isLoading,
+  st as isNotAsked,
+  N as isSuccess,
+  H as iso,
+  a as lens,
+  c as loading,
+  it as mapAsyncData,
+  ut as mapError,
+  q as mapOf,
+  d as notAsked,
+  $ as nth,
+  K as nullable,
+  f as prism,
+  L as product,
+  W as recordOf,
+  g as signal,
+  G as some,
+  X as stateful,
+  A as success,
+  Q as tagged,
+  bt as toNextValue,
+  v as traversal
 };

package/dist/rainbow.umd.cjs

@@ -1 +1 @@
-(function(n,i){typeof exports=="object"&&typeof module<"u"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(n=typeof globalThis<"u"?globalThis:n||self,i(n.Rainbow={}))})(this,(function(n){"use strict";var x=Object.defineProperty;var tt=(n,i,a)=>i in n?x(n,i,{enumerable:!0,configurable:!0,writable:!0,value:a}):n[i]=a;var c=(n,i,a)=>tt(n,typeof i!="symbol"?i+"":i,a);function i(s,t){return{get:s,set:t}}function a(s,t){return{get:e=>t.get(s.get(e)),set:(e,r)=>s.set(e,t.set(s.get(e),r))}}const O=()=>i(([s])=>s,([,s],t)=>[t,s]),L=()=>i(([,s])=>s,([s],t)=>[s,t]);function E(s){return i(t=>t[s],(t,e)=>({...t,[s]:e}))}function T(){return i(s=>s,(s,t)=>t)}function w(s,t){return{match:s,inject:t}}function P(s,t){return{match:e=>{const r=s.match(e);return r!==void 0?t.match(r):void 0},inject:e=>s.inject(t.inject(e))}}function D(){return w(s=>s,s=>s)}function M(s,t){return w(s,t)}let d=0;const _=new Map;function p(s){d++;try{s()}finally{if(d--,d===0)for(;_.size>0;){const t=[..._.values()];_.clear();for(const e of t)e()}}}class F{constructor(t){c(this,"_value");c(this,"_subscribers",new Set);this._value=t}get(){return this._value}set(t){if(!Object.is(this._value,t))if(this._value=t,d>0)for(const e of this._subscribers)_.set(e,()=>e(this._value));else for(const e of this._subscribers)e(t)}subscribe(t){return this._subscribers.add(t),()=>this._subscribers.delete(t)}map(t){return new f(this,t)}focus(t){return new l(this,t)}narrow(t){return new g(this,t)}}class f{constructor(t,e){c(this,"_source");c(this,"_f");this._source=t,this._f=e}get(){return this._f(this._source.get())}subscribe(t){let e=this.get();return this._source.subscribe(()=>{const r=this.get();Object.is(e,r)||(e=r,t(r))})}map(t){return new f(this,t)}}class l{constructor(t,e){c(this,"_source");c(this,"_lens");this._source=t,this._lens=e}get(){return this._lens.get(this._source.get())}set(t){this._source.set(this._lens.set(this._source.get(),t))}subscribe(t){let e=this.get();return this._source.subscribe(()=>{const r=this.get();Object.is(e,r)||(e=r,t(r))})}map(t){return new f(this,t)}focus(t){return new l(this,t)}narrow(t){return new g(this,t)}}class g{constructor(t,e){c(this,"_source");c(this,"_prism");this._source=t,this._prism=e}get(){return this._prism.match(this._source.get())}set(t){t!==void 0&&this._source.set(this._prism.inject(t))}subscribe(t){let e=this.get();return this._source.subscribe(()=>{const r=this.get();Object.is(e,r)||(e=r,t(r))})}map(t){return new f(this,t)}focus(t){return new l(this,t)}narrow(t){return new g(this,t)}}function v(s){return new F(s)}function N(s,t){return new l(s,t)}function R(s,t){return new g(s,t)}function A(s,t){return new W(s,t)}class W{constructor(t,e){c(this,"_fn");c(this,"_deps");this._fn=t,this._deps=e}get(){return this._fn()}subscribe(t){let e=this.get();const r=this._deps.map(u=>u.subscribe(()=>{const o=this.get();Object.is(e,o)||(e=o,t(o))}));return()=>r.forEach(u=>u())}map(t){return A(()=>t(this.get()),[this])}}function z(s,t){return t.map(e=>e!==void 0&&s(e)?e:void 0)}class C{constructor(t,e){this._a=t,this._b=e}get(){return[this._a.get(),this._b.get()]}set([t,e]){p(()=>{this._a.set(t),this._b.set(e)})}subscribe(t){const e=()=>t(this.get()),r=this._a.subscribe(e),u=this._b.subscribe(e);return()=>{r(),u()}}map(t){let e=t(this.get());const r=v(e);return this.subscribe(u=>{const o=t(u);Object.is(e,o)||(e=o,r.set(o))}),r}focus(t){return N(this,t)}narrow(t){return R(this,t)}}function j(s,t){return new C(s,t)}function q(s,t){return j(v(s),t)}function h(s,t){return{getAll:s,modify:t}}function B(){return h(s=>[...s],(s,t)=>s.map(t))}function G(s){return h(t=>t.filter(s),(t,e)=>t.map(r=>s(r)?e(r):r))}function H(s){return h(t=>t.filter((e,r)=>r===s),(t,e)=>t.map((r,u)=>u===s?e(r):r))}function I(s,t){return h(e=>t.getAll(s.get(e)),(e,r)=>s.set(e,t.modify(s.get(e),r)))}function J(s,t){return h(e=>s.getAll(e).flatMap(r=>t.getAll(r)),(e,r)=>s.modify(e,u=>t.modify(u,r)))}const b={status:"notAsked"},m={status:"loading"},k=s=>({status:"failure",error:s}),y=s=>({status:"success",value:s}),K=s=>s.status==="notAsked",Q=s=>s.status==="loading",U=s=>s.status==="failure",S=s=>s.status==="success",V=(s,t)=>{switch(s.status){case"success":return y(t(s.value));case"failure":return s;case"loading":return m;case"notAsked":return b}},X=(s,t)=>{switch(s.status){case"failure":return k(t(s.error));case"success":return s;case"loading":return m;case"notAsked":return b}},Y=(s,t)=>{switch(s.status){case"success":return t(s.value);case"failure":return s;case"loading":return m;case"notAsked":return b}},Z=(s,t)=>S(s)?s.value:t,$=(s,t)=>{switch(s.status){case"notAsked":return t.notAsked();case"loading":return t.loading();case"failure":return t.failure(s.error);case"success":return t.success(s.value)}};n.batch=p,n.chainAsyncData=Y,n.composeLens=a,n.composePrism=P,n.composeTraversal=J,n.composeWithLens=I,n.computed=A,n.cond=z,n.each=B,n.failure=k,n.field=E,n.filtered=G,n.fold=$,n.fst=O,n.getOrElse=Z,n.id=T,n.isFailure=U,n.isLoading=Q,n.isNotAsked=K,n.isSuccess=S,n.iso=M,n.lens=i,n.loading=m,n.mapAsyncData=V,n.mapError=X,n.notAsked=b,n.nth=H,n.prism=w,n.product=j,n.signal=v,n.snd=L,n.some=D,n.stateful=q,n.success=y,n.traversal=h,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));
+(function(r,u){typeof exports=="object"&&typeof module<"u"?u(exports):typeof define=="function"&&define.amd?define(["exports"],u):(r=typeof globalThis<"u"?globalThis:r||self,u(r.Rainbow={}))})(this,(function(r){"use strict";var he=Object.defineProperty;var de=(r,u,f)=>u in r?he(r,u,{enumerable:!0,configurable:!0,writable:!0,value:f}):r[u]=f;var o=(r,u,f)=>de(r,typeof u!="symbol"?u+"":u,f);function u(t,e){return{view:t,review:e}}function f(t,e){return{view:s=>e.view(t.view(s)),review:(s,n)=>t.review(e.review(s,t.view(n)),n)}}function M(t){return u(e=>e[t],(e,s)=>{const n=[...s];return n[t]=e,n})}function T(t){return u(e=>e[t],(e,s)=>({...s,[t]:e}))}function C(){return u(t=>t,t=>t)}function N(t){return u(e=>e.map(s=>t.view(s)),(e,s)=>s.map((n,i)=>t.review(e[i],n)))}function D(t){return u(e=>Object.fromEntries(Object.entries(e).map(([s,n])=>[s,t.view(n)])),(e,s)=>Object.fromEntries(Object.entries(s).map(([n,i])=>[n,t.review(e[n],i)])))}function F(t){return u(e=>new Map([...e].map(([s,n])=>[s,t.view(n)])),(e,s)=>new Map([...s].map(([n,i])=>[n,t.review(e.get(n),i)])))}function h(t,e){return{view:t,review:e}}function I(t,e){return{view:s=>{const n=t.view(s);return n!==void 0?e.view(n):void 0},review:s=>t.review(e.review(s))}}function R(){return h(t=>t,t=>t)}function V(t,e){return h(t,e)}function W(t){return h(e=>t(e)?e:void 0,e=>e)}function z(){return h(t=>t!==null?t:void 0,t=>t)}function q(t,e){return h(s=>s[t]===e?s:void 0,s=>s)}let O=0;const y=new Map;function S(t){O++;try{t()}finally{if(O--,O===0)for(;y.size>0;){const e=[...y.values()];y.clear();for(const s of e)s()}}}class B{constructor(e){o(this,"_value");o(this,"_subscribers",new Set);this._value=e}get(){return this._value}set(e){if(!Object.is(this._value,e))if(this._value=e,O>0)for(const s of this._subscribers)y.set(s,()=>s(this._value));else for(const s of this._subscribers)s(e)}subscribe(e){return this._subscribers.add(e),()=>this._subscribers.delete(e)}map(e){return new g(this,e)}focus(e){return new m(this,e)}narrow(e){return new w(this,e)}}class g{constructor(e,s){o(this,"_source");o(this,"_f");this._source=e,this._f=s}get(){return this._f(this._source.get())}subscribe(e){let s=this.get();return this._source.subscribe(()=>{const n=this.get();Object.is(s,n)||(s=n,e(n))})}map(e){return new g(this,e)}}class m{constructor(e,s){o(this,"_source");o(this,"_lens");this._source=e,this._lens=s}get(){return this._lens.view(this._source.get())}set(e){this._source.set(this._lens.review(e,this._source.get()))}subscribe(e){let s=this.get();return this._source.subscribe(()=>{const n=this.get();Object.is(s,n)||(s=n,e(n))})}map(e){return new g(this,e)}focus(e){return new m(this,e)}narrow(e){return new w(this,e)}}class w{constructor(e,s){o(this,"_source");o(this,"_prism");this._source=e,this._prism=s}get(){return this._prism.view(this._source.get())}set(e){e!==void 0&&this._source.set(this._prism.review(e))}subscribe(e){let s=this.get();return this._source.subscribe(()=>{const n=this.get();Object.is(s,n)||(s=n,e(n))})}map(e){return new g(this,e)}focus(e){return new m(this,e)}narrow(e){return new w(this,e)}}function d(t){return new B(t)}function G(t,e){return new m(t,e)}function H(t,e){return new w(t,e)}function k(t,e){return new J(t,e)}class J{constructor(e,s){o(this,"_fn");o(this,"_deps");this._fn=e,this._deps=s}get(){return this._fn()}subscribe(e){let s=this.get();const n=this._deps.map(i=>i.subscribe(()=>{const c=this.get();Object.is(s,c)||(s=c,e(c))}));return()=>n.forEach(i=>i())}map(e){return k(()=>e(this.get()),[this])}}function K(t,e){return e.map(s=>s!==void 0&&t(s)?s:void 0)}class Q{constructor(e,s){this._a=e,this._b=s}get(){return[this._a.get(),this._b.get()]}set([e,s]){S(()=>{this._a.set(e),this._b.set(s)})}subscribe(e){const s=()=>e(this.get()),n=this._a.subscribe(s),i=this._b.subscribe(s);return()=>{n(),i()}}map(e){let s=e(this.get());const n=d(s);return this.subscribe(i=>{const c=e(i);Object.is(s,c)||(s=c,n.set(c))}),n}focus(e){return G(this,e)}narrow(e){return H(this,e)}}function P(t,e){return new Q(t,e)}function U(t,e){return P(d(t),e)}function b(t,e){return{getAll:t,modify:e}}function X(){return b(t=>[...t],(t,e)=>t.map(e))}function Y(t){return b(e=>e.filter(t),(e,s)=>e.map(n=>t(n)?s(n):n))}function Z(t){return b(e=>e.filter((s,n)=>n===t),(e,s)=>e.map((n,i)=>i===t?s(n):n))}function $(t,e){return b(s=>e.getAll(t.view(s)),(s,n)=>t.review(e.modify(t.view(s),n),s))}function x(t,e){return b(s=>t.getAll(s).flatMap(n=>e.getAll(n)),(s,n)=>t.modify(s,i=>e.modify(i,n)))}const v={status:"notAsked"},a={status:"loading"},_=t=>({status:"failure",error:t}),p=t=>({status:"success",value:t}),ee=t=>t.status==="notAsked",te=t=>t.status==="loading",se=t=>t.status==="failure",E=t=>t.status==="success",ne=(t,e)=>{switch(t.status){case"success":return p(e(t.value));case"failure":return t;case"loading":return a;case"notAsked":return v}},re=(t,e)=>{switch(t.status){case"failure":return _(e(t.error));case"success":return t;case"loading":return a;case"notAsked":return v}},ie=(t,e)=>{switch(t.status){case"success":return e(t.value);case"failure":return t;case"loading":return a;case"notAsked":return v}},ue=(t,e)=>E(t)?t.value:e,ce=(t,e)=>{switch(t.status){case"notAsked":return e.notAsked();case"loading":return e.loading();case"failure":return e.failure(t.error);case"success":return e.success(t.value)}};function oe(t){const e=d(a);return t.then(s=>e.set(p(s)),s=>e.set(_(s))),e}function ae(t,e){const s=d(a);let n=new AbortController;const i=A=>{n.abort(),n=new AbortController,s.set(a);const{signal:l}=n;e(A,l).then(j=>{l.aborted||s.set(p(j))},j=>{l.aborted||s.set(_(j))})};i(t.get());const c=t.subscribe(i);return[s,()=>{n.abort(),c()}]}function le(t){const e=d(v);let s=null,n=!1;return{result:e,trigger:L=>{if(n)return;s!==null&&s.abort(),s=new AbortController,e.set(a);const{signal:A}=s;t(L,A).then(l=>{!A.aborted&&!n&&e.set(p(l))},l=>{!A.aborted&&!n&&e.set(_(l))})},dispose:()=>{n=!0,s!==null&&(s.abort(),s=null)}}}function fe(t,e){const s=t.get();return e===void 0||e(s)?Promise.resolve(s):new Promise(n=>{const i=t.subscribe(c=>{e(c)&&(i(),n(c))})})}r.arrayOf=N,r.batch=S,r.chainAsyncData=ie,r.composeLens=f,r.composePrism=I,r.composeTraversal=x,r.composeWithLens=$,r.computed=k,r.cond=K,r.each=X,r.failure=_,r.field=T,r.filtered=Y,r.fold=ce,r.fromAsync=ae,r.fromAsyncImperative=le,r.fromPromise=oe,r.getOrElse=ue,r.guard=W,r.id=C,r.index=M,r.isFailure=se,r.isLoading=te,r.isNotAsked=ee,r.isSuccess=E,r.iso=V,r.lens=u,r.loading=a,r.mapAsyncData=ne,r.mapError=re,r.mapOf=F,r.notAsked=v,r.nth=Z,r.nullable=z,r.prism=h,r.product=P,r.recordOf=D,r.signal=d,r.some=R,r.stateful=U,r.success=p,r.tagged=q,r.toNextValue=fe,r.traversal=b,Object.defineProperty(r,Symbol.toStringTag,{value:"Module"})}));

package/dist/signal.d.ts

@@ -13,22 +13,47 @@ export declare function batch(fn: () => void): void;
  * Reading tracks the dependency; writing propagates to subscribers.
  */
 export interface Signal<A> {
+    /** Return the current value. */
     get(): A;
+    /** Update the value and notify subscribers. No-op if the value is unchanged (`Object.is`). */
     set(a: A): void;
+    /**
+     * Subscribe to value changes.
+     * @returns An unsubscribe function.
+     */
     subscribe(fn: Subscriber<A>): () => void;
-    /** Read-only derived signal */
+    /** Return a read-only derived signal by applying `f` to each value. */
     map<B>(f: (a: A) => B): ReadonlySignal<B>;
-    /** Read-write focused signal via lens */
+    /** Return a read-write signal focused on B via a lens. */
     focus<B>(lens: Lens<A, B>): Signal<B>;
-    /** Read-write focused signal via prism (undefined when case doesn't match) */
+    /** Return a read-write signal focused via a prism; yields `undefined` when the case doesn't match. */
     narrow<B>(prism: Prism<A, B>): Signal<B | undefined>;
 }
+/** A read-only view of a reactive value. */
 export interface ReadonlySignal<A> {
+    /** Return the current value. */
     get(): A;
+    /**
+     * Subscribe to value changes.
+     * @returns An unsubscribe function.
+     */
     subscribe(fn: Subscriber<A>): () => void;
+    /** Return a read-only derived signal by applying `f` to each value. */
     map<B>(f: (a: A) => B): ReadonlySignal<B>;
 }
+/**
+ * Create a root signal with the given initial value.
+ * @param initial - The starting value.
+ */
 export declare function signal<A>(initial: A): Signal<A>;
+/**
+ * Create a signal focused on part of another signal via a lens.
+ * Reads and writes pass through the lens; the source signal is the source of truth.
+ */
 export declare function focusSignal<A, B>(source: Signal<A>, lens: Lens<A, B>): Signal<B>;
+/**
+ * Create a signal focused on a prism case of another signal.
+ * Yields `undefined` when the prism doesn't match; writes are no-ops when `b` is `undefined`.
+ */
 export declare function narrowSignal<A, B>(source: Signal<A>, prism: Prism<A, B>): Signal<B | undefined>;
 export {};

package/dist/traversal.d.ts

@@ -7,17 +7,36 @@ import type { Lens } from './lens.ts';
  *   modify(modify(a, f), g) = modify(a, g ∘ f)   [when f, g commute on elements]
  */
 export interface Traversal<A, B> {
+    /** Extract all focused values from `a`. */
     getAll(a: A): B[];
+    /** Apply `f` to every focused value and return the updated `a`. */
     modify(a: A, f: (b: B) => B): A;
 }
+/**
+ * Construct a traversal from explicit getAll and modify functions.
+ * @param getAll - Extract all focused values.
+ * @param modify - Apply a function to every focused value.
+ */
 export declare function traversal<A, B>(getAll: (a: A) => B[], modify: (a: A, f: (b: B) => B) => A): Traversal<A, B>;
 /** Focus on every element of an array */
 export declare function each<B>(): Traversal<B[], B>;
-/** Focus on elements matching a predicate */
+/**
+ * Focus on elements matching a predicate.
+ * Non-matching elements pass through unmodified.
+ */
 export declare function filtered<B>(pred: (b: B) => boolean): Traversal<B[], B>;
-/** Focus on a single element by index */
+/**
+ * Focus on a single element by index.
+ * If the index is out of bounds, `getAll` returns `[]` and `modify` is a no-op.
+ */
 export declare function nth<B>(index: number): Traversal<B[], B>;
-/** Compose a lens with a traversal */
+/**
+ * Compose a lens with a traversal.
+ * Focuses the lens on B within A, then the traversal on C within B.
+ */
 export declare function composeWithLens<A, B extends object, C>(lens: Lens<A, B>, t: Traversal<B, C>): Traversal<A, C>;
-/** Compose two traversals */
+/**
+ * Compose two traversals.
+ * `getAll` flatMaps; `modify` nests.
+ */
 export declare function composeTraversal<A, B, C>(ab: Traversal<A, B>, bc: Traversal<B, C>): Traversal<A, C>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhi-zone/rainbow",
-  "version": "0.1.0",
+  "version": "0.2.0-alpha.0",
   "description": "Optics-based reactivity — structured state for the web",
   "type": "module",
   "main": "./dist/rainbow.umd.cjs",
@@ -15,18 +15,18 @@
   },
   "files": ["dist"],
   "scripts": {
-    "dev": "vite build --watch",
-    "build": "vite build && tsgo --emitDeclarationOnly",
-    "typecheck": "tsgo --noEmit",
-    "test": "vitest run",
+    "dev":        "vite build --watch",
+    "build":      "vite build && tsgo --emitDeclarationOnly",
+    "typecheck":  "tsgo --noEmit",
+    "test":       "vitest run",
     "test:watch": "vitest"
   },
   "devDependencies": {
-    "@types/react": "^19.2.14",
+    "@types/react":      "^19.2.14",
     "@vitejs/plugin-vue": "^6.0.4",
-    "fast-check": "^4.5.3",
-    "vite": "^6.0.0",
-    "vitest": "^2.0.0",
-    "vue": "^3.5.29"
+    "fast-check":        "^4.5.3",
+    "vite":              "^6.0.0",
+    "vitest":            "^2.0.0",
+    "vue":               "^3.5.29"
   }
 }