j-templates 9.0.0 → 10.0.0

package/Store/Store/storeSync.js

@@ -1,4 +1,4 @@
-import { DiffTree } from "../Diff/diffTree";
+import { ObservableDiffTree } from "../Diff/observableDiffTree";
 import { Store } from "./store";
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
@@ -24,21 +24,74 @@ import { Store } from "./store";
  * // Splicing an array
  * store.Splice("user.array", 0, 1, { id: 3 });
  *
+ * The store subscribes to an `ObservableDiffTree` and applies every commit the tree delivers, so
+ * anything else on the thread can subscribe to the same tree (`Tree`), and a commit made on the
+ * tree directly reaches the store too. A change runs the tree's projections and commits
+ * before it returns.
+ *
+ * - **Its own tree** (`new StoreSync()`, `new StoreSync(undefined, { keyFunc })`): the store creates an
+ *   empty tree, and it lives as long as the store.
+ * - **A tree it's given** (`new StoreSync(new ObservableDiffTree({ keyFunc, routes }))`): for a tree
+ *   with routes and projections, whose keyFunc the store takes. Anything else on the thread may hold it too.
+ * - **A hub's tree** (`new StoreSync(hub.OpenLocal(name))`): a tree on this thread a `DiffTreeHub` runs
+ *   for an endpoint, shared by every store opened on it and followed into by the hub. A change from
+ *   any of them reaches all of them, and the trees that follow it, before it returns. The store
+ *   owns the lease and releases it when it's destroyed. When the hub restarts the tree, the store
+ *   moves to the new one, as when it first subscribed.
+ *
+ * @example
+ * // A store on a hub's tree: it lives as long as the component that holds it
+ * @Inject(DiffTreeHub) hub!: DiffTreeHub;
+ * @Destroy() budget = new StoreSync(this.hub.OpenLocal("budget"));
+ *
  * @see Store
  * @see StoreAsync
- * @see DiffTree
+ * @see ObservableDiffTree
  */
 export class StoreSync extends Store {
     /**
-     * Creates an instance of StoreSync.
-     * @param keyFunc Optional function to generate a key for a given data value.
-     * @param routes Optional route definitions. A projection in the root route (`"/"`) is
-     * readable through `Get` at `$projection_<key>`.
-     * @throws When projections depend on each other in a cycle.
+     * Creates a store and subscribes it to its tree: the tree's state is the store's when this returns.
+     * @param tree The tree:
+     *   - A lease from `DiffTreeHub.OpenLocal`, on a hub's tree on this thread. The store owns the
+     *     lease from then on, and releases it when it's destroyed, and follows the tree across
+     *     restarts. A lease on a worker's tree (`DiffTreeHub.Open`) is for a `StoreAsync`, and doesn't
+     *     compile here.
+     *   - An `ObservableDiffTree`, for a tree with routes (`new ObservableDiffTree({ keyFunc, routes })`).
+     *     A projection in the root route (`"/"`) is readable through `Get` at `$projection_<key>`. The
+     *     store doesn't own it: `Destroy` stops listening.
+     *   - Left out, the store creates an empty tree of its own, with the store's `keyFunc` and `opaque`.
+     * @param options `keyFunc`, `roots` and `opaque` (`IStoreSyncOptions`). `keyFunc` is for the tree the
+     *   store creates: a leased tree's is the endpoint's, and a given tree's its own. A tree given or
+     *   leased must write the `opaque` keys whole already (`IObservableDiffTreeConfig.opaque`): share
+     *   them from one file.
+     * @throws When `keyFunc` is given with a tree or a lease, which has its own.
+     */
+    constructor(tree, options = {}) {
+        const lease = tree && !(tree instanceof ObservableDiffTree) ? tree : undefined;
+        if (tree && options.keyFunc)
+            throw new Error(lease
+                ? `StoreSync: the endpoint ${lease.name} gives the store its keyFunc; leave it out of the options.`
+                : "StoreSync: the tree has its keyFunc, which the store takes; leave it out of the options.");
+        super(lease ? lease.endpoint.keyFunc : tree ? tree.KeyFunc : options.keyFunc, options.opaque);
+        /** Over a lease: the roots delivered and not deleted, to delete the ones a restarted tree doesn't hold */
+        this.delivered = new Set();
+        this.roots = options.roots;
+        if (lease) {
+            this.lease = lease;
+            this.Attach(lease.tree, false);
+            this.stopLease = lease.OnTree(tree => this.Attach(tree, true));
+            return;
+        }
+        this.diff = tree ?? new ObservableDiffTree({ keyFunc: options.keyFunc, opaque: options.opaque });
+        this.unsubscribe = this.diff.Subscribe({ roots: this.roots }, post => this.UpdateRootMap(post.diff));
+    }
+    /**
+     * The store's tree: its own, or the hub's. Subscribe to it to receive the
+     * same commits the store applies; a commit made on it reaches the store too. A subscriber can't
+     * write to the store during a delivery.
      */
-    constructor(keyFunc, routes) {
-        super(keyFunc);
-        this.diff = new DiffTree(keyFunc, routes);
+    get Tree() {
+        return this.diff;
     }
     /**
      * Writes data to the store synchronously.
@@ -91,11 +144,51 @@ export class StoreSync extends Store {
         this.Sync();
     }
     /**
-     * Runs projections and applies everything changed since the last sync to the store.
+     * Stops applying the tree's commits. Over a lease, the store then releases it: the last lease on
+     * a hub's tree ends it. The store's values stay readable, and stop changing.
+     */
+    Destroy() {
+        this.stopLease?.();
+        this.stopLease = undefined;
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        this.lease?.Release();
+    }
+    /**
+     * Subscribes to a hub's tree in place of the last. A restarted tree's state is applied in place, so
+     * readers keep their objects, with a delete for each root the last tree had and this one hasn't, in
+     * one update. The first delivery arrives during `Subscribe`.
+     */
+    Attach(tree, again) {
+        this.unsubscribe?.();
+        this.diff = tree;
+        const previous = this.delivered;
+        this.delivered = new Set();
+        let subscribing = true;
+        let first = [];
+        this.unsubscribe = tree.Subscribe({ roots: this.roots }, post => {
+            this.Track(post.diff);
+            subscribing ? (first = post.diff) : this.UpdateRootMap(post.diff);
+        });
+        subscribing = false;
+        const diff = [...first];
+        for (const key of previous)
+            this.delivered.has(key) || diff.push({ type: "delete", path: [key] });
+        diff.length > 0 && (again ? this.UpdateRootMapInPlace(diff) : this.UpdateRootMap(diff));
+    }
+    Track(diff) {
+        for (const record of diff) {
+            const key = String(record.path[0]);
+            record.type === "delete" && record.path.length === 1 ? this.delivered.delete(key) : this.delivered.add(key);
+        }
+    }
+    /**
+     * Runs projections and commits: the commit's delivery applies everything changed since the
+     * last commit to the store.
      * @private
      */
     Sync() {
         this.diff.RunProjections();
-        this.UpdateRootMap(this.diff.Commit());
+        this.diff.Commit();
     }
 }

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) {

package/Store/Tree/observableScope.d.ts

@@ -207,6 +207,7 @@ export declare namespace ObservableScope {
     function OnDestroyed<T>(scope: IObservableScope<T>, callback: {
         (lastValue: T): void;
     }): void;
+    function IsDestroyed(scope: IObservableScope<unknown>): boolean;
     /**
      * Marks a scope as dirty, triggering recomputation on next access or batch.
      * No-op for static scopes (created when a `Create` valueFunction reads no reactive

package/Store/Tree/observableScope.js

@@ -663,6 +663,10 @@ export var ObservableScope;
         Emitter.On(scope.onDestroyed, callback);
     }
     ObservableScope.OnDestroyed = OnDestroyed;
+    function IsDestroyed(scope) {
+        return scope.destroyed;
+    }
+    ObservableScope.IsDestroyed = IsDestroyed;
     /**
      * Marks a scope as dirty, triggering recomputation on next access or batch.
      * No-op for static scopes (created when a `Create` valueFunction reads no reactive

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)
      *