@tldraw/state 4.0.2 → 4.1.0-canary.0259516ffb8c

package/dist-cjs/index.d.ts

@@ -95,13 +95,27 @@ export declare interface AtomOptions<Value, Diff> {
 /* Excluded from this release type: Child */
 
 /**
- * A computed signal created via `computed`.
+ * A computed signal created via the `computed` function or `@computed` decorator.
+ * Computed signals derive their values from other signals and automatically update when their dependencies change.
+ * They use lazy evaluation, only recalculating when accessed and dependencies have changed.
+ *
+ * @example
+ * ```ts
+ * const firstName = atom('firstName', 'John')
+ * const lastName = atom('lastName', 'Doe')
+ * const fullName = computed('fullName', () => `${firstName.get()} ${lastName.get()}`)
+ *
+ * console.log(fullName.get()) // "John Doe"
+ * firstName.set('Jane')
+ * console.log(fullName.get()) // "Jane Doe"
+ * ```
  *
  * @public
  */
 export declare interface Computed<Value, Diff = unknown> extends Signal<Value, Diff> {
     /**
-     * Whether this computed child is involved in an actively-running effect graph.
+     * Whether this computed signal is involved in an actively-running effect graph.
+     * Returns true if there are any reactions or other computed signals depending on this one.
      * @public
      */
     readonly isActivelyListening: boolean;
@@ -111,7 +125,9 @@ export declare interface Computed<Value, Diff = unknown> extends Signal<Value, D
 }
 
 /**
- * Creates a computed signal.
+ * Creates a computed signal that derives its value from other signals.
+ * Computed signals automatically update when their dependencies change and use lazy evaluation
+ * for optimal performance.
  *
  * @example
  * ```ts
@@ -149,43 +165,135 @@ export declare interface Computed<Value, Diff = unknown> extends Signal<Value, D
  * }
  * ```
  *
- * @param name - The name of the signal.
- * @param compute - The function that computes the value of the signal.
- * @param options - Options for the signal.
- *
+ * @param name - The name of the signal for debugging purposes
+ * @param compute - The function that computes the value of the signal. Receives the previous value and last computed epoch
+ * @param options - Optional configuration for the computed signal
+ * @returns A new computed signal
  * @public
  */
 export declare function computed<Value, Diff = unknown>(name: string, compute: (previousValue: typeof UNINITIALIZED | Value, lastComputedEpoch: number) => Value | WithDiff<Value, Diff>, options?: ComputedOptions<Value, Diff>): Computed<Value, Diff>;
 
 /**
- * `@computed` decorator (TC39 decorators).
+ * TC39 decorator for creating computed methods in classes.
+ *
+ * @example
+ * ```ts
+ * class MyClass {
+ *   value = atom('value', 10)
+ *
+ *   @computed
+ *   doubled() {
+ *     return this.value.get() * 2
+ *   }
+ * }
+ * ```
+ *
+ * @param compute - The method to be decorated
+ * @param context - The decorator context provided by TypeScript
+ * @returns The decorated method
  * @public
  */
 export declare function computed<This extends object, Value>(compute: () => Value, context: ClassMethodDecoratorContext<This, () => Value>): () => Value;
 
 /**
- * `@computed` decorator (legacy typescript decorator syntax).
+ * Legacy TypeScript decorator for creating computed methods in classes.
+ *
+ * @example
+ * ```ts
+ * class MyClass {
+ *   value = atom('value', 10)
+ *
+ *   @computed
+ *   doubled() {
+ *     return this.value.get() * 2
+ *   }
+ * }
+ * ```
  *
- * @public */
+ * @param target - The class prototype
+ * @param key - The property key
+ * @param descriptor - The property descriptor
+ * @returns The modified property descriptor
+ * @public
+ */
 export declare function computed(target: any, key: string, descriptor: PropertyDescriptor): PropertyDescriptor;
 
 /**
- * `@computed` decorator with options.
+ * Decorator factory for creating computed methods with options.
+ *
+ * @example
+ * ```ts
+ * class MyClass {
+ *   items = atom('items', [1, 2, 3])
+ *
+ *   @computed({ historyLength: 10 })
+ *   sum() {
+ *     return this.items.get().reduce((a, b) => a + b, 0)
+ *   }
+ * }
+ * ```
+ *
+ * @param options - Configuration options for the computed signal
+ * @returns A decorator function that can be applied to methods
  * @public
  */
 export declare function computed<Value, Diff = unknown>(options?: ComputedOptions<Value, Diff>): ((target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor) & (<This>(compute: () => Value, context: ClassMethodDecoratorContext<This, () => Value>) => () => Value);
 
 /**
- * Computes the diff between the previous and current value.
+ * A function type that computes the difference between two values of a signal.
+ *
+ * This function is used to generate incremental diffs that can be applied to
+ * reconstruct state changes over time. It's particularly useful for features
+ * like undo/redo, synchronization, and change tracking.
+ *
+ * The function should analyze the previous and current values and return a
+ * diff object that represents the change. If the diff cannot be computed
+ * (e.g., the values are too different or incompatible), it should return
+ * the unique symbol RESET_VALUE to indicate that a full state reset is required.
+ *
+ * @param previousValue - The previous value of the signal
+ * @param currentValue - The current value of the signal
+ * @param lastComputedEpoch - The epoch when the previous value was set
+ * @param currentEpoch - The epoch when the current value was set
+ * @returns A diff object representing the change, or the unique symbol RESET_VALUE if no diff can be computed
+ *
+ * @example
+ * ```ts
+ * import { atom, RESET_VALUE } from '@tldraw/state'
  *
- * If the diff cannot be computed for whatever reason, it should return {@link state#RESET_VALUE}.
+ * // Simple numeric diff
+ * const numberDiff: ComputeDiff<number, number> = (prev, curr) => curr - prev
+ *
+ * // Array diff with reset fallback
+ * const arrayDiff: ComputeDiff<string[], { added: string[], removed: string[] }> = (prev, curr) => {
+ *   if (prev.length > 1000 || curr.length > 1000) {
+ *     return RESET_VALUE // Too complex, force reset
+ *   }
+ *   return {
+ *     added: curr.filter(item => !prev.includes(item)),
+ *     removed: prev.filter(item => !curr.includes(item))
+ *   }
+ * }
+ *
+ * const count = atom('count', 0, { computeDiff: numberDiff })
+ * ```
  *
  * @public
  */
 export declare type ComputeDiff<Value, Diff> = (previousValue: Value, currentValue: Value, lastComputedEpoch: number, currentEpoch: number) => Diff | RESET_VALUE;
 
 /**
- * Options for creating computed signals. Used when calling `computed`.
+ * Options for configuring computed signals. Used when calling `computed` or using the `@computed` decorator.
+ *
+ * @example
+ * ```ts
+ * const greeting = computed('greeting', () => `Hello ${name.get()}!`, {
+ *   historyLength: 10,
+ *   isEqual: (a, b) => a === b,
+ *   computeDiff: (oldVal, newVal) => ({ type: 'change', from: oldVal, to: newVal })
+ * })
+ * ```
+ *
  * @public
  */
 export declare interface ComputedOptions<Value, Diff> {
@@ -347,11 +455,46 @@ export declare function getComputedInstance<Obj extends object, Prop extends key
 
 /**
  * Returns true if the given value is an {@link Atom}.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an Atom, false otherwise
+ * @example
+ * ```ts
+ * const myAtom = atom('test', 42)
+ * const notAtom = 'hello'
+ *
+ * console.log(isAtom(myAtom)) // true
+ * console.log(isAtom(notAtom)) // false
+ * ```
  * @public
  */
 export declare function isAtom(value: unknown): value is Atom<unknown>;
 
 /**
+ * Type guard function that determines whether a value is a signal (either an Atom or Computed).
+ *
+ * This utility function is helpful when working with mixed data types and you need to
+ * differentiate between regular values and reactive signal containers. It returns `true`
+ * if the provided value is either an atomic signal created with `atom()` or a computed
+ * signal created with `computed()`.
+ *
+ * @param value - The value to check, can be of any type
+ * @returns `true` if the value is a Signal (Atom or Computed), `false` otherwise
+ *
+ * @example
+ * ```ts
+ * import { atom, computed, isSignal } from '@tldraw/state'
+ *
+ * const count = atom('count', 5)
+ * const doubled = computed('doubled', () => count.get() * 2)
+ * const regularValue = 'hello'
+ *
+ * console.log(isSignal(count))        // true
+ * console.log(isSignal(doubled))      // true
+ * console.log(isSignal(regularValue)) // false
+ * console.log(isSignal(null))         // false
+ * ```
+ *
  * @public
  */
 export declare function isSignal(value: any): value is Signal<any>;
@@ -377,6 +520,35 @@ export declare function isSignal(value: any): value is Signal<any>;
  */
 export declare function isUninitialized(value: any): value is UNINITIALIZED;
 
+/**
+ * Creates a new {@link Atom} that persists its value to localStorage.
+ *
+ * The atom is automatically synced with localStorage - changes to the atom are saved to localStorage,
+ * and the initial value is read from localStorage if it exists. Returns both the atom and a cleanup
+ * function that should be called to stop syncing when the atom is no longer needed. If you need to delete
+ * the atom, you should do it manually after all cleanup functions have been called.
+ *
+ * @example
+ * ```ts
+ * const [theme, cleanup] = localStorageAtom('theme', 'light')
+ *
+ * theme.get() // 'light' or value from localStorage if it exists
+ *
+ * theme.set('dark') // updates atom and saves to localStorage
+ *
+ * // When done:
+ * cleanup() // stops syncing to localStorage
+ * ```
+ *
+ * @param name - The localStorage key and atom name. This is used for both localStorage persistence
+ *   and debugging/profiling purposes.
+ * @param initialValue - The initial value of the atom, used if no value exists in localStorage.
+ * @param options - Optional atom configuration. See {@link AtomOptions}.
+ * @returns A tuple containing the atom and a cleanup function to stop localStorage syncing.
+ * @public
+ */
+export declare function localStorageAtom<Value, Diff = unknown>(name: string, initialValue: Value, options?: AtomOptions<Value, Diff>): [Atom<Value, Diff>, () => void];
+
 /**
  * Starts a new effect scheduler, scheduling the effect immediately.
  *
@@ -450,47 +622,125 @@ export declare interface Reactor<T = unknown> {
  */
 export declare function reactor<Result>(name: string, fn: (lastReactedEpoch: number) => Result, options?: EffectSchedulerOptions): Reactor<Result>;
 
-/** @public */
+/**
+ * A unique symbol used to indicate that a signal's value should be reset or that
+ * there is insufficient history to compute diffs between epochs.
+ *
+ * This value is returned by {@link Signal.getDiffSince} when the requested epoch
+ * is too far in the past and the diff sequence cannot be reconstructed.
+ *
+ * @example
+ * ```ts
+ * import { atom, getGlobalEpoch, RESET_VALUE } from '@tldraw/state'
+ *
+ * const count = atom('count', 0, { historyLength: 3 })
+ * const oldEpoch = getGlobalEpoch()
+ *
+ * // Make many changes that exceed history length
+ * count.set(1)
+ * count.set(2)
+ * count.set(3)
+ * count.set(4)
+ *
+ * const diffs = count.getDiffSince(oldEpoch)
+ * if (diffs === RESET_VALUE) {
+ *   console.log('Too many changes, need to reset state')
+ * }
+ * ```
+ *
+ * @public
+ */
 export declare const RESET_VALUE: unique symbol;
 
-/** @public */
+/**
+ * Type representing the the unique symbol RESET_VALUE symbol, used in type annotations
+ * to indicate when a signal value should be reset or when diff computation
+ * cannot proceed due to insufficient history.
+ *
+ * @public
+ */
 export declare type RESET_VALUE = typeof RESET_VALUE;
 
 /**
- * A Signal is a reactive value container. The value may change over time, and it may keep track of the diffs between sequential values.
+ * A reactive value container that can change over time and track diffs between sequential values.
+ *
+ * Signals are the foundation of the \@tldraw/state reactive system. They automatically manage
+ * dependencies and trigger updates when their values change. Any computed signal or effect
+ * that reads from this signal will be automatically recomputed when the signal's value changes.
  *
  * There are two types of signal:
+ * - **Atomic signals** - Created using `atom()`. These are mutable containers that can be
+ *   directly updated using `set()` or `update()` methods.
+ * - **Computed signals** - Created using `computed()`. These derive their values from other
+ *   signals and are automatically recomputed when dependencies change.
+ *
+ * @example
+ * ```ts
+ * import { atom, computed } from '@tldraw/state'
  *
- * - Atomic signals, created using {@link atom}. These are mutable references to values that can be changed using {@link Atom.set}.
- * - Computed signals, created using `computed`. These are values that are computed from other signals. They are recomputed lazily if their dependencies change.
+ * // Create an atomic signal
+ * const count = atom('count', 0)
+ *
+ * // Create a computed signal that derives from the atom
+ * const doubled = computed('doubled', () => count.get() * 2)
+ *
+ * console.log(doubled.get()) // 0
+ * count.set(5)
+ * console.log(doubled.get()) // 10
+ * ```
  *
  * @public
  */
 export declare interface Signal<Value, Diff = unknown> {
     /**
-     * The name of the signal. This is used at runtime for debugging and perf profiling only. It does not need to be globally unique.
+     * A human-readable identifier for this signal, used primarily for debugging and performance profiling.
+     *
+     * The name is displayed in debug output from {@link whyAmIRunning} and other diagnostic tools.
+     * It does not need to be globally unique within your application.
      */
     name: string;
     /**
-     * The current value of the signal. This is a reactive value, and will update when the signal changes.
-     * Any computed signal that depends on this signal will be lazily recomputed if this signal changes.
-     * Any effect that depends on this signal will be rescheduled if this signal changes.
+     * Gets the current value of the signal and establishes a dependency relationship.
+     *
+     * When called from within a computed signal or effect, this signal will be automatically
+     * tracked as a dependency. If this signal's value changes, any dependent computations
+     * or effects will be marked for re-execution.
+     *
+     * @returns The current value stored in the signal
      */
     get(): Value;
     /**
-     * The epoch when this signal's value last changed. Note that this is not the same as when the value was last computed.
-     * A signal may recompute it's value without changing it.
+     * The global epoch number when this signal's value last changed.
+     *
+     * Note that this represents when the value actually changed, not when it was last computed.
+     * A computed signal may recalculate and produce the same value without changing its epoch.
+     * This is used internally for dependency tracking and history management.
      */
     lastChangedEpoch: number;
     /**
-     * Returns the sequence of diffs between the the value at the given epoch and the current value.
-     * Returns the `RESET_VALUE` constant if there is not enough information to compute the diff sequence.
-     * @param epoch - The epoch to get diffs since.
+     * Gets the sequence of diffs that occurred between a specific epoch and the current state.
+     *
+     * This method enables incremental synchronization by providing a list of changes that
+     * have occurred since a specific point in time. If the requested epoch is too far in
+     * the past or the signal doesn't have enough history, it returns the unique symbol RESET_VALUE
+     * to indicate that a full state reset is required.
+     *
+     * @param epoch - The epoch timestamp to get diffs since
+     * @returns An array of diff objects representing changes since the epoch, or the unique symbol RESET_VALUE if insufficient history is available
      */
     getDiffSince(epoch: number): Diff[] | RESET_VALUE;
     /**
-     * Returns the current value of the signal without capturing it as a dependency.
-     * Use this if you need to retrieve the signal's value in a hot loop where the performance overhead of dependency tracking is too high.
+     * Gets the current value of the signal without establishing a dependency relationship.
+     *
+     * This method bypasses the automatic dependency tracking system, making it useful for
+     * performance-critical code paths where the overhead of dependency capture would be
+     * problematic. Use with caution as it breaks the reactive guarantees of the system.
+     *
+     * **Warning**: This method should only be used when you're certain that you don't need
+     * the calling context to react to changes in this signal.
+     *
+     * @param ignoreErrors - Whether to suppress errors during value retrieval (optional)
+     * @returns The current value without establishing dependencies
      */
     __unsafe__getWithoutCapture(ignoreErrors?: boolean): Value;
     /* Excluded from this release type: children */
@@ -498,22 +748,42 @@ export declare interface Signal<Value, Diff = unknown> {
 
 /**
  * Like {@link transaction}, but does not create a new transaction if there is already one in progress.
+ * This is the preferred way to batch state updates when you don't need the rollback functionality.
+ *
+ * @example
+ * ```ts
+ * const count = atom('count', 0)
+ * const doubled = atom('doubled', 0)
  *
- * @param fn - The function to run in a transaction.
+ * react('update doubled', () => {
+ *   console.log(`Count: ${count.get()}, Doubled: ${doubled.get()}`)
+ * })
+ *
+ * // This batches both updates into a single reaction
+ * transact(() => {
+ *   count.set(5)
+ *   doubled.set(count.get() * 2)
+ * })
+ * // Logs: "Count: 5, Doubled: 10"
+ * ```
+ *
+ * @param fn - The function to run in a transaction
+ * @returns The return value of the function
  * @public
  */
 export declare function transact<T>(fn: () => T): T;
 
 /**
  * Batches state updates, deferring side effects until after the transaction completes.
+ * Unlike {@link transact}, this function always creates a new transaction, allowing for nested transactions.
  *
  * @example
  * ```ts
- * const firstName = atom('John')
- * const lastName = atom('Doe')
+ * const firstName = atom('firstName', 'John')
+ * const lastName = atom('lastName', 'Doe')
  *
  * react('greet', () => {
- *   print(`Hello, ${firstName.get()} ${lastName.get()}!`)
+ *   console.log(`Hello, ${firstName.get()} ${lastName.get()}!`)
  * })
  *
  * // Logs "Hello, John Doe!"
@@ -530,11 +800,11 @@ export declare function transact<T>(fn: () => T): T;
  *
  * @example
  * ```ts
- * const firstName = atom('John')
- * const lastName = atom('Doe')
+ * const firstName = atom('firstName', 'John')
+ * const lastName = atom('lastName', 'Doe')
  *
  * react('greet', () => {
- *   print(`Hello, ${firstName.get()} ${lastName.get()}!`)
+ *   console.log(`Hello, ${firstName.get()} ${lastName.get()}!`)
  * })
  *
  * // Logs "Hello, John Doe!"
@@ -553,11 +823,11 @@ export declare function transact<T>(fn: () => T): T;
  *
  * @example
  * ```ts
- * const firstName = atom('John')
- * const lastName = atom('Doe')
+ * const firstName = atom('firstName', 'John')
+ * const lastName = atom('lastName', 'Doe')
  *
  * react('greet', () => {
- *   print(`Hello, ${firstName.get()} ${lastName.get()}!`)
+ *   console.log(`Hello, ${firstName.get()} ${lastName.get()}!`)
  * })
  *
  * // Logs "Hello, John Doe!"
@@ -574,19 +844,35 @@ export declare function transact<T>(fn: () => T): T;
  * ```
  *
  * @param fn - The function to run in a transaction, called with a function to roll back the change.
+ * @returns The return value of the function
  * @public
  */
 export declare function transaction<T>(fn: (rollback: () => void) => T): T;
 
 /**
+ * A special symbol used to indicate that a computed signal has not been initialized yet.
+ * This is passed as the `previousValue` parameter to a computed signal function on its first run.
+ *
+ * @example
+ * ```ts
+ * const count = atom('count', 0)
+ * const double = computed('double', (prevValue) => {
+ *   if (isUninitialized(prevValue)) {
+ *     console.log('First computation!')
+ *   }
+ *   return count.get() * 2
+ * })
+ * ```
+ *
  * @public
  */
 export declare const UNINITIALIZED: unique symbol;
 
 /**
  * The type of the first value passed to a computed signal function as the 'prevValue' parameter.
+ * This type represents the uninitialized state of a computed signal before its first calculation.
  *
- * @see {@link isUninitialized}.
+ * @see {@link isUninitialized}
  * @public
  */
 export declare type UNINITIALIZED = typeof UNINITIALIZED;
@@ -638,7 +924,25 @@ export declare function unsafe__withoutCapture<T>(fn: () => T): T;
  */
 export declare function whyAmIRunning(): void;
 
-/** @public */
+/**
+ * A singleton class used to wrap computed signal values along with their diffs.
+ * This class is used internally by the {@link withDiff} function to provide both
+ * the computed value and its diff to the signal system.
+ *
+ * @example
+ * ```ts
+ * const count = atom('count', 0)
+ * const double = computed('double', (prevValue) => {
+ *   const nextValue = count.get() * 2
+ *   if (isUninitialized(prevValue)) {
+ *     return nextValue
+ *   }
+ *   return withDiff(nextValue, nextValue - prevValue)
+ * })
+ * ```
+ *
+ * @public
+ */
 export declare const WithDiff: {
     new <Value, Diff>(value: Value, diff: Diff): {
         diff: Diff;
@@ -646,9 +950,20 @@ export declare const WithDiff: {
     };
 };
 
-/** @public */
+/**
+ * Interface representing a value wrapped with its corresponding diff.
+ * Used in incremental computation to provide both the new value and the diff from the previous value.
+ *
+ * @public
+ */
 export declare interface WithDiff<Value, Diff> {
+    /**
+     * The computed value.
+     */
     value: Value;
+    /**
+     * The diff between the previous and current value.
+     */
     diff: Diff;
 }
 

package/dist-cjs/index.js

@@ -30,6 +30,7 @@ __export(index_exports, {
   isAtom: () => import_Atom.isAtom,
   isSignal: () => import_isSignal.isSignal,
   isUninitialized: () => import_Computed.isUninitialized,
+  localStorageAtom: () => import_localStorageAtom.localStorageAtom,
   react: () => import_EffectScheduler.react,
   reactor: () => import_EffectScheduler.reactor,
   transact: () => import_transactions.transact,
@@ -48,6 +49,7 @@ var import_Computed = require("./lib/Computed");
 var import_EffectScheduler = require("./lib/EffectScheduler");
 var import_helpers2 = require("./lib/helpers");
 var import_isSignal = require("./lib/isSignal");
+var import_localStorageAtom = require("./lib/localStorageAtom");
 var import_transactions = require("./lib/transactions");
 var import_types = require("./lib/types");
 const currentApiVersion = 1;
@@ -59,7 +61,7 @@ if (actualApiVersion !== currentApiVersion) {
 }
 (0, import_utils.registerTldrawLibraryVersion)(
   "@tldraw/state",
-  "4.0.2",
+  "4.1.0-canary.0259516ffb8c",
   "cjs"
 );
 //# sourceMappingURL=index.js.map

package/dist-cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["import { registerTldrawLibraryVersion } from '@tldraw/utils'\nimport { singleton } from './lib/helpers'\n\nexport { ArraySet } from './lib/ArraySet'\nexport { atom, isAtom } from './lib/Atom'\nexport type { Atom, AtomOptions } from './lib/Atom'\nexport { unsafe__withoutCapture, whyAmIRunning } from './lib/capture'\nexport {\n\tcomputed,\n\tgetComputedInstance,\n\tisUninitialized,\n\tUNINITIALIZED,\n\twithDiff,\n} from './lib/Computed'\nexport type { Computed, ComputedOptions, WithDiff } from './lib/Computed'\nexport { EffectScheduler, react, reactor } from './lib/EffectScheduler'\nexport type { EffectSchedulerOptions, Reactor } from './lib/EffectScheduler'\nexport { EMPTY_ARRAY } from './lib/helpers'\nexport { isSignal } from './lib/isSignal'\nexport { deferAsyncEffects, transact, transaction } from './lib/transactions'\nexport { RESET_VALUE } from './lib/types'\nexport type { Child, ComputeDiff, Signal } from './lib/types'\n\n// This should be incremented any time an API change is made. i.e. for additions or removals.\n// Bugfixes need not increment this.\nconst currentApiVersion = 1\n\nconst actualApiVersion = singleton('apiVersion', () => currentApiVersion)\n\nif (actualApiVersion !== currentApiVersion) {\n\tthrow new Error(\n\t\t`You have multiple incompatible versions of @tldraw/state in your app. Please deduplicate the package.`\n\t)\n}\n\nregisterTldrawLibraryVersion(\n\t(globalThis as any).TLDRAW_LIBRARY_NAME,\n\t(globalThis as any).TLDRAW_LIBRARY_VERSION,\n\t(globalThis as any).TLDRAW_LIBRARY_MODULES\n)\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA6C;AAC7C,qBAA0B;AAE1B,sBAAyB;AACzB,kBAA6B;AAE7B,qBAAsD;AACtD,sBAMO;AAEP,6BAAgD;AAEhD,IAAAA,kBAA4B;AAC5B,sBAAyB;AACzB,0BAAyD;AACzD,mBAA4B;AAK5B,MAAM,oBAAoB;AAE1B,MAAM,uBAAmB,0BAAU,cAAc,MAAM,iBAAiB;AAExE,IAAI,qBAAqB,mBAAmB;AAC3C,QAAM,IAAI;AAAA,IACT;AAAA,EACD;AACD;AAAA,IAEA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AACF;",
+  "sourcesContent": ["import { registerTldrawLibraryVersion } from '@tldraw/utils'\nimport { singleton } from './lib/helpers'\n\nexport { ArraySet } from './lib/ArraySet'\nexport { atom, isAtom } from './lib/Atom'\nexport type { Atom, AtomOptions } from './lib/Atom'\nexport { unsafe__withoutCapture, whyAmIRunning } from './lib/capture'\nexport {\n\tcomputed,\n\tgetComputedInstance,\n\tisUninitialized,\n\tUNINITIALIZED,\n\twithDiff,\n} from './lib/Computed'\nexport type { Computed, ComputedOptions, WithDiff } from './lib/Computed'\nexport { EffectScheduler, react, reactor } from './lib/EffectScheduler'\nexport type { EffectSchedulerOptions, Reactor } from './lib/EffectScheduler'\nexport { EMPTY_ARRAY } from './lib/helpers'\nexport { isSignal } from './lib/isSignal'\nexport { localStorageAtom } from './lib/localStorageAtom'\nexport { deferAsyncEffects, transact, transaction } from './lib/transactions'\nexport { RESET_VALUE } from './lib/types'\nexport type { Child, ComputeDiff, Signal } from './lib/types'\n\n// This should be incremented any time an API change is made. i.e. for additions or removals.\n// Bugfixes need not increment this.\nconst currentApiVersion = 1\n\nconst actualApiVersion = singleton('apiVersion', () => currentApiVersion)\n\nif (actualApiVersion !== currentApiVersion) {\n\tthrow new Error(\n\t\t`You have multiple incompatible versions of @tldraw/state in your app. Please deduplicate the package.`\n\t)\n}\n\nregisterTldrawLibraryVersion(\n\t(globalThis as any).TLDRAW_LIBRARY_NAME,\n\t(globalThis as any).TLDRAW_LIBRARY_VERSION,\n\t(globalThis as any).TLDRAW_LIBRARY_MODULES\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA6C;AAC7C,qBAA0B;AAE1B,sBAAyB;AACzB,kBAA6B;AAE7B,qBAAsD;AACtD,sBAMO;AAEP,6BAAgD;AAEhD,IAAAA,kBAA4B;AAC5B,sBAAyB;AACzB,8BAAiC;AACjC,0BAAyD;AACzD,mBAA4B;AAK5B,MAAM,oBAAoB;AAE1B,MAAM,uBAAmB,0BAAU,cAAc,MAAM,iBAAiB;AAExE,IAAI,qBAAqB,mBAAmB;AAC3C,QAAM,IAAI;AAAA,IACT;AAAA,EACD;AACD;AAAA,IAEA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AACF;",
   "names": ["import_helpers"]
 }