j-templates 9.0.1 → 10.0.1

package/Store/Tree/observableNode.js

@@ -1,6 +1,7 @@
 import { JsonApplyDiff, JsonDeepClone, JsonDiff } from "../../Utils/json";
 import { JsonType } from "../../Utils/json";
 import { ObservableScope } from "./observableScope";
+import { Opaque } from "./opaque";
 import { Snapshot } from "./snapshot";
 const NODE_VALUE = Symbol("NODE_VALUE");
 const NODE_PROXY = Symbol("NODE_PROXY");
@@ -142,6 +143,45 @@ function AssignNodeValue(obj, prop, value, wrapper) {
     obj[prop] = value;
     NodeValueSet(obj, prop, added, wrapper);
 }
+/** `Array.prototype.sort`'s order when it's given no compare function: by each value as a string */
+function DefaultCompare(a, b) {
+    const x = String(a);
+    const y = String(b);
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+/**
+ * Runs a mutating array method on a node's stored array. Values passed in are stored as
+ * `UnwrapProxy` leaves them, values handed out (removed elements, a sort's compared pair) are read
+ * as `read` gives them, so nothing already stored is rewritten. Returns the array itself for `sort`
+ * and `reverse`, which the caller hands out as the array's proxy.
+ */
+function MutateArray(array, prop, args, read) {
+    switch (prop) {
+        case "push":
+        case "unshift":
+            return array[prop](...args.map(StoredValue));
+        case "splice": {
+            // Spread so a call without a delete count still deletes to the end
+            const stored = args.length > 2 ? [args[0], args[1], ...args.slice(2).map(StoredValue)] : args;
+            return array.splice(...stored).map(read);
+        }
+        case "pop":
+        case "shift": {
+            // An empty array returns undefined, which reads as itself
+            return read(array[prop]());
+        }
+        case "sort": {
+            const compare = args[0] ?? DefaultCompare;
+            return array.sort((a, b) => compare(read(a), read(b)));
+        }
+        case "reverse":
+            return array.reverse();
+    }
+}
+/** A value as a node stores it: proxies removed, an Opaque kept as its box */
+function StoredValue(value) {
+    return UnwrapProxy(value);
+}
 function CreateProxyFactory(alias) {
     // Keyed children are read through their root. Every factory shares the module-level
     // snapshotState, matching wrapperCache; only the resolver differs per factory.
@@ -150,6 +190,20 @@ function CreateProxyFactory(alias) {
         return Snapshot.Get(snapshotState, value, resolveSnapshot);
     }
     const readOnly = alias !== undefined;
+    /**
+     * A descriptor trap whose value is what a read gives: a proxy for an object or array, an
+     * Opaque's raw value, never the stored value itself
+     */
+    function ReadDescriptor(trap) {
+        return function (target, prop) {
+            const descriptor = trap(target, prop);
+            if (descriptor && "value" in descriptor)
+                descriptor.value = CreateProxyFromValue(descriptor.value);
+            return descriptor;
+        };
+    }
+    const readObjectDescriptor = ReadDescriptor(getOwnPropertyDescriptor);
+    const readArrayDescriptor = ReadDescriptor(getOwnPropertyDescriptorArray);
     function CreateArrayProxy(value) {
         const wrapper = Object.assign([], {
             [NODE_VALUE]: value,
@@ -161,7 +215,7 @@ function CreateProxyFactory(alias) {
             set: ArrayProxySetter,
             has: hasArray,
             ownKeys: ownKeysArray,
-            getOwnPropertyDescriptor: getOwnPropertyDescriptorArray,
+            getOwnPropertyDescriptor: readArrayDescriptor,
         });
         wrapperCache.set(value, wrapper);
         return proxy;
@@ -206,10 +260,6 @@ function CreateProxyFactory(alias) {
                     return arrayValue;
                 if (typeof arrayValue === "function")
                     return function ArrayFunction(...args) {
-                        const proxyArray = prop === "slice" ? array.slice(...args).map(CreateProxyFromValue) : array.map(CreateProxyFromValue);
-                        let result = prop === "slice"
-                            ? proxyArray
-                            : proxyArray[prop](...args);
                         switch (prop) {
                             case "push":
                             case "unshift":
@@ -217,15 +267,19 @@ function CreateProxyFactory(alias) {
                             case "pop":
                             case "shift":
                             case "sort":
-                            case "reverse":
-                                array.length = proxyArray.length;
-                                for (let x = 0; x < proxyArray.length; x++)
-                                    array[x] = UnwrapProxy(proxyArray[x]);
+                            case "reverse": {
+                                // Run on the stored array, so what it holds (an Opaque's box included) stays as
+                                // it is: arguments go in as stored values, results come out as read values
+                                const result = MutateArray(array, prop, args, CreateProxyFromValue);
                                 InvalidateSnapshotForValue(object[NODE_VALUE]);
                                 ObservableScope.Update(scope);
-                                break;
+                                return result === array ? object[NODE_PROXY] : result;
+                            }
                         }
-                        return result;
+                        const proxyArray = prop === "slice" ? array.slice(...args).map(CreateProxyFromValue) : array.map(CreateProxyFromValue);
+                        return prop === "slice"
+                            ? proxyArray
+                            : proxyArray[prop](...args);
                     };
                 const proxy = CreateProxyFromValue(arrayValue);
                 return proxy;
@@ -243,7 +297,7 @@ function CreateProxyFactory(alias) {
             set: ObjectProxySetter,
             has,
             ownKeys,
-            getOwnPropertyDescriptor,
+            getOwnPropertyDescriptor: readObjectDescriptor,
         });
         wrapperCache.set(value, wrapper);
         return proxy;
@@ -301,7 +355,8 @@ function CreateProxyFactory(alias) {
                 return proxy;
             }
             default:
-                return value;
+                // An Opaque is stored as its box and read as its raw value
+                return Opaque.Open(value);
         }
     }
     return function CreateProxy(value, unwrapValue = true) {
@@ -361,6 +416,25 @@ export var ObservableNode;
         return DefaultCreateProxy(value, unwrapValue);
     }
     ObservableNode.Create = Create;
+    function WatchProperty(proxy, prop, callback) {
+        if (!proxy[IS_NODE])
+            throw new Error("Parameter proxy is not an ObservableNode");
+        const wrapper = proxy[NODE_WRAPPER];
+        if (Array.isArray(wrapper))
+            throw new Error("Unable to watch individual property on array proxy");
+        const scope = GetPropertyScope(wrapper, prop);
+        ObservableScope.WatchSubscribers(scope, callback);
+    }
+    ObservableNode.WatchProperty = WatchProperty;
+    function UnwatchProperty(proxy, prop, callback) {
+        if (!proxy[IS_NODE])
+            throw new Error("Parameter proxy is not an ObservableNode");
+        const wrapper = proxy[NODE_WRAPPER];
+        if (Array.isArray(wrapper))
+            return;
+        Object.hasOwn(wrapper, prop) && ObservableScope.UnwatchSubscribers(wrapper[prop], callback);
+    }
+    ObservableNode.UnwatchProperty = UnwatchProperty;
     /**
      * Returns an immutable, cached snapshot of an observable node's current value (plain
      * objects/arrays, with keyed children read through their root). The same snapshot is

package/Store/Tree/observableScope.d.ts

@@ -1,4 +1,4 @@
-import { Emitter, EmitterCallback } from "../../Utils/emitter";
+import { Emitter, EmitterCallback, EmitterEventCallback } from "../../Utils/emitter";
 /**
  * Represents a static (non-reactive) observable scope.
  * Static scopes are immutable and do not track dependencies or emit updates.
@@ -189,6 +189,8 @@ export declare namespace ObservableScope {
      * @param callback The callback function to remove.
      */
     function Unwatch<T>(scope: IObservableScope<T> | IBasicObservableScope<T>, callback: (scope: IObservableScope<T>) => void): void;
+    function WatchSubscribers<T = any>(scope: IObservableScope<T> | IBasicObservableScope<T>, callback: EmitterEventCallback): void;
+    function UnwatchSubscribers<T = any>(scope: IObservableScope<T> | IBasicObservableScope<T>, callback: EmitterEventCallback): void;
     /**
      * Registers a callback to be invoked when the scope's value is updated.
      * Only applies to dynamic scopes; no-op for static scopes.

package/Store/Tree/observableScope.js

@@ -639,6 +639,18 @@ export var ObservableScope;
         Emitter.Remove(scope.emitter, callback);
     }
     ObservableScope.Unwatch = Unwatch;
+    function WatchSubscribers(scope, callback) {
+        if (!scope || scope.destroyed || scope.type === "static")
+            return;
+        Emitter.Watch(scope.emitter, callback);
+    }
+    ObservableScope.WatchSubscribers = WatchSubscribers;
+    function UnwatchSubscribers(scope, callback) {
+        if (!scope || scope.destroyed || scope.type === "static")
+            return;
+        Emitter.Unwatch(scope.emitter, callback);
+    }
+    ObservableScope.UnwatchSubscribers = UnwatchSubscribers;
     /**
      * Registers a callback to be invoked when the scope's value is updated.
      * Only applies to dynamic scopes; no-op for static scopes.

package/Store/Tree/opaque.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A value an ObservableNode holds whole: it's never proxied, diffed into or cloned. A node stores
+ * the box and reads open it, so a reader gets the raw value, the same reference until the box is
+ * replaced. The property holding the box is the only thing observed: replacing the box updates its
+ * readers, and a change made inside the raw value notifies no one, so treat it as read-only.
+ *
+ * - Write one into a node by assigning it (`node.view = new Opaque(view)`), pushing or splicing it
+ *   into a node's array, or putting it in a value given to `ObservableNode.Create` or returned from
+ *   a `@Computed` getter.
+ * - A store holds a root whole when the root's key is in the store's `opaque` option. The store
+ *   boxes the root itself; don't pass an `Opaque` to a store's `Write`, `Patch`, `Push` or `Splice`.
+ * - Reads, array methods, property descriptors, snapshots and `JSON.stringify` give the raw value,
+ *   so an object composed from a node's reads holds no box. `ObservableNode.Unwrap` gives a node's
+ *   storage, boxes included, and `ObservableNode.Clone` keeps a box it's given: writing either back
+ *   into a node keeps the value opaque, but don't pass them to a store.
+ *
+ * Reading a box's value through a node and writing it somewhere else writes the raw value, which is
+ * then plain data again: box it again (`new Opaque(value)`) to keep it whole.
+ */
+export declare class Opaque<T = unknown> {
+    readonly value: T;
+    constructor(value: T);
+    /** The raw value, so `JSON.stringify` writes the value, not the box */
+    toJSON(): T;
+    /**
+     * The raw value of a box, or the value itself when it isn't one.
+     * @param value Any value.
+     */
+    static Open<V>(value: V | Opaque<V>): V;
+}

package/Store/Tree/opaque.js

@@ -0,0 +1,35 @@
+/**
+ * A value an ObservableNode holds whole: it's never proxied, diffed into or cloned. A node stores
+ * the box and reads open it, so a reader gets the raw value, the same reference until the box is
+ * replaced. The property holding the box is the only thing observed: replacing the box updates its
+ * readers, and a change made inside the raw value notifies no one, so treat it as read-only.
+ *
+ * - Write one into a node by assigning it (`node.view = new Opaque(view)`), pushing or splicing it
+ *   into a node's array, or putting it in a value given to `ObservableNode.Create` or returned from
+ *   a `@Computed` getter.
+ * - A store holds a root whole when the root's key is in the store's `opaque` option. The store
+ *   boxes the root itself; don't pass an `Opaque` to a store's `Write`, `Patch`, `Push` or `Splice`.
+ * - Reads, array methods, property descriptors, snapshots and `JSON.stringify` give the raw value,
+ *   so an object composed from a node's reads holds no box. `ObservableNode.Unwrap` gives a node's
+ *   storage, boxes included, and `ObservableNode.Clone` keeps a box it's given: writing either back
+ *   into a node keeps the value opaque, but don't pass them to a store.
+ *
+ * Reading a box's value through a node and writing it somewhere else writes the raw value, which is
+ * then plain data again: box it again (`new Opaque(value)`) to keep it whole.
+ */
+export class Opaque {
+    constructor(value) {
+        this.value = value;
+    }
+    /** The raw value, so `JSON.stringify` writes the value, not the box */
+    toJSON() {
+        return this.value;
+    }
+    /**
+     * The raw value of a box, or the value itself when it isn't one.
+     * @param value Any value.
+     */
+    static Open(value) {
+        return value instanceof Opaque ? value.value : value;
+    }
+}

package/Store/Tree/snapshot.js

@@ -1,4 +1,5 @@
 import { JsonType } from "../../Utils/json";
+import { Opaque } from "./opaque";
 function CreateSnapshotLink(state, child, parent) {
     let parents = state.hierarchy.get(child);
     if (!parents)
@@ -21,15 +22,15 @@ function InvalidateValue(state, value) {
             InvalidateValue(state, parent);
 }
 /**
- * An immutable snapshot of a raw value (arrays and plain objects; other values are
- * returned as they are). A snapshot is cached per raw value and returned as-is until a
+ * An immutable snapshot of a raw value (arrays and plain objects; an Opaque gives its raw
+ * value, and other values are returned as they are). A snapshot is cached per raw value and returned as-is until a
  * write invalidates it. A rebuild makes new containers but reuses the cached snapshots of
  * unchanged children, so a snapshot handed out never changes and unchanged parts are
  * shared between snapshots. Keyed children are read through their root.
  */
 function CreateSnapshot(state, resolve, value) {
     if (JsonType(value) === "value")
-        return value;
+        return Opaque.Open(value);
     const cached = state.rawToSnapshotCache.get(value);
     if (cached !== undefined)
         return cached;
@@ -57,7 +58,7 @@ function CreateSnapshot(state, resolve, value) {
 function ChildSnapshot(state, resolve, parent, key) {
     const child = parent[key];
     if (JsonType(child) === "value")
-        return child;
+        return Opaque.Open(child);
     CreateSnapshotLink(state, child, parent);
     const resolved = resolve?.(child);
     if (resolved !== undefined && resolved !== child) {

package/Store/index.d.ts

@@ -1,6 +1,9 @@
 export { ReadStore, Store } from "./Store/store";
+export type { IStoreOptions } from "./Store/store";
+export type { IStoreAsyncOptions } from "./Store/storeAsync";
+export type { IStoreSyncOptions } from "./Store/storeSync";
 export { StoreSync } from "./Store/storeSync";
 export { StoreAsync } from "./Store/storeAsync";
-export { PushStore } from "./Store/pushStore";
 export { ObservableScope } from "./Tree/observableScope";
 export { ObservableNode } from "./Tree/observableNode";
+export { Opaque } from "./Tree/opaque";

package/Store/index.js

@@ -1,6 +1,6 @@
 export { ReadStore, Store } from "./Store/store";
 export { StoreSync } from "./Store/storeSync";
 export { StoreAsync } from "./Store/storeAsync";
-export { PushStore } from "./Store/pushStore";
 export { ObservableScope } from "./Tree/observableScope";
 export { ObservableNode } from "./Tree/observableNode";
+export { Opaque } from "./Tree/opaque";

package/Utils/decorators.d.ts

@@ -5,7 +5,6 @@
  * @module Utils/Decorators
  * @see ObservableScope
  * @see ObservableNode
- * @see StoreAsync
  * @see StoreSync
  * @see Component
  *
@@ -20,7 +19,6 @@
  * | arrays (User[], Todo[])   | @State  | Array mutations tracked       |
  * | getters only (expensive)  | @Computed | Cached + object reuse via Store |
  * | getters only (simple)     | @Scope  | Cached, but new reference on update |
- * | getters only (sync, StoreAsync) | @ComputedAsync | Sync getter, StoreAsync caching + object reuse |
  * | async functions (direct scope) | ObservableScope.Create(async) | Direct async, new reference, initial null |
  * | subscribe to changes      | @Watch  | Calls method when scope value changes |
  * | dependency injection      | @Inject | Gets value from component injector |
@@ -157,104 +155,10 @@ import { Injector } from "./injector";
  * - Use @Scope() for simple computations where object identity doesn't matter
  * - The diff computation overhead is justified when you need object reuse
  * @see {@link Scope} for simple getter-based reactive properties (caches but new reference)
- * @see {@link ComputedAsync} for async computed properties
  * @see {@link ObservableNode.Apply} for how diffs are applied in-place to maintain object identity
  * @see {@link ObservableScope} for the Gated scope mechanism (batched updates)
- * @see {@link StoreSync} for the store-backed variant used by @ComputedAsync
  */
 export declare function Computed<T extends WeakKey, K extends keyof T, D extends T[K]>(): (target: T, propertyKey: K, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * ComputedAsync decorator factory for creating synchronous computed properties with StoreAsync caching.
- * A computed property is derived from other properties and automatically updates when its dependencies change.
- *
- * IMPORTANT: Despite the name, @ComputedAsync expects a SYNC getter, NOT an async function.
- * The "Async" refers to the internal StoreAsync caching mechanism, not the getter signature.
- *
- * Use @ComputedAsync when you need synchronous caching with StoreAsync backend.
- * For direct async operations (no object reuse), use ObservableScope.Create(async () => ...) instead.
- *
- * @example
- * ```typescript
- * // ✅ Good: Synchronous getter with StoreAsync caching
- * @Value()
- * userId: string = "123";
- *
- * @ComputedAsync(null)
- * get userData(): User | null {
- *   // Sync getter - returns value directly
- *   return getUserSync(this.userId);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // ❌ WRONG - Do NOT use async keyword or return Promise
- * @Value()
- * userId: string = "123";
- *
- * @ComputedAsync(null)
- * async getUser(): Promise<User> {  // ERROR: getter must be synchronous!
- *   return await fetch(`/api/users/${this.userId}`);
- * }
- *
- * // ✅ CORRECT - Use ObservableScope.Create for direct async operations
- * import { ObservableScope } from "j-templates/Store";
- *
- * @Value()
- * userId: string = "123";
- *
- * private userDataScope = ObservableScope.Create(async () => {
- *   return await fetch(`/api/users/${this.userId}`);  // Async supported here!
- * });
- *
- * get userData(): User | null {
- *   return ObservableScope.Value(this.userDataScope);  // null while loading
- * }
- * ```
- *
- * @param defaultValue The default value to be used if the computed property is not defined.
- * @returns A property decorator that can be applied to a getter method.
- * @throws Will throw an error if the property is not a getter or if it has a setter.
- * @remarks
- * The @ComputedAsync decorator uses StoreAsync for caching. The getter must be a synchronous function.
- * Unlike @Computed which uses StoreSync, @ComputedAsync uses StoreAsync internally for caching.
- *
- * **Initialization**: @ComputedAsync uses lazy initialization - the scopes are created on first access:
- * ```typescript
- * @ComputedAsync(null)
- * get userData(): User | null {
- *   return getUserSync(this.userId);
- * }
- *
- * // Scope created here, on first access:
- * const user = this.userData;
- * ```
- *
- * **Caching**: Like @Computed, @ComputedAsync caches the result and maintains object identity
- * through diff-based updates. The getter only runs when dependencies change.
- *
- * **Object Reuse**: Like @Computed, the result maintains its identity across updates.
- * Only changed properties are modified in-place, preserving object references.
- *
- * **Key difference from @Computed**: Uses StoreAsync instead of StoreSync for caching.
- * Both use synchronous getters and provide object identity preservation.
- *
- * **Comparison**:
- * | Aspect | @Scope | @Computed | @ComputedAsync | scope(async) + @Scope |
- * |--------|--------|-----------|----------------|----------------------|
- * | Caches value | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes (memoized) |
- * | Getter type | Sync | Sync | Sync | Async supported |
- * | Object identity | ❌ New | ✅ Same | ✅ Same | ❌ New |
- * | Store backend | Single scope | StoreSync | StoreAsync | Direct scope |
- * | Initial value | First access | First access | defaultValue | Promise |
- * | Best for | Simple sync, async | Complex sync | StoreAsync sync | Component async ops |
- *
- * @see {@link Computed} for synchronous computed properties with StoreSync caching
- * @see {@link Scope} for simple getter-based reactive properties (caches, new reference)
- * @see {@link StoreAsync} for async store implementation
- * @see {@link ObservableScope.Create} for async function support
- */
-export declare function ComputedAsync<T extends WeakKey, K extends keyof T, V extends T[K]>(defaultValue: V): (target: T, propertyKey: K, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**
  * State decorator factory for creating reactive properties backed by ObservableNode proxies.
  *
@@ -490,7 +394,6 @@ export declare function Value(): any;
  * | Best for | Primitives, cheap ops, async ops | Complex objects, expensive ops |
  *
  * @see {@link Computed} for cached computed properties with object reuse
- * @see {@link ComputedAsync} for sync getters with StoreAsync backend
  * @see {@link ObservableNode.Apply} for how @Computed maintains object identity
  * @see {@link ObservableScope} for the scope-based reactivity system
  * @see {@link scope} for inline computed scopes within @Scope
@@ -797,7 +700,6 @@ export declare namespace Destroy {
      * - All @Value-decorated property scopes
      * - All @Scope-decorated property scopes
      * - All @Computed-decorated property scopes (both getter and property scopes)
-     * - All @ComputedAsync-decorated property scopes (including StoreAsync)
      * - All @Destroy-marked properties (calls .Destroy() method)
      * - All @Watch subscriptions (via scope destruction)
      *

package/Utils/decorators.js

@@ -5,7 +5,6 @@
  * @module Utils/Decorators
  * @see ObservableScope
  * @see ObservableNode
- * @see StoreAsync
  * @see StoreSync
  * @see Component
  *
@@ -20,7 +19,6 @@
  * | arrays (User[], Todo[])   | @State  | Array mutations tracked       |
  * | getters only (expensive)  | @Computed | Cached + object reuse via Store |
  * | getters only (simple)     | @Scope  | Cached, but new reference on update |
- * | getters only (sync, StoreAsync) | @ComputedAsync | Sync getter, StoreAsync caching + object reuse |
  * | async functions (direct scope) | ObservableScope.Create(async) | Direct async, new reference, initial null |
  * | subscribe to changes      | @Watch  | Calls method when scope value changes |
  * | dependency injection      | @Inject | Gets value from component injector |
@@ -58,7 +56,6 @@
  */
 import { ObservableScope, PeekCallback, } from "../Store/Tree/observableScope";
 import { ObservableNode } from "../Store/Tree/observableNode";
-import { StoreAsync } from "../Store";
 /**
  * WeakMap for storing node instances and their associated properties.
  * @private
@@ -122,27 +119,6 @@ function GetDestroyArrayForPrototype(prototype, create = true) {
     }
     return array;
 }
-function CreateStoreScope(getter, store, defaultValue) {
-    const getterScope = ObservableScope.Gated(function () {
-        const value = getter();
-        return ObservableNode.Clone(value);
-    });
-    ObservableScope.Watch(getterScope, (scope) => {
-        const data = ObservableScope.Peek(scope);
-        store.Write(data, "root");
-    });
-    const data = ObservableScope.Peek(getterScope);
-    store.Write(data, "root");
-    const propertyScope = ObservableScope.Create(() => {
-        return store.Get("root", defaultValue);
-    });
-    ObservableScope.OnDestroyed(propertyScope, function () {
-        ObservableScope.Destroy(getterScope);
-        if (store instanceof StoreAsync)
-            store.Destroy();
-    });
-    return propertyScope;
-}
 /**
  * Creates an observable scope that exposes a getter's value through a persistent
  * observable node, preserving the value's object identity across updates.
@@ -281,10 +257,8 @@ function CreateNodeScope(getter) {
  * - Use @Scope() for simple computations where object identity doesn't matter
  * - The diff computation overhead is justified when you need object reuse
  * @see {@link Scope} for simple getter-based reactive properties (caches but new reference)
- * @see {@link ComputedAsync} for async computed properties
  * @see {@link ObservableNode.Apply} for how diffs are applied in-place to maintain object identity
  * @see {@link ObservableScope} for the Gated scope mechanism (batched updates)
- * @see {@link StoreSync} for the store-backed variant used by @ComputedAsync
  */
 export function Computed() {
     return function (target, propertyKey, descriptor) {
@@ -320,134 +294,6 @@ function ComputedDecorator(target, prop, descriptor) {
         },
     };
 }
-/**
- * ComputedAsync decorator factory for creating synchronous computed properties with StoreAsync caching.
- * A computed property is derived from other properties and automatically updates when its dependencies change.
- *
- * IMPORTANT: Despite the name, @ComputedAsync expects a SYNC getter, NOT an async function.
- * The "Async" refers to the internal StoreAsync caching mechanism, not the getter signature.
- *
- * Use @ComputedAsync when you need synchronous caching with StoreAsync backend.
- * For direct async operations (no object reuse), use ObservableScope.Create(async () => ...) instead.
- *
- * @example
- * ```typescript
- * // ✅ Good: Synchronous getter with StoreAsync caching
- * @Value()
- * userId: string = "123";
- *
- * @ComputedAsync(null)
- * get userData(): User | null {
- *   // Sync getter - returns value directly
- *   return getUserSync(this.userId);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // ❌ WRONG - Do NOT use async keyword or return Promise
- * @Value()
- * userId: string = "123";
- *
- * @ComputedAsync(null)
- * async getUser(): Promise<User> {  // ERROR: getter must be synchronous!
- *   return await fetch(`/api/users/${this.userId}`);
- * }
- *
- * // ✅ CORRECT - Use ObservableScope.Create for direct async operations
- * import { ObservableScope } from "j-templates/Store";
- *
- * @Value()
- * userId: string = "123";
- *
- * private userDataScope = ObservableScope.Create(async () => {
- *   return await fetch(`/api/users/${this.userId}`);  // Async supported here!
- * });
- *
- * get userData(): User | null {
- *   return ObservableScope.Value(this.userDataScope);  // null while loading
- * }
- * ```
- *
- * @param defaultValue The default value to be used if the computed property is not defined.
- * @returns A property decorator that can be applied to a getter method.
- * @throws Will throw an error if the property is not a getter or if it has a setter.
- * @remarks
- * The @ComputedAsync decorator uses StoreAsync for caching. The getter must be a synchronous function.
- * Unlike @Computed which uses StoreSync, @ComputedAsync uses StoreAsync internally for caching.
- *
- * **Initialization**: @ComputedAsync uses lazy initialization - the scopes are created on first access:
- * ```typescript
- * @ComputedAsync(null)
- * get userData(): User | null {
- *   return getUserSync(this.userId);
- * }
- *
- * // Scope created here, on first access:
- * const user = this.userData;
- * ```
- *
- * **Caching**: Like @Computed, @ComputedAsync caches the result and maintains object identity
- * through diff-based updates. The getter only runs when dependencies change.
- *
- * **Object Reuse**: Like @Computed, the result maintains its identity across updates.
- * Only changed properties are modified in-place, preserving object references.
- *
- * **Key difference from @Computed**: Uses StoreAsync instead of StoreSync for caching.
- * Both use synchronous getters and provide object identity preservation.
- *
- * **Comparison**:
- * | Aspect | @Scope | @Computed | @ComputedAsync | scope(async) + @Scope |
- * |--------|--------|-----------|----------------|----------------------|
- * | Caches value | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes (memoized) |
- * | Getter type | Sync | Sync | Sync | Async supported |
- * | Object identity | ❌ New | ✅ Same | ✅ Same | ❌ New |
- * | Store backend | Single scope | StoreSync | StoreAsync | Direct scope |
- * | Initial value | First access | First access | defaultValue | Promise |
- * | Best for | Simple sync, async | Complex sync | StoreAsync sync | Component async ops |
- *
- * @see {@link Computed} for synchronous computed properties with StoreSync caching
- * @see {@link Scope} for simple getter-based reactive properties (caches, new reference)
- * @see {@link StoreAsync} for async store implementation
- * @see {@link ObservableScope.Create} for async function support
- */
-export function ComputedAsync(defaultValue) {
-    return function (target, propertyKey, descriptor) {
-        return ComputedAsyncDecorator(target, propertyKey, descriptor, defaultValue);
-    };
-}
-/**
- * ComputedAsync decorator implementation for creating asynchronous computed properties.
- * @private
- * @param target The target object.
- * @param prop The property key.
- * @param descriptor The property descriptor.
- * @param defaultValue The default value to be used if the computed property is not defined.
- * @returns A property descriptor that replaces the original descriptor with a computed implementation.
- * @throws Will throw an error if the property is not a getter or if it has a setter.
- */
-function ComputedAsyncDecorator(target, prop, descriptor, defaultValue) {
-    const propertyKey = prop;
-    if (!(descriptor && descriptor.get))
-        throw "Computed decorator requires a getter";
-    if (descriptor && descriptor.set)
-        throw "Computed decorator does not support setters";
-    const getter = descriptor.get;
-    return {
-        configurable: false,
-        enumerable: true,
-        get: function () {
-            const scopeMap = GetScopeMapForInstance(this);
-            if (scopeMap[propertyKey] === undefined) {
-                const worker = new Worker(new URL("../Store/Diff/defaultDiffTreeWorker.js", import.meta.url), { type: "module" });
-                const storeAsync = new StoreAsync(worker);
-                const propertyScope = CreateStoreScope(getter.bind(this), storeAsync, defaultValue);
-                scopeMap[propertyKey] = [propertyScope, undefined];
-            }
-            return ObservableScope.Value(scopeMap[propertyKey][0]);
-        },
-    };
-}
 /**
  * State decorator factory for creating reactive properties backed by ObservableNode proxies.
  *
@@ -749,7 +595,6 @@ function ValueDecorator(target, propertyKey) {
  * | Best for | Primitives, cheap ops, async ops | Complex objects, expensive ops |
  *
  * @see {@link Computed} for cached computed properties with object reuse
- * @see {@link ComputedAsync} for sync getters with StoreAsync backend
  * @see {@link ObservableNode.Apply} for how @Computed maintains object identity
  * @see {@link ObservableScope} for the scope-based reactivity system
  * @see {@link scope} for inline computed scopes within @Scope
@@ -1118,7 +963,6 @@ export var Bound;
      * - All @Value-decorated property scopes
      * - All @Scope-decorated property scopes
      * - All @Computed-decorated property scopes (both getter and property scopes)
-     * - All @ComputedAsync-decorated property scopes (including StoreAsync)
      * - All @Destroy-marked properties (calls .Destroy() method)
      * - All @Watch subscriptions (via scope destruction)
      *