@nerdalytics/beacon 1000.3.0 → 1000.3.2

package/README.md

@@ -1,6 +1,6 @@
 # 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
+> Reactive dependency graph runtime for Node.js backends. Tracks dependencies between signals and propagates updates automatically.
 
 [![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)
@@ -10,8 +10,6 @@
 [![language:typescript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)](https://typescriptlang.org/)
 [![linter:biome](https://img.shields.io/badge/biome-60a5fa?style=for-the-badge&logo=biome&logoColor=white)](https://biomejs.dev/)
 
-A lightweight reactive state library for Node.js backends. Enables reactive state management with automatic dependency tracking and efficient updates for server-side applications.
-
 ## Installation
 
 ```
@@ -37,7 +35,17 @@ count.set(5);
 ## Documentation
 
 Full documentation, API reference, and examples available at:
-**[github.com/nerdalytics/beacon](https://github.com/nerdalytics/beacon)**
+**[nerdalytics.github.io/beacon](https://nerdalytics.github.io/beacon/)**
+
+### LLM-friendly docs
+
+The handbook has plain-text endpoints for LLMs:
+
+- [`llms.txt`](https://nerdalytics.github.io/beacon/llms.txt) lists available versions
+- [`<version>/llms.txt`](https://nerdalytics.github.io/beacon/latest/llms.txt) lists pages for a version
+- [`<version>/llms-full.txt`](https://nerdalytics.github.io/beacon/latest/llms-full.txt) concatenates every page into one file
+
+You can also append `.md` to any handbook page URL for its Markdown source (e.g. [`<version>/introduction.md`](https://nerdalytics.github.io/beacon/latest/introduction.md)).
 
 ## License
 

package/dist/src/index.d.ts

@@ -16,5 +16,5 @@ declare const createSelect: <T, R>(source: ReadOnlyState<T>, selectorFn: (state:
 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 };
+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, };

package/dist/src/index.min.js

@@ -1 +1 @@
-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};
+let r=Symbol("STATE_ID"),f=null,o=new Set,s=!1,u=0,a=[],l=new Set,d=new WeakMap,c=new WeakMap,v=new WeakMap,i=new WeakMap,p=new Set(["__proto__","constructor","prototype"]),y=(e,t,r)=>{let n=e.get(t);return n||(n=r(),e.set(t,n)),n},w=()=>{if(!s){s=!0;try{for(;0<o.size;){var e,t=o;o=new Set;for(e of t)e()}}finally{s=!1}}},g=e=>{o.delete(e);var t=c.get(e);if(t){for(var r of t)r.delete(e);t.clear(),c.delete(e)}},h=e=>{g(e),l.delete(e),d.delete(e);var t=v.get(e),t=(t&&(t=i.get(t))&&t.delete(e),v.delete(e),i.get(e));if(t){for(var r of t)h(r);t.clear(),i.delete(e)}},S=(e,n=Object.is)=>{let a=e,l=new Set,i=Symbol(),t=()=>{var e=f;return e&&(l.add(e),y(c,e,()=>new Set).add(l),y(d,e,()=>new Set).add(i)),a};return t.set=e=>{if(!n(a,e)){var t=f;if(t)if(d.get(t)?.has(i)&&!v.get(t))throw new Error("Infinite loop detected: effect() cannot update a state() it depends on!");if(a=e,0!==l.size){for(var r of l)o.add(r);0!==u||s||w()}}},t.update=e=>{t.set(e(a))},t[r]=i,t},b=r=>{let n=()=>{if(!l.has(n)){l.add(n);var e=f;try{g(n),f=n;var t=d.get(n);t?t.clear():d.set(n,new Set),e&&(v.set(n,e),y(i,e,()=>new Set).add(n)),r()}finally{f=e,l.delete(n)}}};var e;return 0===u?n():(f&&(e=f,v.set(n,e),y(i,e,()=>new Set).add(n)),a.push(n)),()=>{h(n)}};var e=e=>{u++;try{return e()}catch(e){throw 1===u&&(o.clear(),a.length=0),e}finally{if(0===--u){if(0<a.length){var t,e=a;a=[];for(t of e)t()}0<o.size&&!s&&w()}}},t=t=>{let r=void 0,n=!1,a=S(void 0);return b(function(){var e=t();n&&Object.is(r,e)||(r=e,a.set(e)),n=!0}),function(){return n||(r=t(),n=!0,a.set(r)),a()}},n=(t,r,n=Object.is)=>{let a=!1,l,i,f=S(void 0);return b(function(){var e=t();a&&Object.is(i,e)||(i=e,e=r(e),a&&void 0!==l&&n(l,e))||(l=e,f.set(e),a=!0)}),function(){return a||(i=t(),l=r(i),f.set(l),a=!0),f()}};let m=(e,t,r)=>{e=[...e];return e[t]=r,e},j=(e,t,r)=>{e={...e};return e[t]=r,e},N=e=>"number"==typeof e||!Number.isNaN(Number(e))?[]:{},O=(n,a,l,i)=>{if(l>=a.length)return i;if(null==n)return O({},a,l,i);var f=a[l];if(void 0===f)return n;if(Array.isArray(n)){var o=Number(f);if(l===a.length-1)return m(n,o,i);var s=[...n];let e=l+1,t=a[e],r=n[o];return null==r&&(r=void 0===t?{}:N(t)),s[o]=O(r,a,e,i),s}o=n;if(l===a.length-1)return j(o,f,i);let e=l+1,t=a[e],r=o[f];null==r&&(r=void 0===t?{}:N(t));s={...o};return s[f]=O(r,a,e,i),s};var _=(e,t)=>{let r=!1;let n=(()=>{let r=[],n=!1,a=new Proxy({},{get:(e,t)=>(n||"string"!=typeof t&&"number"!=typeof t||(p.has(String(t))?n=!0:r.push(t)),a)});try{t(a)}catch{}return n?[]:r})(),a=S(t(e())),l=a.set;return b(function(){if(!r){r=!0;try{a.set(t(e()))}finally{r=!1}}}),a.set=function(t){if(!r&&0!==n.length){r=!0;try{l(t),e.update(e=>O(e,n,0,t))}finally{r=!1}}},a.update=function(e){a.set(e(a()))},a};let k=e=>()=>e();var M=(e,t=Object.is)=>{let r=S(e,t);return[k(r),{set:e=>r.set(e),update:e=>r.update(e)}]};export{t as derive,b as effect,_ as lens,M as protectedState,k as readonlyState,n as select,S as state,e as batch};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"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.",
+	"description": "Reactive dependency graph runtime for Node.js backends. Tracks dependencies between signals and propagates updates automatically.",
 	"devDependencies": {
 		"@biomejs/biome": "2.3.14",
 		"@types/node": "25.2.2",
@@ -13,15 +13,15 @@
 	},
 	"exports": {
 		".": {
+			"types": "./dist/src/index.d.ts",
+			"typescript": "./src/index.ts",
 			"import": {
-				"default": "./dist/src/index.min.js",
-				"types": "./dist/src/index.d.ts"
+				"types": "./dist/src/index.d.ts",
+				"default": "./dist/src/index.min.js"
 			},
 			"require": {
 				"default": "./dist/src/index.min.js"
-			},
-			"types": "./dist/src/index.d.ts",
-			"typescript": "./src/index.ts"
+			}
 		}
 	},
 	"files": [
@@ -56,7 +56,7 @@
 		"url": "git+https://github.com/nerdalytics/beacon.git"
 	},
 	"scripts": {
-		"benchmark": "node --expose-gc scripts/benchmark.ts",
+		"benchmark": "node --expose-gc scripts/benchmark.ts -R 3",
 		"benchmark:naiv": "node scripts/naiv-benchmark.ts",
 		"build": "npm run build:lts",
 		"build:lts": "tsc -p tsconfig.lts.json",
@@ -94,5 +94,5 @@
 	"sideEffects": false,
 	"type": "module",
 	"types": "dist/src/index.d.ts",
-	"version": "1000.3.0"
+	"version": "1000.3.2"
 }

package/src/index.ts

@@ -29,6 +29,20 @@ const subscriberDependencies: WeakMap<Subscriber, Set<Set<Subscriber>>> = new We
 >()
 const parentSubscriber: WeakMap<Subscriber, Subscriber> = new WeakMap<Subscriber, Subscriber>()
 const childSubscribers: WeakMap<Subscriber, Set<Subscriber>> = new WeakMap<Subscriber, Set<Subscriber>>()
+const DANGEROUS_KEYS: ReadonlySet<string> = new Set([
+	'__proto__',
+	'constructor',
+	'prototype',
+])
+
+const getOrCreate = <K extends object, V>(map: WeakMap<K, V>, key: K, factory: () => V): V => {
+	let value = map.get(key)
+	if (!value) {
+		value = factory()
+		map.set(key, value)
+	}
+	return value
+}
 
 const notifySubscribers = (): void => {
 	if (isNotifying) {
@@ -64,9 +78,30 @@ const cleanupEffect = (effect: Subscriber): void => {
 	}
 }
 
-/**
- * Creates a reactive state container with the provided initial value.
- */
+const disposeEffect = (effect: Subscriber): void => {
+	cleanupEffect(effect)
+	activeSubscribers.delete(effect)
+	stateTracking.delete(effect)
+
+	const parent = parentSubscriber.get(effect)
+	if (parent) {
+		const siblings = childSubscribers.get(parent)
+		if (siblings) {
+			siblings.delete(effect)
+		}
+	}
+	parentSubscriber.delete(effect)
+
+	const children = childSubscribers.get(effect)
+	if (children) {
+		for (const child of children) {
+			disposeEffect(child)
+		}
+		children.clear()
+		childSubscribers.delete(effect)
+	}
+}
+
 const createState = <T>(initialValue: T, equalityFn: (a: T, b: T) => boolean = Object.is): State<T> => {
 	let value = initialValue
 	const subscribers = new Set<Subscriber>()
@@ -77,19 +112,9 @@ const createState = <T>(initialValue: T, equalityFn: (a: T, b: T) => boolean = O
 		if (currentEffect) {
 			subscribers.add(currentEffect)
 
-			let dependencies = subscriberDependencies.get(currentEffect)
-			if (!dependencies) {
-				dependencies = new Set()
-				subscriberDependencies.set(currentEffect, dependencies)
-			}
-			dependencies.add(subscribers)
+			getOrCreate(subscriberDependencies, currentEffect, () => new Set()).add(subscribers)
 
-			let readStates = stateTracking.get(currentEffect)
-			if (!readStates) {
-				readStates = new Set()
-				stateTracking.set(currentEffect, readStates)
-			}
-			readStates.add(stateId)
+			getOrCreate(stateTracking, currentEffect, () => new Set()).add(stateId)
 		}
 		return value
 	}
@@ -130,9 +155,6 @@ const createState = <T>(initialValue: T, equalityFn: (a: T, b: T) => boolean = O
 	return get as State<T>
 }
 
-/**
- * Registers a function to run whenever its reactive dependencies change.
- */
 const createEffect = (fn: () => void): Unsubscribe => {
 	const runEffect = (): void => {
 		if (activeSubscribers.has(runEffect)) {
@@ -146,16 +168,16 @@ const createEffect = (fn: () => void): Unsubscribe => {
 			cleanupEffect(runEffect)
 
 			currentSubscriber = runEffect
-			stateTracking.set(runEffect, new Set())
+			const existingStates = stateTracking.get(runEffect)
+			if (existingStates) {
+				existingStates.clear()
+			} else {
+				stateTracking.set(runEffect, new Set())
+			}
 
 			if (parentEffect) {
 				parentSubscriber.set(runEffect, parentEffect)
-				let children = childSubscribers.get(parentEffect)
-				if (!children) {
-					children = new Set()
-					childSubscribers.set(parentEffect, children)
-				}
-				children.add(runEffect)
+				getOrCreate(childSubscribers, parentEffect, () => new Set()).add(runEffect)
 			}
 
 			fn()
@@ -171,46 +193,17 @@ const createEffect = (fn: () => void): Unsubscribe => {
 		if (currentSubscriber) {
 			const parent = currentSubscriber
 			parentSubscriber.set(runEffect, parent)
-			let children = childSubscribers.get(parent)
-			if (!children) {
-				children = new Set()
-				childSubscribers.set(parent, children)
-			}
-			children.add(runEffect)
+			getOrCreate(childSubscribers, parent, () => new Set()).add(runEffect)
 		}
 
 		deferredEffectCreations.push(runEffect)
 	}
 
 	return (): void => {
-		cleanupEffect(runEffect)
-		pendingSubscribers.delete(runEffect)
-		activeSubscribers.delete(runEffect)
-		stateTracking.delete(runEffect)
-
-		const parent = parentSubscriber.get(runEffect)
-		if (parent) {
-			const siblings = childSubscribers.get(parent)
-			if (siblings) {
-				siblings.delete(runEffect)
-			}
-		}
-		parentSubscriber.delete(runEffect)
-
-		const children = childSubscribers.get(runEffect)
-		if (children) {
-			for (const child of children) {
-				cleanupEffect(child)
-			}
-			children.clear()
-			childSubscribers.delete(runEffect)
-		}
+		disposeEffect(runEffect)
 	}
 }
 
-/**
- * Groups multiple state updates to trigger effects only once at the end.
- */
 const executeBatch = <T>(fn: () => T): T => {
 	batchDepth++
 	try {
@@ -240,87 +233,69 @@ const executeBatch = <T>(fn: () => T): T => {
 	}
 }
 
-/**
- * Creates a read-only computed value that updates when its dependencies change.
- */
 const createDerive = <T>(computeFn: () => T): ReadOnlyState<T> => {
-	const container = {
-		cachedValue: undefined as unknown as T,
-		computeFn,
-		initialized: false,
-		valueState: createState<T | undefined>(undefined),
-	}
+	let cachedValue: T = undefined as unknown as T
+	let initialized = false
+	const valueState = createState<T | undefined>(undefined)
 
 	createEffect(function deriveEffect(): void {
-		const newValue = container.computeFn()
+		const newValue = computeFn()
 
-		if (!(container.initialized && Object.is(container.cachedValue, newValue))) {
-			container.cachedValue = newValue
-			container.valueState.set(newValue)
+		if (!(initialized && Object.is(cachedValue, newValue))) {
+			cachedValue = newValue
+			valueState.set(newValue)
 		}
 
-		container.initialized = true
+		initialized = true
 	})
 
 	return function deriveGetter(): T {
-		if (!container.initialized) {
-			container.cachedValue = container.computeFn()
-			container.initialized = true
-			container.valueState.set(container.cachedValue)
+		if (!initialized) {
+			cachedValue = computeFn()
+			initialized = true
+			valueState.set(cachedValue)
 		}
-		return container.valueState() as T
+		return valueState() as T
 	}
 }
 
-/**
- * Creates an efficient subscription to a subset of a state value.
- */
 const createSelect = <T, R>(
 	source: ReadOnlyState<T>,
 	selectorFn: (state: T) => R,
 	equalityFn: (a: R, b: R) => boolean = Object.is
 ): ReadOnlyState<R> => {
-	const container = {
-		equalityFn,
-		initialized: false,
-		lastSelectedValue: undefined as R | undefined,
-		lastSourceValue: undefined as T | undefined,
-		selectorFn,
-		source,
-		valueState: createState<R | undefined>(undefined),
-	}
+	let initialized = false
+	let lastSelectedValue: R | undefined
+	let lastSourceValue: T | undefined
+	const valueState = createState<R | undefined>(undefined)
 
 	createEffect(function selectEffect(): void {
-		const sourceValue = container.source()
+		const sourceValue = source()
 
-		if (container.initialized && Object.is(container.lastSourceValue, sourceValue)) {
+		if (initialized && Object.is(lastSourceValue, sourceValue)) {
 			return
 		}
 
-		container.lastSourceValue = sourceValue
-		const newSelectedValue = container.selectorFn(sourceValue)
+		lastSourceValue = sourceValue
+		const newSelectedValue = selectorFn(sourceValue)
 
-		if (
-			container.initialized &&
-			container.lastSelectedValue !== undefined &&
-			container.equalityFn(container.lastSelectedValue, newSelectedValue)
-		) {
+		if (initialized && lastSelectedValue !== undefined && equalityFn(lastSelectedValue, newSelectedValue)) {
 			return
 		}
 
-		container.lastSelectedValue = newSelectedValue
-		container.valueState.set(newSelectedValue)
-		container.initialized = true
+		lastSelectedValue = newSelectedValue
+		valueState.set(newSelectedValue)
+		initialized = true
 	})
 
 	return function selectGetter(): R {
-		if (!container.initialized) {
-			container.lastSourceValue = container.source()
-			container.lastSelectedValue = container.selectorFn(container.lastSourceValue)
-			container.valueState.set(container.lastSelectedValue)
-			container.initialized = true
+		if (!initialized) {
+			lastSourceValue = source()
+			lastSelectedValue = selectorFn(lastSourceValue)
+			valueState.set(lastSelectedValue)
+			initialized = true
 		}
-		return container.valueState() as R
+		return valueState() as R
 	}
 }
 
@@ -352,101 +327,79 @@ const createContainer = (key: string | number): Record<string | number, unknown>
 	return isArrayKey ? [] : {}
 }
 
-// Helper for handling array path updates
-const updateArrayPath = <V>(array: unknown[], pathSegments: (string | number)[], value: V): unknown[] => {
-	const index = Number(pathSegments[0])
-
-	if (pathSegments.length === 1) {
-		return updateArrayItem(array, index, value)
+const setValueAtPath = <V, O>(obj: O, pathSegments: (string | number)[], depth: number, value: V): O => {
+	if (depth >= pathSegments.length) {
+		return value as unknown as O
 	}
 
-	const copy = [
-		...array,
-	]
-	const nextPathSegments = pathSegments.slice(1)
-	const nextKey = nextPathSegments[0]
-
-	let nextValue = array[index]
-	if (nextValue === undefined || nextValue === null) {
-		nextValue = nextKey !== undefined ? createContainer(nextKey) : {}
+	if (obj === undefined || obj === null) {
+		return setValueAtPath({} as O, pathSegments, depth, value)
 	}
 
-	copy[index] = setValueAtPath(nextValue, nextPathSegments, value)
-	return copy
-}
-
-// Helper for handling object path updates
-const updateObjectPath = <V>(
-	obj: Record<string | number, unknown>,
-	pathSegments: (string | number)[],
-	value: V
-): Record<string | number, unknown> => {
-	const currentKey = pathSegments[0]
+	const currentKey = pathSegments[depth]
 	if (currentKey === undefined) {
 		return obj
 	}
 
-	if (pathSegments.length === 1) {
-		return updateShallowProperty(obj, currentKey, value)
-	}
+	if (Array.isArray(obj)) {
+		const index = Number(currentKey)
 
-	const nextPathSegments = pathSegments.slice(1)
-	const nextKey = nextPathSegments[0]
+		if (depth === pathSegments.length - 1) {
+			return updateArrayItem(obj, index, value) as unknown as O
+		}
 
-	let currentValue = obj[currentKey]
-	if (currentValue === undefined || currentValue === null) {
-		currentValue = nextKey !== undefined ? createContainer(nextKey) : {}
-	}
+		const copy = [
+			...obj,
+		]
+		const nextDepth = depth + 1
+		const nextKey = pathSegments[nextDepth]
 
-	const result = {
-		...obj,
-	}
-	result[currentKey] = setValueAtPath(currentValue, nextPathSegments, value)
-	return result
-}
+		let nextValue = obj[index]
+		if (nextValue === undefined || nextValue === null) {
+			nextValue = nextKey === undefined ? {} : createContainer(nextKey)
+		}
 
-const setValueAtPath = <V, O>(obj: O, pathSegments: (string | number)[], value: V): O => {
-	if (pathSegments.length === 0) {
-		return value as unknown as O
+		copy[index] = setValueAtPath(nextValue, pathSegments, nextDepth, value)
+		return copy as unknown as O
 	}
 
-	if (obj === undefined || obj === null) {
-		return setValueAtPath({} as O, pathSegments, value)
-	}
+	const record = obj as Record<string | number, unknown>
 
-	const currentKey = pathSegments[0]
-	if (currentKey === undefined) {
-		return obj
+	if (depth === pathSegments.length - 1) {
+		return updateShallowProperty(record, currentKey, value) as unknown as O
 	}
 
-	if (Array.isArray(obj)) {
-		return updateArrayPath(obj, pathSegments, value) as unknown as O
+	const nextDepth = depth + 1
+	const nextKey = pathSegments[nextDepth]
+
+	let currentValue = record[currentKey]
+	if (currentValue === undefined || currentValue === null) {
+		currentValue = nextKey === undefined ? {} : createContainer(nextKey)
 	}
 
-	return updateObjectPath(obj as Record<string | number, unknown>, pathSegments, value) as unknown as O
+	const result = {
+		...record,
+	}
+	result[currentKey] = setValueAtPath(currentValue, pathSegments, nextDepth, value)
+	return result as unknown as O
 }
 
-/**
- * Creates a lens for direct updates to nested properties of a state.
- */
 const createLens = <T, K>(source: State<T>, accessor: (state: T) => K): State<K> => {
-	const container = {
-		accessor,
-		isUpdating: false,
-		lensState: null as unknown as State<K>,
-		originalSet: null as unknown as (value: K) => void,
-		path: [] as (string | number)[],
-		source,
-	}
+	let isUpdating = false
 
 	const extractPath = (): (string | number)[] => {
 		const pathCollector: (string | number)[] = []
+		let tainted = false
 		const proxy = new Proxy(
 			{},
 			{
 				get: (_: object, prop: string | symbol): unknown => {
-					if (typeof prop === 'string' || typeof prop === 'number') {
-						pathCollector.push(prop)
+					if (!tainted && (typeof prop === 'string' || typeof prop === 'number')) {
+						if (DANGEROUS_KEYS.has(String(prop))) {
+							tainted = true
+						} else {
+							pathCollector.push(prop)
+						}
 					}
 					return proxy
 				},
@@ -454,65 +407,57 @@ const createLens = <T, K>(source: State<T>, accessor: (state: T) => K): State<K>
 		)
 
 		try {
-			container.accessor(proxy as unknown as T)
+			accessor(proxy as unknown as T)
 		} catch {
 			// Ignore errors, we're just collecting the path
 		}
 
-		return pathCollector
+		return tainted ? [] : pathCollector
 	}
 
-	container.path = extractPath()
-
-	container.lensState = createState<K>(container.accessor(container.source()))
-	container.originalSet = container.lensState.set
+	const path = extractPath()
+	const lensState = createState<K>(accessor(source()))
+	const originalSet = lensState.set
 
 	createEffect(function lensEffect(): void {
-		if (container.isUpdating) {
+		if (isUpdating) {
 			return
 		}
 
-		container.isUpdating = true
+		isUpdating = true
 		try {
-			container.lensState.set(container.accessor(container.source()))
+			lensState.set(accessor(source()))
 		} finally {
-			container.isUpdating = false
+			isUpdating = false
 		}
 	})
 
-	container.lensState.set = function lensSet(value: K): void {
-		if (container.isUpdating) {
+	lensState.set = function lensSet(value: K): void {
+		if (isUpdating || path.length === 0) {
 			return
 		}
 
-		container.isUpdating = true
+		isUpdating = true
 		try {
-			container.originalSet(value)
-
-			container.source.update((current: T): T => setValueAtPath(current, container.path, value))
+			originalSet(value)
+			source.update((current: T): T => setValueAtPath(current, path, 0, value))
 		} finally {
-			container.isUpdating = false
+			isUpdating = false
 		}
 	}
 
-	container.lensState.update = function lensUpdate(fn: (value: K) => K): void {
-		container.lensState.set(fn(container.lensState()))
+	lensState.update = function lensUpdate(fn: (value: K) => K): void {
+		lensState.set(fn(lensState()))
 	}
 
-	return container.lensState
+	return lensState
 }
 
-/**
- * Creates a read-only view of a state, hiding mutation methods.
- */
 const createReadonlyState =
 	<T>(source: State<T>): ReadOnlyState<T> =>
 	(): T =>
 		source()
 
-/**
- * Creates a state with access control, returning a tuple of reader and writer.
- */
 const createProtectedState = <T>(
 	initialValue: T,
 	equalityFn: (a: T, b: T) => boolean = Object.is
@@ -521,8 +466,9 @@ const createProtectedState = <T>(
 	WriteableState<T>,
 ] => {
 	const fullState = createState(initialValue, equalityFn)
+	const reader = createReadonlyState(fullState)
 	return [
-		(): T => createReadonlyState(fullState)(),
+		reader,
 		{
 			set: (value: T): void => fullState.set(value),
 			update: (fn: (value: T) => T): void => fullState.update(fn),
@@ -530,6 +476,7 @@ const createProtectedState = <T>(
 	]
 }
 
+export type { ReadOnlyState, State, Unsubscribe, WriteableState }
 export {
 	createDerive as derive,
 	createEffect as effect,
@@ -540,5 +487,3 @@ export {
 	createState as state,
 	executeBatch as batch,
 }
-
-export type { ReadOnlyState, State, Unsubscribe, WriteableState }