react-fine-grained-signals 0.1.1 → 0.2.0

package/dist/jsx-P6volZdr.js

@@ -0,0 +1,1833 @@
+import { a as untrackedRender, c as getSharedInteropContext, d as UNTRACKED_OWNER, f as executionContext, i as notifyListener, l as isInteropSpeculative, n as SIGNAL_BRAND, o as attachReadableInterop, r as hasActiveRenderCollector, s as getReadableInterop, t as coreRuntime, u as markInteropSpeculativeDeepRead } from "./core-runtime-2jSE9Tz5.js";
+import { a as isSignal, c as untracked, n as computed, o as registerSignal, r as detachedEffect, s as signal, t as batch } from "./base-WD_74mfC.js";
+import { Fragment, createElement, useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
+//#region src/core/deep-signal-engine.ts
+function isObjectLike(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+function assertExtensible(value) {
+	if (!Object.isExtensible(value)) throw new TypeError("deepSignal() cannot proxy a non-extensible object or array");
+}
+function assertDataProperties(value) {
+	for (const key of Reflect.ownKeys(value)) {
+		const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+		if (descriptor !== void 0 && !("value" in descriptor)) throw new TypeError("deepSignal() does not support accessor properties");
+	}
+}
+function emptyArrayOfLength(length) {
+	const result = [];
+	result.length = length;
+	return result;
+}
+function isArrayIndex(key) {
+	if (typeof key !== "string" || key === "") return false;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key;
+}
+const notify = (versions, key) => {
+	const version = versions.get(key);
+	if (version !== void 0) version.value += 1;
+};
+const markPrunable = (metadata, key) => {
+	if (!metadata.properties.has(key) && !metadata.existence.has(key)) return;
+	(metadata.prunable ??= /* @__PURE__ */ new Set()).add(key);
+};
+const notifyIteration = (metadata) => {
+	if (metadata.iteration !== void 0) metadata.iteration.value += 1;
+};
+function createDeepSignalFactory(adapter) {
+	const ARRAY_MUTATORS = /* @__PURE__ */ new Set([
+		"copyWithin",
+		"fill",
+		"pop",
+		"push",
+		"reverse",
+		"shift",
+		"sort",
+		"splice",
+		"unshift"
+	]);
+	const ARRAY_SEARCHES = /* @__PURE__ */ new Set([
+		"includes",
+		"indexOf",
+		"lastIndexOf"
+	]);
+	const proxyToRaw = /* @__PURE__ */ new WeakMap();
+	const rawToMetadata = /* @__PURE__ */ new WeakMap();
+	const readonlyMapViews = /* @__PURE__ */ new WeakMap();
+	const readonlySetViews = /* @__PURE__ */ new WeakMap();
+	const readonlyCollectionViewToRaw = /* @__PURE__ */ new WeakMap();
+	const normalizedProxyCarriers = /* @__PURE__ */ new WeakMap();
+	const isSpeculative = adapter.isSpeculative ?? isInteropSpeculative;
+	const markSpeculativeDeepRead = adapter.markSpeculativeDeepRead ?? markInteropSpeculativeDeepRead;
+	function shouldTrackDeepRead() {
+		if (isSpeculative()) {
+			markSpeculativeDeepRead();
+			return false;
+		}
+		const shared = getSharedInteropContext();
+		return adapter.hasActiveSubscriber() || hasActiveRenderCollector() || shared.graphCollector !== void 0 || shared.renderCollector !== void 0;
+	}
+	/**
+	* The realm's built-in prototype objects, rejected deliberately rather than by
+	* accident. Several of them look exactly like plain data to the rest of this
+	* module: `Array.prototype` is array-exotic (so `Array.isArray` short-circuits
+	* the prototype check below), while `Error.prototype`, `Date.prototype`,
+	* `Promise.prototype`, `String.prototype`, ... all inherit straight from
+	* `Object.prototype` and expose only extensible, writable data properties, so
+	* neither `assertExtensible` nor `assertDataProperties` stops them. Adopting
+	* one as deep state would let the `set` trap `Reflect.set` onto the real,
+	* globally shared intrinsic. Some of them (`Object.prototype.__proto__`,
+	* `Map.prototype.size`, ...) happen to be caught today by the accessor check,
+	* but that protection is incidental and asymmetric; this set makes it uniform.
+	*
+	* Built from `globalThis` so an engine missing a builtin simply contributes
+	* nothing. Only this realm's intrinsics are listed: an object from another
+	* realm already fails the `Object.prototype` identity check below (the one
+	* exception being a cross-realm array, which stays accepted as it is today).
+	*/
+	const INTRINSIC_PROTOTYPES = (() => {
+		const prototypes = /* @__PURE__ */ new Set();
+		for (const name of [
+			"Object",
+			"Array",
+			"Function",
+			"Boolean",
+			"Number",
+			"String",
+			"Symbol",
+			"BigInt",
+			"Date",
+			"RegExp",
+			"Error",
+			"AggregateError",
+			"EvalError",
+			"RangeError",
+			"ReferenceError",
+			"SyntaxError",
+			"TypeError",
+			"URIError",
+			"Map",
+			"Set",
+			"WeakMap",
+			"WeakSet",
+			"WeakRef",
+			"FinalizationRegistry",
+			"Promise",
+			"ArrayBuffer",
+			"SharedArrayBuffer",
+			"DataView"
+		]) {
+			const intrinsic = globalThis[name];
+			if (typeof intrinsic !== "function") continue;
+			const prototype = intrinsic.prototype;
+			if (typeof prototype === "object" && prototype !== null || typeof prototype === "function") prototypes.add(prototype);
+		}
+		return prototypes;
+	})();
+	const isIntrinsicPrototype = (value) => isObjectLike(value) && INTRINSIC_PROTOTYPES.has(value);
+	function isPlainObjectOrArray(value) {
+		if (typeof value !== "object" || value === null || adapter.isSignal(value)) return false;
+		if (INTRINSIC_PROTOTYPES.has(value)) return false;
+		if (Array.isArray(value)) return true;
+		const prototype = Object.getPrototypeOf(value);
+		return prototype === Object.prototype || prototype === null;
+	}
+	/**
+	* Resolves a value that may be one of our proxies or one of our readonly
+	* collection views back to the raw object it wraps. Returns `undefined` when
+	* `value` is not object-like or is not a value this module has wrapped, so
+	* callers can fall back to using it as-is.
+	*/
+	function toRaw(value) {
+		if (!isObjectLike(value)) return void 0;
+		const directRaw = proxyToRaw.get(value);
+		if (directRaw !== void 0) return directRaw;
+		return readonlyCollectionViewToRaw.get(value);
+	}
+	/**
+	* Shared scaffolding for `readonlyMapView`/`readonlySetView`: cache lookup,
+	* the "reject this mutation" factory, defining the descriptors, the
+	* feature-detected extras loop, and the dual-WeakMap registration. Only the
+	* per-type descriptor bodies (which truly differ between Map and Set) and
+	* the extras list are supplied by the caller.
+	*/
+	function createReadonlyCollectionView(raw, cache, prototype, kind, buildCore, buildExtras) {
+		const cached = cache.get(raw);
+		if (cached !== void 0) return cached;
+		const view = Object.create(prototype);
+		const rejectMutation = (operation) => () => {
+			throw new TypeError(`deepSignal() ${kind}#${operation}() is not allowed through .value; replace the ${kind} immutably`);
+		};
+		Object.defineProperties(view, buildCore(raw, view, rejectMutation));
+		for (const [name, impl] of buildExtras(raw, rejectMutation)) Object.defineProperty(view, name, {
+			enumerable: false,
+			configurable: false,
+			value: impl
+		});
+		cache.set(raw, view);
+		readonlyCollectionViewToRaw.set(view, raw);
+		return view;
+	}
+	function readonlyMapView(raw) {
+		return createReadonlyCollectionView(raw, readonlyMapViews, Map.prototype, "Map", (target, view, rejectMutation) => ({
+			size: {
+				enumerable: false,
+				configurable: false,
+				get: () => target.size
+			},
+			get: {
+				enumerable: false,
+				configurable: false,
+				value: (key) => target.get(key)
+			},
+			has: {
+				enumerable: false,
+				configurable: false,
+				value: (key) => target.has(key)
+			},
+			entries: {
+				enumerable: false,
+				configurable: false,
+				value: () => Map.prototype.entries.call(target)
+			},
+			keys: {
+				enumerable: false,
+				configurable: false,
+				value: () => Map.prototype.keys.call(target)
+			},
+			values: {
+				enumerable: false,
+				configurable: false,
+				value: () => Map.prototype.values.call(target)
+			},
+			forEach: {
+				enumerable: false,
+				configurable: false,
+				value: (callback, thisArg) => {
+					Map.prototype.forEach.call(target, (value, key) => callback.call(thisArg, value, key, view));
+				}
+			},
+			[Symbol.iterator]: {
+				enumerable: false,
+				configurable: false,
+				value: () => Map.prototype.entries.call(target)
+			},
+			set: {
+				enumerable: false,
+				configurable: false,
+				value: rejectMutation("set")
+			},
+			delete: {
+				enumerable: false,
+				configurable: false,
+				value: rejectMutation("delete")
+			},
+			clear: {
+				enumerable: false,
+				configurable: false,
+				value: rejectMutation("clear")
+			}
+		}), (_target, rejectMutation) => {
+			const extras = [];
+			for (const operation of [
+				"getOrInsert",
+				"getOrInsertComputed",
+				"emplace"
+			]) if (typeof Map.prototype[operation] === "function") extras.push([operation, rejectMutation(operation)]);
+			return extras;
+		});
+	}
+	function readonlySetView(raw) {
+		return createReadonlyCollectionView(raw, readonlySetViews, Set.prototype, "Set", (target, view, rejectMutation) => ({
+			size: {
+				enumerable: false,
+				configurable: false,
+				get: () => target.size
+			},
+			has: {
+				enumerable: false,
+				configurable: false,
+				value: (value) => target.has(value)
+			},
+			entries: {
+				enumerable: false,
+				configurable: false,
+				value: () => Set.prototype.entries.call(target)
+			},
+			keys: {
+				enumerable: false,
+				configurable: false,
+				value: () => Set.prototype.keys.call(target)
+			},
+			values: {
+				enumerable: false,
+				configurable: false,
+				value: () => Set.prototype.values.call(target)
+			},
+			forEach: {
+				enumerable: false,
+				configurable: false,
+				value: (callback, thisArg) => {
+					Set.prototype.forEach.call(target, (value) => callback.call(thisArg, value, value, view));
+				}
+			},
+			[Symbol.iterator]: {
+				enumerable: false,
+				configurable: false,
+				value: () => Set.prototype.values.call(target)
+			},
+			add: {
+				enumerable: false,
+				configurable: false,
+				value: rejectMutation("add")
+			},
+			delete: {
+				enumerable: false,
+				configurable: false,
+				value: rejectMutation("delete")
+			},
+			clear: {
+				enumerable: false,
+				configurable: false,
+				value: rejectMutation("clear")
+			}
+		}), (target) => {
+			const extras = [];
+			const forwardSetOperation = (operation) => (other) => {
+				const method = Set.prototype[operation];
+				if (typeof method !== "function") throw new TypeError(`Set#${operation}() is unavailable in this JavaScript engine`);
+				const collection = isObjectLike(other) ? readonlyCollectionViewToRaw.get(other) ?? other : other;
+				return Reflect.apply(method, target, [collection]);
+			};
+			for (const operation of [
+				"union",
+				"intersection",
+				"difference",
+				"symmetricDifference",
+				"isSubsetOf",
+				"isSupersetOf",
+				"isDisjointFrom"
+			]) if (typeof Set.prototype[operation] === "function") extras.push([operation, forwardSetOperation(operation)]);
+			return extras;
+		});
+	}
+	function assertRootValue(value) {
+		if (!isPlainObjectOrArray(value)) throw new TypeError("deepSignal() only accepts a plain object or array root");
+	}
+	function assertDeepDataGraph(value) {
+		if (!isObjectLike(value)) return false;
+		const seen = /* @__PURE__ */ new WeakMap();
+		const pending = [{
+			value,
+			insideOpaque: false
+		}];
+		let needsNormalization = false;
+		while (pending.length > 0) {
+			const { value: current, insideOpaque } = pending.pop();
+			if (toRaw(current) !== void 0) {
+				if (insideOpaque) throw new TypeError(proxyToRaw.has(current) ? "deepSignal() cannot store a deep proxy inside an opaque value" : "deepSignal() cannot store a deep collection view inside an opaque value");
+				needsNormalization = true;
+				continue;
+			}
+			const raw = current;
+			const visitedAs = seen.get(raw) ?? 0;
+			const visitFlag = insideOpaque ? 2 : 1;
+			if ((visitedAs & visitFlag) !== 0) continue;
+			seen.set(raw, visitedAs | visitFlag);
+			if (!insideOpaque && isIntrinsicPrototype(raw)) throw new TypeError("deepSignal() cannot store a built-in prototype object in deep state");
+			if (raw instanceof Map) {
+				for (const [key, entry] of raw) {
+					if (isObjectLike(key)) pending.push({
+						value: key,
+						insideOpaque: true
+					});
+					if (isObjectLike(entry)) pending.push({
+						value: entry,
+						insideOpaque: true
+					});
+				}
+				continue;
+			}
+			if (raw instanceof Set) {
+				for (const entry of raw) if (isObjectLike(entry)) pending.push({
+					value: entry,
+					insideOpaque: true
+				});
+				continue;
+			}
+			if (!isPlainObjectOrArray(raw)) {
+				for (const key of Reflect.ownKeys(raw)) {
+					const descriptor = Reflect.getOwnPropertyDescriptor(raw, key);
+					if (descriptor !== void 0 && "value" in descriptor && isObjectLike(descriptor.value)) pending.push({
+						value: descriptor.value,
+						insideOpaque: true
+					});
+				}
+				continue;
+			}
+			if (!insideOpaque) {
+				assertExtensible(raw);
+				assertDataProperties(raw);
+			}
+			for (const key of Reflect.ownKeys(raw)) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(raw, key);
+				if (descriptor !== void 0 && "value" in descriptor) {
+					const child = descriptor.value;
+					if (isObjectLike(child)) pending.push({
+						value: child,
+						insideOpaque
+					});
+				}
+			}
+		}
+		return needsNormalization;
+	}
+	function matchesNormalizedGraph(source, normalized) {
+		const sources = /* @__PURE__ */ new WeakMap();
+		const targets = /* @__PURE__ */ new WeakMap();
+		const pending = [[source, normalized]];
+		while (pending.length > 0) {
+			const [currentSource, currentTarget] = pending.pop();
+			if (typeof currentSource !== "object" || currentSource === null) {
+				if (!Object.is(currentSource, currentTarget)) return false;
+				continue;
+			}
+			const wrapperRaw = toRaw(currentSource);
+			if (wrapperRaw !== void 0) {
+				if (wrapperRaw !== currentTarget) return false;
+				continue;
+			}
+			if (!isPlainObjectOrArray(currentSource)) {
+				if (currentSource !== currentTarget) return false;
+				continue;
+			}
+			if (typeof currentTarget !== "object" || currentTarget === null || !isPlainObjectOrArray(currentTarget)) return false;
+			const knownTarget = sources.get(currentSource);
+			if (knownTarget !== void 0) {
+				if (knownTarget !== currentTarget) return false;
+				continue;
+			}
+			const knownSource = targets.get(currentTarget);
+			if (knownSource !== void 0 && knownSource !== currentSource) return false;
+			sources.set(currentSource, currentTarget);
+			targets.set(currentTarget, currentSource);
+			if (Array.isArray(currentSource) !== Array.isArray(currentTarget) || Object.getPrototypeOf(currentSource) !== Object.getPrototypeOf(currentTarget)) return false;
+			const sourceKeys = Reflect.ownKeys(currentSource);
+			const targetKeys = Reflect.ownKeys(currentTarget);
+			if (sourceKeys.length !== targetKeys.length) return false;
+			for (const [index, key] of sourceKeys.entries()) {
+				if (key !== targetKeys[index]) return false;
+				const sourceDescriptor = Reflect.getOwnPropertyDescriptor(currentSource, key);
+				const targetDescriptor = Reflect.getOwnPropertyDescriptor(currentTarget, key);
+				if (sourceDescriptor === void 0 || targetDescriptor === void 0 || !("value" in sourceDescriptor) || !("value" in targetDescriptor) || sourceDescriptor.configurable !== targetDescriptor.configurable || sourceDescriptor.enumerable !== targetDescriptor.enumerable || sourceDescriptor.writable !== targetDescriptor.writable) return false;
+				pending.push([sourceDescriptor.value, targetDescriptor.value]);
+			}
+		}
+		return true;
+	}
+	/**
+	* An array of `length` with no own index properties — holes, not `undefined`s.
+	* `Array.from({ length })` would materialize every index as an own property,
+	* so cloning a sparse carrier produced an array with strictly more own keys
+	* than its source. `matchesNormalizedGraph` compares own keys one-for-one, so
+	* that clone could never match its source again: the carrier cache missed on
+	* every re-assignment, breaking the documented guarantee that assigning the
+	* same carrier twice preserves identity and aliasing.
+	*/
+	function cloneWithoutProxies(value) {
+		const wrapperRaw = toRaw(value);
+		if (wrapperRaw !== void 0) return wrapperRaw;
+		if (!isObjectLike(value)) return value;
+		const cachedRoot = normalizedProxyCarriers.get(value);
+		if (cachedRoot !== void 0 && matchesNormalizedGraph(value, cachedRoot)) return cachedRoot;
+		const clones = /* @__PURE__ */ new WeakMap();
+		const created = [];
+		const pending = [];
+		const resolve = (current) => {
+			const resolvedRaw = toRaw(current);
+			if (resolvedRaw !== void 0) return resolvedRaw;
+			if (!isPlainObjectOrArray(current)) return current;
+			const local = clones.get(current);
+			if (local !== void 0) return local;
+			const result = Array.isArray(current) ? emptyArrayOfLength(current.length) : Object.create(Object.getPrototypeOf(current));
+			clones.set(current, result);
+			created.push([current, result]);
+			pending.push(current);
+			return result;
+		};
+		const root = resolve(value);
+		while (pending.length > 0) {
+			const source = pending.pop();
+			const target = clones.get(source);
+			for (const key of Reflect.ownKeys(source)) {
+				if (Array.isArray(source) && key === "length") continue;
+				const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+				if (descriptor === void 0) continue;
+				if (!("value" in descriptor)) throw new TypeError("deepSignal() does not support accessor properties");
+				descriptor.value = resolve(descriptor.value);
+				Reflect.defineProperty(target, key, descriptor);
+			}
+		}
+		for (const [source, target] of created) normalizedProxyCarriers.set(source, target);
+		return root;
+	}
+	function prepareDeepValue(value) {
+		const wrapperRaw = toRaw(value);
+		if (wrapperRaw !== void 0) return wrapperRaw;
+		return assertDeepDataGraph(value) ? cloneWithoutProxies(value) : value;
+	}
+	const unwrap = (value) => {
+		return prepareDeepValue(value);
+	};
+	const OBJECT_PROTOTYPE_KEYS = new Set(Reflect.ownKeys(Object.prototype));
+	const ARRAY_PROTOTYPE_KEYS = /* @__PURE__ */ new Set([...Reflect.ownKeys(Object.prototype), ...Reflect.ownKeys(Array.prototype)]);
+	const isInheritedPrototypeMember = (target, key) => {
+		if (Object.prototype.hasOwnProperty.call(target, key)) return false;
+		const prototype = Object.getPrototypeOf(target);
+		if (prototype === Object.prototype) return OBJECT_PROTOTYPE_KEYS.has(key);
+		if (prototype === Array.prototype) return ARRAY_PROTOTYPE_KEYS.has(key);
+		return false;
+	};
+	const getVersion = (versions, key) => {
+		let version = versions.get(key);
+		if (version === void 0) {
+			version = adapter.createVersionSignal(0);
+			versions.set(key, version);
+		}
+		return version;
+	};
+	const track = (metadata, target, versions, indices, key) => {
+		if (!shouldTrackDeepRead()) return;
+		if (isInheritedPrototypeMember(target, key)) {
+			if (!Array.isArray(target)) trackIterationOf(metadata);
+			return;
+		}
+		if (isArrayIndex(key)) indices.add(Number(key));
+		const version = getVersion(versions, key);
+		adapter.markWatched(version);
+		version.value;
+	};
+	/**
+	* Queues `key`'s version signals for removal once nothing depends on them.
+	* Only called for a key that has just been removed *and* notified, which is
+	* what makes the eventual removal safe: the notification forces every
+	* subscriber to re-run, so one that still cares re-reads the key (re-arming
+	* `markWatched`) and one that does not has already been unlinked.
+	*/
+	/**
+	* Drops the version signals of removed keys once they have no subscribers
+	* left, so a virtualized or repeatedly-spliced list stops accumulating one
+	* entry per key that ever existed.
+	*
+	* Runs only at batch depth 0, where the write that queued these keys has
+	* already flushed its effects; before that, `hasSubscribers()` would still
+	* report the pre-flush picture. A key that is still subscribed (typically a
+	* React store whose re-render has not committed yet) stays queued and is
+	* reconsidered on the next sweep rather than being dropped early.
+	*/
+	const sweepPrunedKeys = (metadata, target) => {
+		const prunable = metadata.prunable;
+		if (prunable === void 0 || prunable.size === 0) return;
+		if (adapter.getBatchDepth() !== 0) return;
+		for (const key of prunable) {
+			if (Object.prototype.hasOwnProperty.call(target, key)) {
+				prunable.delete(key);
+				continue;
+			}
+			const property = metadata.properties.get(key);
+			const existence = metadata.existence.get(key);
+			if (property !== void 0 && adapter.hasSubscribers(property) || existence !== void 0 && adapter.hasSubscribers(existence)) continue;
+			metadata.properties.delete(key);
+			metadata.existence.delete(key);
+			if (isArrayIndex(key)) {
+				const index = Number(key);
+				metadata.propertyIndices.delete(index);
+				metadata.existenceIndices.delete(index);
+			}
+			prunable.delete(key);
+		}
+		if (prunable.size === 0) metadata.prunable = void 0;
+	};
+	const trackIterationOf = (metadata) => {
+		metadata.iteration ??= adapter.createVersionSignal(0);
+		metadata.iteration.value;
+	};
+	const trackIteration = (metadata) => {
+		if (!shouldTrackDeepRead()) return;
+		trackIterationOf(metadata);
+	};
+	const notifyTruncatedIndices = (metadata, currentLength, oldLength) => {
+		const truncatedCount = oldLength - currentLength;
+		const trackedCount = metadata.propertyIndices.size + metadata.existenceIndices.size;
+		if (trackedCount === 0) return;
+		if (truncatedCount <= trackedCount) {
+			for (let index = currentLength; index < oldLength; index++) {
+				const key = String(index);
+				notify(metadata.properties, key);
+				notify(metadata.existence, key);
+				markPrunable(metadata, key);
+			}
+			return;
+		}
+		for (const index of metadata.propertyIndices) if (index >= currentLength && index < oldLength) {
+			const key = String(index);
+			notify(metadata.properties, key);
+			markPrunable(metadata, key);
+		}
+		for (const index of metadata.existenceIndices) if (index >= currentLength && index < oldLength) {
+			const key = String(index);
+			notify(metadata.existence, key);
+			markPrunable(metadata, key);
+		}
+	};
+	/**
+	* Whether `wrap()` would hand back something other than `value` itself — a
+	* deep proxy for a plain object/array, or a readonly view for a Map/Set. The
+	* `get` trap uses this to reject a non-configurable, non-writable property
+	* whose value cannot be substituted, before `wrap()` performs the swap.
+	*/
+	const isWrappedByValue = (value) => isPlainObjectOrArray(value) || value instanceof Map || value instanceof Set;
+	const wrap = (value) => {
+		const rawValue = toRaw(value) ?? value;
+		if (rawValue instanceof Map) return readonlyMapView(rawValue);
+		if (rawValue instanceof Set) return readonlySetView(rawValue);
+		if (!isPlainObjectOrArray(rawValue)) return rawValue;
+		assertExtensible(rawValue);
+		const cached = rawToMetadata.get(rawValue);
+		if (cached !== void 0) return cached.proxy;
+		assertDataProperties(rawValue);
+		const metadata = {
+			properties: /* @__PURE__ */ new Map(),
+			existence: /* @__PURE__ */ new Map(),
+			propertyIndices: /* @__PURE__ */ new Set(),
+			existenceIndices: /* @__PURE__ */ new Set(),
+			arrayMethods: /* @__PURE__ */ new Map(),
+			proxy: void 0
+		};
+		const proxy = new Proxy(rawValue, {
+			get(target, key, receiver) {
+				if (key === SIGNAL_BRAND && !Object.prototype.hasOwnProperty.call(target, key)) return;
+				track(metadata, target, metadata.properties, metadata.propertyIndices, key);
+				const result = Reflect.get(target, key, receiver);
+				if (Array.isArray(target) && ARRAY_MUTATORS.has(key) && typeof result === "function") {
+					const cachedMethod = metadata.arrayMethods.get(key);
+					if (cachedMethod?.method === result) return cachedMethod.wrapper;
+					const method = result;
+					const wrapper = function(...args) {
+						try {
+							return adapter.batch(() => adapter.untracked(() => Reflect.apply(method, this, args)));
+						} finally {
+							sweepPrunedKeys(metadata, target);
+						}
+					};
+					metadata.arrayMethods.set(key, {
+						method,
+						wrapper
+					});
+					return wrapper;
+				}
+				if (Array.isArray(target) && ARRAY_SEARCHES.has(key) && typeof result === "function") {
+					const cachedMethod = metadata.arrayMethods.get(key);
+					if (cachedMethod?.method === result) return cachedMethod.wrapper;
+					const method = result;
+					const wrapper = function(...args) {
+						const found = Reflect.apply(method, this, args);
+						if (found !== -1 && found !== false || !isObjectLike(args[0])) return found;
+						args[0] = toRaw(args[0]) ?? args[0];
+						return Reflect.apply(method, toRaw(this) ?? this, args);
+					};
+					metadata.arrayMethods.set(key, {
+						method,
+						wrapper
+					});
+					return wrapper;
+				}
+				if (isWrappedByValue(result)) {
+					const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+					if (descriptor !== void 0 && "value" in descriptor && descriptor.configurable === false && descriptor.writable === false) throw new TypeError("deepSignal() cannot wrap a non-configurable, non-writable object property");
+				}
+				return wrap(result);
+			},
+			set(target, key, nextValue, receiver) {
+				if (receiver !== metadata.proxy) return Reflect.set(target, key, nextValue, receiver);
+				if (key === "__proto__") throw new TypeError("deepSignal() does not support prototype mutation");
+				if (key === SIGNAL_BRAND) throw new TypeError("deepSignal() does not support branding state as a signal");
+				const oldValue = Reflect.get(target, key, target);
+				const existed = Reflect.has(target, key);
+				const owned = Object.prototype.hasOwnProperty.call(target, key);
+				const oldLength = Array.isArray(target) ? target.length : void 0;
+				const rawNextValue = unwrap(nextValue);
+				if (!Reflect.set(target, key, rawNextValue, target)) return false;
+				const currentValue = Reflect.get(target, key, target);
+				const existsNow = Reflect.has(target, key);
+				const ownedNow = Object.prototype.hasOwnProperty.call(target, key);
+				adapter.batch(() => {
+					if (!Object.is(oldValue, currentValue) || owned !== ownedNow) notify(metadata.properties, key);
+					if (existed !== existsNow || owned !== ownedNow) notify(metadata.existence, key);
+					if (owned !== ownedNow) notifyIteration(metadata);
+					if (Array.isArray(target) && oldLength !== void 0) {
+						const currentLength = target.length;
+						if (key !== "length" && oldLength !== currentLength) notify(metadata.properties, "length");
+						if (key === "length" && currentLength < oldLength) {
+							notifyTruncatedIndices(metadata, currentLength, oldLength);
+							notifyIteration(metadata);
+						}
+					}
+				});
+				sweepPrunedKeys(metadata, target);
+				return true;
+			},
+			deleteProperty(target, key) {
+				const owned = Object.prototype.hasOwnProperty.call(target, key);
+				const succeeded = Reflect.deleteProperty(target, key);
+				if (!succeeded || !owned) return succeeded;
+				adapter.batch(() => {
+					notify(metadata.properties, key);
+					notify(metadata.existence, key);
+					notifyIteration(metadata);
+					markPrunable(metadata, key);
+				});
+				sweepPrunedKeys(metadata, target);
+				return true;
+			},
+			getOwnPropertyDescriptor(target, key) {
+				track(metadata, target, metadata.existence, metadata.existenceIndices, key);
+				const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+				if (descriptor === void 0 || !("value" in descriptor)) return descriptor;
+				if (descriptor.configurable === false && descriptor.writable === false) return descriptor;
+				descriptor.value = wrap(descriptor.value);
+				return descriptor;
+			},
+			has(target, key) {
+				track(metadata, target, metadata.existence, metadata.existenceIndices, key);
+				return Reflect.has(target, key);
+			},
+			ownKeys(target) {
+				trackIteration(metadata);
+				return Reflect.ownKeys(target);
+			},
+			defineProperty() {
+				throw new TypeError("deepSignal() does not support property descriptors");
+			},
+			preventExtensions() {
+				throw new TypeError("deepSignal() state must remain extensible");
+			},
+			setPrototypeOf() {
+				throw new TypeError("deepSignal() does not support prototype mutation");
+			}
+		});
+		metadata.proxy = proxy;
+		rawToMetadata.set(rawValue, metadata);
+		proxyToRaw.set(proxy, rawValue);
+		return proxy;
+	};
+	class DeepSignalImpl {
+		#source;
+		constructor(source) {
+			this.#source = source;
+			const protocol = getReadableInterop(this.#source);
+			if (protocol !== void 0) attachReadableInterop(this, protocol);
+		}
+		get value() {
+			return wrap(this.#source.value);
+		}
+		set value(nextValue) {
+			const rawValue = unwrap(nextValue);
+			assertRootValue(rawValue);
+			this.#source.value = rawValue;
+		}
+		peek() {
+			return this.#source.peek();
+		}
+	}
+	/**
+	* Reports the per-key reactive metadata currently retained for a deep proxy
+	* (or for the raw object behind it). Exposed for this package's own tests
+	* only — it is deliberately absent from every published entry point, and the
+	* shape it returns is internal detail, not API.
+	*/
+	function inspectDeepSignalMetadata(value) {
+		const metadata = rawToMetadata.get(toRaw(value) ?? value);
+		if (metadata === void 0) return void 0;
+		return {
+			properties: [...metadata.properties.keys()],
+			existence: [...metadata.existence.keys()],
+			propertyIndices: [...metadata.propertyIndices],
+			existenceIndices: [...metadata.existenceIndices]
+		};
+	}
+	/**
+	* Creates a signal that lazily tracks nested plain-object and array properties.
+	* Mutations must go through `.value`; changes made through the original raw
+	* object are intentionally not observable.
+	*/
+	function deepSignal(initialValue) {
+		const rawInitialValue = prepareDeepValue(initialValue);
+		assertRootValue(rawInitialValue);
+		wrap(rawInitialValue);
+		const root = adapter.createSignal(rawInitialValue);
+		const result = new DeepSignalImpl(root);
+		adapter.registerDeepSignal?.(result);
+		return result;
+	}
+	return {
+		deepSignal,
+		inspectDeepSignalMetadata
+	};
+}
+//#endregion
+//#region src/core/deep-signal.ts
+let productionDeepSignals;
+function getProductionDeepSignals() {
+	return productionDeepSignals ??= createDeepSignalFactory({
+		createSignal(initial) {
+			return coreRuntime.createDeepSignal(initial);
+		},
+		createVersionSignal(initial) {
+			return coreRuntime.createDeepSignalVersion(initial);
+		},
+		markWatched(source) {
+			coreRuntime.markDeepSignalWatched(source);
+		},
+		hasSubscribers(source) {
+			return coreRuntime.hasDeepSignalSubscribers(source);
+		},
+		batch,
+		untracked,
+		isSignal,
+		hasActiveSubscriber: () => {
+			const owner = executionContext.owner;
+			if (owner === UNTRACKED_OWNER) return false;
+			return coreRuntime.hasActiveSubscriber() || owner !== void 0 && typeof owner !== "symbol" && (owner.kind === "graph" || owner.kind === "render");
+		},
+		getBatchDepth: () => coreRuntime.getBatchDepth(),
+		isSpeculative: () => coreRuntime.isSpeculative(),
+		markSpeculativeDeepRead: () => coreRuntime.markSpeculativeDeepRead(),
+		registerDeepSignal(value) {
+			registerSignal(value);
+		}
+	});
+}
+/**
+* Creates a signal that lazily tracks nested plain-object and array properties.
+* Mutations must go through `.value`; changes made through the original raw
+* object are intentionally not observable.
+*/
+function deepSignal(initialValue) {
+	return getProductionDeepSignals().deepSignal(initialValue);
+}
+//#endregion
+//#region src/core/readable-subscription.ts
+/** Subscribe through the private V1 boundary without creating an EffectNode. */
+function subscribeReadableV1(readable, listener) {
+	const protocol = getReadableInterop(readable);
+	if (protocol === void 0) return void 0;
+	const subscription = protocol.subscribe(() => notifyListener(listener));
+	return () => subscription.unsubscribe();
+}
+//#endregion
+//#region src/react/hooks.ts
+const EMPTY_DEPENDENCIES = [];
+function assertSignalSnapshot(value) {
+	if (typeof value === "object" && value !== null || typeof value === "function") throw new TypeError("useDeepSignalValue selector must return a primitive snapshot; objects, Proxies, and functions are not supported");
+}
+/**
+* Shared `useSyncExternalStore` wiring for effect-backed subscriptions only:
+* the dynamic deep-selector store and structural-readable compatibility
+* fallback. Package readables with ReadableInterop V1 use a direct watcher.
+* On `subscribe`, starts an `effect()` that reruns `onEvaluate` on relevant
+* writes and notifies React when it reports a change.
+*
+* `getSnapshot` is intentionally not this helper's concern — the caller
+* wires its own, whether that means recomputing fresh each call
+* (`useSignalValue`) or returning a cached result (the deep-selector store).
+*
+* An exception thrown by `onEvaluate` is swallowed here and treated as a
+* change worth notifying about. That leaves the next render-time snapshot
+* read to surface the error to an Error Boundary rather than letting the
+* background effect's exception escape through the signal writer.
+*/
+function createEffectBackedStoreSubscription(onEvaluate) {
+	return (notify) => {
+		let isInitialRun = true;
+		return detachedEffect(() => {
+			let changed;
+			try {
+				changed = onEvaluate();
+			} catch {
+				changed = true;
+			}
+			if (isInitialRun) {
+				isInitialRun = false;
+				return;
+			}
+			if (changed) notify();
+		});
+	};
+}
+/**
+* Holds a selector result outside the reactive graph. A selector error must
+* not escape from the signal write that caused a reactive re-evaluation:
+* React needs to observe it during its next render so an Error Boundary can
+* handle it. The cached result also avoids rerunning the selector on every
+* render.
+*/
+function createDeepSelectorStore(source, selector) {
+	const evaluate = () => {
+		try {
+			const value = untrackedRender(() => selector(source.value));
+			assertSignalSnapshot(value);
+			return {
+				kind: "value",
+				value
+			};
+		} catch (error) {
+			return {
+				kind: "error",
+				error
+			};
+		}
+	};
+	let result = evaluate();
+	const hasChanged = (next) => {
+		if (result.kind !== next.kind) return true;
+		return result.kind === "value" && next.kind === "value" ? !Object.is(result.value, next.value) : result.kind === "error" && next.kind === "error" ? !Object.is(result.error, next.error) : false;
+	};
+	return {
+		subscribe: createEffectBackedStoreSubscription(() => {
+			const next = evaluate();
+			if (!hasChanged(next)) return false;
+			result = next;
+			return true;
+		}),
+		getSnapshot() {
+			if (result.kind === "error") throw result.error;
+			return result.value;
+		}
+	};
+}
+/** Creates a signal whose identity is stable for the lifetime of this component. */
+function useSignal(initialValue) {
+	const signalRef = useRef(void 0);
+	if (signalRef.current === void 0) signalRef.current = signal(initialValue);
+	return signalRef.current;
+}
+/**
+* Creates a deep signal whose identity is stable for the component lifetime.
+* A factory is evaluated only while initializing a mounted component instance;
+* it must remain pure because React Strict Mode may replay initial rendering.
+*/
+function useDeepSignal(initialValue) {
+	const signalRef = useRef(void 0);
+	if (signalRef.current === void 0) signalRef.current = deepSignal(typeof initialValue === "function" ? initialValue() : initialValue);
+	return signalRef.current;
+}
+/**
+* Selects a property-level primitive snapshot from a deep signal.
+*
+* Every non-signal value captured by `selector` must be listed in
+* `dependencies`. Object and proxy results are intentionally rejected because
+* mutable snapshots cannot satisfy `useSyncExternalStore` identity semantics.
+*
+* `dependencies` must keep a fixed length across this component's lifetime,
+* matching `useMemo`'s own rule (its length feeds a `useMemo` deps array
+* below via `[source, ...dependencies]`). A length change is caught and
+* thrown as a clear error rather than left to degrade into React's silent
+* "changed size between renders" dev warning, mirroring `useComputed`'s
+* dependency-mode-switch guard.
+*/
+function useDeepSignalValue(source, selector, dependencies) {
+	const initialDependencyLengthRef = useRef(void 0);
+	initialDependencyLengthRef.current ??= dependencies.length;
+	if (dependencies.length !== initialDependencyLengthRef.current) {
+		const error = /* @__PURE__ */ new Error(`useDeepSignalValue: the \`dependencies\` array length changed between renders (from ${initialDependencyLengthRef.current} to ${dependencies.length}) for this call site. Keep \`dependencies\` a fixed length across the component's lifetime, matching useMemo's rules.`);
+		error.name = "UseDeepSignalValueDependencyLengthChangeError";
+		throw error;
+	}
+	const store = useMemo(() => createDeepSelectorStore(source, selector), [source, ...dependencies]);
+	return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+/**
+* Creates a computed signal with a stable identity.
+*
+* When `dependencies` is omitted, the getter must only read signals. Its initial
+* closure is retained for the component lifetime, so props, state, and other
+* non-signal values must not be captured in that mode.
+*
+* When the getter captures props, state, or any other non-signal value, list all
+* of those values in `dependencies`. React memoization then creates a separate
+* computed when they change, rather than replacing the getter of an existing
+* computed during render. An abandoned render therefore cannot change the
+* closure used by the previously committed computed. Choose one mode for a
+* component's lifetime.
+*/
+function useComputed(getValue, dependencies) {
+	const dependencyComputed = useMemo(() => dependencies === void 0 ? void 0 : computed(getValue), dependencies ?? EMPTY_DEPENDENCIES);
+	const initialModeRef = useRef(void 0);
+	const signalOnlyComputedRef = useRef(void 0);
+	const mode = dependencies === void 0 ? "without a dependency array" : "with a dependency array";
+	initialModeRef.current ??= mode;
+	if (initialModeRef.current !== mode) {
+		const error = /* @__PURE__ */ new Error(`useComputed: the dependency-array mode changed between renders (from ${initialModeRef.current} to ${mode}) for this call site. Keep passing deps consistently, matching useMemo's rules.`);
+		error.name = "UseComputedModeChangeError";
+		throw error;
+	}
+	if (dependencyComputed !== void 0) return dependencyComputed;
+	if (signalOnlyComputedRef.current === void 0) signalOnlyComputedRef.current = computed(getValue);
+	return signalOnlyComputedRef.current;
+}
+/**
+* Runs a reactive effect after this component has committed, disposing it when
+* the component unmounts (and during React Strict Mode's development replay).
+*
+* When `dependencies` is omitted, the callback must only capture signals. Its
+* initial closure is retained for the component lifetime, so unrelated React
+* renders do not restart the effect.
+*
+* When the callback captures props, state, or any other non-signal value, list
+* all of those values in `dependencies`. The effect is then reconnected after
+* those dependencies change. Choose one mode for a component's lifetime.
+*/
+function useSignalEffect(callback, dependencies) {
+	useEffect(() => detachedEffect(callback), dependencies ?? EMPTY_DEPENDENCIES);
+}
+/**
+* Reads a signal and subscribes the component to subsequent changes through
+* ReadableInterop V1 when available.
+*
+* `useSyncExternalStore` owns the initial consistency check after subscribing.
+* For V1 readables, its watcher tracks revisions without an EffectNode. A
+* read that throws (a computed whose cached error `.value` rethrows) remains
+* for the render-time `getSnapshot` to surface to an Error Boundary; only the
+* structural-readable fallback needs an effect to contain background errors.
+*
+* A `deepSignal` is rejected at compile time: this subscribes to root
+* replacement only, so nested mutations would never re-render. Read deep state
+* with `useDeepSignalValue` or inside a tracked component instead.
+*/
+function useSignalValue(source) {
+	const subscribe = useCallback((notify) => {
+		const unsubscribe = subscribeReadableV1(source, notify);
+		if (unsubscribe !== void 0) return unsubscribe;
+		return createEffectBackedStoreSubscription(() => {
+			source.value;
+			return true;
+		})(notify);
+	}, [source]);
+	const getSnapshot = useCallback(() => untracked(() => source.value), [source]);
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+//#endregion
+//#region src/runtime/jsx.ts
+/** The small set of DOM properties that support direct signal bindings. */
+const REACTIVE_PROP_NAMES = /* @__PURE__ */ new Set([
+	"title",
+	"id",
+	"className",
+	"hidden",
+	"disabled",
+	"style",
+	"value",
+	"checked"
+]);
+function isControlledTwoWayProp(tagName, name) {
+	if (name === "value") return tagName === "input" || tagName === "textarea" || tagName === "select";
+	if (name === "checked") return tagName === "input";
+	return false;
+}
+function resolveBindingKind(tagName, name) {
+	if (name === "style") return "style";
+	if (isControlledTwoWayProp(tagName, name)) {
+		if (name === "value") return tagName === "select" ? "select-value" : "text-value";
+		return "checked";
+	}
+	return "prop";
+}
+function isTwoWayBindingKind(kind) {
+	return kind === "select-value" || kind === "text-value" || kind === "checked";
+}
+const UNCONTROLLED_PROP_NAMES = {
+	value: "defaultValue",
+	checked: "defaultChecked"
+};
+const UNITLESS_CSS_PROPERTIES = /* @__PURE__ */ new Set([
+	"animationIterationCount",
+	"aspectRatio",
+	"borderImageOutset",
+	"borderImageSlice",
+	"borderImageWidth",
+	"boxFlex",
+	"boxFlexGroup",
+	"boxOrdinalGroup",
+	"columnCount",
+	"columns",
+	"flex",
+	"flexGrow",
+	"flexPositive",
+	"flexShrink",
+	"flexNegative",
+	"flexOrder",
+	"gridArea",
+	"gridColumn",
+	"gridColumnEnd",
+	"gridColumnSpan",
+	"gridColumnStart",
+	"gridRow",
+	"gridRowEnd",
+	"gridRowSpan",
+	"gridRowStart",
+	"fontWeight",
+	"lineClamp",
+	"lineHeight",
+	"opacity",
+	"order",
+	"orphans",
+	"scale",
+	"tabSize",
+	"WebkitLineClamp",
+	"widows",
+	"zIndex",
+	"zoom"
+]);
+const SVG_ELEMENTS = [
+	"svg",
+	"animate",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"clipPath",
+	"defs",
+	"desc",
+	"ellipse",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"filter",
+	"foreignObject",
+	"g",
+	"image",
+	"line",
+	"linearGradient",
+	"marker",
+	"mask",
+	"metadata",
+	"mpath",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialGradient",
+	"rect",
+	"set",
+	"stop",
+	"switch",
+	"symbol",
+	"text",
+	"textPath",
+	"tspan",
+	"use",
+	"view"
+];
+const MATHML_ELEMENTS = [
+	"annotation",
+	"annotation-xml",
+	"maction",
+	"math",
+	"merror",
+	"mfrac",
+	"mi",
+	"mmultiscripts",
+	"mn",
+	"mo",
+	"mover",
+	"mpadded",
+	"mphantom",
+	"mprescripts",
+	"mroot",
+	"mrow",
+	"ms",
+	"mspace",
+	"msqrt",
+	"mstyle",
+	"msub",
+	"msubsup",
+	"msup",
+	"mtable",
+	"mtd",
+	"mtext",
+	"mtr",
+	"munder",
+	"munderover",
+	"semantics"
+];
+const NON_HTML_HOST_ELEMENTS = /* @__PURE__ */ (() => {
+	const tags = new Set(SVG_ELEMENTS);
+	for (const tag of MATHML_ELEMENTS) tags.add(tag);
+	return tags;
+})();
+const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+/**
+* A leaf that lets React own reconciliation while its signal dependency stays
+* local to the leaf.  A signal resolving to another signal/array is normalized
+* again so nested reactive children also work.
+*/
+function SignalValue({ source }) {
+	return normalizeChild(useSignalValue(source));
+}
+function normalizeChild(value) {
+	if (isSignal(value)) return createElement(SignalValue, { source: value });
+	if (Array.isArray(value)) return value.map(normalizeArrayItem);
+	return value;
+}
+/**
+* A signal inside an array child has no way to carry a key of its own, so the
+* leaf it becomes is keyed by position. That is the identity such an array
+* already has (a literal `[a, b]` never reorders), and it keeps React's
+* missing-key warning for genuinely dynamic element lists intact. The prefix
+* keeps these keys out of the way of keys on the array's other elements.
+*/
+function normalizeArrayItem(value, index) {
+	if (isSignal(value)) return createElement(SignalValue, {
+		source: value,
+		key: `rfgs-signal:${index}`
+	});
+	return normalizeChild(value);
+}
+function isReactiveHostProp(name, value) {
+	if (!isSignal(value)) return false;
+	return REACTIVE_PROP_NAMES.has(name) || name.startsWith("data-") || name.startsWith("aria-");
+}
+function readInitialValue(source, kind) {
+	const value = source.peek();
+	if (kind === "style" && typeof value === "object" && value !== null && !Array.isArray(value)) return { ...value };
+	return value;
+}
+/**
+* Reads a signal on behalf of one of this module's direct DOM bindings (see
+* the module doc: these write straight to the DOM from a subscription mounted
+* alongside the element's ref, bypassing React's render, so the owning
+* component never re-renders). A `computed()` whose getter throws caches and
+* rethrows that error on every read (see `updateComputed` in
+* src/core/alien-derived-runtime-core.mts) —
+* if `source` is such a computed and it starts failing after the binding is
+* already mounted, an unguarded read here could throw from the subscription's
+* update callback while processing the write. The direct V1 watcher contains
+* computed dirty-check errors, but this binding read is a separate operation;
+* catching it here also keeps the structural-readable effect fallback local.
+*
+* Catching here keeps a failure local to this one binding: the DOM write for
+* this cycle is skipped (the DOM is left at its last successful value) and
+* the failure is reported with `console.error(message, { cause: error })` —
+* assert against `mock.calls[i][1].cause` in tests, the same shape used by
+* `effect()`'s failure report (`reportFailure` in
+* src/core/alien-derived-runtime-core.mts) and by `render-tracking.ts`. Reporting is intentional here too: a direct binding
+* has no Error Boundary or other surface to fall back on, and silence would
+* mean a binding that mysteriously stops updating with zero trace.
+*
+* Reported at most once per contiguous run of failures ("episode"): `episode`
+* latches after the first report and is cleared the moment a read next
+* succeeds, so a later, distinct failure episode logs again. This keeps a
+* `computed()` that fails on every keystroke from spamming one `console.error`
+* per keystroke.
+*/
+function readBoundSignal(read, episode) {
+	try {
+		const value = read();
+		episode.hasReported = false;
+		return {
+			ok: true,
+			value
+		};
+	} catch (error) {
+		if (!episode.hasReported) {
+			episode.hasReported = true;
+			console.error("react-fine-grained-signals: a direct signal binding's read threw; skipping this update and leaving the DOM at its last value.", { cause: error });
+		}
+		return { ok: false };
+	}
+}
+/**
+* Reads via `readBoundSignal` and, on success, hands the value to `apply`; a
+* failed read is already reported by `readBoundSignal`, so this just skips
+* the write. Shared by every read-and-apply call site below, including the
+* one that isn't itself a subscription callback — the MutationObserver-triggered
+* re-apply in `bindSelectValue`, which reads outside the reactive graph via
+* `.peek()`.
+*/
+function applyBoundSignal(read, apply, episode) {
+	const result = readBoundSignal(read, episode);
+	if (result.ok) apply(result.value);
+}
+function createBindingSubscription(source, apply, episode = { hasReported: false }) {
+	const update = () => applyBoundSignal(() => source.value, apply, episode);
+	const refresh = () => untracked(update);
+	const unsubscribe = subscribeReadableV1(source, update);
+	if (unsubscribe !== void 0) {
+		untracked(() => notifyListener(update));
+		return {
+			dispose: unsubscribe,
+			refresh
+		};
+	}
+	return {
+		dispose: detachedEffect(update),
+		refresh
+	};
+}
+function setAttribute(node, name, value) {
+	if (value == null) node.removeAttribute(name);
+	else node.setAttribute(name, String(value));
+}
+function setDomProp(node, name, value) {
+	if (node.namespaceURI !== HTML_NAMESPACE) {
+		setAttribute(node, name === "className" ? "class" : name, value);
+		return;
+	}
+	switch (name) {
+		case "title":
+			node.title = value == null ? "" : String(value);
+			return;
+		case "id":
+			node.id = value == null ? "" : String(value);
+			return;
+		case "className":
+			node.className = value == null ? "" : String(value);
+			return;
+		case "hidden":
+			if (value === "until-found") setAttribute(node, "hidden", value);
+			else node.hidden = Boolean(value);
+			return;
+		case "disabled":
+			if ("disabled" in node) node.disabled = Boolean(value);
+			else if (value == null || value === false) node.removeAttribute(name);
+			else setAttribute(node, name, value);
+			return;
+		default: setAttribute(node, name, value);
+	}
+}
+/**
+* Writes `value`/`checked` on a controlled-two-way element, skipping the DOM
+* write when it already holds the value being written. A binding update
+* follows signal writes, including keystrokes written by `onChange`, so without
+* this guard every keystroke would re-set a property the DOM already has,
+* moving the caret and disrupting IME composition for no reason.
+*/
+function setControlledProp(node, name, value) {
+	if (name === "value") {
+		const select = node;
+		if (select.tagName === "SELECT") {
+			setSelectValue(select, value);
+			return;
+		}
+		const next = value == null ? "" : String(value);
+		const input = node;
+		if (input.value !== next) input.value = next;
+		if (input.defaultValue !== next) input.defaultValue = next;
+		return;
+	}
+	const next = Boolean(value);
+	const input = node;
+	if (input.checked !== next) input.checked = next;
+	if (input.defaultChecked !== next) input.defaultChecked = next;
+}
+/**
+* `<select multiple>` does not support assigning `.value` directly — the DOM
+* setter only ever selects a single option, silently corrupting the
+* selection instead of erroring. Its documented API for a multi-value select
+* is per-`<option>` `.selected`, so an array-valued signal (React's own
+* typing for a multi-select) is applied that way instead.
+*/
+function setSelectValue(select, value) {
+	const multiple = select.multiple;
+	const values = new Set(Array.isArray(value) && multiple ? value.map(String) : value == null ? multiple ? [] : [""] : [String(value)]);
+	if (!multiple) {
+		const next = [...values][0];
+		if (select.value !== next) select.value = next;
+	}
+	for (const option of select.options) {
+		const selected = values.has(option.value);
+		if (multiple && option.selected !== selected) option.selected = selected;
+		if (option.defaultSelected !== selected) option.defaultSelected = selected;
+	}
+}
+/**
+* A `<select>` whose matching `<option>` does not exist yet (for example when
+* the options themselves are rendered from a signal or other state, mounted
+* after this one) silently ends up with nothing selected: the DOM neither
+* errors nor retroactively applies `.value`/`.selected` once a matching
+* `<option>` is later added. The value subscription below only updates when
+* the bound signal itself changes, so it cannot see that the option list changed
+* out from under it. A MutationObserver on the select's subtree re-applies
+* the signal's current value whenever its `<option>` list changes, closing
+* that gap without requiring the signal to change too.
+*/
+function bindSelectValue(select, source, apply) {
+	const episode = { hasReported: false };
+	const subscription = createBindingSubscription(source, apply, episode);
+	const observer = new MutationObserver(() => {
+		applyBoundSignal(() => source.peek(), apply, episode);
+	});
+	observer.observe(select, {
+		childList: true,
+		subtree: true
+	});
+	return {
+		dispose() {
+			subscription.dispose();
+			observer.disconnect();
+		},
+		refresh: subscription.refresh
+	};
+}
+/**
+* Forcing a `value` write while an IME composition is in progress can abort
+* the composition outright, independent of whether the string being written
+* happens to match what was typed — the write-skip guard in
+* `setControlledProp` only protects the same-value echo case, not this one.
+* `compositionstart`/`compositionend` listeners on the node itself track
+* composition state directly, regardless of whether the component declares
+* its own composition handlers, and a write requested while composing is
+* deferred until composition ends instead of applied immediately.
+*/
+function bindTextValue(node, source, write) {
+	let composing = false;
+	let hasPending = false;
+	let pending;
+	const episode = { hasReported: false };
+	const onCompositionStart = () => {
+		composing = true;
+	};
+	const onCompositionEnd = () => {
+		composing = false;
+		if (hasPending) {
+			hasPending = false;
+			write(pending);
+		}
+	};
+	node.addEventListener("compositionstart", onCompositionStart);
+	node.addEventListener("compositionend", onCompositionEnd);
+	const subscription = createBindingSubscription(source, (next) => {
+		if (composing) {
+			hasPending = true;
+			pending = next;
+			return;
+		}
+		write(next);
+	}, episode);
+	return {
+		dispose() {
+			subscription.dispose();
+			node.removeEventListener("compositionstart", onCompositionStart);
+			node.removeEventListener("compositionend", onCompositionEnd);
+		},
+		refresh: subscription.refresh
+	};
+}
+function clearStyleProperty(style, key) {
+	if (key.startsWith("--")) style.removeProperty(key);
+	else style[key] = "";
+}
+function setStyleProperty(style, key, value) {
+	if (value == null) {
+		clearStyleProperty(style, key);
+		return;
+	}
+	if (key.startsWith("--")) {
+		style.setProperty(key, String(value));
+		return;
+	}
+	style[key] = typeof value === "number" && !UNITLESS_CSS_PROPERTIES.has(key) ? `${value}px` : String(value);
+}
+/**
+* Applies a whole style object to an element, clearing keys that were present
+* in a previous call but are absent from this one. Only the coarse
+* `style={signal}` form is bound this way — an object whose individual entries
+* are themselves signals is out of scope (see development/design/direct-binding-value-checked-style.md).
+*/
+function applyStyle(node, value, previousKeys) {
+	const nextStyle = typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+	const nextKeys = Object.keys(nextStyle);
+	const nextKeySet = new Set(nextKeys);
+	for (const key of previousKeys) if (!nextKeySet.has(key)) clearStyleProperty(node.style, key);
+	for (const key of nextKeys) setStyleProperty(node.style, key, nextStyle[key]);
+	return nextKeys;
+}
+function applyRef(ref, node) {
+	if (typeof ref === "function") return ref(node);
+	if (ref != null) ref.current = node;
+}
+/** A binding's identity for the re-render diff: same name, source, and kind. */
+function isSameBinding(a, b) {
+	return b !== void 0 && a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+/** Whether two style values set the same properties to the same values. */
+function isSameStyle(a, b) {
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return Object.is(a, b);
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => Object.is(a[key], b[key]));
+}
+/**
+* Whether React was handed the same value for this binding's prop. A two-way
+* binding hands React an uncontrolled default that it reads only at mount, so
+* only `"prop"` and `"style"` snapshots count; a style snapshot is a fresh copy
+* every render (see `readInitialValue`), so it is compared by content.
+*/
+function hasSameSnapshot(a, b) {
+	return isTwoWayBindingKind(a[2]) || (a[2] === "style" ? isSameStyle(a[3], b[3]) : Object.is(a[3], b[3]));
+}
+/**
+* Subscribes a single binding to `node` and returns its teardown. Split out of
+* the ref callback so `NodeBinder` can rebuild one binding on
+* its own, without disturbing the siblings that did not change.
+*
+* `initialStyleKeys` seeds a `"style"` binding's own `previousKeys` (see
+* `getInitialStyleKeys`), so the fresh binding starts already knowing which
+* CSS properties may be on the node, instead of starting from an empty set
+* and never clearing them. Ignored for every other kind.
+*/
+function subscribeBinding(node, name, source, kind, initialStyleKeys, binder) {
+	const whileAttached = (write) => (value) => {
+		if (binder.attached) write(value);
+	};
+	switch (kind) {
+		case "style": {
+			let previousKeys = initialStyleKeys ?? [];
+			let applied;
+			const write = (value) => {
+				applied = value;
+				previousKeys = applyStyle(node, value, previousKeys);
+			};
+			const subscription = createBindingSubscription(source, whileAttached(write));
+			return {
+				...subscription,
+				refresh: (snapshot) => {
+					previousKeys = getInitialStyleKeys(previousKeys, snapshot);
+					subscription.refresh();
+				},
+				getStyleKeys: () => previousKeys,
+				restore: (snapshot) => {
+					if (!isSameStyle(applied, snapshot)) write(snapshot);
+				}
+			};
+		}
+		case "select-value": return {
+			...bindSelectValue(node, source, whileAttached((value) => setControlledProp(node, "value", value))),
+			getStyleKeys: void 0,
+			restore: void 0
+		};
+		case "text-value": return {
+			...bindTextValue(node, source, whileAttached((value) => setControlledProp(node, "value", value))),
+			getStyleKeys: void 0,
+			restore: void 0
+		};
+		case "checked": return {
+			...createBindingSubscription(source, whileAttached((value) => setControlledProp(node, name, value))),
+			getStyleKeys: void 0,
+			restore: void 0
+		};
+		case "prop": {
+			let applied;
+			const write = (value) => {
+				applied = value;
+				setDomProp(node, name, value);
+			};
+			return {
+				...createBindingSubscription(source, whileAttached(write)),
+				getStyleKeys: void 0,
+				restore: (snapshot) => {
+					if (!Object.is(applied, snapshot)) write(snapshot);
+				}
+			};
+		}
+	}
+}
+/**
+* The CSS properties a new `"style"` binding may find on the node: React wrote
+* this binding's render-time snapshot, and a replaced binding (`staleKeys`) may
+* have written keys React never saw. The signal can drop any of them before the
+* binding attaches (a write between render and commit, an Activity or Suspense
+* reveal), so the first write must be able to clear all of them. A kept
+* binding re-attached for a newer render widens its own keys the same way.
+*/
+function getInitialStyleKeys(staleKeys, snapshot) {
+	const keys = typeof snapshot === "object" && snapshot !== null && !Array.isArray(snapshot) ? Object.keys(snapshot) : [];
+	if (staleKeys === void 0) return keys;
+	for (const key of staleKeys) if (!keys.includes(key)) keys.push(key);
+	return keys;
+}
+function mountBinding(node, binding, binder, staleStyleKeys) {
+	const initialStyleKeys = binding[2] === "style" ? getInitialStyleKeys(staleStyleKeys, binding[3]) : void 0;
+	const { dispose, refresh, getStyleKeys, restore } = subscribeBinding(node, binding[0], binding[1], binding[2], initialStyleKeys, binder);
+	return {
+		binding,
+		dispose,
+		refresh,
+		getStyleKeys,
+		restore
+	};
+}
+/**
+* Owns the direct bindings mounted on one DOM node.
+*
+* Bindings are attached through a callback ref on the host element itself
+* rather than through a wrapper component. A wrapper would change the element
+* type whenever a prop switched between a signal and a plain value, and React
+* remounts a subtree whose element type changes, losing descendant state and
+* focus. With the ref, the element stays the same host type in both cases.
+*
+* The binder is keyed by the node, not by the ref callback, because React
+* replaces a callback ref whose identity changed by detaching the old one and
+* attaching the new one to the same node within a single commit. Tearing the
+* bindings down on that detach would recreate every subscription — and reset
+* `bindTextValue`'s in-flight IME composition state — on unrelated re-renders.
+* So a detach only schedules the teardown, and a re-attach of the same node in
+* the same commit reconciles the bindings in place instead (`syncBindings`
+* diffs by `(name, source, kind)`). A detach that is not followed by an attach
+* (unmount, a hidden Activity or Suspense boundary) tears down in a microtask.
+*
+* The user's own ref is forwarded synchronously on every attach and detach,
+* which is exactly what React would do with it directly; `getBindingRef` keeps
+* the callback's identity stable whenever the inputs are, so a stable user ref
+* is not churned.
+*/
+var NodeBinder = class {
+	#node;
+	#mounted = [];
+	#token = 0;
+	#detached = false;
+	constructor(node) {
+		this.#node = node;
+	}
+	/** Whether React currently has this node attached through a binding ref. */
+	get attached() {
+		return !this.#detached;
+	}
+	attach(bindings, userRef) {
+		const token = ++this.#token;
+		const wasDetached = this.#detached;
+		this.#detached = false;
+		if (wasDetached) for (const entry of this.#mounted) {
+			const next = bindings.find((binding) => binding[0] === entry.binding[0]);
+			if (isSameBinding(entry.binding, next)) entry.refresh(next[3]);
+		}
+		this.#sync(bindings);
+		let userCleanup;
+		try {
+			userCleanup = applyRef(userRef, this.#node);
+		} catch (error) {
+			this.#detach(token, bindings);
+			throw error;
+		}
+		return () => {
+			try {
+				if (typeof userCleanup === "function") userCleanup();
+				else applyRef(userRef, null);
+			} finally {
+				this.#detach(token, bindings);
+			}
+		};
+	}
+	/**
+	* Hands the node back to React for the attach identified by `token`: writes
+	* are held back from now on, and the bindings are disposed in a microtask
+	* unless the same node is attached again first (see the class doc).
+	*/
+	#detach(token, bindings) {
+		if (token !== this.#token) return;
+		this.#detached = true;
+		this.#mounted.forEach((entry, index) => entry.restore?.(bindings[index][3]));
+		queueMicrotask(() => {
+			if (this.#detached && token === this.#token) this.#dispose();
+		});
+	}
+	#dispose() {
+		const mounted = this.#mounted;
+		this.#mounted = [];
+		for (const binding of mounted) binding.dispose();
+	}
+	#sync(bindings) {
+		const mounted = this.#mounted;
+		if (mounted.length === bindings.length && mounted.every((entry, index) => isSameBinding(entry.binding, bindings[index]))) return;
+		const reusable = /* @__PURE__ */ new Map();
+		for (const entry of mounted) reusable.set(entry.binding[0], entry);
+		const reused = bindings.map((binding) => {
+			const candidate = reusable.get(binding[0]);
+			if (candidate === void 0 || !isSameBinding(candidate.binding, binding)) return void 0;
+			reusable.delete(binding[0]);
+			return candidate;
+		});
+		const staleStyleKeys = /* @__PURE__ */ new Map();
+		for (const stale of reusable.values()) if (stale.getStyleKeys !== void 0) staleStyleKeys.set(stale.binding[0], stale.getStyleKeys());
+		for (const stale of reusable.values()) stale.dispose();
+		const node = this.#node;
+		this.#mounted = bindings.map((binding, index) => reused[index] ?? mountBinding(node, binding, this, staleStyleKeys.get(binding[0])));
+	}
+};
+const nodeBinders = /* @__PURE__ */ new WeakMap();
+function createBindingRef(bindings, userRef) {
+	return (node) => {
+		if (node == null) return;
+		let binder = nodeBinders.get(node);
+		if (binder === void 0) {
+			binder = new NodeBinder(node);
+			nodeBinders.set(node, binder);
+		}
+		return binder.attach(bindings, userRef);
+	};
+}
+const bindingRefs = /* @__PURE__ */ new WeakMap();
+const BINDING_REF_CACHE_LIMIT = 8;
+function haveSameBindings(a, b) {
+	return a.length === b.length && a.every((binding, index) => isSameBinding(binding, b[index]) && hasSameSnapshot(binding, b[index]));
+}
+function getBindingRef(bindings, userRef) {
+	const cacheKey = userRef ?? bindings[0][1];
+	const cache = bindingRefs;
+	let entries = cache.get(cacheKey);
+	if (entries !== void 0) {
+		for (const entry of entries) if (entry.userRef === userRef && haveSameBindings(entry.bindings, bindings)) return entry.ref;
+	} else {
+		entries = [];
+		cache.set(cacheKey, entries);
+	}
+	const ref = createBindingRef(bindings, userRef);
+	if (entries.length >= BINDING_REF_CACHE_LIMIT) entries.shift();
+	entries.push({
+		bindings,
+		userRef,
+		ref
+	});
+	return ref;
+}
+/**
+* Scans a native host element's props for anything reactive (see
+* `isReactiveHostProp`). Kept separate from building the transformed props
+* copy in `transformHostProps` so that function can decide whether a copy is
+* needed at all before ever allocating one.
+*/
+function findHostBindings(props, tagName) {
+	const bindings = [];
+	for (const [name, value] of Object.entries(props)) if (isReactiveHostProp(name, value)) {
+		const kind = resolveBindingKind(tagName, name);
+		bindings.push([
+			name,
+			value,
+			kind,
+			readInitialValue(value, kind)
+		]);
+	}
+	return bindings;
+}
+/**
+* Transforms a native host element's (`<div>`, `<svg>`, ...) props: replaces
+* any directly-bound prop with its initial, non-reactive value (`bindings`
+* carries the reactive ones for the binding ref to mount later — see
+* `createJsxWrapper`) and normalizes a signal/array `children` the same way
+* `Fragment` does.
+*
+* The overwhelmingly common host element has neither. Scanning first and only
+* allocating a copy when something is actually found means a plain
+* `<div className="card">…</div>` costs one prop walk and zero extra
+* allocations — the original props object is returned as-is (see the
+* `bindings.length === 0 && !childrenNeedNormalization` branch below), and
+* `createJsxWrapper` passes it straight to `factory` unchanged.
+*/
+function transformHostProps(type, input) {
+	const inputProps = input ?? {};
+	const bindings = !NON_HTML_HOST_ELEMENTS.has(type) ? findHostBindings(inputProps, type) : [];
+	const rawChildren = inputProps.children;
+	const childrenNeedNormalization = "children" in inputProps && (isSignal(rawChildren) || Array.isArray(rawChildren));
+	if (bindings.length === 0 && !childrenNeedNormalization) return {
+		props: inputProps,
+		bindings
+	};
+	const props = { ...inputProps };
+	if (childrenNeedNormalization) props.children = normalizeChild(rawChildren);
+	for (const [name, , kind, snapshot] of bindings) {
+		const uncontrolledName = isTwoWayBindingKind(kind) ? UNCONTROLLED_PROP_NAMES[name] : void 0;
+		if (uncontrolledName !== void 0) {
+			delete props[name];
+			props[uncontrolledName] = snapshot;
+		} else props[name] = snapshot;
+	}
+	return {
+		props,
+		bindings
+	};
+}
+/**
+* `Fragment`'s only prop worth transforming is `children`, and only when it
+* is itself a signal or array — `normalizeChild` is the identity for
+* anything else (see its definition) — so a plain `<>...</>` with ordinary
+* children is passed straight through, uncopied, the same way a custom
+* component is below.
+*/
+function transformFragmentProps(input) {
+	const props = input;
+	if (props == null || !("children" in props) || !isSignal(props.children) && !Array.isArray(props.children)) return input;
+	return {
+		...props,
+		children: normalizeChild(props.children)
+	};
+}
+/**
+* A host element's final props: the transformed copy with the binding ref in
+* place of the user's own ref, which the binding ref forwards to. `props` is
+* always a fresh copy whenever there are bindings (see `transformHostProps`).
+*/
+function withBindingRef(props, bindings) {
+	if (bindings.length > 0) props.ref = getBindingRef(bindings, props.ref);
+	return props;
+}
+/** Creates a JSX wrapper while letting each module supply React's JSX factory. */
+function createJsxWrapper(factory) {
+	return (type, input, key) => {
+		if (typeof type === "string") {
+			const { props, bindings } = transformHostProps(type, input);
+			return factory(type, withBindingRef(props, bindings), key);
+		}
+		if (type === Fragment) return factory(type, transformFragmentProps(input), key);
+		return factory(type, input, key);
+	};
+}
+/**
+* The classic-runtime `createElement` that the automatic runtime falls back to
+* for `<div {...props} key="k" />` — TypeScript, Babel and Oxc all import it
+* from the package root of `jsxImportSource`. It applies the same host-prop
+* bindings and child normalization as `jsx`, and leaves `key` (and `ref`) in
+* the config for React's own `createElement` to extract.
+*/
+function createSignalAwareElement(type, config, ...children) {
+	if (typeof type !== "string" && type !== Fragment) return createElement(type, config, ...children);
+	const normalizedChildren = children.map((child) => normalizeChild(child));
+	if (typeof type !== "string") return createElement(type, config, ...normalizedChildren);
+	const { props, bindings } = transformHostProps(type, config ?? {});
+	return createElement(type, withBindingRef(props, bindings), ...normalizedChildren);
+}
+//#endregion
+export { useDeepSignalValue as a, useSignalValue as c, useDeepSignal as i, deepSignal as l, createSignalAwareElement as n, useSignal as o, useComputed as r, useSignalEffect as s, createJsxWrapper as t };
+
+//# sourceMappingURL=jsx-P6volZdr.js.map