@getforma/core 0.9.0 → 1.0.0

package/README.md

@@ -505,9 +505,14 @@ deactivateIsland(islandElement);
 
 ## Subpath Exports
 
+The main entry point (`@getforma/core`) has **zero network code** — no `fetch`, no WebSocket, no `process.env`. Network-capable modules are separate subpath imports.
+
 | Import | Description |
 |--------|-------------|
-| `@getforma/core` | Signals, `h()`, `mount()`, lists, stores, components |
+| `@getforma/core` | Signals, `h()`, `mount()`, lists, stores, components, islands, events, DOM utils |
+| `@getforma/core/http` | `createFetch`, `fetchJSON`, `createSSE`, `createWebSocket` |
+| `@getforma/core/storage` | `createLocalStorage`, `createSessionStorage`, `createIndexedDB` |
+| `@getforma/core/server` | `createAction`, `$$serverFunction`, `handleRPC`, `createRPCMiddleware` |
 | `@getforma/core/runtime` | HTML Runtime — `initRuntime()`, `mount()`, `unmount()` |
 | `@getforma/core/runtime/global` | HTML Runtime global build (IIFE, for `<script>` tags) |
 | `@getforma/core/runtime-hardened` | Runtime with `new Function()` locked off (strict CSP) |
@@ -516,6 +521,20 @@ deactivateIsland(islandElement);
 | `@getforma/core/ssr` | Server-side rendering — `renderToString()`, `renderToStream()` |
 | `@getforma/core/tc39` | TC39-compatible `Signal.State` and `Signal.Computed` classes |
 
+```typescript
+// Core (zero network code)
+import { createSignal, h, mount, createStore } from '@getforma/core';
+
+// HTTP (only if needed)
+import { createFetch, createSSE } from '@getforma/core/http';
+
+// Storage (only if needed)
+import { createLocalStorage } from '@getforma/core/storage';
+
+// Server (only if needed)
+import { createAction, $$serverFunction } from '@getforma/core/server';
+```
+
 ## Examples
 
 See the [`examples/`](./examples) directory:

package/dist/chunk-DCTOXHPF.cjs

@@ -0,0 +1,399 @@
+'use strict';
+
+var chunk3U57L2TY_cjs = require('./chunk-3U57L2TY.cjs');
+var alienSignals = require('alien-signals');
+
+var currentRoot = null;
+var rootStack = [];
+function createRoot(fn) {
+  const scope = { disposers: [], scopeDispose: null };
+  rootStack.push(currentRoot);
+  currentRoot = scope;
+  const dispose = () => {
+    if (scope.scopeDispose) {
+      try {
+        scope.scopeDispose();
+      } catch {
+      }
+      scope.scopeDispose = null;
+    }
+    for (const d of scope.disposers) {
+      try {
+        d();
+      } catch {
+      }
+    }
+    scope.disposers.length = 0;
+  };
+  let result;
+  try {
+    scope.scopeDispose = alienSignals.effectScope(() => {
+      result = fn(dispose);
+    });
+  } finally {
+    currentRoot = rootStack.pop() ?? null;
+  }
+  return result;
+}
+function registerDisposer(dispose) {
+  if (currentRoot) {
+    currentRoot.disposers.push(dispose);
+  }
+}
+function hasActiveRoot() {
+  return currentRoot !== null;
+}
+
+// src/reactive/cleanup.ts
+var currentCleanupCollector = null;
+function onCleanup(fn) {
+  currentCleanupCollector?.(fn);
+}
+function setCleanupCollector(collector) {
+  const prev = currentCleanupCollector;
+  currentCleanupCollector = collector;
+  return prev;
+}
+
+// src/reactive/dev.ts
+var __DEV__ = typeof process !== "undefined" ? process.env?.NODE_ENV !== "production" : true;
+var _errorHandler = null;
+function onError(handler) {
+  _errorHandler = handler;
+}
+function reportError(error, source) {
+  if (_errorHandler) {
+    try {
+      _errorHandler(error, source ? { source } : {});
+    } catch {
+    }
+  }
+  if (__DEV__) {
+    console.error(`[forma] ${source ?? "Unknown"} error:`, error);
+  }
+}
+var POOL_SIZE = 32;
+var MAX_REENTRANT_RUNS = 100;
+var pool = [];
+for (let i = 0; i < POOL_SIZE; i++) pool.push([]);
+var poolIdx = POOL_SIZE;
+function acquireArray() {
+  if (poolIdx > 0) {
+    const arr = pool[--poolIdx];
+    arr.length = 0;
+    return arr;
+  }
+  return [];
+}
+function releaseArray(arr) {
+  arr.length = 0;
+  if (poolIdx < POOL_SIZE) {
+    pool[poolIdx++] = arr;
+  }
+}
+function runCleanup(fn) {
+  if (fn === void 0) return;
+  try {
+    fn();
+  } catch (e) {
+    reportError(e, "effect cleanup");
+  }
+}
+function runCleanups(bag) {
+  if (bag === void 0) return;
+  for (let i = 0; i < bag.length; i++) {
+    try {
+      bag[i]();
+    } catch (e) {
+      reportError(e, "effect cleanup");
+    }
+  }
+}
+function internalEffect(fn) {
+  const dispose = alienSignals.effect(fn);
+  if (hasActiveRoot()) {
+    registerDisposer(dispose);
+  }
+  return dispose;
+}
+function createEffect(fn) {
+  const shouldRegister = hasActiveRoot();
+  let cleanup;
+  let cleanupBag;
+  let nextCleanup;
+  let nextCleanupBag;
+  const addCleanup = (cb) => {
+    if (nextCleanupBag !== void 0) {
+      nextCleanupBag.push(cb);
+      return;
+    }
+    if (nextCleanup !== void 0) {
+      const bag = acquireArray();
+      bag.push(nextCleanup, cb);
+      nextCleanup = void 0;
+      nextCleanupBag = bag;
+      return;
+    }
+    nextCleanup = cb;
+  };
+  let skipCleanupInfra = false;
+  let firstRun = true;
+  let running = false;
+  let rerunRequested = false;
+  const runOnce = () => {
+    if (cleanup !== void 0) {
+      runCleanup(cleanup);
+      cleanup = void 0;
+    }
+    if (cleanupBag !== void 0) {
+      runCleanups(cleanupBag);
+      releaseArray(cleanupBag);
+      cleanupBag = void 0;
+    }
+    if (skipCleanupInfra) {
+      try {
+        fn();
+      } catch (e) {
+        reportError(e, "effect");
+      }
+      return;
+    }
+    nextCleanup = void 0;
+    nextCleanupBag = void 0;
+    const prevCollector = setCleanupCollector(addCleanup);
+    try {
+      const result = fn();
+      if (typeof result === "function") {
+        addCleanup(result);
+      }
+      if (nextCleanup === void 0 && nextCleanupBag === void 0) {
+        if (firstRun) skipCleanupInfra = true;
+        return;
+      }
+      if (nextCleanupBag !== void 0) {
+        cleanupBag = nextCleanupBag;
+      } else {
+        cleanup = nextCleanup;
+      }
+    } catch (e) {
+      reportError(e, "effect");
+      if (nextCleanupBag !== void 0) {
+        cleanupBag = nextCleanupBag;
+      } else {
+        cleanup = nextCleanup;
+      }
+    } finally {
+      setCleanupCollector(prevCollector);
+      firstRun = false;
+    }
+  };
+  const safeFn = () => {
+    if (running) {
+      rerunRequested = true;
+      return;
+    }
+    running = true;
+    try {
+      let reentrantRuns = 0;
+      do {
+        rerunRequested = false;
+        runOnce();
+        if (rerunRequested) {
+          reentrantRuns++;
+          if (reentrantRuns >= MAX_REENTRANT_RUNS) {
+            reportError(
+              new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} re-entrant runs`),
+              "effect"
+            );
+            rerunRequested = false;
+          }
+        }
+      } while (rerunRequested);
+    } finally {
+      running = false;
+    }
+  };
+  const dispose = alienSignals.effect(safeFn);
+  let disposed = false;
+  const wrappedDispose = () => {
+    if (disposed) return;
+    disposed = true;
+    dispose();
+    if (cleanup !== void 0) {
+      runCleanup(cleanup);
+      cleanup = void 0;
+    }
+    if (cleanupBag !== void 0) {
+      runCleanups(cleanupBag);
+      releaseArray(cleanupBag);
+      cleanupBag = void 0;
+    }
+  };
+  if (shouldRegister) {
+    registerDisposer(wrappedDispose);
+  }
+  return wrappedDispose;
+}
+
+// src/reactive/memo.ts
+var createMemo = chunk3U57L2TY_cjs.createComputed;
+function batch(fn) {
+  alienSignals.startBatch();
+  try {
+    fn();
+  } finally {
+    alienSignals.endBatch();
+  }
+}
+function untrack(fn) {
+  const prev = alienSignals.setActiveSub(void 0);
+  try {
+    return fn();
+  } finally {
+    alienSignals.setActiveSub(prev);
+  }
+}
+
+// src/reactive/on.ts
+function on(deps, fn, options) {
+  let prev;
+  let isFirst = true;
+  return () => {
+    const value2 = deps();
+    if (options?.defer && isFirst) {
+      isFirst = false;
+      prev = value2;
+      return void 0;
+    }
+    const result = untrack(() => fn(value2, prev));
+    prev = value2;
+    return result;
+  };
+}
+
+// src/reactive/ref.ts
+function createRef(initialValue) {
+  return { current: initialValue };
+}
+
+// src/reactive/reducer.ts
+function createReducer(reducer, initialState) {
+  const [state, setState] = chunk3U57L2TY_cjs.createSignal(initialState);
+  const dispatch = (action) => {
+    setState((prev) => reducer(prev, action));
+  };
+  return [state, dispatch];
+}
+
+// src/reactive/suspense-context.ts
+var currentSuspenseContext = null;
+var suspenseStack = [];
+function pushSuspenseContext(ctx) {
+  suspenseStack.push(currentSuspenseContext);
+  currentSuspenseContext = ctx;
+}
+function popSuspenseContext() {
+  currentSuspenseContext = suspenseStack.pop() ?? null;
+}
+function getSuspenseContext() {
+  return currentSuspenseContext;
+}
+
+// src/reactive/resource.ts
+function createResource(source, fetcher, options) {
+  const [data, setData] = chunk3U57L2TY_cjs.createSignal(options?.initialValue);
+  const [loading, setLoading] = chunk3U57L2TY_cjs.createSignal(false);
+  const [error, setError] = chunk3U57L2TY_cjs.createSignal(void 0);
+  const suspenseCtx = getSuspenseContext();
+  let abortController = null;
+  let fetchVersion = 0;
+  const doFetch = () => {
+    const sourceValue = untrack(source);
+    if (abortController) {
+      abortController.abort();
+    }
+    const controller = new AbortController();
+    abortController = controller;
+    const version = ++fetchVersion;
+    const isLatest = () => version === fetchVersion;
+    let suspensePending = false;
+    if (suspenseCtx) {
+      suspenseCtx.increment();
+      suspensePending = true;
+    }
+    setLoading(true);
+    setError(void 0);
+    Promise.resolve(fetcher(sourceValue)).then((result) => {
+      if (isLatest() && !controller.signal.aborted) {
+        setData(() => result);
+      }
+    }).catch((err) => {
+      if (isLatest() && !controller.signal.aborted) {
+        if (err?.name !== "AbortError") {
+          setError(err);
+        }
+      }
+    }).finally(() => {
+      if (suspensePending) suspenseCtx?.decrement();
+      if (isLatest()) {
+        setLoading(false);
+        if (abortController === controller) {
+          abortController = null;
+        }
+      }
+    });
+  };
+  internalEffect(() => {
+    source();
+    doFetch();
+  });
+  const resource = (() => data());
+  resource.loading = loading;
+  resource.error = error;
+  resource.refetch = doFetch;
+  resource.mutate = (value2) => setData(() => value2);
+  return resource;
+}
+
+Object.defineProperty(exports, "getBatchDepth", {
+  enumerable: true,
+  get: function () { return alienSignals.getBatchDepth; }
+});
+Object.defineProperty(exports, "isComputed", {
+  enumerable: true,
+  get: function () { return alienSignals.isComputed; }
+});
+Object.defineProperty(exports, "isEffect", {
+  enumerable: true,
+  get: function () { return alienSignals.isEffect; }
+});
+Object.defineProperty(exports, "isEffectScope", {
+  enumerable: true,
+  get: function () { return alienSignals.isEffectScope; }
+});
+Object.defineProperty(exports, "isSignal", {
+  enumerable: true,
+  get: function () { return alienSignals.isSignal; }
+});
+Object.defineProperty(exports, "trigger", {
+  enumerable: true,
+  get: function () { return alienSignals.trigger; }
+});
+exports.__DEV__ = __DEV__;
+exports.batch = batch;
+exports.createEffect = createEffect;
+exports.createMemo = createMemo;
+exports.createReducer = createReducer;
+exports.createRef = createRef;
+exports.createResource = createResource;
+exports.createRoot = createRoot;
+exports.internalEffect = internalEffect;
+exports.on = on;
+exports.onCleanup = onCleanup;
+exports.onError = onError;
+exports.popSuspenseContext = popSuspenseContext;
+exports.pushSuspenseContext = pushSuspenseContext;
+exports.reportError = reportError;
+exports.untrack = untrack;
+//# sourceMappingURL=chunk-DCTOXHPF.cjs.map
+//# sourceMappingURL=chunk-DCTOXHPF.cjs.map

package/dist/chunk-DCTOXHPF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reactive/root.ts","../src/reactive/cleanup.ts","../src/reactive/dev.ts","../src/reactive/effect.ts","../src/reactive/memo.ts","../src/reactive/batch.ts","../src/reactive/untrack.ts","../src/reactive/on.ts","../src/reactive/ref.ts","../src/reactive/reducer.ts","../src/reactive/suspense-context.ts","../src/reactive/resource.ts"],"names":["rawEffectScope","rawEffect","createComputed","startBatch","endBatch","setActiveSub","value","createSignal"],"mappings":"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","file":"chunk-DCTOXHPF.cjs","sourcesContent":["/**\n * Forma Reactive - Root\n *\n * Explicit reactive ownership scope. All effects created inside a root\n * are automatically disposed when the root is torn down.\n *\n * Uses alien-signals' `effectScope` under the hood for native graph-level\n * effect tracking, with a userland disposer list for non-effect cleanup\n * (e.g., event listeners, DOM references, timers).\n */\n\nimport { effectScope as rawEffectScope } from 'alien-signals';\n\n// ---------------------------------------------------------------------------\n// Root scope tracking\n// ---------------------------------------------------------------------------\n\nlet currentRoot: RootScope | null = null;\nconst rootStack: (RootScope | null)[] = [];\n\ninterface RootScope {\n  /** Userland disposers (event listeners, DOM refs, timers, etc.) */\n  disposers: (() => void)[];\n  /** alien-signals effect scope dispose — tears down all reactive effects */\n  scopeDispose: (() => void) | null;\n}\n\n/**\n * Create a reactive root scope.\n *\n * All effects created (via `createEffect`) inside the callback are tracked\n * at both the reactive graph level (via alien-signals effectScope) and the\n * userland level (via registerDisposer). The returned `dispose` function\n * tears down everything.\n *\n * ```ts\n * const dispose = createRoot(() => {\n *   createEffect(() => console.log(count()));\n *   createEffect(() => console.log(name()));\n * });\n * // later: dispose() stops both effects\n * ```\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const scope: RootScope = { disposers: [], scopeDispose: null };\n\n  rootStack.push(currentRoot);\n  currentRoot = scope;\n\n  const dispose = () => {\n    // Dispose alien-signals effect scope first (reactive graph cleanup)\n    if (scope.scopeDispose) {\n      try { scope.scopeDispose(); } catch { /* ensure userland disposers still run */ }\n      scope.scopeDispose = null;\n    }\n    // Then run userland disposers\n    for (const d of scope.disposers) {\n      try { d(); } catch { /* ensure all disposers run */ }\n    }\n    scope.disposers.length = 0;\n  };\n\n  let result: T;\n  try {\n    // Wrap in alien-signals effectScope for native effect tracking\n    scope.scopeDispose = rawEffectScope(() => {\n      result = fn(dispose);\n    });\n  } finally {\n    currentRoot = rootStack.pop() ?? null;\n  }\n\n  return result!;\n}\n\n/**\n * @internal — called by createEffect to register disposers in the current root.\n */\nexport function registerDisposer(dispose: () => void): void {\n  if (currentRoot) {\n    currentRoot.disposers.push(dispose);\n  }\n}\n\n/**\n * @internal — check if we're inside a root scope.\n */\nexport function hasActiveRoot(): boolean {\n  return currentRoot !== null;\n}\n","/**\n * Forma Reactive - Cleanup\n *\n * Register cleanup functions within reactive scopes.\n * Inspired by SolidJS onCleanup().\n */\n\n// ---------------------------------------------------------------------------\n// Cleanup context tracking\n// ---------------------------------------------------------------------------\n\ntype CleanupCollector = ((fn: () => void) => void) | null;\n\nlet currentCleanupCollector: CleanupCollector = null;\n\n/**\n * Register a cleanup function in the current reactive scope.\n * The cleanup runs before the effect re-executes and on disposal.\n *\n * More composable than returning a cleanup from the effect function,\n * since it can be called from helper functions.\n *\n * ```ts\n * createEffect(() => {\n *   const timer = setInterval(tick, 1000);\n *   onCleanup(() => clearInterval(timer));\n * });\n * ```\n */\nexport function onCleanup(fn: () => void): void {\n  currentCleanupCollector?.(fn);\n}\n\n/**\n * @internal — Set the cleanup collector for the current effect execution.\n */\nexport function setCleanupCollector(collector: CleanupCollector): CleanupCollector {\n  const prev = currentCleanupCollector;\n  currentCleanupCollector = collector;\n  return prev;\n}\n","/**\n * Forma Reactive - Dev Mode\n *\n * Development utilities stripped from production builds via __DEV__ flag.\n * Bundlers replace __DEV__ with false → dead-code elimination removes all dev paths.\n */\n\n// __DEV__ is replaced by bundler (tsup define). Defaults to true for unbundled usage.\ndeclare const process: { env?: Record<string, string | undefined> } | undefined;\nexport const __DEV__: boolean = typeof process !== 'undefined'\n  ? (process!.env?.NODE_ENV !== 'production')\n  : true;\n\n// ---------------------------------------------------------------------------\n// Global error handler\n// ---------------------------------------------------------------------------\n\nexport type ErrorHandler = (error: unknown, info?: { source?: string }) => void;\n\nlet _errorHandler: ErrorHandler | null = null;\n\n/**\n * Install a global error handler for FormaJS reactive errors.\n * Called when effects, computeds, or event handlers throw.\n *\n * ```ts\n * onError((err, info) => {\n *   console.error(`[${info?.source}]`, err);\n *   Sentry.captureException(err);\n * });\n * ```\n */\nexport function onError(handler: ErrorHandler): void {\n  _errorHandler = handler;\n}\n\n/** @internal */\nexport function reportError(error: unknown, source?: string): void {\n  if (_errorHandler) {\n    try { _errorHandler(error, source ? { source } : {}); } catch { /* prevent infinite loop */ }\n  }\n  if (__DEV__) {\n    console.error(`[forma] ${source ?? 'Unknown'} error:`, error);\n  }\n}\n","/**\n * Forma Reactive - Effect\n *\n * Side-effectful reactive computation that auto-tracks signal dependencies.\n * Backed by alien-signals for automatic dependency tracking.\n *\n * TC39 Signals equivalent: Signal.subtle.Watcher (effect is a userland concept)\n */\n\nimport { effect as rawEffect } from 'alien-signals';\nimport { hasActiveRoot, registerDisposer } from './root.js';\nimport { setCleanupCollector } from './cleanup.js';\nimport { reportError } from './dev.js';\n\n// ---------------------------------------------------------------------------\n// Cleanup array pool — avoids allocating a new array every effect re-run\n// ---------------------------------------------------------------------------\n\nconst POOL_SIZE = 32;\nconst MAX_REENTRANT_RUNS = 100;\nconst pool: (() => void)[][] = [];\nfor (let i = 0; i < POOL_SIZE; i++) pool.push([]);\nlet poolIdx = POOL_SIZE;\n\nfunction acquireArray(): (() => void)[] {\n  if (poolIdx > 0) {\n    const arr = pool[--poolIdx]!;\n    arr.length = 0;\n    return arr;\n  }\n  return [];\n}\n\nfunction releaseArray(arr: (() => void)[]): void {\n  arr.length = 0;\n  if (poolIdx < POOL_SIZE) {\n    pool[poolIdx++] = arr;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Unified cleanup runner — single function for both re-run and dispose paths\n// ---------------------------------------------------------------------------\n\nfunction runCleanup(fn: (() => void) | undefined): void {\n  if (fn === undefined) return;\n  try {\n    fn();\n  } catch (e) {\n    reportError(e, 'effect cleanup');\n  }\n}\n\nfunction runCleanups(bag: (() => void)[] | undefined): void {\n  if (bag === undefined) return;\n  for (let i = 0; i < bag.length; i++) {\n    try { bag[i]!(); } catch (e) { reportError(e, 'effect cleanup'); }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Create a reactive effect that auto-tracks signal dependencies.\n *\n * The provided function runs immediately and re-runs whenever any signal it\n * reads changes. If the function returns a cleanup function, that cleanup is\n * called before each re-run and on disposal.\n *\n * Additionally, `onCleanup()` can be called inside the effect to register\n * cleanup functions composably.\n *\n * Returns a dispose function that stops the effect.\n */\n/**\n * @internal — Lightweight effect for Forma's internal DOM bindings.\n *\n * Bypasses createEffect's cleanup infrastructure (pool, collector, error\n * reporting, engine compression) since internal effects never use\n * onCleanup() or return cleanup functions.  This saves ~4 function calls\n * per effect creation and per re-run.\n *\n * ONLY use for effects that:\n * 1. Never call onCleanup()\n * 2. Never return a cleanup function\n * 3. Contain simple \"read signal → write DOM\" logic\n */\nexport function internalEffect(fn: () => void): () => void {\n  const dispose = rawEffect(fn);\n  if (hasActiveRoot()) {\n    registerDisposer(dispose);\n  }\n  return dispose;\n}\n\nexport function createEffect(fn: () => void | (() => void)): () => void {\n  const shouldRegister = hasActiveRoot();\n\n  // Most effects have zero or one cleanup. Track the single-cleanup case\n  // without array allocation; only promote to pooled array when needed.\n  let cleanup: (() => void) | undefined;\n  let cleanupBag: (() => void)[] | undefined;\n  let nextCleanup: (() => void) | undefined;\n  let nextCleanupBag: (() => void)[] | undefined;\n\n  const addCleanup = (cb: () => void) => {\n    if (nextCleanupBag !== undefined) {\n      nextCleanupBag.push(cb);\n      return;\n    }\n    if (nextCleanup !== undefined) {\n      const bag = acquireArray();\n      bag.push(nextCleanup, cb);\n      nextCleanup = undefined;\n      nextCleanupBag = bag;\n      return;\n    }\n    nextCleanup = cb;\n  };\n\n  // \"Engine Compression\" exploit: most effects never use cleanup (onCleanup()\n  // or return value). After the first clean run, we know this effect is\n  // \"cleanup-free\" and can skip the entire cleanup infrastructure on re-runs.\n  // This saves 4 function calls per re-run: acquireArray, setCleanupCollector,\n  // releaseArray, and bag inspection. Like the engine compression ratio exploit —\n  // the \"rules\" say we should always prepare for cleanup, but we measure at\n  // \"room temperature\" (first run) and exploit the gap.\n  let skipCleanupInfra = false;\n  let firstRun = true;\n  let running = false;\n  let rerunRequested = false;\n\n  const runOnce = () => {\n    // Run and clear previous cleanups (only if any exist).\n    if (cleanup !== undefined) {\n      runCleanup(cleanup);\n      cleanup = undefined;\n    }\n    if (cleanupBag !== undefined) {\n      runCleanups(cleanupBag);\n      releaseArray(cleanupBag);\n      cleanupBag = undefined;\n    }\n\n    // Ultra-fast path: this effect has proven it doesn't use cleanup.\n    // Skip acquireArray + setCleanupCollector + bag checks + releaseArray.\n    if (skipCleanupInfra) {\n      try { fn(); } catch (e) { reportError(e, 'effect'); }\n      return;\n    }\n\n    nextCleanup = undefined;\n    nextCleanupBag = undefined;\n\n    // Full path: install collector for onCleanup() calls.\n    const prevCollector = setCleanupCollector(addCleanup);\n\n    try {\n      const result = fn();\n\n      if (typeof result === 'function') {\n        addCleanup(result as () => void);\n      }\n\n      // Hot path: no cleanups registered or returned — enable ultra-fast path.\n      if (nextCleanup === undefined && nextCleanupBag === undefined) {\n        // First clean run → enable ultra-fast path for all subsequent runs\n        if (firstRun) skipCleanupInfra = true;\n        return;\n      }\n\n      if (nextCleanupBag !== undefined) {\n        cleanupBag = nextCleanupBag;\n      } else {\n        cleanup = nextCleanup;\n      }\n    } catch (e) {\n      reportError(e, 'effect');\n\n      if (nextCleanupBag !== undefined) {\n        cleanupBag = nextCleanupBag;\n      } else {\n        cleanup = nextCleanup;\n      }\n    } finally {\n      setCleanupCollector(prevCollector);\n      firstRun = false;\n    }\n  };\n\n  const safeFn = () => {\n    if (running) {\n      rerunRequested = true;\n      return;\n    }\n\n    running = true;\n    try {\n      let reentrantRuns = 0;\n      do {\n        rerunRequested = false;\n        runOnce();\n        if (rerunRequested) {\n          reentrantRuns++;\n          if (reentrantRuns >= MAX_REENTRANT_RUNS) {\n            reportError(\n              new Error(`createEffect exceeded ${MAX_REENTRANT_RUNS} re-entrant runs`),\n              'effect',\n            );\n            rerunRequested = false;\n          }\n        }\n      } while (rerunRequested);\n    } finally {\n      running = false;\n    }\n  };\n\n  const dispose = rawEffect(safeFn);\n\n  // Wrap dispose to also run final cleanups\n  let disposed = false;\n  const wrappedDispose = () => {\n    if (disposed) return;\n    disposed = true;\n    dispose();\n    if (cleanup !== undefined) {\n      runCleanup(cleanup);\n      cleanup = undefined;\n    }\n    if (cleanupBag !== undefined) {\n      runCleanups(cleanupBag);\n      releaseArray(cleanupBag);\n      cleanupBag = undefined;\n    }\n  };\n\n  // Register in current root scope (if any)\n  if (shouldRegister) {\n    registerDisposer(wrappedDispose);\n  }\n\n  return wrappedDispose;\n}\n","/**\n * Forma Reactive - Memo\n *\n * Alias for createComputed with SolidJS/React-familiar naming.\n * A memoized derived value that only recomputes when its dependencies change.\n *\n * TC39 Signals equivalent: Signal.Computed\n */\n\nimport { createComputed } from './computed.js';\n\n/**\n * Create a memoized computed value.\n * Identical to `createComputed` — provided for React/SolidJS familiarity.\n *\n * Note: Unlike SolidJS's createComputed (which is an eager synchronous\n * side effect), both createComputed and createMemo in FormaJS are lazy\n * cached derivations — equivalent to SolidJS's createMemo. They are\n * identical.\n *\n * The computation runs lazily and caches the result. It only recomputes\n * when a signal it reads during computation changes.\n *\n * ```ts\n * const [count, setCount] = createSignal(0);\n * const doubled = createMemo(() => count() * 2);\n * console.log(doubled()); // 0\n * setCount(5);\n * console.log(doubled()); // 10\n * ```\n */\nexport const createMemo: typeof createComputed = createComputed;\n","/**\n * Forma Reactive - Batch\n *\n * Groups multiple signal updates and defers effect execution until the\n * outermost batch completes. Prevents intermediate re-renders.\n * Backed by alien-signals.\n *\n * TC39 Signals: no built-in batch — this is a userland optimization.\n */\n\nimport { startBatch, endBatch } from 'alien-signals';\n\n/**\n * Group multiple signal updates so that effects only run once after all\n * updates have been applied.\n *\n * ```ts\n * batch(() => {\n *   setA(1);\n *   setB(2);\n *   // effects that depend on A and B won't run yet\n * });\n * // effects run here, once\n * ```\n *\n * Batches are nestable — only the outermost batch triggers the flush.\n */\nexport function batch(fn: () => void): void {\n  startBatch();\n  try {\n    fn();\n  } finally {\n    endBatch();\n  }\n}\n","/**\n * Forma Reactive - Untrack\n *\n * Read signals without subscribing to them in the reactive graph.\n * Essential for reading values inside effects without creating dependencies.\n *\n * TC39 Signals equivalent: Signal.subtle.untrack()\n */\n\nimport { setActiveSub } from 'alien-signals';\n\n/**\n * Execute a function without tracking signal reads.\n * Any signals read inside `fn` will NOT become dependencies of the\n * surrounding effect or computed.\n *\n * ```ts\n * createEffect(() => {\n *   const a = count();           // tracked — effect re-runs when count changes\n *   const b = untrack(() => other()); // NOT tracked — effect ignores other changes\n * });\n * ```\n */\nexport function untrack<T>(fn: () => T): T {\n  const prev = setActiveSub(undefined);\n  try {\n    return fn();\n  } finally {\n    setActiveSub(prev);\n  }\n}\n","/**\n * Forma Reactive - On\n *\n * Explicit dependency tracking for effects.\n * Only re-runs when the specified signals change, ignoring all other reads.\n *\n * SolidJS equivalent: on()\n * Vue equivalent: watch() with explicit deps\n * React equivalent: useEffect dependency array\n */\n\nimport { untrack } from './untrack.js';\n\n/**\n * Create a tracked effect body that only fires when specific dependencies change.\n *\n * Wraps a function so that only the `deps` signals are tracked.\n * All signal reads inside `fn` are untracked (won't cause re-runs).\n *\n * Use with `createEffect`:\n *\n * ```ts\n * const [a, setA] = createSignal(1);\n * const [b, setB] = createSignal(2);\n *\n * // Only re-runs when `a` changes, NOT when `b` changes:\n * createEffect(on(a, (value, prev) => {\n *   console.log(`a changed: ${prev} → ${value}, b is ${b()}`);\n * }));\n *\n * setA(10);  // fires: \"a changed: 1 → 10, b is 2\"\n * setB(20);  // does NOT fire\n * ```\n *\n * Multiple dependencies:\n * ```ts\n * createEffect(on(\n *   () => [a(), b()] as const,\n *   ([aVal, bVal], prev) => { ... }\n * ));\n * ```\n */\nexport function on<T, U>(\n  deps: () => T,\n  fn: (value: T, prev: T | undefined) => U,\n  options?: { defer?: boolean },\n): () => U | undefined {\n  let prev: T | undefined;\n  let isFirst = true;\n\n  return () => {\n    // Track only the deps\n    const value = deps();\n\n    if (options?.defer && isFirst) {\n      isFirst = false;\n      prev = value;\n      return undefined;\n    }\n\n    // Run the body untracked so it doesn't add extra dependencies\n    const result = untrack(() => fn(value, prev));\n    prev = value;\n    return result;\n  };\n}\n","/**\n * Forma Reactive - Ref\n *\n * Mutable container that does NOT trigger reactivity.\n * Use for DOM references, previous values, instance variables —\n * anything that needs to persist across effect re-runs without\n * causing re-execution.\n *\n * React equivalent: useRef\n * SolidJS equivalent: (none — uses plain variables in setup)\n */\n\nexport interface Ref<T> {\n  current: T;\n}\n\n/**\n * Create a mutable ref container.\n *\n * Unlike signals, writing to `.current` does NOT trigger effects.\n * Use when you need a stable reference across reactive scopes.\n *\n * ```ts\n * const timerRef = createRef<number | null>(null);\n *\n * createEffect(() => {\n *   timerRef.current = setInterval(tick, 1000);\n *   onCleanup(() => clearInterval(timerRef.current!));\n * });\n *\n * // DOM ref pattern:\n * const elRef = createRef<HTMLElement | null>(null);\n * h('div', { ref: (el) => { elRef.current = el; } });\n * ```\n */\nexport function createRef<T>(initialValue: T): Ref<T> {\n  return { current: initialValue };\n}\n","/**\n * Forma Reactive - Reducer\n *\n * State machine pattern — dispatch actions to a pure reducer function.\n * Fine-grained: only the resulting state signal is reactive.\n *\n * React equivalent: useReducer\n * SolidJS equivalent: (none — uses createSignal + helpers)\n */\n\nimport { createSignal, type SignalGetter } from './signal.js';\n\nexport type Dispatch<A> = (action: A) => void;\n\n/**\n * Create a reducer — predictable state updates via dispatched actions.\n *\n * The reducer function must be pure: `(state, action) => newState`.\n * Returns a [state, dispatch] tuple.\n *\n * ```ts\n * type Action = { type: 'increment' } | { type: 'decrement' } | { type: 'reset' };\n *\n * const [count, dispatch] = createReducer(\n *   (state: number, action: Action) => {\n *     switch (action.type) {\n *       case 'increment': return state + 1;\n *       case 'decrement': return state - 1;\n *       case 'reset': return 0;\n *     }\n *   },\n *   0,\n * );\n *\n * dispatch({ type: 'increment' }); // count() === 1\n * dispatch({ type: 'increment' }); // count() === 2\n * dispatch({ type: 'reset' });     // count() === 0\n * ```\n */\nexport function createReducer<S, A>(\n  reducer: (state: S, action: A) => S,\n  initialState: S,\n): [state: SignalGetter<S>, dispatch: Dispatch<A>] {\n  const [state, setState] = createSignal(initialState);\n\n  const dispatch: Dispatch<A> = (action) => {\n    setState((prev) => reducer(prev, action));\n  };\n\n  return [state, dispatch];\n}\n","/**\n * Forma Reactive - Suspense Context\n *\n * Shared context stack for Suspense boundaries. Lives in the reactive layer\n * (not DOM) so that createResource can import it without circular dependencies.\n *\n * The pattern mirrors the lifecycle context stack in component/define.ts.\n */\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface SuspenseContext {\n  /** Increment when a resource starts loading inside this boundary. */\n  increment(): void;\n  /** Decrement when a resource resolves/rejects inside this boundary. */\n  decrement(): void;\n}\n\n// ---------------------------------------------------------------------------\n// Context stack\n// ---------------------------------------------------------------------------\n\nlet currentSuspenseContext: SuspenseContext | null = null;\nconst suspenseStack: (SuspenseContext | null)[] = [];\n\nexport function pushSuspenseContext(ctx: SuspenseContext): void {\n  suspenseStack.push(currentSuspenseContext);\n  currentSuspenseContext = ctx;\n}\n\nexport function popSuspenseContext(): void {\n  currentSuspenseContext = suspenseStack.pop() ?? null;\n}\n\n/** Get the current Suspense context (if any). Called by createResource. */\nexport function getSuspenseContext(): SuspenseContext | null {\n  return currentSuspenseContext;\n}\n","/**\n * Forma Reactive - Resource\n *\n * Async data fetching primitive with reactive loading/error state.\n * Tracks a source signal and refetches when it changes.\n *\n * SolidJS equivalent: createResource\n * React equivalent: use() + Suspense (React 19), or useSWR/react-query\n */\n\nimport { createSignal, type SignalGetter } from './signal.js';\nimport { internalEffect } from './effect.js';\nimport { untrack } from './untrack.js';\nimport { getSuspenseContext } from './suspense-context.js';\n\nexport interface Resource<T> {\n  /** The resolved data (or undefined while loading). */\n  (): T | undefined;\n  /** True while the fetcher is running. */\n  loading: SignalGetter<boolean>;\n  /** The error if the fetcher rejected (or undefined). */\n  error: SignalGetter<unknown>;\n  /** Manually refetch with the current source value. */\n  refetch: () => void;\n  /** Manually set the data (overrides fetcher result). */\n  mutate: (value: T | undefined) => void;\n}\n\nexport interface ResourceOptions<T> {\n  /** Initial value before first fetch resolves. */\n  initialValue?: T;\n}\n\n/**\n * Create an async resource that fetches data reactively.\n *\n * When `source` changes, the fetcher re-runs automatically.\n * Provides reactive `loading` and `error` signals.\n *\n * ```ts\n * const [userId, setUserId] = createSignal(1);\n *\n * const user = createResource(\n *   userId,                                    // source signal\n *   (id) => fetch(`/api/users/${id}`).then(r => r.json()), // fetcher\n * );\n *\n * internalEffect(() => {\n *   if (user.loading()) console.log('Loading...');\n *   else if (user.error()) console.log('Error:', user.error());\n *   else console.log('User:', user());\n * });\n *\n * setUserId(2); // automatically refetches\n * ```\n *\n * Without a source signal (static fetch):\n * ```ts\n * const posts = createResource(\n *   () => true,  // constant source — fetches once\n *   () => fetch('/api/posts').then(r => r.json()),\n * );\n * ```\n */\nexport function createResource<T, S = true>(\n  source: SignalGetter<S>,\n  fetcher: (source: S) => Promise<T>,\n  options?: ResourceOptions<T>,\n): Resource<T> {\n  const [data, setData] = createSignal<T | undefined>(options?.initialValue);\n  const [loading, setLoading] = createSignal(false);\n  const [error, setError] = createSignal<unknown>(undefined);\n\n  // Capture the Suspense context at creation time (not at fetch time).\n  // This is critical because the Suspense boundary pushes/pops its context\n  // synchronously during children() execution.\n  const suspenseCtx = getSuspenseContext();\n\n  let abortController: AbortController | null = null;\n  let fetchVersion = 0;\n\n  const doFetch = () => {\n    // Read source outside tracking to get current value\n    const sourceValue = untrack(source);\n\n    // Abort previous in-flight request\n    if (abortController) {\n      abortController.abort();\n    }\n    const controller = new AbortController();\n    abortController = controller;\n\n    const version = ++fetchVersion;\n    const isLatest = () => version === fetchVersion;\n    let suspensePending = false;\n\n    // Notify Suspense boundary that a fetch has started\n    if (suspenseCtx) {\n      suspenseCtx.increment();\n      suspensePending = true;\n    }\n\n    setLoading(true);\n    setError(undefined);\n\n    Promise.resolve(fetcher(sourceValue))\n      .then((result) => {\n        // Only apply if this is still the latest fetch and wasn't aborted.\n        if (isLatest() && !controller.signal.aborted) {\n          setData(() => result);\n        }\n      })\n      .catch((err) => {\n        if (isLatest() && !controller.signal.aborted) {\n          // Ignore abort errors\n          if (err?.name !== 'AbortError') {\n            setError(err);\n          }\n        }\n      })\n      .finally(() => {\n        if (suspensePending) suspenseCtx?.decrement();\n        if (isLatest()) {\n          setLoading(false);\n          if (abortController === controller) {\n            abortController = null; // Release controller for GC\n          }\n        }\n      });\n  };\n\n  // Auto-fetch when source changes\n  internalEffect(() => {\n    source(); // track the source signal\n    doFetch();\n  });\n\n  // Build the resource object\n  const resource = (() => data()) as Resource<T>;\n  resource.loading = loading;\n  resource.error = error;\n  resource.refetch = doFetch;\n  resource.mutate = (value) => setData(() => value);\n\n  return resource;\n}\n"]}