@pyreon/solid-compat 0.13.0 → 0.14.0

package/lib/analysis/index.js.html

@@ -5386,7 +5386,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"491c766f-1","name":"jsx-runtime.ts"},{"uid":"491c766f-3","name":"index.ts"}]}]}],"isRoot":true},"nodeParts":{"491c766f-1":{"renderedLength":186,"gzipLength":138,"brotliLength":0,"metaUid":"491c766f-0"},"491c766f-3":{"renderedLength":5815,"gzipLength":1730,"brotliLength":0,"metaUid":"491c766f-2"}},"nodeMetas":{"491c766f-0":{"id":"/src/jsx-runtime.ts","moduleParts":{"index.js":"491c766f-1"},"imported":[{"uid":"491c766f-4"},{"uid":"491c766f-5"}],"importedBy":[{"uid":"491c766f-2"}]},"491c766f-2":{"id":"/src/index.ts","moduleParts":{"index.js":"491c766f-3"},"imported":[{"uid":"491c766f-4"},{"uid":"491c766f-5"},{"uid":"491c766f-0"}],"importedBy":[],"isEntry":true},"491c766f-4":{"id":"@pyreon/core","moduleParts":{},"imported":[],"importedBy":[{"uid":"491c766f-2"},{"uid":"491c766f-0"}]},"491c766f-5":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"491c766f-2"},{"uid":"491c766f-0"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"7b35df5d-1","name":"jsx-runtime.ts"},{"uid":"7b35df5d-3","name":"index.ts"}]}]}],"isRoot":true},"nodeParts":{"7b35df5d-1":{"renderedLength":186,"gzipLength":138,"brotliLength":0,"metaUid":"7b35df5d-0"},"7b35df5d-3":{"renderedLength":19175,"gzipLength":5477,"brotliLength":0,"metaUid":"7b35df5d-2"}},"nodeMetas":{"7b35df5d-0":{"id":"/src/jsx-runtime.ts","moduleParts":{"index.js":"7b35df5d-1"},"imported":[{"uid":"7b35df5d-4"},{"uid":"7b35df5d-5"}],"importedBy":[{"uid":"7b35df5d-2"}]},"7b35df5d-2":{"id":"/src/index.ts","moduleParts":{"index.js":"7b35df5d-3"},"imported":[{"uid":"7b35df5d-4"},{"uid":"7b35df5d-5"},{"uid":"7b35df5d-0"}],"importedBy":[],"isEntry":true},"7b35df5d-4":{"id":"@pyreon/core","moduleParts":{},"imported":[],"importedBy":[{"uid":"7b35df5d-2"},{"uid":"7b35df5d-0"}]},"7b35df5d-5":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"7b35df5d-2"},{"uid":"7b35df5d-0"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/lib/analysis/jsx-runtime.js.html

@@ -5386,7 +5386,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"jsx-runtime.js","children":[{"name":"src","children":[{"uid":"a89fb633-1","name":"jsx-runtime.ts"},{"uid":"a89fb633-3","name":"jsx-dev-runtime.ts"}]}]}],"isRoot":true},"nodeParts":{"a89fb633-1":{"renderedLength":3959,"gzipLength":1335,"brotliLength":0,"metaUid":"a89fb633-0"},"a89fb633-3":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"a89fb633-2"}},"nodeMetas":{"a89fb633-0":{"id":"/src/jsx-runtime.ts","moduleParts":{"jsx-runtime.js":"a89fb633-1"},"imported":[{"uid":"a89fb633-4"},{"uid":"a89fb633-5"}],"importedBy":[{"uid":"a89fb633-2"}]},"a89fb633-2":{"id":"/src/jsx-dev-runtime.ts","moduleParts":{"jsx-runtime.js":"a89fb633-3"},"imported":[{"uid":"a89fb633-0"}],"importedBy":[],"isEntry":true},"a89fb633-4":{"id":"@pyreon/core","moduleParts":{},"imported":[],"importedBy":[{"uid":"a89fb633-0"}]},"a89fb633-5":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"a89fb633-0"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"jsx-runtime.js","children":[{"name":"src","children":[{"uid":"e600c1ac-1","name":"jsx-runtime.ts"},{"uid":"e600c1ac-3","name":"jsx-dev-runtime.ts"}]}]}],"isRoot":true},"nodeParts":{"e600c1ac-1":{"renderedLength":4138,"gzipLength":1377,"brotliLength":0,"metaUid":"e600c1ac-0"},"e600c1ac-3":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"e600c1ac-2"}},"nodeMetas":{"e600c1ac-0":{"id":"/src/jsx-runtime.ts","moduleParts":{"jsx-runtime.js":"e600c1ac-1"},"imported":[{"uid":"e600c1ac-4"},{"uid":"e600c1ac-5"}],"importedBy":[{"uid":"e600c1ac-2"}]},"e600c1ac-2":{"id":"/src/jsx-dev-runtime.ts","moduleParts":{"jsx-runtime.js":"e600c1ac-3"},"imported":[{"uid":"e600c1ac-0"}],"importedBy":[],"isEntry":true},"e600c1ac-4":{"id":"@pyreon/core","moduleParts":{},"imported":[],"importedBy":[{"uid":"e600c1ac-0"}]},"e600c1ac-5":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"e600c1ac-0"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/lib/index.js

@@ -1,5 +1,5 @@
-import { ErrorBoundary, For, Match, Show, Suspense, Switch, createContext as pyreonCreateContext, onMount as onMount$1, onUnmount, useContext as pyreonUseContext } from "@pyreon/core";
-import { batch as pyreonBatch, computed, createSelector as createSelector$1, effect, effectScope, getCurrentScope, runUntracked, setCurrentScope, signal } from "@pyreon/reactivity";
+import { ErrorBoundary, For, Match, Show, Suspense, Switch, createContext as createContext$1, onMount as onMount$1, onUnmount, provide, useContext as useContext$1 } from "@pyreon/core";
+import { batch as pyreonBatch, computed, createSelector as createSelector$1, effect, effectScope, getCurrentScope, onCleanup as onCleanup$1, runUntracked, setCurrentScope, signal } from "@pyreon/reactivity";
 
 //#region src/jsx-runtime.ts
 let _currentCtx = null;
@@ -13,48 +13,93 @@ function getHookIndex() {
 
 //#endregion
 //#region src/index.ts
-function createSignal(initialValue) {
+function createSignal(initialValue, options) {
+	const neverEqual = options?.equals === false;
 	const ctx = getCurrentCtx();
 	if (ctx) {
 		const idx = getHookIndex();
-		if (idx >= ctx.hooks.length) ctx.hooks[idx] = signal(initialValue);
-		const s = ctx.hooks[idx];
-		const { scheduleRerender } = ctx;
-		const getter = () => s();
+		if (idx >= ctx.hooks.length) {
+			const { scheduleRerender } = ctx;
+			let getter;
+			let setter;
+			if (neverEqual) {
+				const s = signal({ v: initialValue });
+				getter = () => s().v;
+				setter = (v) => {
+					const prev = s.peek().v;
+					const next = typeof v === "function" ? v(prev) : v;
+					s.set({ v: next });
+					scheduleRerender();
+				};
+			} else {
+				const s = signal(initialValue);
+				getter = () => s();
+				setter = (v) => {
+					const prev = s.peek();
+					const next = typeof v === "function" ? v(prev) : v;
+					if (shouldSkipUpdate(prev, next, options)) return;
+					s.set(next);
+					scheduleRerender();
+				};
+			}
+			ctx.hooks[idx] = {
+				signal: null,
+				getter,
+				setter
+			};
+		}
+		const entry = ctx.hooks[idx];
+		return [entry.getter, entry.setter];
+	}
+	if (neverEqual) {
+		const s = signal({ v: initialValue });
+		const getter = () => s().v;
 		const setter = (v) => {
-			if (typeof v === "function") s.update(v);
-			else s.set(v);
-			scheduleRerender();
+			const prev = s.peek().v;
+			const next = typeof v === "function" ? v(prev) : v;
+			s.set({ v: next });
 		};
 		return [getter, setter];
 	}
 	const s = signal(initialValue);
 	const getter = () => s();
 	const setter = (v) => {
-		if (typeof v === "function") s.update(v);
-		else s.set(v);
+		const prev = s.peek();
+		const next = typeof v === "function" ? v(prev) : v;
+		if (shouldSkipUpdate(prev, next, options)) return;
+		s.set(next);
 	};
 	return [getter, setter];
 }
+/** Solid default: skip update when prev === next. Custom `equals` fn for user-defined comparison. */
+function shouldSkipUpdate(prev, next, options) {
+	if (typeof options?.equals === "function") return options.equals(prev, next);
+	return prev === next;
+}
 /**
 * Solid-compatible `createEffect` — creates a reactive side effect.
 *
+* Supports the `(prev) => next` signature with an optional initial value,
+* matching Solid's `createEffect<T>(fn: (prev: T) => T, initialValue: T)`.
+*
 * In component context: hook-indexed, only created on first render. The effect
 * uses Pyreon's native tracking so signal reads are automatically tracked.
 * A re-entrance guard prevents infinite loops from signal writes inside
 * the effect.
 */
-function createEffect(fn) {
+function createEffect(fn, initialValue) {
 	const ctx = getCurrentCtx();
 	if (ctx) {
 		const idx = getHookIndex();
 		if (idx < ctx.hooks.length) return;
+		let prevValue = initialValue;
 		let running = false;
 		const e = effect(() => {
 			if (running) return;
 			running = true;
 			try {
-				fn();
+				const result = fn(prevValue);
+				if (result !== void 0) prevValue = result;
 			} finally {
 				running = false;
 			}
@@ -64,7 +109,11 @@ function createEffect(fn) {
 		ctx.unmountCallbacks.push(stop);
 		return;
 	}
-	effect(fn);
+	let prevValue = initialValue;
+	effect(() => {
+		const result = fn(prevValue);
+		if (result !== void 0) prevValue = result;
+	});
 }
 /**
 * Solid-compatible `createRenderEffect` — same as createEffect.
@@ -76,18 +125,34 @@ function createRenderEffect(fn) {
 /**
 * Solid-compatible `createMemo` — derives a value from reactive sources.
 *
+* Supports the `(prev) => next` signature with an optional initial value,
+* matching Solid's `createMemo<T>(fn: (prev: T) => T, initialValue: T)`.
+*
 * In component context: hook-indexed, only created on first render.
 * Uses Pyreon's native computed for auto-tracking.
 */
-function createMemo(fn) {
+function createMemo(fn, initialValue) {
 	const ctx = getCurrentCtx();
 	if (ctx) {
 		const idx = getHookIndex();
-		if (idx >= ctx.hooks.length) ctx.hooks[idx] = computed(fn);
+		if (idx >= ctx.hooks.length) {
+			let prevValue = initialValue;
+			const c = computed(() => {
+				const result = fn(prevValue);
+				prevValue = result;
+				return result;
+			});
+			ctx.hooks[idx] = c;
+		}
 		const c = ctx.hooks[idx];
 		return () => c();
 	}
-	const c = computed(fn);
+	let prevValue = initialValue;
+	const c = computed(() => {
+		const result = fn(prevValue);
+		prevValue = result;
+		return result;
+	});
 	return () => c();
 }
 function createRoot(fn) {
@@ -100,7 +165,7 @@ function createRoot(fn) {
 		setCurrentScope(prev);
 	}
 }
-function on(deps, fn) {
+function on(deps, fn, options) {
 	let prevInput;
 	let prevValue;
 	let initialized = false;
@@ -108,6 +173,10 @@ function on(deps, fn) {
 		const input = Array.isArray(deps) ? deps.map((d) => d()) : deps();
 		if (!initialized) {
 			initialized = true;
+			if (options?.defer) {
+				prevInput = input;
+				return prevValue;
+			}
 			prevValue = fn(input, void 0, void 0);
 			prevInput = input;
 			return prevValue;
@@ -243,6 +312,43 @@ function lazy(loader) {
 	LazyComp.preload = load;
 	return LazyComp;
 }
+const SOLID_CTX = Symbol.for("pyreon:solid-ctx");
+const SOLID_CTX_BRAND = SOLID_CTX;
+const NATIVE_COMPONENT = Symbol.for("pyreon:native-compat");
+/**
+* Solid-compatible `createContext` — creates a context with a `.Provider`
+* component. Uses Pyreon's native context stack for tree-scoped nesting.
+*/
+function createContext(defaultValue) {
+	const pyreonCtx = createContext$1(defaultValue);
+	const Provider = (props) => {
+		const { value, children } = props;
+		provide(pyreonCtx, value);
+		return children ?? null;
+	};
+	Provider[NATIVE_COMPONENT] = true;
+	return {
+		[SOLID_CTX_BRAND]: true,
+		id: pyreonCtx.id,
+		defaultValue,
+		Provider
+	};
+}
+/**
+* Solid-compatible `useContext` — reads the nearest provided value for a context.
+* Works with both compat contexts (from this module's `createContext`) and
+* Pyreon native contexts (from `@pyreon/core`).
+*/
+function useContext(context) {
+	if (SOLID_CTX in context) {
+		const solidCtx = context;
+		return useContext$1({
+			id: solidCtx.id,
+			defaultValue: solidCtx.defaultValue
+		});
+	}
+	return useContext$1(context);
+}
 function getOwner() {
 	return getCurrentScope();
 }
@@ -255,7 +361,341 @@ function runWithOwner(owner, fn) {
 		setCurrentScope(prev);
 	}
 }
+function createResource(sourceOrFetcher, maybeFetcherOrOptions, maybeOptions) {
+	const hasSource = typeof maybeFetcherOrOptions === "function";
+	const source = hasSource ? sourceOrFetcher : (() => true);
+	const fetcher = hasSource ? maybeFetcherOrOptions : sourceOrFetcher;
+	const initialValue = (hasSource ? maybeOptions : typeof maybeFetcherOrOptions === "object" ? maybeFetcherOrOptions : void 0)?.initialValue;
+	const [data, setData] = createSignal(initialValue);
+	const [loading, setLoading] = createSignal(false);
+	const [error, setError] = createSignal(void 0);
+	let latestValue = initialValue;
+	let fetchPromise = null;
+	const doFetch = () => {
+		const src = typeof source === "function" ? source() : source;
+		if (src === false || src === null || src === void 0) return;
+		setLoading(true);
+		setError(void 0);
+		try {
+			const result = fetcher(src, { value: latestValue });
+			if (result instanceof Promise) {
+				fetchPromise = result;
+				result.then((val) => {
+					latestValue = val;
+					fetchPromise = null;
+					setData(() => val);
+					setLoading(false);
+				}, (err) => {
+					fetchPromise = null;
+					setError(() => err instanceof Error ? err : new Error(String(err)));
+					setLoading(false);
+				});
+			} else {
+				latestValue = result;
+				fetchPromise = null;
+				setData(() => result);
+				setLoading(false);
+			}
+		} catch (err) {
+			setError(() => err instanceof Error ? err : new Error(String(err)));
+			setLoading(false);
+		}
+	};
+	if (hasSource && typeof source === "function") createEffect(() => {
+		source();
+		doFetch();
+	});
+	else doFetch();
+	const resource = (() => {
+		const err = error();
+		if (err) throw err;
+		const current = data();
+		if (loading() && fetchPromise && current === void 0) throw fetchPromise;
+		return current;
+	});
+	Object.defineProperty(resource, "loading", {
+		get: () => loading(),
+		enumerable: true
+	});
+	Object.defineProperty(resource, "error", {
+		get: () => error(),
+		enumerable: true
+	});
+	Object.defineProperty(resource, "latest", {
+		get: () => latestValue,
+		enumerable: true
+	});
+	const mutate = (v) => {
+		if (typeof v === "function") {
+			const next = v(data());
+			latestValue = next;
+			setData(() => next);
+		} else {
+			latestValue = v;
+			setData(() => v);
+		}
+	};
+	const refetch = () => doFetch();
+	return [resource, {
+		mutate,
+		refetch
+	}];
+}
+/**
+* Deep clones plain objects and arrays. Functions, DOM nodes, class instances,
+* and other non-plain values are kept by reference — `structuredClone` would
+* throw on them.
+*/
+function deepClone(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	if (obj.constructor !== Object && obj.constructor !== Array) return obj;
+	const result = {};
+	for (const key of Object.keys(obj)) result[key] = deepClone(obj[key]);
+	return result;
+}
+function createStore(initialValue) {
+	const signals = /* @__PURE__ */ new Map();
+	let raw = deepClone(initialValue);
+	function getByPath(obj, path) {
+		if (!path) return obj;
+		return path.split(".").reduce((o, k) => o?.[k], obj);
+	}
+	function getSignal(path) {
+		let sig = signals.get(path);
+		if (!sig) {
+			sig = signal(getByPath(raw, path));
+			signals.set(path, sig);
+		}
+		return sig;
+	}
+	function resolveValue(basePath) {
+		return basePath ? getByPath(raw, basePath) : raw;
+	}
+	function makeProxy(basePath) {
+		return new Proxy({}, {
+			get(_target, prop) {
+				if (typeof prop === "symbol") return resolveValue(basePath)?.[prop];
+				const path = basePath ? `${basePath}.${String(prop)}` : String(prop);
+				getSignal(path)();
+				const value = getByPath(raw, path);
+				if (value !== null && typeof value === "object") return makeProxy(path);
+				return value;
+			},
+			has(_target, prop) {
+				const current = resolveValue(basePath);
+				return current !== null && typeof current === "object" && prop in current;
+			},
+			ownKeys(_target) {
+				if (basePath) getSignal(basePath)();
+				else getSignal("__keys__")();
+				const current = resolveValue(basePath);
+				return current !== null && typeof current === "object" ? Reflect.ownKeys(current) : [];
+			},
+			getOwnPropertyDescriptor(_target, prop) {
+				const current = resolveValue(basePath);
+				if (current !== null && typeof current === "object") return Object.getOwnPropertyDescriptor(current, prop);
+			},
+			set() {
+				console.warn("[Pyreon] Direct mutation on store is not supported. Use the setter function.");
+				return true;
+			}
+		});
+	}
+	const proxy = makeProxy("");
+	function updateRaw(newRaw) {
+		const oldRaw = raw;
+		raw = newRaw;
+		for (const [path, sig] of signals) {
+			const oldVal = getByPath(oldRaw, path);
+			const newVal = getByPath(newRaw, path);
+			if (!Object.is(oldVal, newVal)) sig.set(newVal);
+		}
+	}
+	/**
+	* Applies a value at a path, supporting numeric indices (array access)
+	* and filter predicates (functions that select matching array items).
+	*/
+	function applyAtPath(obj, path, value) {
+		if (path.length === 0) {
+			if (typeof value === "function") {
+				const result = value(obj);
+				Object.assign(obj, result);
+			} else Object.assign(obj, value);
+			return;
+		}
+		const [head, ...rest] = path;
+		if (typeof head === "function") {
+			if (Array.isArray(obj)) {
+				for (let i = 0; i < obj.length; i++) if (head(obj[i], i)) if (rest.length === 0) obj[i] = typeof value === "function" ? value(obj[i]) : value;
+				else applyAtPath(obj[i], rest, value);
+			}
+			return;
+		}
+		const key = head;
+		if (rest.length === 0) obj[key] = typeof value === "function" ? value(obj[key]) : value;
+		else applyAtPath(obj[key], rest, value);
+	}
+	const setStore = (...args) => {
+		if (args.length === 1 && typeof args[0] === "function") {
+			const draft = deepClone(raw);
+			args[0](draft);
+			updateRaw(draft);
+		} else if (args.length >= 2) {
+			const value = args[args.length - 1];
+			const pathArgs = args.slice(0, -1);
+			const draft = deepClone(raw);
+			applyAtPath(draft, pathArgs, value);
+			updateRaw(draft);
+		}
+	};
+	return [proxy, setStore];
+}
+/**
+* Solid-compatible `reconcile` — replaces the entire store state with the given value.
+* Used with setStore: `setStore(reconcile(newData))`
+*/
+function reconcile(value) {
+	return () => value;
+}
+/**
+* Solid-compatible `unwrap` — returns a deep clone of the store's raw data,
+* stripping the reactive proxy.
+*/
+function unwrap(value) {
+	return deepClone(value);
+}
+/**
+* Solid-compatible `produce` — creates an Immer-like updater function for stores.
+* Returns a function that clones the state, applies mutations, and returns the result.
+*/
+function produce(fn) {
+	return (state) => {
+		const draft = deepClone(state);
+		fn(draft);
+		return draft;
+	};
+}
+/**
+* Solid-compatible `startTransition` — runs a function as a transition.
+* In Pyreon, this is a no-op wrapper that calls the function synchronously.
+*/
+function startTransition(fn) {
+	fn();
+}
+/**
+* Solid-compatible `useTransition` — returns `[isPending, startTransition]`.
+* In Pyreon, transitions are not deferred — isPending is always false.
+*/
+function useTransition() {
+	return [() => false, (fn) => fn()];
+}
+/**
+* Solid-compatible `observable` — converts a signal accessor to an observable.
+* Returns an object with a `subscribe` method that tracks signal changes.
+*/
+function observable(input) {
+	return { subscribe(observer) {
+		const e = effect(() => {
+			observer.next(input());
+		});
+		return { unsubscribe: () => e.dispose() };
+	} };
+}
+/**
+* Solid-compatible `from` — converts an observable or producer into a signal accessor.
+* Accepts either a producer function `(setter) => cleanup` or an observable with `.subscribe()`.
+*/
+function from(producer) {
+	const [value, setValue] = createSignal(void 0);
+	if (typeof producer === "function") onCleanup$1(producer((v) => setValue(() => v)));
+	else {
+		const sub = producer.subscribe({ next: (v) => setValue(() => v) });
+		onCleanup$1(() => sub.unsubscribe());
+	}
+	return value;
+}
+/**
+* Solid-compatible `mapArray` — maps a reactive list by item identity.
+* Each item is a static value, while the index is a reactive accessor.
+*/
+function mapArray(list, mapFn) {
+	return createMemo(() => {
+		return list().map((item, i) => mapFn(item, () => i));
+	});
+}
+/**
+* Solid-compatible `indexArray` — maps a reactive list by index position.
+* Each item is a reactive accessor, while the index is a static number.
+*/
+function indexArray(list, mapFn) {
+	return createMemo(() => {
+		return list().map((item, i) => mapFn(() => item, i));
+	});
+}
+/**
+* Solid-compatible `Index` — like `For` but keyed by index.
+* Items are reactive accessors, indices are static numbers.
+*
+* In Solid, `<Index>` keeps DOM nodes stable per index position.
+* Here we use a computed that maps items to `(item: () => T, index: number)`.
+*/
+function Index(props) {
+	const list = typeof props.each === "function" ? props.each : () => props.each;
+	const mapped = createMemo(() => {
+		return list().map((item, i) => props.children(() => item, i));
+	});
+	return (() => mapped());
+}
+let _uniqueIdCounter = 0;
+/**
+* Solid-compatible `createUniqueId` — returns a unique string identifier.
+*/
+function createUniqueId() {
+	return `solid-${(_uniqueIdCounter++).toString(36)}`;
+}
+/**
+* Solid-compatible `DEV` — an object in dev mode, `undefined` in production.
+* Used for conditional dev-only code: `if (DEV) { ... }`
+*/
+const DEV = import.meta.env?.DEV === true ? {} : void 0;
+/**
+* Solid-compatible `catchError` — wraps a function and catches synchronous errors.
+*/
+function catchError(tryFn, onError) {
+	try {
+		return tryFn();
+	} catch (e) {
+		onError(e instanceof Error ? e : new Error(String(e)));
+		return;
+	}
+}
+/**
+* Solid-compatible `createDeferred` — creates a memo that updates on next idle frame.
+* In Pyreon there is no concurrent scheduling, so this behaves the same as `createMemo`.
+*/
+function createDeferred(fn) {
+	return createMemo(fn);
+}
+/**
+* Solid-compatible `createReaction` — manual tracking primitive.
+* Returns a function that accepts a tracking function. When any tracked
+* dependency changes, `onInvalidate` fires (but only after the first run).
+*/
+function createReaction(onInvalidate) {
+	return (trackingFn) => {
+		let first = true;
+		effect(() => {
+			trackingFn();
+			if (first) {
+				first = false;
+				return;
+			}
+			onInvalidate();
+		});
+	};
+}
 
 //#endregion
-export { ErrorBoundary, For, Match, Show, Suspense, Switch, pyreonBatch as batch, children, createEffect as createComputed, createEffect, pyreonCreateContext as createContext, createMemo, createRenderEffect, createRoot, createSelector, createSignal, getOwner, lazy, mergeProps, on, onCleanup, onMount, runWithOwner, splitProps, runUntracked as untrack, pyreonUseContext as useContext };
+export { DEV, ErrorBoundary, For, Index, Match, Show, Suspense, Switch, pyreonBatch as batch, catchError, children, createEffect as createComputed, createEffect, createContext, createDeferred, createMemo, createReaction, createRenderEffect, createResource, createRoot, createSelector, createSignal, createStore, createUniqueId, from, getOwner, indexArray, lazy, mapArray, mergeProps, observable, on, onCleanup, onMount, produce, reconcile, runWithOwner, splitProps, startTransition, runUntracked as untrack, unwrap, useContext, useTransition };
 //# sourceMappingURL=index.js.map