@rlabs-inc/signals 0.2.0 → 1.1.0

package/dist/primitives/bind.d.ts

@@ -0,0 +1,95 @@
+import type { WritableSignal, ReadableSignal } from '../core/types.js';
+/**
+ * A writable binding that forwards reads and writes to a source.
+ * Reading creates dependency on source, writing triggers source's reactions.
+ */
+export interface Binding<T> {
+    get value(): T;
+    set value(v: T);
+}
+/**
+ * A read-only binding that forwards reads to a source.
+ * Reading creates dependency on source, writing throws an error.
+ */
+export interface ReadonlyBinding<T> {
+    readonly value: T;
+}
+/**
+ * Check if a value is a binding created by bind()
+ */
+export declare function isBinding(value: unknown): value is Binding<unknown>;
+/**
+ * Create a reactive binding to a signal or another binding.
+ *
+ * A binding is a "reactive pointer" - it forwards reads and writes to the source.
+ * This enables connecting user's reactive state to internal component state.
+ *
+ * @example
+ * ```ts
+ * const source = signal(0)
+ * const binding = bind(source)
+ *
+ * // Reading through binding reads from source (creates dependency)
+ * console.log(binding.value)  // → 0
+ *
+ * // Writing through binding writes to source (triggers reactivity)
+ * binding.value = 42
+ * console.log(source.value)  // → 42
+ * ```
+ *
+ * @example Two-way binding for inputs
+ * ```ts
+ * const username = signal('')
+ * const inputBinding = bind(username)
+ *
+ * // When user types:
+ * inputBinding.value = 'alice'  // Updates username signal!
+ * ```
+ *
+ * @example Chaining bindings
+ * ```ts
+ * const source = signal(0)
+ * const b1 = bind(source)
+ * const b2 = bind(b1)  // Points to same source
+ *
+ * b2.value = 99
+ * console.log(source.value)  // → 99
+ * ```
+ */
+export declare function bind<T>(source: WritableSignal<T>): Binding<T>;
+export declare function bind<T>(source: ReadableSignal<T>): ReadonlyBinding<T>;
+export declare function bind<T>(source: Binding<T>): Binding<T>;
+export declare function bind<T>(source: ReadonlyBinding<T>): ReadonlyBinding<T>;
+/**
+ * Create an explicitly read-only binding.
+ * Attempting to write will throw an error at runtime.
+ *
+ * Use this when you want to ensure a binding is never written to,
+ * even if the source is writable.
+ *
+ * @example
+ * ```ts
+ * const source = signal(0)
+ * const readonly = bindReadonly(source)
+ *
+ * console.log(readonly.value)  // → 0
+ * readonly.value = 42  // Throws: Cannot write to a read-only binding
+ * ```
+ */
+export declare function bindReadonly<T>(source: ReadableSignal<T> | Binding<T>): ReadonlyBinding<T>;
+/**
+ * Get the value from a binding or return the value directly if not a binding.
+ * Useful for reading values that may or may not be bound.
+ *
+ * @example
+ * ```ts
+ * const arr: (string | Binding<string>)[] = [
+ *   'static',
+ *   bind(signal('dynamic'))
+ * ]
+ *
+ * arr.map(unwrap)  // → ['static', 'dynamic']
+ * ```
+ */
+export declare function unwrap<T>(value: T | Binding<T> | ReadonlyBinding<T>): T;
+//# sourceMappingURL=bind.d.ts.map

package/dist/primitives/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../../src/primitives/bind.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAMtE;;;GAGG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,IAAI,KAAK,IAAI,CAAC,CAAA;IACd,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,EAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAClB;AAQD;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAEnE;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAC9D,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;AACtE,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AACvD,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;AA6BvE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAQ1F;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAKvE"}

package/dist/primitives/derived.d.ts

@@ -0,0 +1,45 @@
+import type { Derived, Effect, DerivedSignal, Equals } from '../core/types.js';
+export interface DerivedOptions<T> {
+    equals?: Equals<T>;
+}
+/**
+ * Create a derived signal (internal)
+ * This is the low-level primitive
+ */
+export declare function createDerived<T>(fn: () => T, options?: DerivedOptions<T>): Derived<T>;
+/**
+ * Execute a derived's computation function
+ * Cleans up old effects and tracks new dependencies
+ */
+export declare function executeDerived<T>(derived: Derived<T>): T;
+/**
+ * Update a derived signal's value
+ * Only called when the derived is dirty and being read
+ */
+export declare function updateDerived<T>(derived: Derived<T>): void;
+export declare function setDestroyEffectImpl(impl: (effect: Effect) => void): void;
+/**
+ * Create a derived signal
+ *
+ * Derived signals are lazy - they only compute when read.
+ * They cache their value and only recompute when dependencies change.
+ *
+ * @example
+ * ```ts
+ * const count = signal(1)
+ * const doubled = derived(() => count.value * 2)
+ * console.log(doubled.value) // 2
+ * count.value = 5
+ * console.log(doubled.value) // 10
+ * ```
+ */
+export declare function derived<T>(fn: () => T, options?: DerivedOptions<T>): DerivedSignal<T>;
+export declare namespace derived {
+    var by: typeof derived;
+}
+/**
+ * Disconnect a derived from its dependencies
+ * Used when a derived is no longer needed
+ */
+export declare function disconnectDerived(derived: Derived): void;
+//# sourceMappingURL=derived.d.ts.map

package/dist/primitives/derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.d.ts","sourceRoot":"","sources":["../../src/primitives/derived.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAuB9E,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;CACnB;AAMD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CA4BrF;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAQxD;AAMD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAc1D;AAYD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAEzE;AAmBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAQrF;yBARe,OAAO;;;AAoBvB;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAKxD"}

package/dist/primitives/effect.d.ts

@@ -0,0 +1,41 @@
+import type { Effect, EffectFn, DisposeFn } from '../core/types.js';
+/**
+ * Create an effect (internal)
+ *
+ * @param type - Effect type flags
+ * @param fn - Effect function
+ * @param sync - Whether to run synchronously
+ * @param push - Whether to add to parent's child list
+ */
+export declare function createEffect(type: number, fn: EffectFn | null, sync: boolean, push?: boolean): Effect;
+/**
+ * Run an effect and track its dependencies
+ */
+export declare function updateEffect(effect: Effect): void;
+/**
+ * Destroy an effect and all its children
+ */
+export declare function destroyEffect(effect: Effect, removeFromParent?: boolean): void;
+/**
+ * Create an effect that runs when dependencies change
+ *
+ * Effects are scheduled asynchronously (microtask).
+ * The function can return a cleanup function that runs before the next execution.
+ *
+ * @example
+ * ```ts
+ * const count = signal(0)
+ *
+ * effect(() => {
+ *   console.log('Count:', count.value)
+ *   return () => console.log('Cleanup')
+ * })
+ * ```
+ */
+export declare function effect(fn: EffectFn): DisposeFn;
+export declare namespace effect {
+    var pre: (fn: EffectFn) => DisposeFn;
+    var root: (fn: () => void) => DisposeFn;
+    var tracking: () => boolean;
+}
+//# sourceMappingURL=effect.d.ts.map

package/dist/primitives/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/primitives/effect.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAa,SAAS,EAAE,MAAM,kBAAkB,CAAA;AA8B9E;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,QAAQ,GAAG,IAAI,EACnB,IAAI,EAAE,OAAO,EACb,IAAI,UAAO,GACV,MAAM,CA8BR;AAyBD;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CA4BjD;AASD;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,UAAO,GAAG,IAAI,CA0B3E;AA8ED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,GAAG,SAAS,CAI9C;yBAJe,MAAM;kBAUc,QAAQ,KAAG,SAAS;mBAqBlB,MAAM,IAAI,KAAG,SAAS;wBAUf,OAAO"}

package/dist/primitives/signal.d.ts

@@ -0,0 +1,54 @@
+import type { Source, WritableSignal, Equals } from '../core/types.js';
+export interface SourceOptions<T> {
+    equals?: Equals<T>;
+}
+/**
+ * Create a source (internal signal)
+ * This is the low-level primitive - use signal() for the public API
+ */
+export declare function source<T>(initialValue: T, options?: SourceOptions<T>): Source<T>;
+/**
+ * Create a mutable source with safe equality
+ * Used for values that may contain NaN or need object reference tracking
+ */
+export declare function mutableSource<T>(initialValue: T): Source<T>;
+export interface SignalOptions<T> {
+    equals?: Equals<T>;
+}
+/**
+ * Create a writable signal
+ *
+ * @example
+ * ```ts
+ * const count = signal(0)
+ * console.log(count.value) // 0
+ * count.value = 1
+ * console.log(count.value) // 1
+ * ```
+ */
+export declare function signal<T>(initialValue: T, options?: SignalOptions<T>): WritableSignal<T>;
+export declare function setProxyFn(fn: <T extends object>(value: T) => T): void;
+/**
+ * Create a deeply reactive state object
+ * Unlike signal(), state() returns the proxy directly (no .value needed)
+ *
+ * @example
+ * ```ts
+ * const user = state({ name: 'John', age: 30 })
+ * user.name = 'Jane' // No .value needed
+ * ```
+ */
+export declare function state<T extends object>(initialValue: T): T;
+/**
+ * Create a signal that holds an object reference without deep reactivity
+ * Useful for DOM elements, class instances, or large objects where
+ * you only want to track reference changes
+ *
+ * @example
+ * ```ts
+ * const canvas = stateRaw(document.createElement('canvas'))
+ * // Only triggers when canvas.value is reassigned, not on canvas mutations
+ * ```
+ */
+export declare function stateRaw<T>(initialValue: T): WritableSignal<T>;
+//# sourceMappingURL=signal.d.ts.map

package/dist/primitives/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/primitives/signal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAQtE,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;CACnB;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAShF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAE3D;AAMD,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAWxF;AASD,wBAAgB,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAEtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,CAK1D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAE9D"}

package/dist/reactivity/batching.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Batch multiple signal updates into a single reaction cycle
+ *
+ * Without batching, each signal update triggers effects immediately.
+ * With batching, effects only run once after all updates complete.
+ *
+ * @example
+ * ```ts
+ * const a = signal(1)
+ * const b = signal(2)
+ *
+ * effect(() => {
+ *   console.log(a.value + b.value)
+ * })
+ *
+ * // Without batch: logs twice (during each update)
+ * // With batch: logs once (after both updates)
+ * batch(() => {
+ *   a.value = 10
+ *   b.value = 20
+ * })
+ * ```
+ */
+export declare function batch<T>(fn: () => T): T;
+/**
+ * Read signals without creating dependencies
+ *
+ * Useful when you need to read a value but don't want
+ * the effect to re-run when it changes.
+ *
+ * @example
+ * ```ts
+ * const a = signal(1)
+ * const b = signal(2)
+ *
+ * effect(() => {
+ *   // This creates a dependency on 'a'
+ *   console.log(a.value)
+ *
+ *   // This does NOT create a dependency on 'b'
+ *   untrack(() => {
+ *     console.log(b.value)
+ *   })
+ * })
+ *
+ * a.value = 10 // Effect re-runs
+ * b.value = 20 // Effect does NOT re-run
+ * ```
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Alias for untrack()
+ * Some prefer this name as it's more explicit about "peeking" at a value
+ */
+export declare const peek: typeof untrack;
+//# sourceMappingURL=batching.d.ts.map

package/dist/reactivity/batching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batching.d.ts","sourceRoot":"","sources":["../../src/reactivity/batching.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAavC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzC;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,gBAAU,CAAA"}

package/dist/reactivity/equality.d.ts

@@ -0,0 +1,36 @@
+import type { Equals } from '../core/types.js';
+/**
+ * Default strict equality function using Object.is
+ * This is the default for source() signals
+ */
+export declare const equals: Equals;
+/**
+ * Safe not-equal check
+ * Handles NaN correctly and considers objects/functions as not equal
+ */
+export declare function safeNotEqual<T>(a: T, b: T): boolean;
+/**
+ * Safe equality function
+ * Used for mutable sources where NaN and objects need special handling
+ */
+export declare const safeEquals: Equals;
+/**
+ * Shallow equality for objects/arrays
+ * Compares own enumerable properties one level deep
+ */
+export declare const shallowEquals: Equals;
+/**
+ * Create a custom equality function
+ */
+export declare function createEquals<T>(fn: (a: T, b: T) => boolean): Equals<T>;
+/**
+ * Never equal - always triggers updates
+ * Useful for forcing reactivity
+ */
+export declare const neverEquals: Equals;
+/**
+ * Always equal - never triggers updates
+ * Useful for static values
+ */
+export declare const alwaysEquals: Equals;
+//# sourceMappingURL=equality.d.ts.map

package/dist/reactivity/equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality.d.ts","sourceRoot":"","sources":["../../src/reactivity/equality.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAM9C;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,MAA8D,CAAA;AAMnF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAQnD;AAED;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,MAAkE,CAAA;AAM3F;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAkD3B,CAAA;AAMD;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAEtE;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAAoB,CAAA;AAE9C;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAmB,CAAA"}

package/dist/reactivity/scheduling.d.ts

@@ -0,0 +1,26 @@
+import type { Reaction, Effect } from '../core/types.js';
+/**
+ * Schedule an effect for execution
+ * Walks up the effect tree to find the root and queues it
+ */
+export declare function scheduleEffect(reaction: Reaction): void;
+export declare function setUpdateEffectImpl(impl: (effect: Effect) => void): void;
+/**
+ * Flush all queued effects
+ */
+export declare function flushEffects(): void;
+/**
+ * Flush pending reactions from a batch
+ */
+export declare function flushPendingReactions(): void;
+/**
+ * Synchronously flush all pending updates
+ * Runs all effects immediately instead of waiting for microtask
+ */
+export declare function flushSync<T>(fn?: () => T): T | undefined;
+/**
+ * Wait for the next update cycle
+ * Returns a promise that resolves after all pending effects have run
+ */
+export declare function tick(): Promise<void>;
+//# sourceMappingURL=scheduling.d.ts.map

package/dist/reactivity/scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../../src/reactivity/scheduling.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAkBxD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAmCvD;AAWD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAExE;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAYnC;AAwBD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAc5C;AASD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CA6CxD;AAMD;;;GAGG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1C"}

package/dist/reactivity/tracking.d.ts

@@ -0,0 +1,47 @@
+import type { Source, Reaction, Derived } from '../core/types.js';
+/**
+ * Read a signal's value and track it as a dependency
+ * This is the core of Svelte 5's fine-grained reactivity
+ *
+ * Key optimizations:
+ * 1. Version-based deduplication (rv) prevents duplicate dependencies
+ * 2. skippedDeps optimization reuses existing dependency arrays
+ */
+export declare function get<T>(signal: Source<T>): T;
+/**
+ * Write a signal's value and trigger dependent reactions
+ */
+export declare function set<T>(signal: Source<T>, value: T): T;
+/**
+ * Mark all reactions of a signal with the given status
+ * For effects: schedule them for execution
+ * For deriveds: cascade MAYBE_DIRTY to their reactions
+ */
+export declare function markReactions(signal: Source, status: number): void;
+/**
+ * Set the status flags of a signal (CLEAN, DIRTY, MAYBE_DIRTY)
+ */
+export declare function setSignalStatus(signal: {
+    f: number;
+}, status: number): void;
+/**
+ * Check if a reaction is dirty and needs to be updated
+ *
+ * DIRTY: definitely needs update
+ * MAYBE_DIRTY: check dependencies to see if any actually changed
+ * CLEAN: no update needed
+ */
+export declare function isDirty(reaction: Reaction): boolean;
+export declare function updateDerived(derived: Derived): void;
+export declare function setUpdateDerivedImpl(impl: (derived: Derived) => void): void;
+/**
+ * Remove a reaction from its dependencies, starting at the given index
+ * Uses swap-and-pop for O(1) removal
+ */
+export declare function removeReactions(reaction: Reaction, start: number): void;
+/**
+ * Run a reaction function and track its dependencies
+ * This is the core algorithm for dynamic dependency tracking
+ */
+export declare function updateReaction(reaction: Reaction): unknown;
+//# sourceMappingURL=tracking.d.ts.map

package/dist/reactivity/tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracking.d.ts","sourceRoot":"","sources":["../../src/reactivity/tracking.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAkCjE;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAmD3C;AAQD;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CA8BrD;AAMD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAuBlE;AAMD;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAE3E;AAMD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAiCnD;AAWD,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEpD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAE3E;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAOvE;AA8BD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAmG1D"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rlabs-inc/signals",
-  "version": "0.2.0",
-  "description": "Ultra-lightweight fine-grained reactivity for TypeScript. Signals, effects, derived values, and reactive collections with deep reactivity support.",
+  "version": "1.1.0",
+  "description": "Production-grade fine-grained reactivity for TypeScript. A complete standalone mirror of Svelte 5's reactivity system - signals, effects, derived values, deep reactivity, reactive collections, and reactive bindings.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -21,6 +21,9 @@
     "build": "bun build src/index.ts --outfile dist/index.mjs --target node --format esm && bun build src/index.ts --outfile dist/index.js --target node --format cjs && bun run build:types",
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist",
     "test": "bun test",
+    "test:unit": "bun test test/unit",
+    "test:integration": "bun test test/integration",
+    "test:perf": "bun test test/performance",
     "prepublishOnly": "bun run build"
   },
   "keywords": [
@@ -34,6 +37,7 @@
     "derived",
     "computed",
     "observable",
+    "svelte",
     "typescript"
   ],
   "author": "RLabs Inc.",