@tschk/moonshine 0.3.1

package/README.md

@@ -0,0 +1,18 @@
+# `@tschk/moonshine`
+
+Signal-only kernel of the Moonshine framework. Bun-first.
+
+```ts
+import { createSignal, createMemo, createStore, batch } from "@tschk/moonshine";
+import { createApp, useSignal } from "@tschk/moonshine/react";
+import { state, derived, effect } from "@tschk/moonshine/runes";
+```
+
+The default export contains only signals, memos, stores, and resources. Router,
+server, compiler, and deployment packages are separate imports.
+
+Optional compatibility subpaths (`/react`, `/runes`, `/router`, `/server`,
+`/shaders`) remain available during the `0.3.x` line.
+
+See [Moonshine README](../../README.md), [DESIGN.md](../../DESIGN.md), and
+[docs/MANIFEST.md](../../docs/MANIFEST.md).

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@tschk/moonshine",
+  "version": "0.3.1",
+  "description": "Hyperminimal signal runtime — Bun-first; import /react for TSX apps",
+  "license": "ISC",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./react": "./src/react.ts",
+    "./host-react": "./src/host-react.ts",
+    "./runes": "./src/runes.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/jsx-runtime.ts",
+    "./router": "./src/router.ts",
+    "./server": "./src/server.ts",
+    "./shaders": "./src/shaders.ts"
+  },
+  "dependencies": {
+    "@tschk/moonshine-react": "^0.3.1",
+    "@tschk/moonshine-router": "^0.3.1",
+    "@tschk/moonshine-server": "^0.3.1",
+    "@tschk/moonshine-shaders": "^0.3.1"
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "bunx tsc --noEmit",
+    "format": "bunx prettier --check .",
+    "lint": "bunx oxlint ."
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "react": "19.1.0",
+    "react-dom": "19.1.0",
+    "typescript": "7.0.2"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "signals",
+    "moonshine",
+    "bun",
+    "react",
+    "runes"
+  ]
+}

package/src/create-app.ts

@@ -0,0 +1,79 @@
+import { createElement, type ComponentType, type ReactNode } from "react";
+import { createRoot, type Root } from "react-dom/client";
+
+export type MoonshineAppOptions = {
+  /** React root component. */
+  root: ComponentType;
+  /** Optional CSS class applied to the mount host. */
+  className?: string;
+};
+
+export type MoonshineApp = {
+  /** Mount into a DOM container (selector or element). */
+  mount: (container: string | Element) => void;
+  /** Unmount and dispose the React root. */
+  unmount: () => void;
+  /** True after a successful mount and before unmount. */
+  readonly mounted: boolean;
+};
+
+/**
+ * Create a lightweight Moonshine app shell.
+ *
+ * ```ts
+ * const app = createMoonshineApp({ root: App });
+ * app.mount("#app");
+ * ```
+ */
+export function createMoonshineApp(options: MoonshineAppOptions): MoonshineApp {
+  let reactRoot: Root | null = null;
+  let host: Element | null = null;
+  let mounted = false;
+
+  return {
+    get mounted() {
+      return mounted;
+    },
+    mount(container) {
+      if (mounted) {
+        throw new Error("createMoonshineApp: already mounted");
+      }
+
+      const el =
+        typeof container === "string"
+          ? document.querySelector(container)
+          : container;
+      if (!el) {
+        throw new Error(
+          `createMoonshineApp: mount target not found: ${String(container)}`,
+        );
+      }
+
+      host = el;
+      if (options.className) {
+        el.classList.add(...options.className.split(/\s+/).filter(Boolean));
+      }
+
+      reactRoot = createRoot(el);
+      reactRoot.render(createElement(options.root));
+      mounted = true;
+    },
+    unmount() {
+      if (!mounted || !reactRoot) return;
+      reactRoot.unmount();
+      reactRoot = null;
+      if (host && options.className) {
+        for (const cls of options.className.split(/\s+/).filter(Boolean)) {
+          host.classList.remove(cls);
+        }
+      }
+      host = null;
+      mounted = false;
+    },
+  };
+}
+
+/** @internal helper for tests / SSR stubs that only need an element tree. */
+export function renderToNode(root: ComponentType): ReactNode {
+  return createElement(root);
+}

package/src/host-react.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared React-host surface for framework adapters.
+ * Signals + hooks + resources + runes + jsx. No host router.
+ */
+export {
+  batch,
+  createMemo,
+  createSignal,
+  createStore,
+  untrack,
+} from "./signal";
+export type { Memo, Signal, StoreSetter } from "./signal";
+
+export { createResource } from "./resource";
+export type {
+  CreateResourceOptions,
+  Resource,
+  ResourceStatus,
+} from "./resource";
+
+export {
+  createApp,
+  createIslandSignal,
+  createMoonshineApp,
+  renderToNode,
+  useResource,
+  useSignal,
+  useStore,
+} from "./react";
+export type { MoonshineApp, MoonshineAppOptions } from "./react";
+
+export { jsx, jsxs, Fragment } from "./jsx-runtime";
+export type { JSX } from "./jsx-runtime";
+
+export { state, derived, effect } from "./runes";

package/src/index.ts

@@ -0,0 +1,28 @@
+/**
+ * @tschk/moonshine — hyperminimal signal runtime (no React).
+ *
+ * Import what you need:
+ *   import { createSignal, createMemo } from "@tschk/moonshine"
+ *   import { createApp, useSignal } from "@tschk/moonshine/react"
+ *   import { state, derived, effect } from "@tschk/moonshine/runes"
+ *   import { MoonshineRouter } from "@tschk/moonshine/router"
+ *   import { createMoonshineServer } from "@tschk/moonshine/server"
+ *   import { useFragmentShader } from "@tschk/moonshine/shaders"
+ */
+
+export {
+  batch,
+  createMemo,
+  createSignal,
+  createStore,
+  getStoreRoot,
+  untrack,
+} from "./signal";
+export type { Memo, Signal, StoreSetter } from "./signal";
+
+export { createResource } from "./resource";
+export type {
+  CreateResourceOptions,
+  Resource,
+  ResourceStatus,
+} from "./resource";

package/src/jsx-runtime.ts

@@ -0,0 +1,14 @@
+/**
+ * Thin JSX runtime re-export.
+ *
+ * Moonshine apps use the React JSX transform. Point TypeScript `jsxImportSource`
+ * at `@tschk/moonshine` (or import from `@tschk/moonshine/jsx-runtime`).
+ * The runtime itself is React's — use only when building TSX apps.
+ *
+ * tsconfig:
+ * ```json
+ * { "compilerOptions": { "jsx": "react-jsx", "jsxImportSource": "@tschk/moonshine" } }
+ * ```
+ */
+export { jsx, jsxs, Fragment } from "react/jsx-runtime";
+export type { JSX } from "react/jsx-runtime";

package/src/react.ts

@@ -0,0 +1,8 @@
+/**
+ * React bridge for `@tschk/moonshine`.
+ *
+ * ```ts
+ * import { createApp, useSignal, createSignal } from "@tschk/moonshine/react";
+ * ```
+ */
+export * from "@tschk/moonshine-react";

package/src/resource.ts

@@ -0,0 +1,82 @@
+import { createSignal, type Signal } from "./signal";
+
+export type ResourceStatus = "pending" | "ready" | "errored";
+
+export type Resource<T> = {
+  /** Current value (undefined until first success unless `initial` set). */
+  (): T | undefined;
+  /** true while a fetch is in flight. */
+  loading: Signal<boolean>;
+  /** Last error, if any. */
+  error: Signal<Error | undefined>;
+  /** Coarse status. */
+  status: Signal<ResourceStatus>;
+  /** Re-run the fetcher. */
+  refetch: () => Promise<T | undefined>;
+  peek: () => T | undefined;
+  subscribe: (listener: () => void) => () => void;
+};
+
+export type CreateResourceOptions<T> = {
+  /** Seed value before first fetch settles. */
+  initial?: T;
+  /** If false, do not fetch until `refetch()` (default true). */
+  immediate?: boolean;
+  /** Invoked when fetcher throws. */
+  onError?: (error: Error) => void;
+};
+
+/**
+ * Async resource backed by moonshine signals (Solid-inspired).
+ *
+ * ```ts
+ * const users = createResource(() => fetch("/api/users").then((r) => r.json()));
+ * users();           // data
+ * users.loading();   // boolean
+ * await users.refetch();
+ * ```
+ */
+export function createResource<T>(
+  fetcher: () => Promise<T>,
+  options: CreateResourceOptions<T> = {},
+): Resource<T> {
+  const data = createSignal<T | undefined>(options.initial);
+  const loading = createSignal(false);
+  const error = createSignal<Error | undefined>(undefined);
+  const status = createSignal<ResourceStatus>(
+    options.initial !== undefined ? "ready" : "pending",
+  );
+
+  const refetch = async (): Promise<T | undefined> => {
+    loading.set(true);
+    status.set("pending");
+    error.set(undefined);
+    try {
+      const value = await fetcher();
+      data.set(() => value);
+      status.set("ready");
+      return value;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      error.set(err);
+      status.set("errored");
+      options.onError?.(err);
+      return undefined;
+    } finally {
+      loading.set(false);
+    }
+  };
+
+  if (options.immediate !== false) {
+    void refetch();
+  }
+
+  const read = (() => data()) as Resource<T>;
+  read.loading = loading;
+  read.error = error;
+  read.status = status;
+  read.refetch = refetch;
+  read.peek = () => data.peek();
+  read.subscribe = data.subscribe;
+  return read;
+}

package/src/router.ts

@@ -0,0 +1,74 @@
+import type { ReactNode } from "react";
+import {
+  compilePattern,
+  createRouteGraph,
+  matchRoutes as matchRoutesOnGraph,
+  createMoonshineRouter,
+  navigate,
+  getLocation,
+  useLocation,
+  useParams,
+  useNavigate,
+  useRouter,
+  MoonshineRouter,
+  Link,
+  type MoonshineRouterProps,
+  type MoonshineRouterInstance,
+} from "@tschk/moonshine-router";
+
+export type RouteParams = Record<string, string>;
+
+export type RouteMatch = {
+  path: string;
+  pattern: string;
+  params: RouteParams;
+};
+
+export type RouteDefinition = {
+  /** Path pattern, e.g. `/`, `/about`, `/users/:id`. */
+  path: string;
+  element: ReactNode;
+};
+
+/** Compile `/users/:id` → matcher with named params. */
+export function matchPath(
+  pattern: string,
+  pathname: string,
+): RouteMatch | null {
+  const compiled = compilePattern(pattern);
+  const result = compiled.match(pathname);
+  if (!result) return null;
+  return { path: pathname, pattern, params: result.params };
+}
+
+/** Resolve first matching route definition. */
+export function matchRoutes(
+  routes: RouteDefinition[],
+  pathname: string,
+): (RouteMatch & { element: ReactNode }) | null {
+  const graph = createRouteGraph(
+    routes.map((route) => ({ ...route, id: route.path, file: "" })),
+  );
+  const match = matchRoutesOnGraph(graph, pathname);
+  if (!match) return null;
+  return {
+    path: match.path,
+    pattern: match.pattern,
+    params: match.params,
+    element: match.route.element,
+  };
+}
+
+export {
+  createMoonshineRouter,
+  navigate,
+  getLocation,
+  useLocation,
+  useParams,
+  useNavigate,
+  useRouter,
+  MoonshineRouter,
+  Link,
+  type MoonshineRouterProps,
+  type MoonshineRouterInstance,
+};

package/src/runes.ts

@@ -0,0 +1,72 @@
+/**
+ * Svelte-inspired approachability sugar over moonshine signals.
+ * Thin aliases — not real compiler runes.
+ *
+ * ```ts
+ * import { state, derived, effect } from "@tschk/moonshine/runes";
+ * ```
+ */
+import {
+  collectDeps,
+  createMemo,
+  createSignal,
+  type Memo,
+  type Signal,
+} from "./signal";
+
+/** Alias for `createSignal` — readable `$state`-like naming. */
+export function state<T>(initial: T): Signal<T> {
+  return createSignal(initial);
+}
+
+/** Alias for `createMemo` — readable `$derived`-like naming. */
+export function derived<T>(fn: () => T): Memo<T> {
+  return createMemo(fn);
+}
+
+/**
+ * Run `fn` now and again whenever tracked signal/memo/store deps change.
+ * Returns an unsubscribe function.
+ *
+ * Dep tracking uses the same tracker as `createMemo` (reads during `fn`).
+ */
+export function effect(fn: () => void): () => void {
+  let unsubs: Array<() => void> = [];
+  let disposed = false;
+  let scheduled = false;
+
+  const run = () => {
+    for (const u of unsubs.splice(0)) u();
+    if (disposed) return;
+
+    const deps = collectDeps(fn);
+    for (const dep of deps) {
+      unsubs.push(
+        dep.subscribe(() => {
+          if (disposed || scheduled) return;
+          scheduled = true;
+          queueMicrotask(() => {
+            scheduled = false;
+            if (!disposed) run();
+          });
+        }),
+      );
+    }
+  };
+
+  run();
+
+  return () => {
+    disposed = true;
+    for (const u of unsubs.splice(0)) u();
+  };
+}
+
+export {
+  createSignal,
+  createMemo,
+  createStore,
+  batch,
+  untrack,
+} from "./signal";
+export type { Signal, Memo, StoreSetter } from "./signal";

package/src/server.ts

@@ -0,0 +1,196 @@
+/**
+ * Light server-entry helpers.
+ *
+ * Thin page-module table on top of Bun.serve (or any fetch handler).
+ * Greenfield HTTP path — no metaframework required.
+ */
+
+import {
+  callAction,
+  callLoader,
+  createRequestHandler,
+  createRouteContext,
+  errorResponse,
+  json,
+  redirect,
+  Redirect,
+  resolveStaticPath,
+  serializeData,
+  tryServeStatic,
+  type Action,
+  type ErrorBoundary,
+  type Loader,
+  type Middleware,
+  type RequestHandlerOptions,
+  type RouteContext,
+  type RouteModule,
+} from "@tschk/moonshine-server";
+
+export type MoonshineRequest = {
+  url: string;
+  method: string;
+  headers: Headers;
+  pathname: string;
+  searchParams: URLSearchParams;
+};
+
+export type MoonshinePageModule = {
+  /** Optional data loader hook. */
+  getConfig?: () => Promise<Record<string, unknown>> | Record<string, unknown>;
+  /** Render body for the path. May return a string (HTML), Response, or JSON-able. */
+  render: (req: MoonshineRequest) => Promise<unknown> | unknown;
+};
+
+export type MoonshineServerOptions = {
+  /** Map of pathname → page module (file-ish routing table). */
+  pages: Record<string, MoonshinePageModule>;
+  /** Called when no page or static file matches. */
+  notFound?: (req: MoonshineRequest) => Promise<Response> | Response;
+  /** Port for `Bun.serve` helper (default 3000). */
+  port?: number;
+  /**
+   * Directory of static assets (CSS/JS/images). Checked before pages.
+   * Path traversal outside the directory is rejected.
+   */
+  staticDir?: string;
+};
+
+/** Normalize a Fetch API Request into a Moonshine request bag. */
+export function toMoonshineRequest(request: Request): MoonshineRequest {
+  const url = new URL(request.url);
+  return {
+    url: request.url,
+    method: request.method,
+    headers: request.headers,
+    pathname: url.pathname.replace(/\/+$/, "") || "/",
+    searchParams: url.searchParams,
+  };
+}
+
+/**
+ * Resolve a page module for a pathname.
+ * Supports exact keys and a trailing `/*` splat prefix.
+ */
+export function resolvePage(
+  pages: Record<string, MoonshinePageModule>,
+  pathname: string,
+): MoonshinePageModule | null {
+  if (pages[pathname]) return pages[pathname]!;
+  if (pages["/"] && pathname === "") return pages["/"]!;
+
+  let best: { key: string; mod: MoonshinePageModule } | null = null;
+  for (const [key, mod] of Object.entries(pages)) {
+    if (!key.endsWith("/*")) continue;
+    const prefix = key.slice(0, -1);
+    const base = prefix.endsWith("/") ? prefix.slice(0, -1) || "/" : prefix;
+    if (
+      pathname === base ||
+      pathname.startsWith(base === "/" ? "/" : `${base}/`)
+    ) {
+      if (!best || key.length > best.key.length) best = { key, mod };
+    }
+  }
+  return best?.mod ?? null;
+}
+
+/** Handle one request against static dir + pages table. */
+export async function handleMoonshineRequest(
+  request: Request,
+  options: Pick<MoonshineServerOptions, "pages" | "notFound" | "staticDir">,
+): Promise<Response> {
+  const req = toMoonshineRequest(request);
+
+  if (options.staticDir && req.method === "GET" && req.pathname !== "/") {
+    const staticRes = await tryServeStatic(options.staticDir, req.pathname);
+    if (staticRes) return staticRes;
+  }
+
+  const page = resolvePage(options.pages, req.pathname);
+
+  if (!page) {
+    if (options.notFound) return options.notFound(req);
+    return new Response("Not Found", { status: 404 });
+  }
+
+  const body = await page.render(req);
+  if (body instanceof Response) return body;
+  if (typeof body === "string") {
+    return new Response(body, {
+      headers: { "content-type": "text/html; charset=utf-8" },
+    });
+  }
+  return new Response(JSON.stringify(body), {
+    headers: { "content-type": "application/json; charset=utf-8" },
+  });
+}
+
+export type MoonshineServer = {
+  fetch: (request: Request) => Promise<Response>;
+  /** Start Bun.serve when running under Bun; returns the server handle. */
+  listen: () => unknown;
+  port: number;
+};
+
+/**
+ * Create a Bun-first server entry from a pages map (+ optional static dir).
+ *
+ * ```ts
+ * const server = createMoonshineServer({
+ *   staticDir: "./public",
+ *   pages: {
+ *     "/": { render: () => "<h1>Home</h1><script type=module src=/client.js></script>" },
+ *   },
+ * });
+ * server.listen();
+ * ```
+ */
+export function createMoonshineServer(
+  options: MoonshineServerOptions,
+): MoonshineServer {
+  const port = options.port ?? 3000;
+
+  const fetch = (request: Request) => handleMoonshineRequest(request, options);
+
+  return {
+    fetch,
+    port,
+    listen() {
+      if (typeof Bun === "undefined") {
+        throw new Error("createMoonshineServer.listen() requires Bun");
+      }
+      return Bun.serve({
+        port,
+        fetch,
+      });
+    },
+  };
+}
+
+/** Define a page module with inference-friendly typing. */
+export function definePage(page: MoonshinePageModule): MoonshinePageModule {
+  return page;
+}
+
+export {
+  callAction,
+  callLoader,
+  createRequestHandler,
+  createRouteContext,
+  errorResponse,
+  json,
+  redirect,
+  Redirect,
+  resolveStaticPath,
+  serializeData,
+  tryServeStatic,
+};
+
+export type {
+  Action,
+  ErrorBoundary,
+  Loader,
+  Middleware,
+  RequestHandlerOptions,
+  RouteContext,
+  RouteModule,
+};

package/src/shaders.ts

@@ -0,0 +1,13 @@
+/**
+ * Compat re-export — prefer `@tschk/moonshine-shaders`.
+ * Kept so existing `@tschk/moonshine/shaders` imports keep working.
+ */
+export {
+  createFullscreenFragment,
+  useFragmentShader,
+  wrapFragmentSource,
+} from "@tschk/moonshine-shaders";
+export type {
+  FragmentShaderHandle,
+  UseFragmentShaderOptions,
+} from "@tschk/moonshine-shaders";

package/src/signal.ts

@@ -0,0 +1,357 @@
+type Listener = () => void;
+
+export type Trackable = {
+  subscribe: (listener: Listener) => () => void;
+};
+
+/**
+ * A node in the reactive graph.
+ *
+ * `version` changes only when the node's *value* changes, which lets a consumer
+ * tell "something upstream fired" apart from "my input actually differs".
+ * `validate` brings the node's cached value up to date on demand, so reads pull
+ * rather than writes pushing all the way down.
+ */
+type Source = Trackable & {
+  version: number;
+  validate: () => void;
+};
+
+/**
+ * Bumped once per write anywhere in the graph. A node that already validated at
+ * the current epoch cannot be stale, so repeated reads stay O(1).
+ */
+let epoch = 0;
+/** Monotonic stamp handed out whenever a node's value actually changes. */
+let versionCounter = 0;
+
+let batchDepth = 0;
+const pending = new Set<Listener>();
+let currentTracker: ((dep: Source) => void) | null = null;
+
+/** Coalesce nested writes into one subscriber flush. */
+export function batch(fn: () => void): void {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0 && pending.size > 0) {
+      const queue = [...pending];
+      pending.clear();
+      for (const listener of queue) listener();
+    }
+  }
+}
+
+function notifyListeners(listeners: Set<Listener>): void {
+  if (batchDepth > 0) {
+    for (const listener of listeners) pending.add(listener);
+    return;
+  }
+  for (const listener of Array.from(listeners)) listener();
+}
+
+function track(dep: Source): void {
+  currentTracker?.(dep);
+}
+
+/** Read without subscribing the enclosing memo or effect to what you touch. */
+export function untrack<T>(fn: () => T): T {
+  const previous = currentTracker;
+  currentTracker = null;
+  try {
+    return fn();
+  } finally {
+    currentTracker = previous;
+  }
+}
+
+/**
+ * Run `fn` while collecting signal/memo/store deps via the active tracker.
+ * Used by `@tschk/moonshine/runes` `effect`.
+ */
+export function collectDeps(fn: () => void): Trackable[] {
+  const deps: Trackable[] = [];
+  const seen = new Set<Trackable>();
+  const previous = currentTracker;
+  currentTracker = (dep) => {
+    if (seen.has(dep)) return;
+    seen.add(dep);
+    deps.push(dep);
+  };
+  try {
+    fn();
+  } finally {
+    currentTracker = previous;
+  }
+  return deps;
+}
+
+export type Signal<T> = {
+  (): T;
+  set: (value: T | ((prev: T) => T)) => void;
+  peek: () => T;
+  subscribe: (listener: Listener) => () => void;
+};
+
+/**
+ * Solid-inspired signal: read by calling, write via `.set`.
+ * React apps subscribe with `useSignal` from `@tschk/moonshine/react`.
+ */
+export function createSignal<T>(initial: T): Signal<T> {
+  let value = initial;
+  const listeners = new Set<Listener>();
+  const node: Source = {
+    version: ++versionCounter,
+    validate: () => {},
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+  };
+
+  const read = (() => {
+    track(node);
+    return value;
+  }) as Signal<T>;
+
+  read.set = (next) => {
+    const resolved =
+      typeof next === "function" ? (next as (prev: T) => T)(value) : next;
+    if (Object.is(resolved, value)) return;
+    value = resolved;
+    node.version = ++versionCounter;
+    epoch++;
+    notifyListeners(listeners);
+  };
+  read.peek = () => value;
+  read.subscribe = node.subscribe;
+
+  return read;
+}
+
+export type Memo<T> = {
+  (): T;
+  peek: () => T;
+  subscribe: (listener: Listener) => () => void;
+};
+
+/**
+ * Derived value that recomputes when tracked dependencies change.
+ * Any `createSignal` / `createMemo` read during `compute` is tracked.
+ *
+ * Recomputation is pull-based: an unread memo with no subscribers costs nothing
+ * when its sources change, and a memo validates its whole dependency chain
+ * before answering, so it never reports a half-updated view of the graph.
+ */
+export function createMemo<T>(compute: () => T): Memo<T> {
+  const listeners = new Set<Listener>();
+  let deps: Array<{ node: Source; version: number }> = [];
+  const unsubs: Array<() => void> = [];
+  let value!: T;
+  let hasValue = false;
+  let stale = true;
+  let checkedAt = -1;
+
+  const node: Source = {
+    version: ++versionCounter,
+    validate: () => validate(),
+    subscribe: (listener) => {
+      // Dependencies are only observed while somebody is listening, so the
+      // push path exists solely to serve real subscribers.
+      validate();
+      listeners.add(listener);
+      if (listeners.size === 1) observe();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) unobserve();
+      };
+    },
+  };
+
+  function observe(): void {
+    for (const unsub of unsubs.splice(0)) unsub();
+    for (const dep of deps) unsubs.push(dep.node.subscribe(onDepChange));
+  }
+
+  function unobserve(): void {
+    for (const unsub of unsubs.splice(0)) unsub();
+  }
+
+  function onDepChange(): void {
+    const before = node.version;
+    validate();
+    // Only wake downstream when the derived value actually moved.
+    if (node.version !== before) notifyListeners(listeners);
+  }
+
+  function recompute(): void {
+    const collected: Array<{ node: Source; version: number }> = [];
+    const seen = new Set<Source>();
+    const previous = currentTracker;
+    currentTracker = (dep) => {
+      if (seen.has(dep)) return;
+      seen.add(dep);
+      collected.push({ node: dep, version: dep.version });
+    };
+
+    let next: T;
+    try {
+      next = compute();
+    } finally {
+      currentTracker = previous;
+    }
+
+    deps = collected;
+    stale = false;
+    if (listeners.size > 0) observe();
+
+    if (!hasValue || !Object.is(next, value)) {
+      value = next;
+      hasValue = true;
+      node.version = ++versionCounter;
+    }
+  }
+
+  function validate(): void {
+    if (!stale && checkedAt === epoch) return;
+    checkedAt = epoch;
+    if (!stale) {
+      let changed = false;
+      for (const dep of deps) {
+        dep.node.validate();
+        if (dep.node.version !== dep.version) {
+          changed = true;
+          break;
+        }
+      }
+      if (!changed) return;
+    }
+    recompute();
+  }
+
+  const read = (() => {
+    // Validate before tracking, so the enclosing memo records the version this
+    // node settles on rather than the one it is about to leave behind.
+    validate();
+    track(node);
+    return value;
+  }) as Memo<T>;
+
+  read.peek = () => {
+    validate();
+    return value;
+  };
+  read.subscribe = node.subscribe;
+
+  return read;
+}
+
+export type StoreSetter<T extends object> = (fn: (state: T) => void) => void;
+
+const storeRoots = new WeakMap<object, Trackable>();
+
+/** Resolve the trackable root for a `createStore` proxy (used by `/react` hooks). */
+export function getStoreRoot(store: object): Trackable | undefined {
+  return storeRoots.get(store);
+}
+
+/**
+ * Plain objects and arrays are the only things worth proxying. Wrapping a Date,
+ * Map or class instance would hand its methods a proxy as `this`, which breaks
+ * every implementation that reaches for internal slots.
+ */
+function isWrappable(value: unknown): value is object {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return (
+    proto === Object.prototype || proto === Array.prototype || proto === null
+  );
+}
+
+/**
+ * Copy the caller's plain structure so later mutations go through the proxy,
+ * and pass everything else through by reference. `structuredClone` throws on
+ * functions and DOM nodes, and silently flattens class instances.
+ */
+function clone<V>(value: V): V {
+  if (Array.isArray(value)) return value.map((entry) => clone(entry)) as V;
+  if (isWrappable(value)) {
+    const out: Record<string, unknown> = {};
+    for (const [key, entry] of Object.entries(value)) out[key] = clone(entry);
+    return out as V;
+  }
+  return value;
+}
+
+/**
+ * Nested reactive store (Solid-inspired).
+ * Mutate through the proxy (or `setStore`) to notify subscribers.
+ */
+export function createStore<T extends object>(initial: T): [T, StoreSetter<T>] {
+  const listeners = new Set<Listener>();
+  const state = clone(initial);
+
+  const node: Source = {
+    version: ++versionCounter,
+    validate: () => {},
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+  };
+
+  const notify = () => {
+    node.version = ++versionCounter;
+    epoch++;
+    notifyListeners(listeners);
+  };
+
+  // Cached so `store.user === store.user`, which React dependency arrays and
+  // `React.memo` both compare by identity.
+  const proxies = new WeakMap<object, object>();
+
+  const wrap = <V extends object>(target: V): V => {
+    const cached = proxies.get(target);
+    if (cached) return cached as V;
+    const proxy = new Proxy(target, {
+      get(obj, prop, receiver) {
+        track(node);
+        const value = Reflect.get(obj, prop, receiver);
+        if (isWrappable(value)) return wrap(value);
+        return value;
+      },
+      set(obj, prop, value, receiver) {
+        const prev = Reflect.get(obj, prop, receiver);
+        if (Object.is(prev, value)) return true;
+        const ok = Reflect.set(obj, prop, value, receiver);
+        if (ok) notify();
+        return ok;
+      },
+      deleteProperty(obj, prop) {
+        if (!Object.prototype.hasOwnProperty.call(obj, prop)) return true;
+        const ok = Reflect.deleteProperty(obj, prop);
+        if (ok) notify();
+        return ok;
+      },
+    });
+    proxies.set(target, proxy);
+    return proxy;
+  };
+
+  const proxy = wrap(state);
+  storeRoots.set(proxy, node);
+
+  const setStore: StoreSetter<T> = (fn) => {
+    batch(() => {
+      fn(proxy);
+    });
+  };
+
+  return [proxy, setStore];
+}