@assistant-ui/tap 0.0.1

package/README.md

@@ -0,0 +1,252 @@
+# @assistant-ui/tap
+
+Zero-dependency reactive state management inspired by React hooks.
+
+## Installation
+
+```bash
+npm install @assistant-ui/tap
+```
+
+## Overview
+
+This library brings React's hooks mental model to state management outside of React components. It provides familiar APIs like `tapState` and `tapEffect` that work exactly like their React counterparts, but can be used anywhere.
+
+## Core Concepts
+
+### Resources
+
+Resources are self-contained units of reactive state and logic. They follow the same rules as React hooks:
+
+- Hooks must be called in the same order every render
+- Hooks cannot be called conditionally
+- Resources automatically handle cleanup and lifecycle
+
+### Creating Resources
+
+```typescript
+import { createResource, tapState, tapEffect } from "@assistant-ui/tap";
+
+// Define a resource using familiar hook patterns
+const Counter = resource(({ incrementBy = 1 }: { incrementBy?: number }) => {
+  const [count, setCount] = tapState(0);
+
+  tapEffect(() => {
+    console.log(`Count is now: ${count}`);
+  }, [count]);
+
+  return {
+    count,
+    increment: () => setCount((c) => c + incrementBy),
+    decrement: () => setCount((c) => c - incrementBy),
+  };
+});
+
+// Create an instance
+const counter = createResource(new Counter({ incrementBy: 2 }));
+
+// Subscribe to changes
+const unsubscribe = counter.subscribe(() => {
+  console.log("Counter value:", counter.getState().count);
+});
+
+// Use the resource
+counter.getState().increment();
+```
+
+## `resource`
+
+Creates a resource element factory. Resource elements are plain objects of the type `{ type: ResourceFn<R, P>, props: P, key?: string | number }`.
+
+```typescript
+const Counter = resource(({ incrementBy = 1 }: { incrementBy?: number }) => {
+  const [count, setCount] = tapState(0);
+});
+
+// create a Counter element
+const counterEl = new Counter({ incrementBy: 2 });
+
+// create a Counter instance
+const counter = createResource(counterEl);
+counter.dispose();
+```
+
+## Hook APIs
+
+### `tapState`
+
+Manages local state within a resource, exactly like React's `useState`.
+
+```typescript
+const [value, setValue] = tapState(initialValue);
+const [value, setValue] = tapState(() => computeInitialValue());
+```
+
+### `tapEffect`
+
+Runs side effects with automatic cleanup, exactly like React's `useEffect`.
+
+```typescript
+tapEffect(() => {
+  // Effect logic
+  return () => {
+    // Cleanup logic
+  };
+}, [dependencies]);
+```
+
+### `tapMemo`
+
+Memoizes expensive computations, exactly like React's `useMemo`.
+
+```typescript
+const expensiveValue = tapMemo(() => {
+  return computeExpensiveValue(dep1, dep2);
+}, [dep1, dep2]);
+```
+
+### `tapCallback`
+
+Memoizes callbacks to prevent unnecessary re-renders, exactly like React's `useCallback`.
+
+```typescript
+const stableCallback = tapCallback(() => {
+  doSomething(value);
+}, [value]);
+```
+
+### `tapRef`
+
+Creates a mutable reference that persists across renders, exactly like React's `useRef`.
+
+```typescript
+// With initial value
+const ref = tapRef(initialValue);
+ref.current = newValue;
+
+// Without initial value
+const ref = tapRef<string>(); // ref.current is undefined
+ref.current = "hello";
+```
+
+### `tapResource`
+
+Composes resources together - resources can render other resources.
+
+```typescript
+const Timer = resource(() => {
+  const counter = tapResource({ type: Counter, props: { incrementBy: 1 } });
+
+  tapEffect(() => {
+    const interval = setInterval(() => {
+      counter.increment();
+    }, 1000);
+    return () => clearInterval(interval);
+  }, []);
+
+  return counter.count;
+});
+```
+
+### `tapResources`
+
+Renders multiple resources with keys, similar to React's list rendering. All resources must have a unique `key` property.
+
+```typescript
+// Using with createResourceNodeConstructor
+const TodoItem = resource((props: { text: string }) => {
+  const [completed, setCompleted] = tapState(false);
+  return { text: props.text, completed, setCompleted };
+});
+
+const MyTodos = resource(() => {
+  const todos = [
+    { id: "1", text: "Learn reactive-resources" },
+    { id: "2", text: "Build something awesome" },
+  ];
+
+  const todoResources = tapResources(
+    todos.map((todo) => new TodoItem({ text: todo.text }, { key: todo.id }))
+  );
+
+  return todoResources;
+});
+```
+
+
+## Resource Management
+
+### `createResource`
+
+Create an instance of a resource. This renders the resource and mounts the tapEffect hooks.
+
+```typescript
+import { createResource } from "@assistant-ui/tap";
+
+const handle = createResource(new Counter({ incrementBy: 1 }));
+
+// Access current value
+console.log(handle.getState().count);
+
+// Subscribe to changes
+const unsubscribe = handle.subscribe(() => {
+  console.log("Counter updated:", handle.getState());
+});
+
+// Update props to the resource
+handle.updateInput({ incrementBy: 2 });
+
+// Cleanup
+unsubscribe();
+```
+
+## Why Reactive Resources?
+
+### Unified Mental Model
+
+Use the same hooks pattern everywhere - no need to learn different state management concepts for component state vs application state.
+
+### Lifecycle Management
+
+Unlike traditional state management libraries, resources handle their own lifecycle:
+
+```typescript
+const WebSocketResource = () => {
+  const [messages, setMessages] = tapState<string[]>([]);
+
+  tapEffect(() => {
+    const ws = new WebSocket("ws://localhost:8080");
+
+    ws.onmessage = (event) => {
+      setMessages((prev) => [...prev, event.data]);
+    };
+
+    // Cleanup happens automatically when resource unmounts
+    return () => ws.close();
+  }, []);
+
+  return messages;
+};
+```
+
+### Framework Agnostic
+
+Works with React or vanilla JavaScript. The core library has zero dependencies and doesn't require any specific framework.
+
+### Type Safety
+
+Full TypeScript support with proper type inference throughout.
+
+## Comparison with React Hooks
+
+| React Hook    | Reactive Resource | Behavior  |
+| ------------- | ----------------- | --------- |
+| `useState`    | `tapState`        | Identical |
+| `useEffect`   | `tapEffect`       | Identical |
+| `useMemo`     | `tapMemo`         | Identical |
+| `useCallback` | `tapCallback`     | Identical |
+| `useRef`      | `tapRef`          | Identical |
+
+## License
+
+MIT

package/dist/__tests__/test-utils.d.ts

@@ -0,0 +1,79 @@
+import { ResourceFn, ResourceFiber } from "../core/types";
+/**
+ * Creates a test resource fiber for unit testing.
+ * This is a low-level utility that creates a ResourceFiber directly.
+ * Sets up a rerender callback that automatically re-renders when state changes.
+ */
+export declare function createTestResource<R, P>(type: ResourceFn<R, P>): ResourceFiber;
+/**
+ * Renders a test resource fiber with the given props and manages its lifecycle.
+ * - Tracks resources for cleanup
+ * - Returns the current state after render
+ */
+export declare function renderTest<R, P>(fiber: ResourceFiber, props: P): R;
+/**
+ * Unmounts a specific resource fiber and removes it from tracking.
+ */
+export declare function unmountResource(fiber: ResourceFiber): void;
+/**
+ * Cleans up all resources. Should be called after each test.
+ */
+export declare function cleanupAllResources(): void;
+/**
+ * Gets the current committed state of a resource fiber.
+ * Returns the state from the last render/commit cycle.
+ */
+export declare function getCommittedState<R>(fiber: ResourceFiber): R;
+/**
+ * Helper to subscribe to resource state changes for testing.
+ * Tracks call count and latest state value.
+ */
+export declare class TestSubscriber<T> {
+    callCount: number;
+    lastState: T;
+    private fiber;
+    constructor(fiber: ResourceFiber);
+    cleanup(): void;
+}
+/**
+ * Helper class to manage resource lifecycle in tests with explicit control.
+ * Useful when you need fine-grained control over mount/unmount timing.
+ */
+export declare class TestResourceManager<R, P> {
+    fiber: ResourceFiber;
+    private isActive;
+    constructor(fiber: ResourceFiber);
+    renderAndMount(props: P): R;
+    cleanup(): void;
+}
+/**
+ * Waits for the next tick of the event loop.
+ * Useful for testing async state updates.
+ */
+export declare function waitForNextTick(): Promise<void>;
+/**
+ * Waits for a condition to be true with timeout.
+ * Useful for testing eventual consistency.
+ */
+export declare function waitFor(condition: () => boolean, timeout?: number, interval?: number): Promise<void>;
+/**
+ * Creates a simple counter resource for testing.
+ * Commonly used across multiple test files.
+ */
+export declare function createCounterResource(initialValue?: number): (props: {
+    value?: number;
+}) => {
+    count: number;
+};
+/**
+ * Creates a stateful counter resource for testing.
+ * Includes increment/decrement functions.
+ */
+export declare function createStatefulCounterResource(): (props: {
+    initial: number;
+}) => {
+    count: any;
+    increment: () => any;
+    decrement: () => any;
+};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/__tests__/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/__tests__/test-utils.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAM1D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,iBAe9D;AAWD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAclE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,QAKnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,SAGlC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,GAAG,CAAC,CAQ5D;AAMD;;;GAGG;AACH,qBAAa,cAAc,CAAC,CAAC;IACpB,SAAS,SAAK;IACd,SAAS,EAAE,CAAC,CAAC;IACpB,OAAO,CAAC,KAAK,CAAgB;gBAEjB,KAAK,EAAE,aAAa;IAsBhC,OAAO;CAMR;AAED;;;GAGG;AACH,qBAAa,mBAAmB,CAAC,CAAC,EAAE,CAAC;IAGhB,KAAK,EAAE,aAAa;IAFvC,OAAO,CAAC,QAAQ,CAAS;gBAEN,KAAK,EAAE,aAAa;IAEvC,cAAc,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;IAc3B,OAAO;CAOR;AAMD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;GAGG;AACH,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,EACxB,OAAO,SAAO,EACd,QAAQ,SAAK,GACZ,OAAO,CAAC,IAAI,CAAC,CAQf;AAMD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,SAAI,IAC5C,OAAO;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE;;EAIlC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,KAInC,OAAO;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE;;;;EAQnC"}

package/dist/__tests__/test-utils.js

@@ -0,0 +1,216 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/tap-state.ts
+var tap_state_exports = {};
+__export(tap_state_exports, {
+  tapState: () => tapState
+});
+import { getCurrentResourceFiber } from "../core/execution-context.js";
+function getStateCell(initialValue) {
+  const executionContext = getCurrentResourceFiber();
+  const index = executionContext.currentIndex++;
+  if (!executionContext.isFirstRender && index >= executionContext.cells.length) {
+    throw new Error(
+      "Rendered more hooks than during the previous render. Hooks must be called in the exact same order in every render."
+    );
+  }
+  if (!executionContext.cells[index]) {
+    const value = typeof initialValue === "function" ? initialValue() : initialValue;
+    const cell2 = {
+      type: "state",
+      value,
+      set: (updater) => {
+        const currentValue = cell2.value;
+        const nextValue = typeof updater === "function" ? updater(currentValue) : updater;
+        if (!Object.is(currentValue, nextValue)) {
+          cell2.value = nextValue;
+          if (executionContext.isRendering) {
+            throw new Error("Resource updated during render");
+          }
+          executionContext.scheduleRerender();
+        }
+      }
+    };
+    executionContext.cells[index] = cell2;
+  }
+  const cell = executionContext.cells[index];
+  if (cell.type !== "state") {
+    throw new Error("Hook order changed between renders");
+  }
+  return cell;
+}
+function tapState(initial) {
+  const cell = getStateCell(initial);
+  return [cell.value, cell.set];
+}
+var init_tap_state = __esm({
+  "src/hooks/tap-state.ts"() {
+    "use strict";
+  }
+});
+
+// src/__tests__/test-utils.ts
+import {
+  createResourceFiber,
+  unmountResource as unmountResourceFiber,
+  renderResource as renderResourceFiber,
+  commitResource
+} from "../core/ResourceFiber.js";
+function createTestResource(type) {
+  let fiber;
+  const rerenderCallback = () => {
+    if (activeResources.has(fiber)) {
+      const lastProps = propsMap.get(fiber);
+      const result = renderResourceFiber(fiber, lastProps);
+      commitResource(fiber, result);
+      lastRenderResultMap.set(fiber, result);
+    }
+  };
+  fiber = createResourceFiber(type, rerenderCallback);
+  return fiber;
+}
+var activeResources = /* @__PURE__ */ new Set();
+var propsMap = /* @__PURE__ */ new WeakMap();
+var lastRenderResultMap = /* @__PURE__ */ new WeakMap();
+function renderTest(fiber, props) {
+  propsMap.set(fiber, props);
+  activeResources.add(fiber);
+  const result = renderResourceFiber(fiber, props);
+  commitResource(fiber, result);
+  lastRenderResultMap.set(fiber, result);
+  return result.state;
+}
+function unmountResource(fiber) {
+  if (activeResources.has(fiber)) {
+    unmountResourceFiber(fiber);
+    activeResources.delete(fiber);
+  }
+}
+function cleanupAllResources() {
+  activeResources.forEach((fiber) => unmountResourceFiber(fiber));
+  activeResources.clear();
+}
+function getCommittedState(fiber) {
+  const lastResult = lastRenderResultMap.get(fiber);
+  if (!lastResult) {
+    throw new Error(
+      "No render result found for fiber. Make sure to call renderResource first."
+    );
+  }
+  return lastResult.state;
+}
+var TestSubscriber = class {
+  callCount = 0;
+  lastState;
+  fiber;
+  constructor(fiber) {
+    this.fiber = fiber;
+    const lastProps = propsMap.get(fiber) ?? void 0;
+    const initialResult = renderResourceFiber(fiber, lastProps);
+    commitResource(fiber, initialResult);
+    this.lastState = initialResult.state;
+    lastRenderResultMap.set(fiber, initialResult);
+    activeResources.add(fiber);
+    fiber._rerenderCallback = () => {
+      this.callCount++;
+      const lastProps2 = propsMap.get(fiber) ?? void 0;
+      const result = renderResourceFiber(fiber, lastProps2);
+      commitResource(fiber, result);
+      this.lastState = result.state;
+      lastRenderResultMap.set(fiber, result);
+    };
+  }
+  cleanup() {
+    if (activeResources.has(this.fiber)) {
+      unmountResourceFiber(this.fiber);
+      activeResources.delete(this.fiber);
+    }
+  }
+};
+var TestResourceManager = class {
+  constructor(fiber) {
+    this.fiber = fiber;
+  }
+  isActive = false;
+  renderAndMount(props) {
+    if (this.isActive) {
+      throw new Error("Resource already active");
+    }
+    this.isActive = true;
+    activeResources.add(this.fiber);
+    propsMap.set(this.fiber, props);
+    const result = renderResourceFiber(this.fiber, props);
+    commitResource(this.fiber, result);
+    lastRenderResultMap.set(this.fiber, result);
+    return result.state;
+  }
+  cleanup() {
+    if (this.isActive && activeResources.has(this.fiber)) {
+      unmountResourceFiber(this.fiber);
+      activeResources.delete(this.fiber);
+      this.isActive = false;
+    }
+  }
+};
+function waitForNextTick() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function waitFor(condition, timeout = 1e3, interval = 10) {
+  const start = Date.now();
+  while (!condition()) {
+    if (Date.now() - start > timeout) {
+      throw new Error("Timeout waiting for condition");
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+}
+function createCounterResource(initialValue = 0) {
+  return (props) => {
+    const value = props.value ?? initialValue;
+    return { count: value };
+  };
+}
+function createStatefulCounterResource() {
+  const { tapState: tapState2 } = (init_tap_state(), __toCommonJS(tap_state_exports));
+  return (props) => {
+    const [count, setCount] = tapState2(props.initial);
+    return {
+      count,
+      increment: () => setCount((c) => c + 1),
+      decrement: () => setCount((c) => c - 1)
+    };
+  };
+}
+export {
+  TestResourceManager,
+  TestSubscriber,
+  cleanupAllResources,
+  createCounterResource,
+  createStatefulCounterResource,
+  createTestResource,
+  getCommittedState,
+  renderTest,
+  unmountResource,
+  waitFor,
+  waitForNextTick
+};
+//# sourceMappingURL=test-utils.js.map

package/dist/__tests__/test-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/tap-state.ts","../../src/__tests__/test-utils.ts"],"sourcesContent":["import { getCurrentResourceFiber } from \"../core/execution-context\";\nimport { StateUpdater, Cell } from \"../core/types\";\n\nfunction getStateCell<T>(\n  initialValue: T | (() => T)\n): Cell & { type: \"state\" } {\n  const executionContext = getCurrentResourceFiber();\n  const index = executionContext.currentIndex++;\n\n  // Check if we're trying to use more hooks than in previous renders\n  if (\n    !executionContext.isFirstRender &&\n    index >= executionContext.cells.length\n  ) {\n    throw new Error(\n      \"Rendered more hooks than during the previous render. \" +\n        \"Hooks must be called in the exact same order in every render.\"\n    );\n  }\n\n  if (!executionContext.cells[index]) {\n    // Initialize the value immediately\n    const value =\n      typeof initialValue === \"function\"\n        ? (initialValue as () => T)()\n        : initialValue;\n\n    const cell: Cell & { type: \"state\" } = {\n      type: \"state\",\n      value,\n      set: (updater: StateUpdater<T>) => {\n        const currentValue = cell.value;\n        const nextValue =\n          typeof updater === \"function\"\n            ? (updater as (prev: T) => T)(currentValue)\n            : updater;\n\n        if (!Object.is(currentValue, nextValue)) {\n          cell.value = nextValue;\n\n          // Check if called during render (not allowed)\n          if (executionContext.isRendering) {\n            throw new Error(\"Resource updated during render\");\n          }\n          executionContext.scheduleRerender();\n        }\n      },\n    };\n\n    executionContext.cells[index] = cell;\n  }\n\n  const cell = executionContext.cells[index];\n  if (cell.type !== \"state\") {\n    throw new Error(\"Hook order changed between renders\");\n  }\n\n  return cell as Cell & { type: \"state\" };\n}\n\nexport function tapState<S = undefined>(): [\n  S | undefined,\n  (updater: StateUpdater<S>) => void\n];\nexport function tapState<S>(\n  initial: S | (() => S)\n): [S, (updater: StateUpdater<S>) => void];\nexport function tapState<S>(\n  initial?: S | (() => S)\n): [S | undefined, (updater: StateUpdater<S>) => void] {\n  const cell = getStateCell(initial as S | (() => S));\n\n  return [cell.value, cell.set];\n}\n","import {\n  createResourceFiber,\n  unmountResource as unmountResourceFiber,\n  renderResource as renderResourceFiber,\n  commitResource,\n} from \"../core/ResourceFiber\";\nimport { ResourceFn, ResourceFiber } from \"../core/types\";\n\n// ============================================================================\n// Resource Creation\n// ============================================================================\n\n/**\n * Creates a test resource fiber for unit testing.\n * This is a low-level utility that creates a ResourceFiber directly.\n * Sets up a rerender callback that automatically re-renders when state changes.\n */\nexport function createTestResource<R, P>(type: ResourceFn<R, P>) {\n  let fiber: ResourceFiber;\n\n  const rerenderCallback = () => {\n    // Re-render when state changes\n    if (activeResources.has(fiber)) {\n      const lastProps = propsMap.get(fiber);\n      const result = renderResourceFiber(fiber, lastProps);\n      commitResource(fiber, result);\n      lastRenderResultMap.set(fiber, result);\n    }\n  };\n\n  fiber = createResourceFiber(type, rerenderCallback);\n  return fiber;\n}\n\n// ============================================================================\n// Resource Lifecycle Management\n// ============================================================================\n\n// Track resources for cleanup\nconst activeResources = new Set<ResourceFiber>();\nconst propsMap = new WeakMap<ResourceFiber, any>();\nconst lastRenderResultMap = new WeakMap<ResourceFiber, any>();\n\n/**\n * Renders a test resource fiber with the given props and manages its lifecycle.\n * - Tracks resources for cleanup\n * - Returns the current state after render\n */\nexport function renderTest<R, P>(fiber: ResourceFiber, props: P): R {\n  propsMap.set(fiber, props);\n\n  // Track resource for cleanup\n  activeResources.add(fiber);\n\n  // Render with new props\n  const result = renderResourceFiber(fiber, props);\n  commitResource(fiber, result);\n  lastRenderResultMap.set(fiber, result);\n\n  // Return the committed state from the result\n  // This accounts for any re-renders that happened during commit\n  return result.state;\n}\n\n/**\n * Unmounts a specific resource fiber and removes it from tracking.\n */\nexport function unmountResource(fiber: ResourceFiber) {\n  if (activeResources.has(fiber)) {\n    unmountResourceFiber(fiber);\n    activeResources.delete(fiber);\n  }\n}\n\n/**\n * Cleans up all resources. Should be called after each test.\n */\nexport function cleanupAllResources() {\n  activeResources.forEach((fiber) => unmountResourceFiber(fiber));\n  activeResources.clear();\n}\n\n/**\n * Gets the current committed state of a resource fiber.\n * Returns the state from the last render/commit cycle.\n */\nexport function getCommittedState<R>(fiber: ResourceFiber): R {\n  const lastResult = lastRenderResultMap.get(fiber);\n  if (!lastResult) {\n    throw new Error(\n      \"No render result found for fiber. Make sure to call renderResource first.\"\n    );\n  }\n  return lastResult.state;\n}\n\n// ============================================================================\n// Test Helpers\n// ============================================================================\n\n/**\n * Helper to subscribe to resource state changes for testing.\n * Tracks call count and latest state value.\n */\nexport class TestSubscriber<T> {\n  public callCount = 0;\n  public lastState: T;\n  private fiber: ResourceFiber;\n\n  constructor(fiber: ResourceFiber) {\n    this.fiber = fiber;\n    // Need to render once to get initial state\n    const lastProps = propsMap.get(fiber) ?? undefined;\n    const initialResult = renderResourceFiber(fiber, lastProps as any);\n    commitResource(fiber, initialResult);\n    this.lastState = initialResult.state;\n    lastRenderResultMap.set(fiber, initialResult);\n    activeResources.add(fiber);\n\n    // Update the fiber's rerender callback\n    (fiber as any)._rerenderCallback = () => {\n      this.callCount++;\n      // Re-render to get latest state\n      const lastProps = propsMap.get(fiber) ?? undefined;\n      const result = renderResourceFiber(fiber, lastProps as any);\n      commitResource(fiber, result);\n      this.lastState = result.state;\n      lastRenderResultMap.set(fiber, result);\n    };\n  }\n\n  cleanup() {\n    if (activeResources.has(this.fiber)) {\n      unmountResourceFiber(this.fiber);\n      activeResources.delete(this.fiber);\n    }\n  }\n}\n\n/**\n * Helper class to manage resource lifecycle in tests with explicit control.\n * Useful when you need fine-grained control over mount/unmount timing.\n */\nexport class TestResourceManager<R, P> {\n  private isActive = false;\n\n  constructor(public fiber: ResourceFiber) {}\n\n  renderAndMount(props: P): R {\n    if (this.isActive) {\n      throw new Error(\"Resource already active\");\n    }\n\n    this.isActive = true;\n    activeResources.add(this.fiber);\n    propsMap.set(this.fiber, props);\n    const result = renderResourceFiber(this.fiber, props);\n    commitResource(this.fiber, result);\n    lastRenderResultMap.set(this.fiber, result);\n    return result.state;\n  }\n\n  cleanup() {\n    if (this.isActive && activeResources.has(this.fiber)) {\n      unmountResourceFiber(this.fiber);\n      activeResources.delete(this.fiber);\n      this.isActive = false;\n    }\n  }\n}\n\n// ============================================================================\n// Async Utilities\n// ============================================================================\n\n/**\n * Waits for the next tick of the event loop.\n * Useful for testing async state updates.\n */\nexport function waitForNextTick(): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, 0));\n}\n\n/**\n * Waits for a condition to be true with timeout.\n * Useful for testing eventual consistency.\n */\nexport async function waitFor(\n  condition: () => boolean,\n  timeout = 1000,\n  interval = 10\n): Promise<void> {\n  const start = Date.now();\n  while (!condition()) {\n    if (Date.now() - start > timeout) {\n      throw new Error(\"Timeout waiting for condition\");\n    }\n    await new Promise((resolve) => setTimeout(resolve, interval));\n  }\n}\n\n// ============================================================================\n// Test Data Factories\n// ============================================================================\n\n/**\n * Creates a simple counter resource for testing.\n * Commonly used across multiple test files.\n */\nexport function createCounterResource(initialValue = 0) {\n  return (props: { value?: number }) => {\n    const value = props.value ?? initialValue;\n    return { count: value };\n  };\n}\n\n/**\n * Creates a stateful counter resource for testing.\n * Includes increment/decrement functions.\n */\nexport function createStatefulCounterResource() {\n  // Import at top of file to avoid issues\n  const { tapState } = require(\"../hooks/tap-state\");\n\n  return (props: { initial: number }) => {\n    const [count, setCount] = tapState(props.initial);\n    return {\n      count,\n      increment: () => setCount((c: number) => c + 1),\n      decrement: () => setCount((c: number) => c - 1),\n    };\n  };\n}\n"],"mappings":"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","names":["cell","lastProps","tapState"]}

package/dist/core/ResourceFiber.d.ts

@@ -0,0 +1,6 @@
+import { ResourceFn, ResourceFiber, RenderResult } from "./types";
+export declare function createResourceFiber<R, P>(resourceFn: ResourceFn<R, P>, scheduleRerender: () => void): ResourceFiber;
+export declare function unmountResource(fiber: ResourceFiber): void;
+export declare function renderResource<R, P>(fiber: ResourceFiber, props: P): RenderResult;
+export declare function commitResource(fiber: ResourceFiber, result: RenderResult): void;
+//# sourceMappingURL=ResourceFiber.d.ts.map

package/dist/core/ResourceFiber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceFiber.d.ts","sourceRoot":"","sources":["../../src/core/ResourceFiber.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAIlE,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,UAAU,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAC5B,gBAAgB,EAAE,MAAM,IAAI,GAC3B,aAAa,CAWf;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAG1D;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EACjC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,CAAC,GACP,YAAY,CAed;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,YAAY,GACnB,IAAI,CAGN"}

package/dist/core/ResourceFiber.js

@@ -0,0 +1,41 @@
+// src/core/ResourceFiber.ts
+import { commitRender, cleanupAllEffects } from "./commit.js";
+import { withResourceFiber } from "./execution-context.js";
+function createResourceFiber(resourceFn, scheduleRerender) {
+  return {
+    resourceFn,
+    scheduleRerender,
+    cells: [],
+    commitTasks: [],
+    currentIndex: 0,
+    committedProps: void 0,
+    isRendering: false,
+    isFirstRender: true
+  };
+}
+function unmountResource(fiber) {
+  cleanupAllEffects(fiber);
+}
+function renderResource(fiber, props) {
+  let state;
+  withResourceFiber(fiber, () => {
+    state = fiber.resourceFn(props);
+  });
+  fiber.committedProps ??= props;
+  return {
+    commitTasks: fiber.commitTasks,
+    props,
+    state
+  };
+}
+function commitResource(fiber, result) {
+  commitRender(result, fiber);
+  fiber.committedProps = result.props;
+}
+export {
+  commitResource,
+  createResourceFiber,
+  renderResource,
+  unmountResource
+};
+//# sourceMappingURL=ResourceFiber.js.map

package/dist/core/ResourceFiber.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/ResourceFiber.ts"],"sourcesContent":["import { ResourceFn, ResourceFiber, RenderResult } from \"./types\";\nimport { commitRender, cleanupAllEffects } from \"./commit\";\nimport { withResourceFiber } from \"./execution-context\";\n\nexport function createResourceFiber<R, P>(\n  resourceFn: ResourceFn<R, P>,\n  scheduleRerender: () => void\n): ResourceFiber {\n  return {\n    resourceFn,\n    scheduleRerender,\n    cells: [],\n    commitTasks: [],\n    currentIndex: 0,\n    committedProps: undefined,\n    isRendering: false,\n    isFirstRender: true,\n  };\n}\n\nexport function unmountResource(fiber: ResourceFiber): void {\n  // Clean up all effects\n  cleanupAllEffects(fiber);\n}\n\nexport function renderResource<R, P>(\n  fiber: ResourceFiber,\n  props: P\n): RenderResult {\n  let state: R | undefined;\n\n  withResourceFiber(fiber, () => {\n    state = fiber.resourceFn(props);\n  });\n\n  // on first render, we save the props for setState calls post render before commit\n  fiber.committedProps ??= props;\n\n  return {\n    commitTasks: fiber.commitTasks,\n    props,\n    state,\n  };\n}\n\nexport function commitResource(\n  fiber: ResourceFiber,\n  result: RenderResult\n): void {\n  commitRender(result, fiber);\n  fiber.committedProps = result.props;\n}\n"],"mappings":";AACA,SAAS,cAAc,yBAAyB;AAChD,SAAS,yBAAyB;AAE3B,SAAS,oBACd,YACA,kBACe;AACf,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,CAAC;AAAA,IACR,aAAa,CAAC;AAAA,IACd,cAAc;AAAA,IACd,gBAAgB;AAAA,IAChB,aAAa;AAAA,IACb,eAAe;AAAA,EACjB;AACF;AAEO,SAAS,gBAAgB,OAA4B;AAE1D,oBAAkB,KAAK;AACzB;AAEO,SAAS,eACd,OACA,OACc;AACd,MAAI;AAEJ,oBAAkB,OAAO,MAAM;AAC7B,YAAQ,MAAM,WAAW,KAAK;AAAA,EAChC,CAAC;AAGD,QAAM,mBAAmB;AAEzB,SAAO;AAAA,IACL,aAAa,MAAM;AAAA,IACnB;AAAA,IACA;AAAA,EACF;AACF;AAEO,SAAS,eACd,OACA,QACM;AACN,eAAa,QAAQ,KAAK;AAC1B,QAAM,iBAAiB,OAAO;AAChC;","names":[]}

package/dist/core/ResourceHandle.d.ts

@@ -0,0 +1,8 @@
+import { ResourceElement, Unsubscribe } from "./types";
+export interface ResourceHandle<R, P> {
+    getState(): R;
+    subscribe(callback: () => void): Unsubscribe;
+    updateInput(props: P): void;
+}
+export declare const createResource: <R, P>(element: ResourceElement<R, P>) => ResourceHandle<R, P>;
+//# sourceMappingURL=ResourceHandle.d.ts.map

package/dist/core/ResourceHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceHandle.d.ts","sourceRoot":"","sources":["../../src/core/ResourceHandle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAcvD,MAAM,WAAW,cAAc,CAAC,CAAC,EAAE,CAAC;IAClC,QAAQ,IAAI,CAAC,CAAC;IACd,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,WAAW,CAAC;IAC7C,WAAW,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAC7B;AAuCD,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EACjC,SAAS,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,KAC7B,cAAc,CAAC,CAAC,EAAE,CAAC,CAmBrB,CAAC"}