@mocanvas/state 1.0.0 → 4.0.0

package/dist/index.d.ts

@@ -1,144 +1,98 @@
-/**
- * Fine-grained reactive signals.
- *
- * Model
- * -----
- * - A single global epoch counter advances on every atom write.
- * - Every signal remembers `lastChangedEpoch`, the epoch of the write that
- *   last changed its value.
- * - Computeds are lazy and pull-based: `get()` verifies the cached value by
- *   comparing the `lastChangedEpoch` of each recorded parent against the
- *   epoch at which the computed was last verified (`lastCheckedEpoch`).
- *   Recomputation happens only when a parent actually changed.
- * - Reactions (effects) are push-notified: an atom write walks the children
- *   graph and marks reachable reactions pending. Pending reactions execute
- *   once, after the outermost transaction commits, and re-check their
- *   dependencies' epochs before running so that equal computed values never
- *   trigger a run.
- * - Dependency tracking uses a single "active dependent" slot that behaves
- *   like a capture stack through the native call stack (save/restore).
- */
-declare const UNINITIALIZED: unique symbol;
-type Uninitialized = typeof UNINITIALIZED;
-declare const EMPTY_ARRAY: readonly [];
-interface Signal<T> {
+export { A as Atom, a as AtomOptions, C as ComputeDiff, b as Computed, c as ComputedOptions, E as EMPTY_ARRAY, d as EffectScheduler, e as EffectSchedulerOptions, H as HistoryBuffer, R as RESET_VALUE, f as ReactOptions, g as Reactor, h as RenderTracker, i as ResetValue, S as Signal, U as UNINITIALIZED, j as Uninitialized, W as WithDiff, k as atom, l as computed, m as getComputedInstance, n as getGlobalEpoch, o as isAtom, p as isComputed, q as isSignal, r as isUninitialized, s as isWithDiff, t as localStorageAtom, u as react, v as reactor, w as subscribeToSignal, x as transact, y as transaction, z as unsafe__withoutCapture, B as whyAmIRunning, D as withDiff } from './core-DVexut58.js';
+
+/** A reactive map from `K` to `V`, backed by one atom per key. */
+declare class AtomMap<K, V> {
     readonly name: string;
-    get(): T;
-    lastChangedEpoch: number;
-}
-interface Atom<T> extends Signal<T> {
-    set(value: T): T;
-    update(fn: (prev: T) => T): T;
-}
-interface Computed<T> extends Signal<T> {
-    /** Epoch at which the cached value was last verified against its parents. */
-    readonly lastCheckedEpoch: number;
-}
-interface AtomOptions<T> {
-    isEqual?: (a: T, b: T) => boolean;
-}
-interface ComputedOptions<T> {
-    isEqual?: (a: T, b: T) => boolean;
-}
-interface ReactOptions {
+    private readonly atoms;
     /**
-     * Called whenever the effect needs to (re)run after its first run. The
-     * default runs `execute` synchronously. Supply e.g. a requestAnimationFrame
-     * wrapper to batch effect runs per frame.
+     * Bumped whenever a key is added or removed. Anything that depends on which
+     * keys exist — `size`, iteration, a `get` that missed — reads this, so it is
+     * invalidated by an insert without being invalidated by every value write.
      */
-    scheduleEffect?: (execute: () => void) => void;
-}
-interface EffectScheduler {
-    readonly name: string;
-    readonly isActive: boolean;
-    readonly lastRunEpoch: number;
-    /** Runs the effect now if any dependency changed since its last run. */
-    execute(): void;
-}
-interface Reactor {
-    start(): void;
-    stop(): void;
-    readonly scheduler: EffectScheduler;
-}
-/** Anything that records parents while it runs (computeds, effects). */
-interface Dependent {
-    parents: Set<SignalNode>;
-    prevParents: Set<SignalNode>;
-    __notify(): void;
-}
-/** Anything that can be read and can have dependents (atoms, computeds). */
-interface SignalNode<T = unknown> extends Signal<T> {
-    __addChild(child: Dependent): void;
-    __removeChild(child: Dependent): void;
-    /** Bring the value up to date without recording a dependency. */
-    __refresh(): void;
+    private readonly keyEpoch;
+    constructor(name: string, entries?: Iterable<readonly [K, V]>);
+    /** The value for `key`, or `undefined` when there is none. */
+    get(key: K): V | undefined;
+    /** Whether `key` has a value. */
+    has(key: K): boolean;
+    /** Set `key`, returning the map so calls can be chained. */
+    set(key: K, value: V): this;
+    /**
+     * The value for `key`, inserting `defaultValue` first if there is none.
+     *
+     * `defaultValue` is always evaluated by the caller; use
+     * {@link AtomMap.getOrInsertComputed} when producing it is expensive.
+     */
+    getOrInsert(key: K, defaultValue: V): V;
+    /**
+     * The value for `key`, inserting `create()` first if there is none.
+     * `create` runs **only** when the key is absent.
+     */
+    getOrInsertComputed(key: K, create: (key: K) => V): V;
+    /**
+     * The value for `key`, or `UNINITIALIZED` when there is none — the one read
+     * that can tell a stored `undefined` apart from a missing key. Subscribes the
+     * same way {@link AtomMap.get} does.
+     */
+    private peek;
+    /** Replace `key`'s value with `fn` applied to it. Throws if `key` is absent. */
+    update(key: K, fn: (prev: V) => V): V;
+    /** Remove `key`. Returns whether it was there. */
+    delete(key: K): boolean;
+    /**
+     * Remove several keys at once, in one transaction. Returns the keys that
+     * were actually there.
+     *
+     * Deleting in a loop wakes every dependent once per key; a bulk delete —
+     * clearing a selection, dropping a page's shapes — should wake them once.
+     */
+    deleteMany(keys: Iterable<K>): [K, V][];
+    get [Symbol.toStringTag](): string;
+    /** Remove every entry. */
+    clear(): void;
+    /** How many entries the map holds. */
+    get size(): number;
+    /** The live keys, in insertion order. */
+    keys(): IterableIterator<K>;
+    /** The live values, in insertion order. */
+    values(): IterableIterator<V>;
+    /** The live entries, in insertion order. */
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    forEach(fn: (value: V, key: K, map: AtomMap<K, V>) => void, thisArg?: unknown): void;
 }
-declare function getGlobalEpoch(): number;
-/** Runs `fn` without recording any dependencies for the current dependent. */
-declare function unsafe__withoutCapture<T>(fn: () => T): T;
-declare function atom<T>(name: string, initialValue: T, options?: AtomOptions<T>): Atom<T>;
-declare function computed<T>(name: string, fn: (prev: T | Uninitialized) => T, options?: ComputedOptions<T>): Computed<T>;
-declare abstract class EffectBase implements Dependent {
+
+/** A reactive set of `T`, backed by one boolean atom per member. */
+declare class AtomSet<T> {
     readonly name: string;
-    parents: Set<SignalNode<unknown>>;
-    prevParents: Set<SignalNode<unknown>>;
-    lastRunEpoch: number;
-    isActive: boolean;
-    constructor(name: string);
-    __notify(): void;
-    /** Called by the flush loop once per batch of changes. */
-    abstract __schedule(): void;
-    protected attachToParents(): void;
-    protected detachFromParents(): void;
-    /** True when any parent changed after this effect last ran. */
-    protected depsChanged(): boolean;
-}
-declare function react(name: string, fn: () => void, options?: ReactOptions): () => void;
-declare function reactor(name: string, fn: () => void, options?: ReactOptions): Reactor;
-/**
- * Dependency tracker for externally driven executions (e.g. a UI render).
- *
- * The host calls `track(fn)` to run `fn` with dependency capture, and
- * `subscribe(listener)` to be told when any captured dependency changes.
- * `getSnapshot()` returns a version number that increments on each such
- * change, which makes the tracker a drop-in external store for React's
- * `useSyncExternalStore`. Subscribing and unsubscribing repeatedly (as strict
- * mode does) is safe: captured parents are kept across unsubscribe so the next
- * subscribe re-attaches to them.
- */
-declare class RenderTracker extends EffectBase {
-    private version;
-    private listener;
-    constructor(name: string);
-    __schedule(): void;
-    private execute;
-    private bump;
-    /** Runs `fn(a, b)` while recording every signal read as a dependency. */
-    track<A, B, R>(fn: (a: A, b: B) => R, a: A, b: B): R;
-    readonly getSnapshot: () => number;
-    readonly subscribe: (listener: () => void) => (() => void);
-    readonly unsubscribe: () => void;
+    /**
+     * One atom per value ever seen. A removed value keeps its atom, holding
+     * `false`, so anything already subscribed to that value is told it left
+     * rather than silently going stale.
+     */
+    private readonly atoms;
+    /** Bumped whenever membership changes, for readers of the set's shape. */
+    private readonly membershipEpoch;
+    constructor(name: string, values?: Iterable<T>);
+    get [Symbol.toStringTag](): string;
+    /** Whether `value` is a member. */
+    has(value: T): boolean;
+    /** Add `value`, returning the set so calls can be chained. */
+    add(value: T): this;
+    /** Remove `value`. Returns whether it was a member. */
+    delete(value: T): boolean;
+    /** Remove every member. */
+    clear(): void;
+    /** How many members the set holds. */
+    get size(): number;
+    /** The live members, in insertion order. */
+    keys(): IterableIterator<T>;
+    /** The live members, in insertion order. Same as {@link AtomSet.keys}, as on `Set`. */
+    values(): IterableIterator<T>;
+    /** `[value, value]` pairs, as on `Set`. */
+    entries(): IterableIterator<[T, T]>;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(fn: (value: T, value2: T, set: AtomSet<T>) => void, thisArg?: unknown): void;
 }
-/**
- * Calls `onChange` whenever `signal`'s value changes. The initial subscription
- * does not call `onChange`. Returns an unsubscribe function.
- */
-declare function subscribeToSignal(signal: Signal<unknown>, onChange: () => void): () => void;
-/**
- * Batches atom writes: dependents are notified as writes happen, but effects
- * run once, after the outermost transaction commits. If `fn` throws, writes
- * made inside the transaction are rolled back and the error is rethrown.
- */
-declare function transact<T>(fn: () => T): T;
-/**
- * Like `transact`, but `fn` receives a `rollback` function that restores every
- * atom written inside this transaction (including committed nested ones) to
- * the value it had when this transaction began. The transaction stays open
- * after a rollback, so further writes are recorded again.
- */
-declare function transaction<T>(fn: (rollback: () => void) => T): T;
-declare function isSignal(value: unknown): value is Signal<unknown>;
-declare function isAtom(value: unknown): value is Atom<unknown>;
-declare function isComputed(value: unknown): value is Computed<unknown>;
 
-export { type Atom, type AtomOptions, type Computed, type ComputedOptions, EMPTY_ARRAY, type EffectScheduler, type ReactOptions, type Reactor, RenderTracker, type Signal, UNINITIALIZED, type Uninitialized, atom, computed, getGlobalEpoch, isAtom, isComputed, isSignal, react, reactor, subscribeToSignal, transact, transaction, unsafe__withoutCapture };
+export { AtomMap, AtomSet };

package/dist/index.js

@@ -1,3 +1,286 @@
-export { EMPTY_ARRAY, RenderTracker, UNINITIALIZED, atom, computed, getGlobalEpoch, isAtom, isComputed, isSignal, react, reactor, subscribeToSignal, transact, transaction, unsafe__withoutCapture } from './chunk-XCRMDUZF.js';
+import { atom, UNINITIALIZED, transact, getWithoutCapture } from './chunk-KGMTQKZV.js';
+export { EMPTY_ARRAY, HistoryBuffer, RESET_VALUE, RenderTracker, UNINITIALIZED, WithDiff, atom, computed, getComputedInstance, getGlobalEpoch, isAtom, isComputed, isSignal, isUninitialized, isWithDiff, localStorageAtom, react, reactor, subscribeToSignal, transact, transaction, unsafe__withoutCapture, whyAmIRunning, withDiff } from './chunk-KGMTQKZV.js';
+
+// src/AtomMap.ts
+var AtomMap = class {
+  constructor(name, entries) {
+    this.name = name;
+    this.keyEpoch = atom(`${name}:keys`, 0);
+    if (entries) {
+      for (const [key, value] of entries) {
+        this.atoms.set(key, atom(`${name}:${String(key)}`, value));
+      }
+    }
+  }
+  name;
+  atoms = /* @__PURE__ */ new Map();
+  /**
+   * Bumped whenever a key is added or removed. Anything that depends on which
+   * keys exist — `size`, iteration, a `get` that missed — reads this, so it is
+   * invalidated by an insert without being invalidated by every value write.
+   */
+  keyEpoch;
+  /** The value for `key`, or `undefined` when there is none. */
+  get(key) {
+    const a = this.atoms.get(key);
+    if (!a) {
+      this.keyEpoch.get();
+      return void 0;
+    }
+    const value = a.get();
+    return value === UNINITIALIZED ? void 0 : value;
+  }
+  /** Whether `key` has a value. */
+  has(key) {
+    const a = this.atoms.get(key);
+    if (!a) {
+      this.keyEpoch.get();
+      return false;
+    }
+    return a.get() !== UNINITIALIZED;
+  }
+  /** Set `key`, returning the map so calls can be chained. */
+  set(key, value) {
+    const a = this.atoms.get(key);
+    if (a) {
+      transact(() => {
+        const wasAbsent = getWithoutCapture(a) === UNINITIALIZED;
+        a.set(value);
+        if (wasAbsent) this.keyEpoch.update((n) => n + 1);
+      });
+    } else {
+      this.atoms.set(key, atom(`${this.name}:${String(key)}`, value));
+      this.keyEpoch.update((n) => n + 1);
+    }
+    return this;
+  }
+  /**
+   * The value for `key`, inserting `defaultValue` first if there is none.
+   *
+   * `defaultValue` is always evaluated by the caller; use
+   * {@link AtomMap.getOrInsertComputed} when producing it is expensive.
+   */
+  getOrInsert(key, defaultValue) {
+    const existing = this.peek(key);
+    if (existing !== UNINITIALIZED) return existing;
+    this.set(key, defaultValue);
+    return defaultValue;
+  }
+  /**
+   * The value for `key`, inserting `create()` first if there is none.
+   * `create` runs **only** when the key is absent.
+   */
+  getOrInsertComputed(key, create) {
+    const existing = this.peek(key);
+    if (existing !== UNINITIALIZED) return existing;
+    const value = create(key);
+    this.set(key, value);
+    return value;
+  }
+  /**
+   * The value for `key`, or `UNINITIALIZED` when there is none — the one read
+   * that can tell a stored `undefined` apart from a missing key. Subscribes the
+   * same way {@link AtomMap.get} does.
+   */
+  peek(key) {
+    const a = this.atoms.get(key);
+    if (!a) {
+      this.keyEpoch.get();
+      return UNINITIALIZED;
+    }
+    return a.get();
+  }
+  /** Replace `key`'s value with `fn` applied to it. Throws if `key` is absent. */
+  update(key, fn) {
+    const a = this.atoms.get(key);
+    const prev = a ? getWithoutCapture(a) : UNINITIALIZED;
+    if (!a || prev === UNINITIALIZED) {
+      throw new Error(`AtomMap ${this.name}: no entry for ${String(key)}`);
+    }
+    const next = fn(prev);
+    a.set(next);
+    return next;
+  }
+  /** Remove `key`. Returns whether it was there. */
+  delete(key) {
+    const a = this.atoms.get(key);
+    if (!a || getWithoutCapture(a) === UNINITIALIZED) return false;
+    transact(() => {
+      a.set(UNINITIALIZED);
+      this.keyEpoch.update((n) => n + 1);
+    });
+    return true;
+  }
+  /**
+   * Remove several keys at once, in one transaction. Returns the keys that
+   * were actually there.
+   *
+   * Deleting in a loop wakes every dependent once per key; a bulk delete —
+   * clearing a selection, dropping a page's shapes — should wake them once.
+   */
+  deleteMany(keys) {
+    const deleted = [];
+    transact(() => {
+      for (const key of keys) {
+        const a = this.atoms.get(key);
+        if (!a) continue;
+        const previous = getWithoutCapture(a);
+        if (previous === UNINITIALIZED) continue;
+        a.set(UNINITIALIZED);
+        deleted.push([key, previous]);
+      }
+      if (deleted.length > 0) this.keyEpoch.update((n) => n + 1);
+    });
+    return deleted;
+  }
+  get [Symbol.toStringTag]() {
+    return "AtomMap";
+  }
+  /** Remove every entry. */
+  clear() {
+    transact(() => {
+      let removedAny = false;
+      for (const a of this.atoms.values()) {
+        if (getWithoutCapture(a) === UNINITIALIZED) continue;
+        a.set(UNINITIALIZED);
+        removedAny = true;
+      }
+      if (removedAny) this.keyEpoch.update((n) => n + 1);
+    });
+  }
+  /** How many entries the map holds. */
+  get size() {
+    this.keyEpoch.get();
+    let n = 0;
+    for (const a of this.atoms.values()) if (a.get() !== UNINITIALIZED) n++;
+    return n;
+  }
+  /** The live keys, in insertion order. */
+  *keys() {
+    this.keyEpoch.get();
+    for (const [key, a] of this.atoms) {
+      if (a.get() !== UNINITIALIZED) yield key;
+    }
+  }
+  /** The live values, in insertion order. */
+  *values() {
+    this.keyEpoch.get();
+    for (const a of this.atoms.values()) {
+      const value = a.get();
+      if (value !== UNINITIALIZED) yield value;
+    }
+  }
+  /** The live entries, in insertion order. */
+  *entries() {
+    this.keyEpoch.get();
+    for (const [key, a] of this.atoms) {
+      const value = a.get();
+      if (value !== UNINITIALIZED) yield [key, value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(fn, thisArg) {
+    for (const [key, value] of this.entries()) fn.call(thisArg, value, key, this);
+  }
+};
+
+// src/AtomSet.ts
+var AtomSet = class {
+  constructor(name, values) {
+    this.name = name;
+    this.membershipEpoch = atom(`${name}:members`, 0);
+    if (values) {
+      for (const value of values) this.atoms.set(value, atom(`${name}:${String(value)}`, true));
+    }
+  }
+  name;
+  /**
+   * One atom per value ever seen. A removed value keeps its atom, holding
+   * `false`, so anything already subscribed to that value is told it left
+   * rather than silently going stale.
+   */
+  atoms = /* @__PURE__ */ new Map();
+  /** Bumped whenever membership changes, for readers of the set's shape. */
+  membershipEpoch;
+  get [Symbol.toStringTag]() {
+    return "AtomSet";
+  }
+  /** Whether `value` is a member. */
+  has(value) {
+    const a = this.atoms.get(value);
+    if (!a) {
+      this.membershipEpoch.get();
+      return false;
+    }
+    return a.get();
+  }
+  /** Add `value`, returning the set so calls can be chained. */
+  add(value) {
+    const a = this.atoms.get(value);
+    if (a) {
+      if (getWithoutCapture(a)) return this;
+      transact(() => {
+        a.set(true);
+        this.membershipEpoch.update((n) => n + 1);
+      });
+    } else {
+      this.atoms.set(value, atom(`${this.name}:${String(value)}`, true));
+      this.membershipEpoch.update((n) => n + 1);
+    }
+    return this;
+  }
+  /** Remove `value`. Returns whether it was a member. */
+  delete(value) {
+    const a = this.atoms.get(value);
+    if (!a || !getWithoutCapture(a)) return false;
+    transact(() => {
+      a.set(false);
+      this.membershipEpoch.update((n) => n + 1);
+    });
+    return true;
+  }
+  /** Remove every member. */
+  clear() {
+    transact(() => {
+      let removedAny = false;
+      for (const a of this.atoms.values()) {
+        if (!getWithoutCapture(a)) continue;
+        a.set(false);
+        removedAny = true;
+      }
+      if (removedAny) this.membershipEpoch.update((n) => n + 1);
+    });
+  }
+  /** How many members the set holds. */
+  get size() {
+    this.membershipEpoch.get();
+    let n = 0;
+    for (const a of this.atoms.values()) if (a.get()) n++;
+    return n;
+  }
+  /** The live members, in insertion order. */
+  *keys() {
+    this.membershipEpoch.get();
+    for (const [value, a] of this.atoms) if (a.get()) yield value;
+  }
+  /** The live members, in insertion order. Same as {@link AtomSet.keys}, as on `Set`. */
+  values() {
+    return this.keys();
+  }
+  /** `[value, value]` pairs, as on `Set`. */
+  *entries() {
+    for (const value of this.keys()) yield [value, value];
+  }
+  [Symbol.iterator]() {
+    return this.keys();
+  }
+  forEach(fn, thisArg) {
+    for (const value of this.keys()) fn.call(thisArg, value, value, this);
+  }
+};
+
+export { AtomMap, AtomSet };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}
+{"version":3,"sources":["../src/AtomMap.ts","../src/AtomSet.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * A reactive `Map`.\n *\n * Reading one key subscribes to that key alone, so a computed that looks up a\n * single entry is not woken by every unrelated write. Reading the map's shape\n * (`size`, iteration, a miss on `get`) subscribes to the key set instead, so a\n * later insert or delete does wake it.\n */\nimport { atom, getWithoutCapture, transact, UNINITIALIZED, type Atom, type Uninitialized } from \"./core\"\n\n/** A reactive map from `K` to `V`, backed by one atom per key. */\nexport class AtomMap<K, V> {\n\tprivate readonly atoms = new Map<K, Atom<V | Uninitialized>>()\n\t/**\n\t * Bumped whenever a key is added or removed. Anything that depends on which\n\t * keys exist — `size`, iteration, a `get` that missed — reads this, so it is\n\t * invalidated by an insert without being invalidated by every value write.\n\t */\n\tprivate readonly keyEpoch: Atom<number>\n\n\tconstructor(\n\t\treadonly name: string,\n\t\tentries?: Iterable<readonly [K, V]>,\n\t) {\n\t\tthis.keyEpoch = atom(`${name}:keys`, 0)\n\t\tif (entries) {\n\t\t\tfor (const [key, value] of entries) {\n\t\t\t\tthis.atoms.set(key, atom(`${name}:${String(key)}`, value as V | Uninitialized))\n\t\t\t}\n\t\t}\n\t}\n\n\t/** The value for `key`, or `undefined` when there is none. */\n\tget(key: K): V | undefined {\n\t\tconst a = this.atoms.get(key)\n\t\tif (!a) {\n\t\t\t// Depend on the key set, so inserting `key` later invalidates this read.\n\t\t\tthis.keyEpoch.get()\n\t\t\treturn undefined\n\t\t}\n\t\tconst value = a.get()\n\t\treturn value === UNINITIALIZED ? undefined : value\n\t}\n\n\t/** Whether `key` has a value. */\n\thas(key: K): boolean {\n\t\tconst a = this.atoms.get(key)\n\t\tif (!a) {\n\t\t\tthis.keyEpoch.get()\n\t\t\treturn false\n\t\t}\n\t\treturn a.get() !== UNINITIALIZED\n\t}\n\n\t/** Set `key`, returning the map so calls can be chained. */\n\tset(key: K, value: V): this {\n\t\tconst a = this.atoms.get(key)\n\t\tif (a) {\n\t\t\t// One transaction, so a subscriber that reads both the value and the key\n\t\t\t// set (`size`, iteration) is notified once rather than twice.\n\t\t\ttransact(() => {\n\t\t\t\tconst wasAbsent = getWithoutCapture(a) === UNINITIALIZED\n\t\t\t\ta.set(value)\n\t\t\t\tif (wasAbsent) this.keyEpoch.update((n) => n + 1)\n\t\t\t})\n\t\t} else {\n\t\t\tthis.atoms.set(key, atom(`${this.name}:${String(key)}`, value as V | Uninitialized))\n\t\t\tthis.keyEpoch.update((n) => n + 1)\n\t\t}\n\t\treturn this\n\t}\n\n\t/**\n\t * The value for `key`, inserting `defaultValue` first if there is none.\n\t *\n\t * `defaultValue` is always evaluated by the caller; use\n\t * {@link AtomMap.getOrInsertComputed} when producing it is expensive.\n\t */\n\tgetOrInsert(key: K, defaultValue: V): V {\n\t\tconst existing = this.peek(key)\n\t\tif (existing !== UNINITIALIZED) return existing\n\t\tthis.set(key, defaultValue)\n\t\treturn defaultValue\n\t}\n\n\t/**\n\t * The value for `key`, inserting `create()` first if there is none.\n\t * `create` runs **only** when the key is absent.\n\t */\n\tgetOrInsertComputed(key: K, create: (key: K) => V): V {\n\t\tconst existing = this.peek(key)\n\t\tif (existing !== UNINITIALIZED) return existing\n\t\tconst value = create(key)\n\t\tthis.set(key, value)\n\t\treturn value\n\t}\n\n\t/**\n\t * The value for `key`, or `UNINITIALIZED` when there is none — the one read\n\t * that can tell a stored `undefined` apart from a missing key. Subscribes the\n\t * same way {@link AtomMap.get} does.\n\t */\n\tprivate peek(key: K): V | Uninitialized {\n\t\tconst a = this.atoms.get(key)\n\t\tif (!a) {\n\t\t\tthis.keyEpoch.get()\n\t\t\treturn UNINITIALIZED\n\t\t}\n\t\treturn a.get()\n\t}\n\n\t/** Replace `key`'s value with `fn` applied to it. Throws if `key` is absent. */\n\tupdate(key: K, fn: (prev: V) => V): V {\n\t\tconst a = this.atoms.get(key)\n\t\tconst prev = a ? getWithoutCapture(a) : UNINITIALIZED\n\t\tif (!a || prev === UNINITIALIZED) {\n\t\t\tthrow new Error(`AtomMap ${this.name}: no entry for ${String(key)}`)\n\t\t}\n\t\tconst next = fn(prev)\n\t\ta.set(next)\n\t\treturn next\n\t}\n\n\t/** Remove `key`. Returns whether it was there. */\n\tdelete(key: K): boolean {\n\t\tconst a = this.atoms.get(key)\n\t\tif (!a || getWithoutCapture(a) === UNINITIALIZED) return false\n\t\ttransact(() => {\n\t\t\t// The atom is kept and emptied rather than dropped, so anything already\n\t\t\t// subscribed to this key is notified of the removal.\n\t\t\ta.set(UNINITIALIZED)\n\t\t\tthis.keyEpoch.update((n) => n + 1)\n\t\t})\n\t\treturn true\n\t}\n\n\t/**\n\t * Remove several keys at once, in one transaction. Returns the keys that\n\t * were actually there.\n\t *\n\t * Deleting in a loop wakes every dependent once per key; a bulk delete —\n\t * clearing a selection, dropping a page's shapes — should wake them once.\n\t */\n\tdeleteMany(keys: Iterable<K>): [K, V][] {\n\t\tconst deleted: [K, V][] = []\n\t\ttransact(() => {\n\t\t\tfor (const key of keys) {\n\t\t\t\tconst a = this.atoms.get(key)\n\t\t\t\tif (!a) continue\n\t\t\t\tconst previous = getWithoutCapture(a)\n\t\t\t\tif (previous === UNINITIALIZED) continue\n\t\t\t\ta.set(UNINITIALIZED)\n\t\t\t\tdeleted.push([key, previous])\n\t\t\t}\n\t\t\tif (deleted.length > 0) this.keyEpoch.update((n) => n + 1)\n\t\t})\n\t\treturn deleted\n\t}\n\n\tget [Symbol.toStringTag](): string {\n\t\treturn \"AtomMap\"\n\t}\n\n\t/** Remove every entry. */\n\tclear(): void {\n\t\ttransact(() => {\n\t\t\tlet removedAny = false\n\t\t\tfor (const a of this.atoms.values()) {\n\t\t\t\tif (getWithoutCapture(a) === UNINITIALIZED) continue\n\t\t\t\ta.set(UNINITIALIZED)\n\t\t\t\tremovedAny = true\n\t\t\t}\n\t\t\tif (removedAny) this.keyEpoch.update((n) => n + 1)\n\t\t})\n\t}\n\n\t/** How many entries the map holds. */\n\tget size(): number {\n\t\tthis.keyEpoch.get()\n\t\tlet n = 0\n\t\tfor (const a of this.atoms.values()) if (a.get() !== UNINITIALIZED) n++\n\t\treturn n\n\t}\n\n\t/** The live keys, in insertion order. */\n\t*keys(): IterableIterator<K> {\n\t\tthis.keyEpoch.get()\n\t\tfor (const [key, a] of this.atoms) {\n\t\t\tif (a.get() !== UNINITIALIZED) yield key\n\t\t}\n\t}\n\n\t/** The live values, in insertion order. */\n\t*values(): IterableIterator<V> {\n\t\tthis.keyEpoch.get()\n\t\tfor (const a of this.atoms.values()) {\n\t\t\tconst value = a.get()\n\t\t\tif (value !== UNINITIALIZED) yield value\n\t\t}\n\t}\n\n\t/** The live entries, in insertion order. */\n\t*entries(): IterableIterator<[K, V]> {\n\t\tthis.keyEpoch.get()\n\t\tfor (const [key, a] of this.atoms) {\n\t\t\tconst value = a.get()\n\t\t\tif (value !== UNINITIALIZED) yield [key, value]\n\t\t}\n\t}\n\n\t[Symbol.iterator](): IterableIterator<[K, V]> {\n\t\treturn this.entries()\n\t}\n\n\tforEach(fn: (value: V, key: K, map: AtomMap<K, V>) => void, thisArg?: unknown): void {\n\t\tfor (const [key, value] of this.entries()) fn.call(thisArg, value, key, this)\n\t}\n}\n","/**\n * A reactive `Set`.\n *\n * The counterpart of {@link AtomMap} for membership: asking whether one value\n * is in the set subscribes to that value alone, so a computed that watches a\n * single id is not woken every time an unrelated one is added. Reading the\n * set's shape (`size`, iteration) subscribes to the membership epoch instead.\n *\n * That split is the whole reason to reach for this over a plain `Set` in an\n * atom: `atom(\"selection\", new Set(...))` invalidates every reader on every\n * change, however small.\n */\nimport { atom, getWithoutCapture, transact, type Atom } from \"./core\"\n\n/** A reactive set of `T`, backed by one boolean atom per member. */\nexport class AtomSet<T> {\n\t/**\n\t * One atom per value ever seen. A removed value keeps its atom, holding\n\t * `false`, so anything already subscribed to that value is told it left\n\t * rather than silently going stale.\n\t */\n\tprivate readonly atoms = new Map<T, Atom<boolean>>()\n\t/** Bumped whenever membership changes, for readers of the set's shape. */\n\tprivate readonly membershipEpoch: Atom<number>\n\n\tconstructor(\n\t\treadonly name: string,\n\t\tvalues?: Iterable<T>,\n\t) {\n\t\tthis.membershipEpoch = atom(`${name}:members`, 0)\n\t\tif (values) {\n\t\t\tfor (const value of values) this.atoms.set(value, atom(`${name}:${String(value)}`, true))\n\t\t}\n\t}\n\n\tget [Symbol.toStringTag](): string {\n\t\treturn \"AtomSet\"\n\t}\n\n\t/** Whether `value` is a member. */\n\thas(value: T): boolean {\n\t\tconst a = this.atoms.get(value)\n\t\tif (!a) {\n\t\t\t// Depend on membership, so adding `value` later invalidates this read.\n\t\t\tthis.membershipEpoch.get()\n\t\t\treturn false\n\t\t}\n\t\treturn a.get()\n\t}\n\n\t/** Add `value`, returning the set so calls can be chained. */\n\tadd(value: T): this {\n\t\tconst a = this.atoms.get(value)\n\t\tif (a) {\n\t\t\tif (getWithoutCapture(a)) return this\n\t\t\t// One transaction, so a reader of both the member and the set's shape\n\t\t\t// is notified once rather than twice.\n\t\t\ttransact(() => {\n\t\t\t\ta.set(true)\n\t\t\t\tthis.membershipEpoch.update((n) => n + 1)\n\t\t\t})\n\t\t} else {\n\t\t\tthis.atoms.set(value, atom(`${this.name}:${String(value)}`, true))\n\t\t\tthis.membershipEpoch.update((n) => n + 1)\n\t\t}\n\t\treturn this\n\t}\n\n\t/** Remove `value`. Returns whether it was a member. */\n\tdelete(value: T): boolean {\n\t\tconst a = this.atoms.get(value)\n\t\tif (!a || !getWithoutCapture(a)) return false\n\t\ttransact(() => {\n\t\t\ta.set(false)\n\t\t\tthis.membershipEpoch.update((n) => n + 1)\n\t\t})\n\t\treturn true\n\t}\n\n\t/** Remove every member. */\n\tclear(): void {\n\t\ttransact(() => {\n\t\t\tlet removedAny = false\n\t\t\tfor (const a of this.atoms.values()) {\n\t\t\t\tif (!getWithoutCapture(a)) continue\n\t\t\t\ta.set(false)\n\t\t\t\tremovedAny = true\n\t\t\t}\n\t\t\tif (removedAny) this.membershipEpoch.update((n) => n + 1)\n\t\t})\n\t}\n\n\t/** How many members the set holds. */\n\tget size(): number {\n\t\tthis.membershipEpoch.get()\n\t\tlet n = 0\n\t\tfor (const a of this.atoms.values()) if (a.get()) n++\n\t\treturn n\n\t}\n\n\t/** The live members, in insertion order. */\n\t*keys(): IterableIterator<T> {\n\t\tthis.membershipEpoch.get()\n\t\tfor (const [value, a] of this.atoms) if (a.get()) yield value\n\t}\n\n\t/** The live members, in insertion order. Same as {@link AtomSet.keys}, as on `Set`. */\n\tvalues(): IterableIterator<T> {\n\t\treturn this.keys()\n\t}\n\n\t/** `[value, value]` pairs, as on `Set`. */\n\t*entries(): IterableIterator<[T, T]> {\n\t\tfor (const value of this.keys()) yield [value, value]\n\t}\n\n\t[Symbol.iterator](): IterableIterator<T> {\n\t\treturn this.keys()\n\t}\n\n\tforEach(fn: (value: T, value2: T, set: AtomSet<T>) => void, thisArg?: unknown): void {\n\t\tfor (const value of this.keys()) fn.call(thisArg, value, value, this)\n\t}\n}\n"]}

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { ComponentType } from 'react';
-import { Atom, Computed, ComputedOptions, Signal } from './index.js';
+import { A as Atom, b as Computed, c as ComputedOptions, S as Signal } from './core-DVexut58.js';
 
 /**
  * Subscribes the component to a signal and returns its current value.
@@ -20,6 +20,24 @@ declare function useComputed<T>(name: string, fn: () => T, options: ComputedOpti
 declare function useReactor(name: string, fn: () => void, deps: unknown[]): void;
 /** Like `useReactor` but re-runs synchronously as soon as a dependency changes. */
 declare function useQuickReactor(name: string, fn: () => void, deps: unknown[]): void;
+/**
+ * Run `render` with signal tracking on, and re-render the calling component
+ * whenever anything it read changes.
+ *
+ * This is the hook {@link track} is built from, exposed for the cases the
+ * wrapper cannot cover: a component that only wants part of its body tracked,
+ * a class component's render delegate, or a render function received as a
+ * prop, where there is no component to wrap.
+ *
+ * ```tsx
+ * function Panel({ shape }: { shape: TLShape }) {
+ *   return useStateTracking("Panel", () => <span>{editor.getShapePageBounds(shape)?.w}</span>)
+ * }
+ * ```
+ *
+ * The name is for debugging only; it shows up in {@link whyAmIRunning} output.
+ */
+declare function useStateTracking<T>(name: string, render: () => T): T;
 /**
  * Wraps a function component so that it re-renders whenever any signal read
  * during its render changes. The result is memoized on props. Supports plain
@@ -27,4 +45,4 @@ declare function useQuickReactor(name: string, fn: () => void, deps: unknown[]):
  */
 declare function track<C extends ComponentType<any>>(Component: C): C;
 
-export { track, useAtom, useComputed, useQuickReactor, useReactor, useValue };
+export { track, useAtom, useComputed, useQuickReactor, useReactor, useStateTracking, useValue };

package/dist/react.js

@@ -1,4 +1,4 @@
-import { EMPTY_ARRAY, computed, atom, reactor, getWithoutCapture, subscribeToSignal, RenderTracker } from './chunk-XCRMDUZF.js';
+import { EMPTY_ARRAY, computed, atom, reactor, RenderTracker, getWithoutCapture, subscribeToSignal } from './chunk-KGMTQKZV.js';
 import { useMemo, useSyncExternalStore, useState, useEffect, memo, forwardRef } from 'react';
 
 function useSignalStore(signal) {
@@ -62,6 +62,14 @@ function useTrackedRender(name, render, props, ref) {
   useSyncExternalStore(tracker.subscribe, tracker.getSnapshot, tracker.getSnapshot);
   return tracker.track(render, props, ref);
 }
+function useStateTracking(name, render) {
+  const [tracker] = useState(() => new RenderTracker(name));
+  useSyncExternalStore(tracker.subscribe, tracker.getSnapshot, tracker.getSnapshot);
+  return tracker.track(runRenderFn, render, null);
+}
+function runRenderFn(fn) {
+  return fn();
+}
 function track(Component) {
   if (typeof Component === "function") {
     const fn = Component;
@@ -90,6 +98,6 @@ function track(Component) {
   throw new Error("track() expects a function component, or one wrapped in memo() or forwardRef()");
 }
 
-export { track, useAtom, useComputed, useQuickReactor, useReactor, useValue };
+export { track, useAtom, useComputed, useQuickReactor, useReactor, useStateTracking, useValue };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map