@tschk/moonshine 0.4.0 → 0.4.4

package/README.md

@@ -11,8 +11,15 @@ 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.
+Installing the kernel installs no runtime dependencies. Compatibility subpaths
+use optional peers: install `@tschk/moonshine-react`, `@tschk/moonshine-router`,
+`@tschk/moonshine-server`, or `@tschk/moonshine-shaders` when using its matching
+subpath. `/runes` needs no extra package. The React bridge also needs `react` and
+`react-dom`.
+
+The opt-in `/tracking` entry exposes dependency collection for native schedulers.
+It can observe first-read versions and preserve an enclosing memo's dependencies;
+it adds no scheduling or rendering behavior to the default kernel.
 
 See [Moonshine README](../../README.md), [DESIGN.md](../../DESIGN.md), and
 [docs/MANIFEST.md](../../docs/MANIFEST.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tschk/moonshine",
-  "version": "0.4.0",
+  "version": "0.4.4",
   "description": "Hyperminimal signal runtime — Bun-first; import /react for TSX apps",
   "license": "ISC",
   "type": "module",
@@ -11,18 +11,13 @@
     "./react": "./src/react.ts",
     "./host-react": "./src/host-react.ts",
     "./runes": "./src/runes.ts",
+    "./tracking": "./src/tracking.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.6",
-    "@tschk/moonshine-router": "^0.3.6",
-    "@tschk/moonshine-server": "^0.3.6",
-    "@tschk/moonshine-shaders": "^0.3.6"
-  },
   "scripts": {
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
@@ -30,10 +25,26 @@
     "lint": "bunx oxlint ."
   },
   "peerDependencies": {
+    "@tschk/moonshine-react": "^0.4.4",
+    "@tschk/moonshine-router": "^0.4.4",
+    "@tschk/moonshine-server": "^0.4.4",
+    "@tschk/moonshine-shaders": "^0.4.4",
     "react": ">=18",
     "react-dom": ">=18"
   },
   "peerDependenciesMeta": {
+    "@tschk/moonshine-react": {
+      "optional": true
+    },
+    "@tschk/moonshine-router": {
+      "optional": true
+    },
+    "@tschk/moonshine-server": {
+      "optional": true
+    },
+    "@tschk/moonshine-shaders": {
+      "optional": true
+    },
     "react": {
       "optional": true
     },
@@ -45,8 +56,6 @@
     "@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": [

package/src/index.ts

@@ -6,8 +6,6 @@
  *   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 {

package/src/resource.ts

@@ -1,4 +1,4 @@
-import { createSignal, type Signal } from "./signal";
+import { batch, createSignal, type Signal } from "./signal";
 
 export type ResourceStatus = "pending" | "ready" | "errored";
 
@@ -47,24 +47,37 @@ export function createResource<T>(
     options.initial !== undefined ? "ready" : "pending",
   );
 
+  let generation = 0;
+
   const refetch = async (): Promise<T | undefined> => {
-    loading.set(true);
-    status.set("pending");
-    error.set(undefined);
+    const current = ++generation;
+    batch(() => {
+      loading.set(true);
+      status.set("pending");
+      error.set(undefined);
+    });
+    let value: T;
     try {
-      const value = await fetcher();
-      data.set(() => value);
-      status.set("ready");
-      return value;
+      value = await fetcher();
     } catch (e) {
+      if (current !== generation) return data.peek();
       const err = e instanceof Error ? e : new Error(String(e));
-      error.set(err);
-      status.set("errored");
+      batch(() => {
+        error.set(err);
+        status.set("errored");
+        loading.set(false);
+      });
       options.onError?.(err);
       return undefined;
-    } finally {
-      loading.set(false);
     }
+    if (current !== generation) return data.peek();
+    // Subscriber failures reject refetch without reclassifying a successful fetch.
+    batch(() => {
+      data.set(() => value);
+      status.set("ready");
+      loading.set(false);
+    });
+    return value;
   };
 
   if (options.immediate !== false) {

package/src/router.ts

@@ -7,6 +7,7 @@ import {
   navigate,
   getLocation,
   useLocation,
+  useHistory,
   useParams,
   useNavigate,
   useRouter,
@@ -66,6 +67,7 @@ export {
   navigate,
   getLocation,
   useLocation,
+  useHistory,
   useParams,
   useNavigate,
   useRouter,

package/src/server.ts

@@ -100,8 +100,17 @@ export async function handleMoonshineRequest(
 ): Promise<Response> {
   const req = toMoonshineRequest(request);
 
-  if (options.staticDir && req.method === "GET" && req.pathname !== "/") {
-    const staticRes = await tryServeStatic(options.staticDir, req.pathname);
+  if (
+    options.staticDir &&
+    (req.method === "GET" || req.method === "HEAD") &&
+    req.pathname !== "/"
+  ) {
+    const staticRes = await tryServeStatic(
+      options.staticDir,
+      req.pathname,
+      undefined,
+      request.method,
+    );
     if (staticRes) return staticRes;
   }
 

package/src/signal.ts

@@ -3,6 +3,7 @@ type Listener = () => void;
 export type Trackable = {
   subscribe: (listener: Listener) => () => void;
   version: number;
+  validate?: () => void;
 };
 
 /**
@@ -15,6 +16,7 @@ export type Trackable = {
  */
 type Source = Trackable & {
   validate: () => void;
+  subscribe: (listener: Listener, request?: InvalidationRequest) => () => void;
 };
 
 /**
@@ -32,16 +34,41 @@ let currentTracker: ((dep: Source) => void) | null = null;
 /** Coalesce nested writes into one subscriber flush. */
 export function batch(fn: () => void): void {
   batchDepth++;
+  let failed = false;
+  let failure: unknown;
   try {
     fn();
-  } finally {
-    batchDepth--;
-    if (batchDepth === 0 && pending.size > 0) {
-      const queue = [...pending];
-      pending.clear();
-      for (const listener of queue) listener();
+  } catch (error) {
+    failed = true;
+    failure = error;
+  }
+  batchDepth--;
+  if (batchDepth === 0 && pending.size > 0) {
+    const queue = [...pending];
+    pending.clear();
+    try {
+      flushListeners(queue);
+    } catch (error) {
+      // A callback failure takes precedence over notification failures.
+      if (!failed) failure = error;
+      failed = true;
     }
   }
+  if (failed) throw failure;
+}
+
+function flushListeners(listeners: Iterable<Listener>): void {
+  let failed = false;
+  let failure: unknown;
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch (error) {
+      if (!failed) failure = error;
+      failed = true;
+    }
+  }
+  if (failed) throw failure;
 }
 
 function notifyListeners(listeners: Set<Listener>): void {
@@ -49,13 +76,18 @@ function notifyListeners(listeners: Set<Listener>): void {
     for (const listener of listeners) pending.add(listener);
     return;
   }
-  for (const listener of Array.from(listeners)) listener();
+  flushListeners(Array.from(listeners));
 }
 
 function track(dep: Source): void {
   currentTracker?.(dep);
 }
 
+/** Whether a synchronous dependency collector is currently active. */
+export function isTracking(): boolean {
+  return currentTracker !== null;
+}
+
 /** Read without subscribing the enclosing memo or effect to what you touch. */
 export function untrack<T>(fn: () => T): T {
   const previous = currentTracker;
@@ -69,9 +101,14 @@ export function untrack<T>(fn: () => T): T {
 
 /**
  * Run `fn` while collecting signal/memo/store deps via the active tracker.
- * Used by `@tschk/moonshine/runes` `effect`.
+ * Opt-in schedulers observe first-read versions; derived values can retain the
+ * enclosing memo's graph by propagating dependencies to its tracker.
  */
-export function collectDeps(fn: () => void): Trackable[] {
+export function collectDeps(
+  fn: () => void,
+  onTrack?: (dependency: Trackable) => void,
+  propagate = false,
+): Trackable[] {
   const deps: Trackable[] = [];
   const seen = new Set<Trackable>();
   const previous = currentTracker;
@@ -79,6 +116,8 @@ export function collectDeps(fn: () => void): Trackable[] {
     if (seen.has(dep)) return;
     seen.add(dep);
     deps.push(dep);
+    if (propagate) previous?.(dep);
+    if (onTrack) untrack(() => onTrack(dep));
   };
   try {
     fn();
@@ -105,7 +144,8 @@ export function createSignal<T>(initial: T): Signal<T> {
   const node: Source = {
     version: ++versionCounter,
     validate: () => {},
-    subscribe: (listener) => {
+    subscribe: (listener: Listener, request?: InvalidationRequest) => {
+      if (request) return request.accept(node, undefined, listeners);
       listeners.add(listener);
       return () => {
         listeners.delete(listener);
@@ -125,7 +165,11 @@ export function createSignal<T>(initial: T): Signal<T> {
     value = resolved;
     node.version = ++versionCounter;
     epoch++;
-    notifyListeners(listeners);
+    if (invalidationRegistry)
+      invalidationRegistry.commit(node, node.version, () =>
+        notifyListeners(listeners),
+      );
+    else notifyListeners(listeners);
   };
   read.peek = () => value;
   read.subscribe = node.subscribe;
@@ -139,95 +183,83 @@ export type Memo<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));
-  }
+type MemoState<T> = {
+  compute: () => T;
+  listeners: Set<Listener>;
+  deps: Array<{ node: Source; version: number }>;
+  unsubs: Array<() => void>;
+  value: T;
+  hasValue: boolean;
+  stale: boolean;
+  checkedAt: number;
+  node: Source;
+  onDepChange: () => void;
+};
 
-  function unobserve(): void {
-    for (const unsub of unsubs.splice(0)) unsub();
+function memoObserve<T>(state: MemoState<T>): void {
+  for (const unsub of state.unsubs) unsub();
+  state.unsubs.length = 0;
+  for (const dep of state.deps) {
+    state.unsubs.push(dep.node.subscribe(state.onDepChange));
   }
+}
 
-  function onDepChange(): void {
-    const before = node.version;
-    validate();
-    // Only wake downstream when the derived value actually moved.
-    if (node.version !== before) notifyListeners(listeners);
-  }
+function memoUnobserve<T>(state: MemoState<T>): void {
+  for (const unsub of state.unsubs) unsub();
+  state.unsubs.length = 0;
+}
 
-  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 });
-    };
+function memoOnDepChange<T>(state: MemoState<T>): void {
+  const before = state.node.version;
+  memoValidate(state);
+  // Only wake downstream when the derived value actually moved.
+  if (state.node.version !== before) notifyListeners(state.listeners);
+}
 
-    let next: T;
-    try {
-      next = compute();
-    } finally {
-      currentTracker = previous;
-    }
+function memoRecompute<T>(state: MemoState<T>): 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 });
+  };
 
-    // Re-subscribing tears down and rebuilds the whole upstream chain, so only
-    // do it when the dependency set actually moved.
-    const sameDeps =
-      collected.length === deps.length &&
-      collected.every((entry, index) => entry.node === deps[index]!.node);
+  let next: T;
+  try {
+    next = state.compute();
+  } finally {
+    currentTracker = previous;
+  }
 
-    deps = collected;
-    stale = false;
-    if (listeners.size > 0 && (!sameDeps || unsubs.length === 0)) observe();
+  // Re-subscribing tears down and rebuilds the whole upstream chain, so only
+  // do it when the dependency set actually moved.
+  const sameDeps =
+    collected.length === state.deps.length &&
+    collected.every((entry, index) => entry.node === state.deps[index]!.node);
+
+  state.deps = collected;
+  invalidationRegistry?.dependencies(state.node, collected);
+  state.stale = false;
+  if (state.listeners.size > 0 && (!sameDeps || state.unsubs.length === 0)) {
+    memoObserve(state);
+  }
 
-    if (!hasValue || !Object.is(next, value)) {
-      value = next;
-      hasValue = true;
-      node.version = ++versionCounter;
-    }
+  if (!state.hasValue || !Object.is(next, state.value)) {
+    state.value = next;
+    state.hasValue = true;
+    state.node.version = ++versionCounter;
   }
+}
 
-  function validate(): void {
-    if (!stale && checkedAt === epoch) return;
-    checkedAt = epoch;
-    if (!stale) {
+function memoValidate<T>(state: MemoState<T>): void {
+  if (!state.stale && state.checkedAt === epoch) return;
+  state.checkedAt = epoch;
+  try {
+    if (!state.stale) {
       let changed = false;
-      for (const dep of deps) {
+      for (const dep of state.deps) {
         dep.node.validate();
         if (dep.node.version !== dep.version) {
           changed = true;
@@ -236,22 +268,66 @@ export function createMemo<T>(compute: () => T): Memo<T> {
       }
       if (!changed) return;
     }
-    recompute();
+    memoRecompute(state);
+  } catch (error) {
+    // Failed validation must retry, never serve the old value at this epoch.
+    state.checkedAt = -1;
+    throw error;
   }
+}
+
+/**
+ * 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 state = {
+    compute,
+    listeners: new Set<Listener>(),
+    deps: [],
+    unsubs: [],
+    value: undefined as unknown as T,
+    hasValue: false,
+    stale: true,
+    checkedAt: -1,
+  } as unknown as MemoState<T>;
+
+  state.onDepChange = () => memoOnDepChange(state);
+
+  state.node = {
+    version: ++versionCounter,
+    validate: () => memoValidate(state),
+    subscribe: (listener: Listener, request?: InvalidationRequest) => {
+      if (request) return request.accept(state.node, state, state.listeners);
+      // Dependencies are only observed while somebody is listening, so the
+      // push path exists solely to serve real subscribers.
+      memoValidate(state);
+      state.listeners.add(listener);
+      if (state.listeners.size === 1) memoObserve(state);
+      return () => {
+        state.listeners.delete(listener);
+        if (state.listeners.size === 0) memoUnobserve(state);
+      };
+    },
+  };
 
   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;
+    memoValidate(state);
+    track(state.node);
+    return state.value;
   }) as Memo<T>;
 
   read.peek = () => {
-    validate();
-    return value;
+    memoValidate(state);
+    return state.value;
   };
-  read.subscribe = node.subscribe;
+  read.subscribe = state.node.subscribe;
 
   return read;
 }
@@ -286,8 +362,14 @@ function isWrappable(value: unknown): value is object {
 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);
+    const out = Object.create(Object.getPrototypeOf(value));
+    for (const key of Object.keys(value))
+      Object.defineProperty(out, key, {
+        value: clone(Reflect.get(value, key)),
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
     return out as V;
   }
   return value;
@@ -304,7 +386,8 @@ export function createStore<T extends object>(initial: T): [T, StoreSetter<T>] {
   const node: Source = {
     version: ++versionCounter,
     validate: () => {},
-    subscribe: (listener) => {
+    subscribe: (listener: Listener, request?: InvalidationRequest) => {
+      if (request) return request.accept(node, undefined, listeners);
       listeners.add(listener);
       return () => {
         listeners.delete(listener);
@@ -315,7 +398,11 @@ export function createStore<T extends object>(initial: T): [T, StoreSetter<T>] {
   const notify = () => {
     node.version = ++versionCounter;
     epoch++;
-    notifyListeners(listeners);
+    if (invalidationRegistry)
+      invalidationRegistry.commit(node, node.version, () =>
+        notifyListeners(listeners),
+      );
+    else notifyListeners(listeners);
   };
 
   // Cached so `store.user === store.user`, which React dependency arrays and
@@ -334,8 +421,17 @@ export function createStore<T extends object>(initial: T): [T, StoreSetter<T>] {
       },
       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);
+        const own = Object.hasOwn(obj, prop);
+        if (own && Object.is(prev, value)) return true;
+        const ok =
+          prop === "__proto__" && !own
+            ? Reflect.defineProperty(obj, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+              })
+            : Reflect.set(obj, prop, value, receiver);
         if (ok) notify();
         return ok;
       },
@@ -361,3 +457,374 @@ export function createStore<T extends object>(initial: T): [T, StoreSetter<T>] {
 
   return [proxy, setStore];
 }
+
+export type InvalidationObserver = {
+  invalidate(origin: Trackable, revision: number): void;
+  notify(): void;
+  demand?: boolean;
+};
+type InvalidationRequest = {
+  accepted: boolean;
+  accept(
+    node: Source,
+    memo?: MemoState<unknown>,
+    listeners?: ReadonlySet<Listener>,
+  ): () => void;
+};
+type InvalidationRegistry = {
+  subscribe(node: Trackable, observer: InvalidationObserver): () => void;
+  dependencies(node: Source, deps: readonly { node: Source }[]): void;
+  demand(node: Source): boolean;
+  commit(node: Source, revision: number, notify: () => void): void;
+};
+let invalidationRegistry: InvalidationRegistry | undefined;
+
+/**
+ * Observe input writes without turning memo observation into value demand.
+ * Initial observation may validate once. Mark callbacks precede wake/value callbacks;
+ * nested writes finish draining by the outermost observed source setter return.
+ */
+export function subscribeInvalidation(
+  node: Trackable,
+  observer: InvalidationObserver,
+): () => void {
+  return (invalidationRegistry ??= createInvalidationRegistry()).subscribe(
+    node,
+    observer,
+  );
+}
+
+function releaseInvalidationStops(stops: Iterable<() => void>): void {
+  let bad = false,
+    error: unknown;
+  for (const stop of stops)
+    try {
+      stop();
+    } catch (next) {
+      if (!bad) error = next;
+      bad = true;
+    }
+  if (bad) throw error;
+}
+
+function createInvalidationRegistry(): InvalidationRegistry {
+  type Registration = { active: boolean; observer: InvalidationObserver };
+  type Entry = {
+    node: Source;
+    memo?: MemoState<unknown>;
+    listeners?: ReadonlySet<Listener>;
+    active: boolean;
+    observers: Set<Registration>;
+    parents: Set<Entry>;
+    stops: Map<Source, () => void>;
+  };
+  const entries = new WeakMap<Source, Entry>();
+  const origins: Array<{
+    node: Source;
+    revision: number;
+    notify: () => void;
+    generation: number;
+  }> = [];
+  const wakes = new Map<Registration, number>();
+  const values: Array<{ notify: () => void; generation: number }> = [];
+  // Sibling writes from one callback share a generation. Only a later callback
+  // advances causal depth, so wide graphs are not mistaken for feedback.
+  let currentGeneration = 0;
+  let running = false,
+    marking = false,
+    failed = false;
+  let failure: unknown;
+  function capture(fn: () => void, generation = currentGeneration): void {
+    const previous = currentGeneration;
+    currentGeneration = generation;
+    try {
+      fn();
+    } catch (error) {
+      if (!failed) failure = error;
+      failed = true;
+    } finally {
+      currentGeneration = previous;
+    }
+  }
+  function inactive(entry: Entry): void {
+    if (entry.observers.size || entry.parents.size || !entry.active) return;
+    entry.active = false;
+    const stops = entry.stops;
+    entry.stops = new Map();
+    releaseInvalidationStops(stops.values());
+  }
+  function entryFor(
+    node: Source,
+    memo?: MemoState<unknown>,
+    listeners?: ReadonlySet<Listener>,
+  ): Entry {
+    let entry = entries.get(node);
+    if (!entry)
+      entries.set(
+        node,
+        (entry = {
+          node,
+          memo,
+          listeners,
+          active: false,
+          observers: new Set(),
+          parents: new Set(),
+          stops: new Map(),
+        }),
+      );
+    return entry;
+  }
+  function invoke(
+    node: Trackable,
+    accept: InvalidationRequest["accept"],
+  ): () => void {
+    const request: InvalidationRequest = {
+      accepted: false,
+      accept(source, memo, listeners) {
+        request.accepted = true;
+        return accept(source, memo, listeners);
+      },
+    };
+    const stop = (node as Source).subscribe(() => {}, request);
+    if (!request.accepted) {
+      const error = new Error(
+        "Trackable does not support invalidation observation",
+      );
+      try {
+        stop();
+      } catch {
+        /* The unsupported protocol error remains primary. */
+      }
+      throw error;
+    }
+    return stop;
+  }
+  function activate(entry: Entry): void {
+    if (entry.active) return;
+    entry.active = true;
+    try {
+      if (entry.memo) sync(entry, entry.memo.deps);
+    } catch (error) {
+      entry.active = false;
+      const stops = entry.stops;
+      entry.stops = new Map();
+      try {
+        releaseInvalidationStops(stops.values());
+      } catch {
+        /* Preserve the activation error. */
+      }
+      throw error;
+    }
+  }
+  function link(node: Source, parent: Entry): () => void {
+    return invoke(node, (source, memo, listeners) => {
+      if (memo && !memo.hasValue) memoValidate(memo);
+      const entry = entryFor(source, memo, listeners);
+      entry.parents.add(parent);
+      try {
+        activate(entry);
+      } catch (error) {
+        entry.parents.delete(parent);
+        throw error;
+      }
+      let active = true;
+      return () => {
+        if (!active) return;
+        active = false;
+        entry.parents.delete(parent);
+        inactive(entry);
+      };
+    });
+  }
+  function sync(entry: Entry, deps: readonly { node: Source }[]): void {
+    const next = new Map<Source, () => void>();
+    try {
+      for (const dep of deps)
+        if (!next.has(dep.node))
+          next.set(
+            dep.node,
+            entry.stops.get(dep.node) ?? link(dep.node, entry),
+          );
+    } catch (error) {
+      try {
+        releaseInvalidationStops(
+          [...next]
+            .filter(([node]) => !entry.stops.has(node))
+            .map(([, stop]) => stop),
+        );
+      } catch {
+        /* Preserve the connection error. */
+      }
+      throw error;
+    }
+    const old = entry.stops;
+    entry.stops = next;
+    releaseInvalidationStops(
+      [...old].filter(([node]) => !next.has(node)).map(([, stop]) => stop),
+    );
+  }
+  function mark(): void {
+    if (marking) return;
+    marking = true;
+    try {
+      while (origins.length) {
+        const origin = origins.shift()!;
+        values.push({ notify: origin.notify, generation: origin.generation });
+        const first = entries.get(origin.node);
+        if (!first) continue;
+        const frontier = [first],
+          visited = new Set<Entry>();
+        while (frontier.length) {
+          const entry = frontier.pop()!;
+          if (visited.has(entry) || !entry.active) continue;
+          visited.add(entry);
+          frontier.push(...entry.parents);
+          // Snapshot registrations: callbacks may dispose or add observations.
+          const registrations = Array.from(entry.observers);
+          for (const registration of registrations)
+            if (registration.active) {
+              capture(
+                () =>
+                  registration.observer.invalidate(
+                    origin.node,
+                    origin.revision,
+                  ),
+                origin.generation,
+              );
+              if (registration.active)
+                wakes.set(
+                  registration,
+                  Math.max(wakes.get(registration) ?? 0, origin.generation),
+                );
+            }
+        }
+      }
+    } finally {
+      marking = false;
+    }
+  }
+  return {
+    subscribe(node, observer) {
+      return invoke(node, (source, memo, listeners) => {
+        if (memo) memoValidate(memo);
+        const entry = entryFor(source, memo, listeners);
+        const registration: Registration = { active: true, observer };
+        entry.observers.add(registration);
+        try {
+          activate(entry);
+        } catch (error) {
+          entry.observers.delete(registration);
+          registration.active = false;
+          throw error;
+        }
+        return () => {
+          if (!registration.active) return;
+          registration.active = false;
+          entry.observers.delete(registration);
+          wakes.delete(registration);
+          inactive(entry);
+        };
+      });
+    },
+    demand(node) {
+      const entry = entries.get(node);
+      if (!entry) return false;
+      const frontier = [entry],
+        visited = new Set<Entry>();
+      while (frontier.length) {
+        const current = frontier.pop()!;
+        if (visited.has(current) || !current.active) continue;
+        visited.add(current);
+        if (
+          current.listeners?.size ||
+          [...current.observers].some(
+            ({ active, observer }) => active && observer.demand !== false,
+          )
+        )
+          return true;
+        frontier.push(...current.parents);
+      }
+      return false;
+    },
+    dependencies(node, deps) {
+      const entry = entries.get(node);
+      if (entry?.active) sync(entry, deps);
+    },
+    commit(node, revision, notify) {
+      if (!running && !entries.get(node)?.active) {
+        notify();
+        return;
+      }
+      const generation = running ? currentGeneration + 1 : 1;
+      if (generation > 1000) {
+        capture(() => {
+          throw new Error("Invalidation update limit exceeded");
+        });
+        return;
+      }
+      origins.push({ node, revision, notify, generation });
+      if (running) {
+        mark();
+        return;
+      }
+      running = true;
+      failed = false;
+      failure = undefined;
+      try {
+        while (origins.length || wakes.size || values.length) {
+          mark();
+          const wake = wakes.entries().next().value as
+            [Registration, number] | undefined;
+          if (wake) {
+            const [registration, wakeGeneration] = wake;
+            wakes.delete(registration);
+            if (registration.active)
+              capture(() => registration.observer.notify(), wakeGeneration);
+            continue;
+          }
+          const value = values.shift();
+          if (value) capture(value.notify, value.generation);
+        }
+      } catch (error) {
+        capture(() => {
+          throw error;
+        });
+      } finally {
+        running = false;
+        origins.length = values.length = 0;
+        wakes.clear();
+        currentGeneration = 0;
+      }
+      if (failed) throw failure;
+    },
+  };
+}
+
+export { track as trackDependency };
+
+/** Query native value-consumer reachability without validating or registering an observer. */
+export function hasValueDemand(node: Trackable): boolean {
+  let demand = false;
+  const request: InvalidationRequest = {
+    accepted: false,
+    accept(source, memo, listeners) {
+      request.accepted = true;
+      demand =
+        !!listeners?.size ||
+        !!memo?.listeners.size ||
+        (invalidationRegistry?.demand(source) ?? false);
+      return () => {};
+    },
+  };
+  const stop = (node as Source).subscribe(() => {}, request);
+  if (!request.accepted) {
+    const error = new Error("Trackable does not support demand inspection");
+    try {
+      stop();
+    } catch {
+      /* The unsupported protocol error remains primary. */
+    }
+    throw error;
+  }
+  return demand;
+}

package/src/tracking.ts

@@ -0,0 +1,10 @@
+/** Dependency collection for opt-in schedulers; no renderer or scheduling policy. */
+export { collectDeps, isTracking } from "./signal";
+export type { Trackable } from "./signal";
+
+export { subscribeInvalidation } from "./signal";
+export type { InvalidationObserver } from "./signal";
+
+export { trackDependency } from "./signal";
+
+export { hasValueDemand } from "./signal";