@nerdalytics/beacon 1000.2.4 → 1000.3.0

package/README.md

@@ -1,11 +1,10 @@
-# Beacon <img align="right" src="https://raw.githubusercontent.com/nerdalytics/beacon/refs/heads/trunk/assets/beacon-logo.svg" width="128px" alt="A stylized lighthouse beacon with golden light against a dark blue background, representing the reactive state library"/>
+# Beacon <img align="right" src="https://raw.githubusercontent.com/nerdalytics/beacon/refs/heads/trunk/assets/beacon-logo-v2.svg" width="128px" alt="A stylized lighthouse beacon with golden light against a dark blue background, representing the reactive state library"/>
 
 > Lightweight reactive state management for Node.js backends
 
-
 [![license:mit](https://flat.badgen.net/static/license/MIT/blue)](https://github.com/nerdalytics/beacon/blob/trunk/LICENSE)
 [![registry:npm:version](https://img.shields.io/npm/v/@nerdalytics/beacon.svg)](https://www.npmjs.com/package/@nerdalytics/beacon)
-[![Socket Badge](https://badge.socket.dev/npm/package/@nerdalytics/beacon/1000.2.3)](https://socket.dev/npm/package/@nerdalytics/beacon/overview/1000.2.3)
+[![Socket Badge](https://badge.socket.dev/npm/package/@nerdalytics/beacon/1000.3.0)](https://socket.dev/npm/package/@nerdalytics/beacon/overview/1000.3.0)
 
 [![tech:nodejs](https://img.shields.io/badge/Node%20js-339933?style=for-the-badge&logo=nodedotjs&logoColor=white)](https://nodejs.org/)
 [![language:typescript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)](https://typescriptlang.org/)
@@ -13,536 +12,33 @@
 
 A lightweight reactive state library for Node.js backends. Enables reactive state management with automatic dependency tracking and efficient updates for server-side applications.
 
-<details>
-<summary><Strong>Table of Contents</Strong></summary>
-
-- [Features](#features)
-- [Quick Start](#quick-start)
-- [Core Concepts](#core-concepts)
-- [API Reference](#api-reference)
-   - [Core Primitives](#core-primitives)
-      - [state](#statetinitialvalue-t-equalityfn-a-t-b-t--boolean-statet)
-      - [derive](#derivetfn---t-readonlystatet)
-      - [effect](#effectfn---void---void)
-      - [batch](#batchtfn---t-t)
-      - [select](#selectt-rsource-readonlystatet-selectorfn-state-t--r-equalityfn-a-r-b-r--boolean-readonlystater)
-      - [lens](#lenst-ksource-statet-accessor-state-t--k-statek)
-   - [Access Control](#access-control)
-      - [readonlyState](#readonlystatetstate-statet-readonlystatet)
-      - [protectedState](#protectedstatetinitialvalue-t-equalityfn-a-t-b-t--boolean-readonlystatet-writeablestatet)
-- [Advanced Features](#advanced-features)
-   - [Infinite Loop Protection](#infinite-loop-protection)
-   - [Automatic Cleanup](#automatic-cleanup)
-   - [Custom Equality Functions](#custom-equality-functions)
-- [Design Philosophy](#design-philosophy)
-- [Architecture](#architecture)
-- [Development](#development)
-- [Key Differences vs TC39 Proposal](#key-differences-vs-tc39-proposal)
-- [FAQ](#faq)
-   - [Why "Beacon" Instead of "Signal"?](#why-beacon-instead-of-signal)
-   - [How does Beacon handle memory management?](#how-does-beacon-handle-memory-management)
-   - [Can I use Beacon with Express or other frameworks?](#can-i-use-beacon-with-express-or-other-frameworks)
-   - [Can Beacon be used in browser applications?](#can-beacon-be-used-in-browser-applications)
-- [License](#license)
-
-</details>
-
-## Features
-
-- 📶 **Reactive state** - Create reactive values that automatically track dependencies
-- 🧮 **Computed values** - Derive values from other states with automatic updates
-- 🔍 **Fine-grained reactivity** - Dependencies are tracked precisely at the state level
-- 🏎️ **Efficient updates** - Only recompute values when dependencies change
-- 📦 **Batched updates** - Group multiple updates for performance
-- 🎯 **Targeted subscriptions** - Select and subscribe to specific parts of state objects
-- 🧹 **Automatic cleanup** - Effects and computations automatically clean up dependencies
-- ♻️ **Cycle handling** - Safely manages cyclic dependencies without crashing
-- 🚨 **Infinite loop detection** - Automatically detects and prevents infinite update loops
-- 🛠️ **TypeScript-first** - Full TypeScript support with generics
-- 🪶 **Lightweight** - Zero dependencies
-- ✅ **Node.js compatibility** - Works with Node.js LTS v20+ and v22+
-
-## Quick Start
+## Installation
 
-```other
+```
 npm install @nerdalytics/beacon --save-exact
 ```
 
+## Quick Start
+
 ```typescript
 import { state, derive, effect } from '@nerdalytics/beacon';
 
-// Create reactive state
 const count = state(0);
-
-// Create a derived value
 const doubled = derive(() => count() * 2);
 
-// Set up an effect
 effect(() => {
   console.log(`Count: ${count()}, Doubled: ${doubled()}`);
 });
-// => "Count: 0, Doubled: 0"
 
-// Update the state - effect runs automatically
 count.set(5);
 // => "Count: 5, Doubled: 10"
 ```
 
-## Core Concepts
-
-Beacon is built around three core primitives:
-
-1. **States**: Mutable, reactive values
-2. **Derived States**: Read-only computed values that update automatically
-3. **Effects**: Side effects that run automatically when dependencies change
-
-The library handles all the dependency tracking and updates automatically, so you can focus on your business logic.
-
-## API Reference
-
-### Version Compatibility
-
-The table below tracks when features were introduced and when function signatures were changed.
-
-| API | Introduced | Last Updated | Notes |
-|-----|------------|--------------|-------|
-| `state` | v1.0.0 | v1000.2.0 | Added `equalityFn` parameter |
-| `derive` | v1.0.0 | v1000.0.0 | Renamed `derived` → `derive` |
-| `effect` | v1.0.0 | - | - |
-| `batch` | v1.0.0 | - | - |
-| `select` | v1000.0.0 | - | - |
-| `lens` | v1000.1.0 | - | - |
-| `readonlyState` | v1000.0.0 | - | - |
-| `protectedState` | v1000.0.0 | v1000.2.0 | Added `equalityFn` parameter |
-
-### Core Primitives
-
-#### `state<T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean): State<T>`
-> *Since v1.0.0*
-
-The foundation of Beacon's reactivity system. Create with `state()` and use like a function.
-
-```typescript
-import { state } from '@nerdalytics/beacon';
-
-const counter = state(0);
-
-// Read current value
-console.log(counter()); // => 0
-
-// Update value
-counter.set(5);
-console.log(counter()); // => 5
-
-// Update with a function
-counter.update(n => n + 1);
-console.log(counter()); // => 6
-
-// With custom equality function
-const deepCounter = state({ value: 0 }, (a, b) => {
-  // Deep equality check
-  return a.value === b.value;
-});
-
-// This won't trigger effects because values are deeply equal
-deepCounter.set({ value: 0 });
-```
-
-#### `derive<T>(fn: () => T): ReadOnlyState<T>`
-> *Since v1.0.0*
-
-Calculate values based on other states. Updates automatically when dependencies change.
-
-```typescript
-import { state, derive } from '@nerdalytics/beacon';
-
-const firstName = state('John');
-const lastName = state('Doe');
-
-const fullName = derive(() => `${firstName()} ${lastName()}`);
-
-console.log(fullName()); // => "John Doe"
-
-firstName.set('Jane');
-console.log(fullName()); // => "Jane Doe"
-```
-
-#### `effect(fn: () => void): () => void`
-> *Since v1.0.0*
-
-Run side effects when reactive values change.
-
-```typescript
-import { state, effect } from '@nerdalytics/beacon';
-
-const user = state({ name: 'Alice', loggedIn: false });
-
-const cleanup = effect(() => {
-  console.log(`User ${user().name} is ${user().loggedIn ? 'online' : 'offline'}`);
-});
-// => "User Alice is offline" (effect runs immediately when created)
-
-user.update(u => ({ ...u, loggedIn: true }));
-// => "User Alice is online"
-
-// Stop the effect and clean up all subscriptions
-cleanup();
-```
-
-#### `batch<T>(fn: () => T): T`
-> *Since v1.0.0*
-
-Group multiple updates to trigger effects only once.
-
-```typescript
-import { state, effect, batch } from "@nerdalytics/beacon";
-
-const count = state(0);
-
-effect(() => {
-  console.log(`Count is ${count()}`);
-});
-// => "Count is 0" (effect runs immediately)
-
-// Without batching, effects run after each update
-count.set(1);
-// => "Count is 1"
-count.set(2);
-// => "Count is 2"
-
-// Batch updates (only triggers effects once at the end)
-batch(() => {
-  count.set(10);
-  count.set(20);
-  count.set(30);
-});
-// => "Count is 30" (only once)
-```
-
-#### `select<T, R>(source: ReadOnlyState<T>, selectorFn: (state: T) => R, equalityFn?: (a: R, b: R) => boolean): ReadOnlyState<R>`
-> *Since v1000.0.0*
-
-Subscribe to specific parts of a state object.
-
-```typescript
-import { state, select, effect } from '@nerdalytics/beacon';
-
-const user = state({
-  profile: { name: 'Alice' },
-  preferences: { theme: 'dark' }
-});
-
-// Only triggers when name changes
-const nameState = select(user, u => u.profile.name);
-
-effect(() => {
-  console.log(`Name: ${nameState()}`);
-});
-// => "Name: Alice"
-
-// This triggers the effect
-user.update(u => ({
-  ...u,
-  profile: { ...u.profile, name: 'Bob' }
-}));
-// => "Name: Bob"
-
-// This doesn't trigger the effect (theme changed, not name)
-user.update(u => ({
-  ...u,
-  preferences: { ...u.preferences, theme: 'light' }
-}));
-```
-
-#### `lens<T, K>(source: State<T>, accessor: (state: T) => K): State<K>`
-> *Since v1000.1.0*
-
-Two-way binding to deeply nested properties.
-
-```typescript
-import { state, lens, effect } from "@nerdalytics/beacon";
-
-const nested = state({
-  user: {
-    profile: {
-      settings: {
-        theme: "dark",
-        notifications: true
-      }
-    }
-  }
-});
-
-// Create a lens focused on a deeply nested property
-const themeLens = lens(nested, n => n.user.profile.settings.theme);
-
-// Read the focused value
-console.log(themeLens()); // => "dark"
-
-// Update the focused value directly (maintains referential integrity)
-themeLens.set("light");
-console.log(themeLens()); // => "light"
-console.log(nested().user.profile.settings.theme); // => "light"
-
-// The entire object is updated with proper referential integrity
-// This makes it easy to detect changes throughout the object tree
-```
-
-### Access Control
-
-Control who can read vs. write to your state.
-
-#### `readonlyState<T>(state: State<T>): ReadOnlyState<T>`
-> *Since v1000.0.0*
-
-Creates a read-only view of a state, hiding mutation methods. Useful when you want to expose state to other parts of your application without allowing direct mutations.
-
-```typescript
-import { state, readonlyState } from "@nerdalytics/beacon";
-
-const counter = state(0);
-const readonlyCounter = readonlyState(counter);
-
-// Reading works
-console.log(readonlyCounter()); // => 0
+## Documentation
 
-// Updating the original state reflects in the readonly view
-counter.set(5);
-console.log(readonlyCounter()); // => 5
-
-// This would cause a TypeScript error since readonlyCounter has no set method
-// readonlyCounter.set(10); // Error: Property 'set' does not exist
-```
-
-#### `protectedState<T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean): [ReadOnlyState<T>, WriteableState<T>]`
-> *Since v1000.0.0*
-
-Creates a state with separated read and write capabilities, returning a tuple of reader and writer. This pattern allows you to expose only the reading capability to consuming code while keeping the writing capability private.
-
-```typescript
-import { protectedState } from "@nerdalytics/beacon";
-
-// Create a state with separated read and write capabilities
-const [getUser, setUser] = protectedState({ name: 'Alice' });
-
-// Read the state
-console.log(getUser()); // => { name: 'Alice' }
-
-// Update the state
-setUser.set({ name: 'Bob' });
-console.log(getUser()); // => { name: 'Bob' }
-
-// This is useful for exposing only read access to outside consumers
-function createProtectedCounter() {
-  const [getCount, setCount] = protectedState(0);
-
-  return {
-    value: getCount,
-    increment: () => setCount.update(n => n + 1),
-    decrement: () => setCount.update(n => n - 1)
-  };
-}
-
-const counter = createProtectedCounter();
-console.log(counter.value()); // => 0
-counter.increment();
-console.log(counter.value()); // => 1
-```
-
-## Advanced Features
-
-Beacon includes several advanced capabilities that help you build robust applications.
-
-### Infinite Loop Protection
-
-Beacon prevents common mistakes that could cause infinite loops:
-
-```typescript
-import { state, effect } from '@nerdalytics/beacon';
-
-const counter = state(0);
-
-// This would throw an error
-effect(() => {
-  const value = counter();
-  counter.set(value + 1); // Error: Infinite loop detected!
-});
-
-// Instead, use proper patterns like:
-const increment = () => counter.update(n => n + 1);
-```
-
-### Automatic Cleanup
-
-All subscriptions are automatically cleaned up when effects are unsubscribed:
-
-```typescript
-import { state, effect } from '@nerdalytics/beacon';
-
-const data = state({ loading: true, items: [] });
-
-// Effect with nested effect
-const cleanup = effect(() => {
-  if (data().loading) {
-    console.log('Loading...');
-  } else {
-    // This nested effect is automatically cleaned up when the parent is
-    effect(() => {
-      console.log(`${data().items.length} items loaded`);
-    });
-  }
-});
-
-// Unsubscribe cleans up everything, including nested effects
-cleanup();
-```
-
-### Custom Equality Functions
-
-Control when subscribers are notified with custom equality checks. You can provide custom equality functions to `state`, `select`, and `protectedState`:
-
-```typescript
-import { state, select, effect, protectedState } from '@nerdalytics/beacon';
-
-// Custom equality function for state
-// Only trigger updates when references are different (useful for logging)
-const logMessages = state([], (a, b) => a === b); // Reference equality
-
-// Add logs - each call triggers effects even with identical content
-logMessages.set(['System started']); // Triggers effects
-logMessages.set(['System started']); // Triggers effects again
-
-// Protected state with custom equality function
-const [getConfig, setConfig] = protectedState({ theme: 'dark' }, (a, b) => {
-  // Only consider configs equal if all properties match
-  return a.theme === b.theme;
-});
-
-// Custom equality with select
-const list = state([1, 2, 3]);
-
-// Only notify when array length changes, not on content changes
-const listLengthState = select(
-  list,
-  arr => arr.length,
-  (a, b) => a === b
-);
-
-effect(() => {
-  console.log(`List has ${listLengthState()} items`);
-});
-```
-
-## Design Philosophy
-
-Beacon follows these key principles:
-
-1. **Simplicity**: Minimal API surface with powerful primitives
-2. **Fine-grained reactivity**: Track dependencies at exactly the right level
-3. **Predictability**: State changes flow predictably through the system
-4. **Performance**: Optimize for server workloads and memory efficiency
-5. **Type safety**: Full TypeScript support with generics
-
-## Architecture
-
-Beacon is built around a centralized reactivity system with fine-grained dependency tracking. Here's how it works:
-
-- **Automatic Dependency Collection**: When a state is read inside an effect, Beacon automatically records this dependency
-- **WeakMap-based Tracking**: Uses WeakMaps for automatic garbage collection
-- **Topological Updates**: Updates flow through the dependency graph in the correct order
-- **Memory-Efficient**: Designed for long-running Node.js processes
-
-### Dependency Tracking
-
-When a state is read inside an effect, Beacon automatically records this dependency relationship and sets up a subscription.
-
-### Infinite Loop Prevention
-
-Beacon actively detects when an effect tries to update a state it depends on, preventing common infinite update cycles:
-
-```typescript
-// This would throw: "Infinite loop detected"
-effect(() => {
-  const value = counter();
-  counter.set(value + 1); // Error! Updating a state the effect depends on
-});
-```
-
-### Cyclic Dependencies
-
-Beacon employs two complementary strategies for handling cyclical updates:
-
-1. **Active Detection**: The system tracks which states an effect reads from and writes to. If an effect attempts to directly update a state it depends on, Beacon throws a clear error.
-2. **Safe Cycles**: For indirect cycles and safe update patterns, Beacon uses a queue-based update system that won't crash even with cyclical dependencies. When states form a cycle where values eventually stabilize, the system handles these updates efficiently without stack overflows.
-
-## Development
-
-```other
-# Install dependencies
-npm install
-
-# Run tests
-npm test
-```
-
-## Key Differences vs [TC39 Proposal][1]
-
-| **Aspect**                  | **@nerdalytics/beacon**                                                     | **TC39 Proposal**                                                                             |
-| --------------------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
-| **API Style**               | Functional approach (`state()`, `derive()`)                                 | Class-based design (`Signal.State`, `Signal.Computed`)                                        |
-| **Reading/Writing Pattern** | Function call for reading (`count()`), methods for writing (`count.set(5)`) | Method-based access (`get()`/`set()`)                                                         |
-| **Framework Support**       | High-level abstractions like `effect()` and `batch()`                       | Lower-level primitives (`Signal.subtle.Watcher`) that frameworks build upon                   |
-| **Advanced Features**       | Focused on core reactivity                                                  | Includes introspection capabilities, watched/unwatched callbacks, and Signal.subtle namespace |
-| **Scope and Purpose**       | Practical Node.js use cases with minimal API surface                        | Standardization with robust interoperability between frameworks                               |
-
-## FAQ
-
-#### Why "Beacon" Instead of "Signal"?
-
-Beacon represents how the library broadcasts notifications when state changes—just like a lighthouse guides ships. The name avoids confusion with the TC39 proposal and similar libraries while accurately describing the core functionality.
-
-#### How does Beacon handle memory management?
-
-Beacon uses WeakMaps for dependency tracking, ensuring that unused states and effects can be garbage collected. When you unsubscribe an effect, all its internal subscriptions are automatically cleaned up.
-
-#### Can I use Beacon with Express or other frameworks?
-
-Yes! Beacon works well as a state management solution in any Node.js application:
-
-```typescript
-import express from 'express';
-import { state, effect } from '@nerdalytics/beacon';
-
-const app = express();
-const stats = state({ requests: 0, errors: 0 });
-
-// Update stats on each request
-app.use((req, res, next) => {
-  stats.update(s => ({ ...s, requests: s.requests + 1 }));
-  next();
-});
-
-// Log stats every minute
-effect(() => {
-  console.log(`Stats: ${stats().requests} requests, ${stats().errors} errors`);
-});
-
-app.listen(3000);
-```
-
-#### Can Beacon be used in browser applications?
-
-While Beacon is optimized for Node.js server-side applications, its core principles would work in browser environments. However, the library is specifically designed for backend use cases and hasn't been optimized for browser bundle sizes or DOM integration patterns.
+Full documentation, API reference, and examples available at:
+**[github.com/nerdalytics/beacon](https://github.com/nerdalytics/beacon)**
 
 ## License
 
-This project is licensed under the MIT License. See the [LICENSE][2] file for details.
-
-<div align="center">
-  <img src="https://raw.githubusercontent.com/nerdalytics/nerdalytics/refs/heads/main/nerdalytics-logo-gray-transparent.svg" width="128px">
-</div>
-
-<!-- Links collection -->
-
-[1]: https://github.com/tc39/proposal-signals
-[2]: ./LICENSE
+MIT - See [LICENSE](./LICENSE) for details.

package/dist/src/index.d.ts

@@ -1,19 +1,20 @@
-export type Unsubscribe = () => void;
-export type ReadOnlyState<T> = () => T;
-export interface WriteableState<T> {
+type Unsubscribe = () => void;
+type ReadOnlyState<T> = () => T;
+interface WriteableState<T> {
     set(value: T): void;
     update(fn: (value: T) => T): void;
 }
 declare const STATE_ID: unique symbol;
-export type State<T> = ReadOnlyState<T> & WriteableState<T> & {
+type State<T> = ReadOnlyState<T> & WriteableState<T> & {
     [STATE_ID]?: symbol;
 };
-export declare const state: <T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean) => State<T>;
-export declare const effect: (fn: () => void) => Unsubscribe;
-export declare const batch: <T>(fn: () => T) => T;
-export declare const derive: <T>(computeFn: () => T) => ReadOnlyState<T>;
-export declare const select: <T, R>(source: ReadOnlyState<T>, selectorFn: (state: T) => R, equalityFn?: (a: R, b: R) => boolean) => ReadOnlyState<R>;
-export declare const readonlyState: <T>(state: State<T>) => ReadOnlyState<T>;
-export declare const protectedState: <T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean) => [ReadOnlyState<T>, WriteableState<T>];
-export declare const lens: <T, K>(source: State<T>, accessor: (state: T) => K) => State<K>;
-export {};
+declare const createState: <T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean) => State<T>;
+declare const createEffect: (fn: () => void) => Unsubscribe;
+declare const executeBatch: <T>(fn: () => T) => T;
+declare const createDerive: <T>(computeFn: () => T) => ReadOnlyState<T>;
+declare const createSelect: <T, R>(source: ReadOnlyState<T>, selectorFn: (state: T) => R, equalityFn?: (a: R, b: R) => boolean) => ReadOnlyState<R>;
+declare const createLens: <T, K>(source: State<T>, accessor: (state: T) => K) => State<K>;
+declare const createReadonlyState: <T>(source: State<T>) => ReadOnlyState<T>;
+declare const createProtectedState: <T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean) => [ReadOnlyState<T>, WriteableState<T>];
+export { createDerive as derive, createEffect as effect, createLens as lens, createProtectedState as protectedState, createReadonlyState as readonlyState, createSelect as select, createState as state, executeBatch as batch, };
+export type { ReadOnlyState, State, Unsubscribe, WriteableState };

package/dist/src/index.min.js

@@ -1 +1 @@
-let i=Symbol("STATE_ID"),a=(e,t=Object.is)=>l.createState(e,t);var e=e=>l.createEffect(e),t=e=>l.executeBatch(e),r=e=>l.createDerive(e),s=(e,t,r=Object.is)=>l.createSelect(e,t,r);let c=e=>()=>e();var n=(e,t=Object.is)=>{let r=a(e,t);return[()=>c(r)(),{set:e=>r.set(e),update:e=>r.update(e)}]},u=(e,t)=>l.createLens(e,t);class l{static currentSubscriber=null;static pendingSubscribers=new Set;static isNotifying=!1;static batchDepth=0;static deferredEffectCreations=[];static activeSubscribers=new Set;static stateTracking=new WeakMap;static subscriberDependencies=new WeakMap;static parentSubscriber=new WeakMap;static childSubscribers=new WeakMap;value;subscribers=new Set;stateId=Symbol();equalityFn;constructor(e,t=Object.is){this.value=e,this.equalityFn=t}static createState=(e,t=Object.is)=>{let r=new l(e,t);e=()=>r.get();return e.set=e=>r.set(e),e.update=e=>r.update(e),e[i]=r.stateId,e};get=()=>{var r=l.currentSubscriber;if(r){this.subscribers.add(r);let e=l.subscriberDependencies.get(r),t=(e||(e=new Set,l.subscriberDependencies.set(r,e)),e.add(this.subscribers),l.stateTracking.get(r));t||(t=new Set,l.stateTracking.set(r,t)),t.add(this.stateId)}return this.value};set=e=>{if(!this.equalityFn(this.value,e)){var t=l.currentSubscriber;if(t)if(l.stateTracking.get(t)?.has(this.stateId)&&!l.parentSubscriber.get(t))throw new Error("Infinite loop detected: effect() cannot update a state() it depends on!");if(this.value=e,0!==this.subscribers.size){for(var r of this.subscribers)l.pendingSubscribers.add(r);0!==l.batchDepth||l.isNotifying||l.notifySubscribers()}}};update=e=>{this.set(e(this.value))};static createEffect=e=>{let r=()=>{if(!l.activeSubscribers.has(r)){l.activeSubscribers.add(r);var t=l.currentSubscriber;try{if(l.cleanupEffect(r),l.currentSubscriber=r,l.stateTracking.set(r,new Set),t){l.parentSubscriber.set(r,t);let e=l.childSubscribers.get(t);e||(e=new Set,l.childSubscribers.set(t,e)),e.add(r)}e()}finally{l.currentSubscriber=t,l.activeSubscribers.delete(r)}}};if(0===l.batchDepth)r();else{if(l.currentSubscriber){var t=l.currentSubscriber;l.parentSubscriber.set(r,t);let e=l.childSubscribers.get(t);e||(e=new Set,l.childSubscribers.set(t,e)),e.add(r)}l.deferredEffectCreations.push(r)}return()=>{l.cleanupEffect(r),l.pendingSubscribers.delete(r),l.activeSubscribers.delete(r),l.stateTracking.delete(r);var e=l.parentSubscriber.get(r),e=(e&&(e=l.childSubscribers.get(e))&&e.delete(r),l.parentSubscriber.delete(r),l.childSubscribers.get(r));if(e){for(var t of e)l.cleanupEffect(t);e.clear(),l.childSubscribers.delete(r)}}};static executeBatch=e=>{l.batchDepth++;try{return e()}catch(e){throw 1===l.batchDepth&&(l.pendingSubscribers.clear(),l.deferredEffectCreations.length=0),e}finally{if(l.batchDepth--,0===l.batchDepth){if(0<l.deferredEffectCreations.length){var t,e=l.deferredEffectCreations;l.deferredEffectCreations=[];for(t of e)t()}0<l.pendingSubscribers.size&&!l.isNotifying&&l.notifySubscribers()}}};static createDerive=e=>{let t={cachedValue:void 0,computeFn:e,initialized:!1,valueState:l.createState(void 0)};return l.createEffect(function(){var e=t.computeFn();t.initialized&&Object.is(t.cachedValue,e)||(t.cachedValue=e,t.valueState.set(e)),t.initialized=!0}),function(){return t.initialized||(t.cachedValue=t.computeFn(),t.initialized=!0,t.valueState.set(t.cachedValue)),t.valueState()}};static createSelect=(e,t,r=Object.is)=>{let i={equalityFn:r,initialized:!1,lastSelectedValue:void 0,lastSourceValue:void 0,selectorFn:t,source:e,valueState:l.createState(void 0)};return l.createEffect(function(){var e=i.source();i.initialized&&Object.is(i.lastSourceValue,e)||(i.lastSourceValue=e,e=i.selectorFn(e),i.initialized&&void 0!==i.lastSelectedValue&&i.equalityFn(i.lastSelectedValue,e))||(i.lastSelectedValue=e,i.valueState.set(e),i.initialized=!0)}),function(){return i.initialized||(i.lastSourceValue=i.source(),i.lastSelectedValue=i.selectorFn(i.lastSourceValue),i.valueState.set(i.lastSelectedValue),i.initialized=!0),i.valueState()}};static createLens=(e,t)=>{let a={accessor:t,isUpdating:!1,lensState:null,originalSet:null,path:[],source:e};return a.path=(()=>{let r=[],i=new Proxy({},{get:(e,t)=>("string"!=typeof t&&"number"!=typeof t||r.push(t),i)});try{a.accessor(i)}catch{}return r})(),a.lensState=l.createState(a.accessor(a.source())),a.originalSet=a.lensState.set,l.createEffect(function(){if(!a.isUpdating){a.isUpdating=!0;try{a.lensState.set(a.accessor(a.source()))}finally{a.isUpdating=!1}}}),a.lensState.set=function(t){if(!a.isUpdating){a.isUpdating=!0;try{a.originalSet(t),a.source.update(e=>p(e,a.path,t))}finally{a.isUpdating=!1}}},a.lensState.update=function(e){a.lensState.set(e(a.lensState()))},a.lensState};static notifySubscribers=()=>{if(!l.isNotifying){l.isNotifying=!0;try{for(;0<l.pendingSubscribers.size;){var e,t=l.pendingSubscribers;l.pendingSubscribers=new Set;for(e of t)e()}}finally{l.isNotifying=!1}}};static cleanupEffect=e=>{l.pendingSubscribers.delete(e);var t=l.subscriberDependencies.get(e);if(t){for(var r of t)r.delete(e);t.clear(),l.subscriberDependencies.delete(e)}}}let b=(e,t,r)=>{e=[...e];return e[t]=r,e},d=(e,t,r)=>{e={...e};return e[t]=r,e},f=e=>"number"==typeof e||!Number.isNaN(Number(e))?[]:{},S=(e,t,r)=>{var i=Number(t[0]);if(1===t.length)return b(e,i,r);var a=[...e],t=t.slice(1),s=t[0];let c=e[i];return null==c&&(c=void 0!==s?f(s):{}),a[i]=p(c,t,r),a},o=(e,t,r)=>{var i=t[0];if(void 0===i)return e;if(1===t.length)return d(e,i,r);var t=t.slice(1),a=t[0];let s=e[i];null==s&&(s=void 0!==a?f(a):{});a={...e};return a[i]=p(s,t,r),a},p=(e,t,r)=>0===t.length?r:null==e?p({},t,r):void 0===t[0]?e:(Array.isArray(e)?S:o)(e,t,r);export{a as state,e as effect,t as batch,r as derive,s as select,c as readonlyState,n as protectedState,u as lens};
+let a=Symbol("STATE_ID"),s=null,u=new Set,d=!1,c=0,l=[],i=new Set,o=new WeakMap,f=new WeakMap,S=new WeakMap,r=new WeakMap,v=()=>{if(!d){d=!0;try{for(;0<u.size;){var e,t=u;u=new Set;for(e of t)e()}}finally{d=!1}}},n=e=>{u.delete(e);var t=f.get(e);if(t){for(var a of t)a.delete(e);t.clear(),f.delete(e)}},p=(e,l=Object.is)=>{let i=e,r=new Set,n=Symbol(),t=()=>{var a=s;if(a){r.add(a);let e=f.get(a),t=(e||(e=new Set,f.set(a,e)),e.add(r),o.get(a));t||(t=new Set,o.set(a,t)),t.add(n)}return i};return t.set=e=>{if(!l(i,e)){var t=s;if(t)if(o.get(t)?.has(n)&&!S.get(t))throw new Error("Infinite loop detected: effect() cannot update a state() it depends on!");if(i=e,0!==r.size){for(var a of r)u.add(a);0!==c||d||v()}}},t.update=e=>{t.set(e(i))},t[a]=n,t},g=e=>{let a=()=>{if(!i.has(a)){i.add(a);var t=s;try{if(n(a),s=a,o.set(a,new Set),t){S.set(a,t);let e=r.get(t);e||(e=new Set,r.set(t,e)),e.add(a)}e()}finally{s=t,i.delete(a)}}};if(0===c)a();else{if(s){var t=s;S.set(a,t);let e=r.get(t);e||(e=new Set,r.set(t,e)),e.add(a)}l.push(a)}return()=>{n(a),u.delete(a),i.delete(a),o.delete(a);var e=S.get(a),e=(e&&(e=r.get(e))&&e.delete(a),S.delete(a),r.get(a));if(e){for(var t of e)n(t);e.clear(),r.delete(a)}}};var e=e=>{c++;try{return e()}catch(e){throw 1===c&&(u.clear(),l.length=0),e}finally{if(0===--c){if(0<l.length){var t,e=l;l=[];for(t of e)t()}0<u.size&&!d&&v()}}},t=e=>{let t={cachedValue:void 0,computeFn:e,initialized:!1,valueState:p(void 0)};return g(function(){var e=t.computeFn();t.initialized&&Object.is(t.cachedValue,e)||(t.cachedValue=e,t.valueState.set(e)),t.initialized=!0}),function(){return t.initialized||(t.cachedValue=t.computeFn(),t.initialized=!0,t.valueState.set(t.cachedValue)),t.valueState()}},h=(e,t,a=Object.is)=>{let l={equalityFn:a,initialized:!1,lastSelectedValue:void 0,lastSourceValue:void 0,selectorFn:t,source:e,valueState:p(void 0)};return g(function(){var e=l.source();l.initialized&&Object.is(l.lastSourceValue,e)||(l.lastSourceValue=e,e=l.selectorFn(e),l.initialized&&void 0!==l.lastSelectedValue&&l.equalityFn(l.lastSelectedValue,e))||(l.lastSelectedValue=e,l.valueState.set(e),l.initialized=!0)}),function(){return l.initialized||(l.lastSourceValue=l.source(),l.lastSelectedValue=l.selectorFn(l.lastSourceValue),l.valueState.set(l.lastSelectedValue),l.initialized=!0),l.valueState()}};let y=(e,t,a)=>{e=[...e];return e[t]=a,e},w=(e,t,a)=>{e={...e};return e[t]=a,e},V=e=>"number"==typeof e||!Number.isNaN(Number(e))?[]:{},z=(e,t,a)=>{var l=Number(t[0]);if(1===t.length)return y(e,l,a);var i=[...e],t=t.slice(1),r=t[0];let n=e[l];return null==n&&(n=void 0!==r?V(r):{}),i[l]=m(n,t,a),i},b=(e,t,a)=>{var l=t[0];if(void 0===l)return e;if(1===t.length)return w(e,l,a);var t=t.slice(1),i=t[0];let r=e[l];null==r&&(r=void 0!==i?V(i):{});i={...e};return i[l]=m(r,t,a),i},m=(e,t,a)=>0===t.length?a:null==e?m({},t,a):void 0===t[0]?e:(Array.isArray(e)?z:b)(e,t,a);var F=(e,t)=>{let i={accessor:t,isUpdating:!1,lensState:null,originalSet:null,path:[],source:e};return i.path=(()=>{let a=[],l=new Proxy({},{get:(e,t)=>("string"!=typeof t&&"number"!=typeof t||a.push(t),l)});try{i.accessor(l)}catch{}return a})(),i.lensState=p(i.accessor(i.source())),i.originalSet=i.lensState.set,g(function(){if(!i.isUpdating){i.isUpdating=!0;try{i.lensState.set(i.accessor(i.source()))}finally{i.isUpdating=!1}}}),i.lensState.set=function(t){if(!i.isUpdating){i.isUpdating=!0;try{i.originalSet(t),i.source.update(e=>m(e,i.path,t))}finally{i.isUpdating=!1}}},i.lensState.update=function(e){i.lensState.set(e(i.lensState()))},i.lensState};let U=e=>()=>e();var j=(e,t=Object.is)=>{let a=p(e,t);return[()=>U(a)(),{set:e=>a.set(e),update:e=>a.update(e)}]};export{t as derive,g as effect,F as lens,j as protectedState,U as readonlyState,h as select,p as state,e as batch};

package/package.json

@@ -2,8 +2,8 @@
 	"author": "Denny Trebbin (nerdalytics)",
 	"description": "A lightweight reactive state library for Node.js backends. Enables reactive state management with automatic dependency tracking and efficient updates for server-side applications.",
 	"devDependencies": {
-		"@biomejs/biome": "2.3.13",
-		"@types/node": "25.0.10",
+		"@biomejs/biome": "2.3.14",
+		"@types/node": "25.2.2",
 		"npm-check-updates": "19.3.2",
 		"typescript": "5.9.3",
 		"uglify-js": "3.19.3"
@@ -50,13 +50,13 @@
 	"license": "MIT",
 	"main": "dist/src/index.min.js",
 	"name": "@nerdalytics/beacon",
-	"packageManager": "npm@11.8.0",
+	"packageManager": "npm@11.9.0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/nerdalytics/beacon.git"
 	},
 	"scripts": {
-		"benchmark": "node scripts/benchmark.ts",
+		"benchmark": "node --expose-gc scripts/benchmark.ts",
 		"benchmark:naiv": "node scripts/naiv-benchmark.ts",
 		"build": "npm run build:lts",
 		"build:lts": "tsc -p tsconfig.lts.json",
@@ -91,7 +91,8 @@
 		"update-dependencies": "npx npm-check-updates --interactive --upgrade --removeRange",
 		"update-performance-docs": "node --experimental-config-file=node.config.json scripts/update-performance-docs.ts"
 	},
+	"sideEffects": false,
 	"type": "module",
 	"types": "dist/src/index.d.ts",
-	"version": "1000.2.4"
+	"version": "1000.3.0"
 }