@praxisjs/concurrent 1.3.8 → 1.3.9

package/dist/utils.js

@@ -1,12 +1,26 @@
+import { createEffect, disposeEffect, pauseTracking, readSignal, resumeTracking, } from "@praxisjs/core/internal";
+const signalParams = new WeakMap();
 /**
  * Returns true if the function declares `signal` as its first parameter name.
  * Used to decide whether to inject an AbortSignal at call time.
  *
  * Works on unminified source (class methods, arrow functions, async functions).
  * Bound functions always return false — check the original method before binding.
+ *
+ * Cached per function: a decorated method is the same prototype function for every instance, and
+ * reading its source on each construction was the main cost of creating a decorated component.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function acceptsSignal(fn) {
+    let result = signalParams.get(fn);
+    if (result === undefined) {
+        result = readsSignalParam(fn);
+        signalParams.set(fn, result);
+    }
+    return result;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function readsSignalParam(fn) {
     try {
         const src = fn.toString();
         // Match the first character of the parameter list, e.g.:
@@ -23,4 +37,32 @@ export function acceptsSignal(fn) {
         return false;
     }
 }
+/**
+ * A read-only `Computed` view of a signal node: reading it tracks the node directly, without the
+ * extra computed node, getter closure and recomputation a `computed(() => sig())` wrapper costs.
+ */
+export function readonlyView(node) {
+    const view = (() => readSignal(node));
+    view.subscribe = (fn) => {
+        const effect = createEffect(() => {
+            const value = readSignal(node);
+            const prev = pauseTracking();
+            try {
+                fn(value);
+            }
+            finally {
+                resumeTracking(prev);
+            }
+        });
+        return () => { disposeEffect(effect); };
+    };
+    view.__isComputed = true;
+    return view;
+}
+export function isAbortError(err) {
+    return err instanceof Error && err.name === "AbortError";
+}
+export function toError(err) {
+    return err instanceof Error ? err : new Error(String(err));
+}
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,8DAA8D;AAC9D,MAAM,UAAU,aAAa,CAAC,EAA2B;IACvD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC1B,yDAAyD;QACzD,4CAA4C;QAC5C,6EAA6E;QAC7E,yCAAyC;QACzC,sCAAsC;QACtC,MAAM,CAAC,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtC,MAAM,QAAQ,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC9B,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACnD,OAAO,SAAS,KAAK,QAAQ,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,cAAc,GAEf,MAAM,yBAAyB,CAAC;AAGjC,MAAM,YAAY,GAAG,IAAI,OAAO,EAAmB,CAAC;AAEpD;;;;;;;;;GASG;AACH,8DAA8D;AAC9D,MAAM,UAAU,aAAa,CAAC,EAA2B;IACvD,IAAI,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAClC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,GAAG,gBAAgB,CAAC,EAAE,CAAC,CAAC;QAC9B,YAAY,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,8DAA8D;AAC9D,SAAS,gBAAgB,CAAC,EAA2B;IACnD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;QAC1B,yDAAyD;QACzD,4CAA4C;QAC5C,6EAA6E;QAC7E,yCAAyC;QACzC,sCAAsC;QACtC,MAAM,CAAC,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtC,MAAM,QAAQ,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC9B,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACnD,OAAO,SAAS,KAAK,QAAQ,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAI,IAAmB;IACjD,MAAM,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAgB,CAAC;IACrD,IAAI,CAAC,SAAS,GAAG,CAAC,EAAsB,EAAE,EAAE;QAC1C,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,EAAE;YAC/B,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;YAC/B,MAAM,IAAI,GAAG,aAAa,EAAE,CAAC;YAC7B,IAAI,CAAC;gBACH,EAAE,CAAC,KAAK,CAAC,CAAC;YACZ,CAAC;oBAAS,CAAC;gBACT,cAAc,CAAC,IAAI,CAAC,CAAC;YACvB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC,CAAC;IACF,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IACzB,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,OAAO,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,IAAI,KAAK,YAAY,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,GAAY;IAClC,OAAO,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7D,CAAC"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@praxisjs/concurrent",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -10,16 +11,24 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist",
+    "src",
+    "!dist/**/__tests__",
+    "!src/**/__tests__",
+    "CHANGELOG.md"
+  ],
   "devDependencies": {
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@praxisjs/core": "2.2.0",
-    "@praxisjs/decorators": "1.7.0",
-    "@praxisjs/shared": "0.3.1"
+    "@praxisjs/core": "2.3.0",
+    "@praxisjs/shared": "0.3.2",
+    "@praxisjs/decorators": "2.0.0"
   },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch"
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/decorators.ts

@@ -1,4 +1,4 @@
-import { createFieldDecorator } from "@praxisjs/decorators";
+import { assertFieldContext } from "@praxisjs/decorators";
 import type { Computed } from "@praxisjs/shared";
 
 import { pool } from "./pool";
@@ -58,54 +58,53 @@ export type QueueOf<C, K extends keyof C> =
 export type PoolOf<C, K extends keyof C> =
   C[K] extends AnyAsyncFn ? PoolDecorated<C[K]> : never;
 
+// ── Field decorators ───────────────────────────────────────────────────────────
+
+// Each decorator returns the field's initializer: the value is created per instance while the
+// field is defined, instead of redefining the field afterwards with Object.defineProperty.
+function fieldFrom(
+  methodName: string,
+  create: (method: AnyAsyncFn, wantsSignal: boolean) => unknown,
+): (this: object) => unknown {
+  return function (this: object): unknown {
+    const method = (this as Record<string, AnyAsyncFn>)[methodName];
+    // Detect signal on the unbound method — bound functions lose their source.
+    return create(method.bind(this), acceptsSignal(method));
+  };
+}
+
 // ── @Task ──────────────────────────────────────────────────────────────────────
 
 export function Task(methodName: string) {
-  return createFieldDecorator({
-    bind(instance: object, _name: string) {
-      const inst = instance as Record<string, AnyAsyncFn>;
-      // Detect signal on the unbound method — bound functions lose their source.
-      const wantsSignal = acceptsSignal(inst[methodName]);
-      return {
-        descriptor: {
-          value: task(inst[methodName].bind(instance), { signal: wantsSignal }) as unknown,
-          writable: true,
-        },
-      };
-    },
-  });
+  return function <This extends object, Value = unknown>(
+    _value: undefined,
+    context: ClassFieldDecoratorContext<This, Value>,
+  ): (this: This) => Value {
+    assertFieldContext(context);
+    return fieldFrom(methodName, (method, signal) => task(method, { signal })) as (this: This) => Value;
+  };
 }
 
 // ── @Queue ─────────────────────────────────────────────────────────────────────
 
 export function Queue(methodName: string) {
-  return createFieldDecorator({
-    bind(instance: object, _name: string) {
-      const inst = instance as Record<string, AnyAsyncFn>;
-      const wantsSignal = acceptsSignal(inst[methodName]);
-      return {
-        descriptor: {
-          value: queue(inst[methodName].bind(instance), { signal: wantsSignal }) as unknown,
-          writable: true,
-        },
-      };
-    },
-  });
+  return function <This extends object, Value = unknown>(
+    _value: undefined,
+    context: ClassFieldDecoratorContext<This, Value>,
+  ): (this: This) => Value {
+    assertFieldContext(context);
+    return fieldFrom(methodName, (method, signal) => queue(method, { signal })) as (this: This) => Value;
+  };
 }
 
 // ── @Pool ──────────────────────────────────────────────────────────────────────
 
 export function Pool(methodName: string, concurrency = 1) {
-  return createFieldDecorator({
-    bind(instance: object, _name: string) {
-      const inst = instance as Record<string, AnyAsyncFn>;
-      const wantsSignal = acceptsSignal(inst[methodName]);
-      return {
-        descriptor: {
-          value: pool(concurrency, inst[methodName].bind(instance), { signal: wantsSignal }) as unknown,
-          writable: true,
-        },
-      };
-    },
-  });
+  return function <This extends object, Value = unknown>(
+    _value: undefined,
+    context: ClassFieldDecoratorContext<This, Value>,
+  ): (this: This) => Value {
+    assertFieldContext(context);
+    return fieldFrom(methodName, (method, signal) => pool(concurrency, method, { signal })) as (this: This) => Value;
+  };
 }

package/src/pool.ts

@@ -1,7 +1,7 @@
-import { signal, computed } from "@praxisjs/core/internal";
+import { endBatch, SignalNode, startBatch, writeSignal } from "@praxisjs/core/internal";
 import type { Computed } from "@praxisjs/shared";
 
-import { acceptsSignal } from "./utils";
+import { acceptsSignal, isAbortError, readonlyView, toError } from "./utils";
 
 export interface PoolInstance<T> {
   (...args: unknown[]): Promise<T | undefined>;
@@ -12,8 +12,10 @@ export interface PoolInstance<T> {
   cancelAll(): void;
 }
 
-function isAbortError(err: unknown): boolean {
-  return err instanceof Error && err.name === "AbortError";
+interface PoolItem<T> {
+  args: unknown[];
+  resolve: (v: T | undefined) => void;
+  controller: AbortController | undefined;
 }
 
 export function pool<T>(
@@ -22,65 +24,81 @@ export function pool<T>(
   options?: { signal?: boolean },
 ): PoolInstance<T> {
   concurrency = Math.max(1, concurrency);
-  const _active = signal(0);
-  const _pending = signal(0);
-  const _error = signal<Error | null>(null);
-  const _wantsSignal = options?.signal ?? acceptsSignal(fn);
-  const _queue: Array<{
-    args: unknown[];
-    resolve: (v: T | undefined) => void;
-    controller: AbortController;
-  }> = [];
-  const _activeControllers = new Set<AbortController>();
+  const activeNode = new SignalNode(0);
+  const pendingNode = new SignalNode(0);
+  const loadingNode = new SignalNode(false);
+  const error = new SignalNode<Error | null>(null);
+  const wantsSignal = options?.signal ?? acceptsSignal(fn);
+  // Plain counters drive scheduling: reading the signals here would subscribe whatever effect
+  // happens to call the pool.
+  let active = 0;
+  let items: Array<PoolItem<T> | undefined> = [];
+  let head = 0;
+  const activeControllers = new Set<AbortController>();
 
-  async function tryRun(): Promise<void> {
-    if (_active() >= concurrency || _queue.length === 0) return;
-    const item = _queue[0];
-    _queue.shift();
+  function publish(): void {
+    startBatch();
+    writeSignal(activeNode, active);
+    writeSignal(pendingNode, items.length - head);
+    writeSignal(loadingNode, active > 0);
+    endBatch();
+  }
 
+  async function execute(item: PoolItem<T>): Promise<void> {
     const { args, resolve, controller } = item;
-    _pending.update((n) => n - 1);
-    _active.update((n) => n + 1);
-    _activeControllers.add(controller);
+    if (controller) activeControllers.add(controller);
     try {
-      const result = await (_wantsSignal ? fn(controller.signal, ...args) : fn(...args));
-      resolve(result);
+      resolve(await (controller ? fn(controller.signal, ...args) : fn(...args)));
     } catch (err) {
-      if (!isAbortError(err)) {
-        _error.set(err instanceof Error ? err : new Error(String(err)));
-      }
+      if (!isAbortError(err)) writeSignal(error, toError(err));
       resolve(undefined);
     } finally {
-      _activeControllers.delete(controller);
-      _active.update((n) => n - 1);
-      void tryRun();
+      if (controller) activeControllers.delete(controller);
+      active--;
+      pump();
     }
   }
 
+  function pump(): void {
+    while (active < concurrency && head < items.length) {
+      const item = items[head] as PoolItem<T>;
+      items[head++] = undefined;
+      if (head === items.length) {
+        items = [];
+        head = 0;
+      }
+      active++;
+      void execute(item);
+    }
+    publish();
+  }
+
   function run(...args: unknown[]): Promise<T | undefined> {
-    const controller = new AbortController();
     return new Promise<T | undefined>((resolve) => {
-      _queue.push({ args, resolve, controller });
-      _pending.update((n) => n + 1);
-      void tryRun();
+      items.push({ args, resolve, controller: wantsSignal ? new AbortController() : undefined });
+      // While every slot is busy only the backlog grows.
+      if (active < concurrency) pump();
+      else writeSignal(pendingNode, items.length - head);
     });
   }
 
-  run.loading = computed(() => _active() > 0);
-  run.active = computed(() => _active());
-  run.pending = computed(() => _pending());
-  run.error = computed(() => _error());
+  run.loading = readonlyView(loadingNode);
+  run.active = readonlyView(activeNode);
+  run.pending = readonlyView(pendingNode);
+  run.error = readonlyView(error);
   run.cancelAll = () => {
-    for (const c of _activeControllers) {
-      c.abort();
-    }
-    _activeControllers.clear();
-    while (_queue.length > 0) {
-      const item = _queue.shift();
-      item?.controller.abort();
-      item?.resolve(undefined);
+    for (const c of activeControllers) c.abort();
+    activeControllers.clear();
+    const cleared = items;
+    const from = head;
+    items = [];
+    head = 0;
+    for (let i = from; i < cleared.length; i++) {
+      const item = cleared[i] as PoolItem<T>;
+      item.controller?.abort();
+      item.resolve(undefined);
     }
-    _pending.set(0);
+    publish();
   };
 
   return run as PoolInstance<T>;

package/src/queue.ts

@@ -1,7 +1,7 @@
-import { signal, computed } from "@praxisjs/core/internal";
+import { SignalNode, writeSignal } from "@praxisjs/core/internal";
 import type { Computed } from "@praxisjs/shared";
 
-import { acceptsSignal } from "./utils";
+import { acceptsSignal, isAbortError, readonlyView, toError } from "./utils";
 
 export class QueueClearedError extends Error {
   constructor() {
@@ -10,10 +10,6 @@ export class QueueClearedError extends Error {
   }
 }
 
-function isAbortError(err: unknown): boolean {
-  return err instanceof Error && err.name === "AbortError";
-}
-
 export interface QueueInstance<T> {
   (...args: unknown[]): Promise<T>;
   loading: Computed<boolean>;
@@ -22,86 +18,94 @@ export interface QueueInstance<T> {
   clear(): void;
 }
 
+interface QueueItem<T> {
+  args: unknown[];
+  resolve: (v: T) => void;
+  reject: (e: Error) => void;
+  controller: AbortController | undefined;
+}
+
 export function queue<T>(
   fn: (...args: unknown[]) => Promise<T>,
   options?: { signal?: boolean },
 ): QueueInstance<T> {
-  const _loading = signal(false);
-  const _pending = signal(0);
-  const _error = signal<Error | null>(null);
-  const _wantsSignal = options?.signal ?? acceptsSignal(fn);
-  const _queue: Array<{
-    args: unknown[];
-    resolve: (v: T) => void;
-    reject: (e: Error) => void;
-    controller: AbortController;
-  }> = [];
-  let _running = false;
-  let _cleared = false;
-  let _activeController: AbortController | null = null;
-  let _activeAbortedByClear = false;
+  const loading = new SignalNode(false);
+  const pending = new SignalNode(0);
+  const error = new SignalNode<Error | null>(null);
+  const wantsSignal = options?.signal ?? acceptsSignal(fn);
+  // FIFO read from `head`: shifting the array instead made draining n calls O(n²).
+  let items: Array<QueueItem<T> | undefined> = [];
+  let head = 0;
+  let running = false;
+  let inCall = false;
+  let activeController: AbortController | undefined;
+  let activeAbortedByClear = false;
 
   async function drain(): Promise<void> {
-    if (_running || _queue.length === 0) return;
-    _running = true;
-    _loading.set(true);
-    while (_queue.length > 0) {
-      const item = _queue[0];
-      _queue.shift();
+    if (running || head === items.length) return;
+    running = true;
+    writeSignal(loading, true);
+    while (head < items.length) {
+      const item = items[head] as QueueItem<T>;
+      items[head++] = undefined;
+      if (head === items.length) {
+        items = [];
+        head = 0;
+      }
 
       const { args, resolve, reject, controller } = item;
-      _activeController = controller;
-      _activeAbortedByClear = false;
-      _pending.update((n) => n - 1);
+      activeController = controller;
+      activeAbortedByClear = false;
+      inCall = true;
+      writeSignal(pending, items.length - head);
       try {
-        const result = await (_wantsSignal ? fn(controller.signal, ...args) : fn(...args));
+        const result = await (controller ? fn(controller.signal, ...args) : fn(...args));
         resolve(result);
       } catch (err) {
-        // _activeAbortedByClear is set asynchronously by clear() between the await and this catch
+        // activeAbortedByClear is set by clear() while the call is awaited
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (isAbortError(err) && _activeAbortedByClear) {
+        if (isAbortError(err) && activeAbortedByClear) {
           reject(new QueueClearedError());
         } else {
-          const e = err instanceof Error ? err : new Error(String(err));
-          _error.set(e);
+          const e = toError(err);
+          writeSignal(error, e);
           reject(e);
         }
       } finally {
-        _activeController = null;
+        inCall = false;
+        activeController = undefined;
       }
     }
-    _cleared = false;
-    _running = false;
-    _loading.set(false);
+    running = false;
+    writeSignal(loading, false);
   }
 
   function enqueue(...args: unknown[]): Promise<T> {
-    if (_cleared) {
-      _cleared = false;
-    }
-    const controller = new AbortController();
     return new Promise<T>((resolve, reject) => {
-      _queue.push({ args, resolve, reject, controller });
-      _pending.update((n) => n + 1);
+      items.push({ args, resolve, reject, controller: wantsSignal ? new AbortController() : undefined });
+      writeSignal(pending, items.length - head);
       void drain();
     });
   }
 
-  enqueue.loading = computed(() => _loading());
-  enqueue.pending = computed(() => _pending());
-  enqueue.error = computed(() => _error());
+  enqueue.loading = readonlyView(loading);
+  enqueue.pending = readonlyView(pending);
+  enqueue.error = readonlyView(error);
   enqueue.clear = () => {
-    if (_activeController) {
-      _activeAbortedByClear = true;
-      _activeController.abort();
+    if (inCall) {
+      activeAbortedByClear = true;
+      activeController?.abort();
     }
-    while (_queue.length > 0) {
-      const item = _queue.shift();
-      item?.controller.abort();
-      item?.reject(new QueueClearedError());
+    const cleared = items;
+    const from = head;
+    items = [];
+    head = 0;
+    for (let i = from; i < cleared.length; i++) {
+      const item = cleared[i] as QueueItem<T>;
+      item.controller?.abort();
+      item.reject(new QueueClearedError());
     }
-    _pending.set(0);
-    _cleared = true;
+    writeSignal(pending, 0);
   };
 
   return enqueue as QueueInstance<T>;

package/src/task.ts

@@ -1,7 +1,7 @@
-import { signal, computed } from "@praxisjs/core/internal";
+import { endBatch, SignalNode, startBatch, writeSignal } from "@praxisjs/core/internal";
 import type { Computed } from "@praxisjs/shared";
 
-import { acceptsSignal } from "./utils";
+import { acceptsSignal, isAbortError, readonlyView, toError } from "./utils";
 
 export interface TaskInstance<T> {
   (...args: unknown[]): Promise<T | undefined>;
@@ -11,52 +11,56 @@ export interface TaskInstance<T> {
   cancelAll(): void;
 }
 
-function isAbortError(err: unknown): boolean {
-  return err instanceof Error && err.name === "AbortError";
-}
-
 export function task<T>(
   fn: (...args: unknown[]) => Promise<T>,
   options?: { signal?: boolean },
 ): TaskInstance<T> {
-  const _loading = signal(false);
-  const _error = signal<Error | null>(null);
-  const _lastResult = signal<T | null>(null);
-  let _runId = 0;
-  let _controller: AbortController | null = null;
-  const _wantsSignal = options?.signal ?? acceptsSignal(fn);
+  const loading = new SignalNode(false);
+  const error = new SignalNode<Error | null>(null);
+  const lastResult = new SignalNode<T | null>(null);
+  let runId = 0;
+  // Only created when `fn` takes a signal: nothing else could observe the abort.
+  let controller: AbortController | null = null;
+  const wantsSignal = options?.signal ?? acceptsSignal(fn);
 
   async function run(...args: unknown[]): Promise<T | undefined> {
-    _controller?.abort();
-    const controller = new AbortController();
-    _controller = controller;
-    const id = ++_runId;
-    _loading.set(true);
-    _error.set(null);
+    const id = ++runId;
+    let signal: AbortSignal | undefined;
+    if (wantsSignal) {
+      controller?.abort();
+      controller = new AbortController();
+      signal = controller.signal;
+    }
+    startBatch();
+    writeSignal(loading, true);
+    writeSignal(error, null);
+    endBatch();
     try {
-      const result = await (_wantsSignal ? fn(controller.signal, ...args) : fn(...args));
-      if (id !== _runId) return undefined;
-      _lastResult.set(result);
-      _loading.set(false);
+      const result = await (signal ? fn(signal, ...args) : fn(...args));
+      if (id !== runId) return undefined;
+      startBatch();
+      writeSignal(lastResult, result);
+      writeSignal(loading, false);
+      endBatch();
       return result;
     } catch (err) {
-      if (id !== _runId) return undefined;
-      if (!isAbortError(err)) {
-        _error.set(err instanceof Error ? err : new Error(String(err)));
-      }
-      _loading.set(false);
+      if (id !== runId) return undefined;
+      startBatch();
+      if (!isAbortError(err)) writeSignal(error, toError(err));
+      writeSignal(loading, false);
+      endBatch();
       return undefined;
     }
   }
 
-  run.loading = computed(() => _loading());
-  run.error = computed(() => _error());
-  run.lastResult = computed(() => _lastResult());
+  run.loading = readonlyView(loading);
+  run.error = readonlyView(error);
+  run.lastResult = readonlyView(lastResult);
   run.cancelAll = () => {
-    _controller?.abort();
-    _controller = null;
-    _runId++;
-    _loading.set(false);
+    controller?.abort();
+    controller = null;
+    runId++;
+    writeSignal(loading, false);
   };
 
   return run as TaskInstance<T>;