j-templates 9.0.0 → 10.0.0

package/Store/Store/store.js

@@ -1,22 +1,24 @@
-import { JsonDeepClone } from "../../Utils/json";
+import { JsonDeepClone, JsonDiff, JsonType } from "../../Utils/json";
 import { ObservableNode } from "../Tree/observableNode";
+import { Opaque } from "../Tree/opaque";
 /**
  * Base class for reading observable data: holds root objects as ObservableNode instances
- * and applies diff results to them. Subclasses decide where the diffs come from: `Store`
- * adds the write methods, and `PushStore` takes them from a `DiffTreeWriter`.
+ * and applies diff results to them. Subclasses decide where the diffs come from: `StoreSync`
+ * and `StoreAsync` apply what an `ObservableDiffTree` delivers to them.
  *
  * @see Store
- * @see PushStore
  */
 export class ReadStore {
     /**
      * Creates an instance of ReadStore.
      * @param keyFunc Optional function to generate a key for a given data value.
      * When provided, enables alias functionality where values can reference other root objects.
+     * @param opaque Root keys held whole, see `IStoreOptions.opaque`.
      */
-    constructor(keyFunc) {
+    constructor(keyFunc, opaque = []) {
         this.keyFunc = keyFunc;
         this.rootMap = new Map();
+        this.opaque = new Set(opaque);
         const aliasFunc = keyFunc &&
             ((value, reactive = true) => {
                 const key = keyFunc(value);
@@ -24,6 +26,8 @@ export class ReadStore {
                 // store: read the embedded copy
                 if (key === undefined || key.startsWith("/"))
                     return undefined;
+                if (this.opaque.has(key))
+                    throw `Opaque root ${key} can't be read through a key`;
                 const rootObject = this.rootMap.get(key);
                 if (rootObject === undefined)
                     throw `No root object found for key: ${key}`;
@@ -39,7 +43,7 @@ export class ReadStore {
     Get(id, defaultValue) {
         let result = this.rootMap.get(id);
         if (result === undefined) {
-            result = this.createNode({ [id]: defaultValue });
+            result = this.createNode({ [id]: this.opaque.has(id) ? Box(defaultValue) : defaultValue });
             this.rootMap.set(id, result);
         }
         return result[id];
@@ -70,6 +74,25 @@ export class ReadStore {
             this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
         }
     }
+    /**
+     * Applies whole-root writes by diffing each one into the root the store already holds, so
+     * readers of an unchanged part aren't notified and keep its objects. Anything else, an opaque
+     * root, or a root the store doesn't hold, is applied as it is.
+     * @param results - Diff results, e.g. a tree's first state after reconnecting
+     * @protected
+     */
+    UpdateRootMapInPlace(results) {
+        const applied = [];
+        for (const result of results) {
+            const key = result.path[0];
+            const rootObject = this.rootMap.get(key);
+            if (result.type !== "write" || result.path.length > 1 || rootObject === undefined || this.opaque.has(key))
+                applied.push(result);
+            else
+                JsonDiff({ [key]: result.value }, ObservableNode.Unwrap(rootObject)).forEach(record => applied.push(record));
+        }
+        applied.length > 0 && this.UpdateRootMap(applied);
+    }
     /**
      * Updates a specific root object with diff results.
      * Creates the root object if it doesn't exist.
@@ -79,6 +102,8 @@ export class ReadStore {
      * @private
      */
     UpdateRootObject(rootPath, results) {
+        if (this.opaque.has(rootPath))
+            results = OpaqueResults(rootPath, results);
         const rootObject = this.rootMap.get(rootPath);
         if (rootObject === undefined) {
             if (results[0].type !== "write" || results[0].path.length > 1)
@@ -104,6 +129,22 @@ export class ReadStore {
  */
 export class Store extends ReadStore {
 }
+/** An opaque root's value as the store holds it: an object or array boxed, anything else as it is */
+function Box(value) {
+    return JsonType(value) === "value" ? value : new Opaque(value);
+}
+/**
+ * An opaque root's diff, each value boxed. A DiffTree that marks the root opaque writes it whole or
+ * deletes it, so any other change means it wasn't told.
+ * @throws When the diff writes inside the root
+ */
+function OpaqueResults(rootPath, results) {
+    return results.map(result => {
+        if (result.path.length > 1 || (result.type !== "write" && result.type !== "delete"))
+            throw `Opaque root ${rootPath} was changed at ${result.path.join(".")}: mark it opaque in the DiffTree too (DiffTree.MarkOpaque)`;
+        return result.type === "write" ? { ...result, value: Box(result.value) } : result;
+    });
+}
 /** The root key a path is in: its text before the first `.` */
 export function RootOf(path) {
     const dot = path.indexOf(".");

package/Store/Store/storeAsync.d.ts

@@ -1,12 +1,38 @@
-import { Store } from "./store";
+import { IChannel, IWorkerLease } from "../Diff/diffTree.types";
+import { IStoreOptions, Store } from "./store";
+/** Options for a `StoreAsync` */
+export interface IStoreAsyncOptions extends IStoreOptions {
+    /**
+     * The root keys the store receives: exact keys and patterns ending in `*`. Omitted, every root.
+     * A root the store writes but doesn't receive is written but never read back. With a
+     * `keyFunc`, include the entity roots the received roots refer to.
+     */
+    roots?: readonly string[];
+}
 /**
  * StoreAsync class extends the base Store class to provide asynchronous data management operations.
  * This class handles writing, patching, pushing, and splicing data in an asynchronous manner.
  *
- * StoreAsync is designed to work with observable data structures, allowing for efficient updates
- * and notifications when data changes. It is particularly useful for scenarios where asynchronous
- * operations are preferred or required, such as handling large datasets or performing complex diffs
- * without blocking the main thread.
+ * The tree lives in a worker, served by a `HostPublisher`. The store subscribes on construction and
+ * applies every commit the tree posts, whatever caused it: its own batches, other writers, or the
+ * worker's own work. A store created after the tree has committed starts from its committed state.
+ * Without writes it's a read-only view of the tree.
+ *
+ * - Changes made in one tick are sent as one batch, and at most one batch waits behind the one in
+ *   flight. A change's promise resolves on its batch's `jt-ack`, which arrives after the commit's
+ *   posts, so the change has been applied when it resolves.
+ * - A failed batch rejects only its own changes; later batches carry on.
+ *
+ * **Over a lease** (`DiffTreeHub.Open`), the store takes its keyFunc from the lease's endpoint, owns
+ * the lease, and releases it when it's destroyed. When the hub restarts the worker,
+ * the store starts over with the new tree, as when it first subscribed: the tree is the source of
+ * truth, nothing the store wrote is written back, and changes the old tree hadn't acknowledged are
+ * rejected.
+ *
+ * @example
+ * // A store over a hub's lease: it lives as long as the component that holds it
+ * @Inject(DiffTreeHub) hub!: DiffTreeHub;
+ * @Destroy() totals = new StoreAsync(this.hub.Open("totals"));
  *
  * @example
  * // Creating a StoreAsync instance from a bundler-built worker entry file
@@ -26,28 +52,55 @@ import { Store } from "./store";
  * // Splicing an array asynchronously
  * await store.Splice("users", 0, 1, { id: 3 });
  *
- * // Cleaning up resources
+ * // Cleaning up resources: the store stops listening; the worker is its creator's to terminate
  * store.Destroy();
+ * worker.terminate();
  *
  * @see Store
  * @see StoreSync
  */
 export declare class StoreAsync extends Store {
     private writeKeySet;
-    private workerQueue;
+    private client;
+    private options;
+    /**
+     * The store's subscription, kept across a restart of the lease's worker: a new tree's first state
+     * deletes the roots the old one posted that it doesn't hold
+     */
+    private subscription;
+    /** The lease the store owns, when it was given one */
+    private lease?;
+    private stopLease?;
     private asyncQueue;
     private currentBatch;
     private currentBatchPromise;
+    /** Batches not yet acknowledged, for `Flush` */
+    private inFlight;
+    /**
+     * Creates an instance of StoreAsync and subscribes to the tree.
+     * @param channel A channel to an `ObservableDiffTree` served by `HostPublisher`: a `Worker` (e.g. a
+     *   bundled `defaultDiffTreeWorker` entry), a `MessagePort`, or a lease from `DiffTreeHub.Open`. Other
+     *   messages may share the channel. Given a lease, the store owns it from then on and releases it
+     *   when it's destroyed, and follows the worker across restarts. A lease on a tree on this thread
+     *   (`DiffTreeHub.OpenLocal`) is for a `StoreSync`, and doesn't compile here.
+     * @param options `keyFunc`, `roots` and `opaque` (`IStoreAsyncOptions`). `keyFunc` is for a plain
+     *   channel: pass the key logic the worker's tree was built with. A lease's is the endpoint's.
+     *   `opaque` is sent to the tree before the store subscribes; over a lease, share it with the tree
+     *   (`IObservableDiffTreeConfig.opaque`) from a file both import.
+     * @throws When `keyFunc` is given with a lease, whose endpoint has its own.
+     */
+    constructor(channel: IChannel | IWorkerLease, options?: IStoreAsyncOptions);
     /**
-     * Creates an instance of StoreAsync.
-     * @param diffWorker A `Worker` running a `DiffTree` connected via `ConnectWorkerToDiffTree`
-     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/routes the diff needs
-     *   must be baked into that worker's own entry file.
-     * @param keyFunc Optional function to generate a key for a given data value, used locally by
-     *   this store to resolve root objects. Pass the same key logic the worker's `DiffTree` was
-     *   constructed with, if any.
+     * The hub restarted the lease's worker: the store moves to the new tree's port, keeping its
+     * readers, and starts over as when it first subscribed. The changes the old tree hadn't
+     * acknowledged are rejected, not sent again, and nothing is written back: the new tree's first
+     * state is diffed into the store's roots in place, with the roots the old tree posted that the
+     * new one lacks deleted (`ChannelSubscription`).
      */
-    constructor(diffWorker: Worker, keyFunc?: (value: any) => string | undefined);
+    private Restarted;
+    private Connect;
+    /** Applies a post. A tree's first state is diffed into the roots in place, its deletes with it. */
+    private Apply;
     private Schedule;
     /**
      * Writes data to the store asynchronously.
@@ -57,8 +110,8 @@ export declare class StoreAsync extends Store {
      * @param data The data to be written. Can be of any type.
      * @param key Optional key for the data. If not provided, the keyFunc will be used to generate a key.
      * @returns A promise that resolves once the write has been applied to the store.
-     * @throws Will throw an error if no key is provided for the data, or reject with the original
-     *   error if an earlier change failed.
+     * @throws Will throw an error if no key is provided for the data, or reject with the error of
+     *   the batch it was sent in.
      */
     Write(data: unknown, key?: string): Promise<void>;
     /**
@@ -69,7 +122,7 @@ export declare class StoreAsync extends Store {
      * @param patch The patch data to be merged with the existing value.
      * @returns A promise that resolves once the patch has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
-     *   the original error if an earlier change failed.
+     *   the error of the batch it was sent in.
      */
     Patch(key: string, patch: unknown): Promise<void>;
     /**
@@ -78,7 +131,7 @@ export declare class StoreAsync extends Store {
      * @param data The data items to be pushed into the array.
      * @returns A promise that resolves once the items have been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
-     *   the original error if an earlier change failed.
+     *   the error of the batch it was sent in.
      */
     Push(key: string, ...data: unknown[]): Promise<void>;
     /**
@@ -90,19 +143,21 @@ export declare class StoreAsync extends Store {
      * @param items Optional elements to insert into the array.
      * @returns A promise that resolves once the splice has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
-     *   the original error if an earlier change failed.
+     *   the error of the batch it was sent in.
      */
     Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<void>;
     /**
      * Returns a promise that resolves once every change made before this call has been applied
-     * to the store. Changes made after this call are sent in a later batch, so they aren't
-     * waited for and haven't been applied when the promise resolves.
-     * @throws Rejects with the original error if a change made before this call failed.
+     * to the store: when the last batch sent before it is acknowledged, and at once when none is in
+     * flight. Changes made after this call are sent in a later batch, so they aren't waited for and
+     * haven't been applied when the promise resolves.
+     * @throws Rejects with the first error of the batches it waited for.
      */
     Flush(): Promise<void>;
     /**
-     * Destroys the StoreAsync instance, stopping the async queue and cleaning up the diff instance.
-     * This method should be called when the instance is no longer needed to free up resources.
+     * Unsubscribes and stops listening to the channel. Changes not yet acknowledged never settle.
+     * Over a lease, the store then releases it: the last lease on a worker ends it. Over a channel, the
+     * channel stays open: whoever created the worker terminates it.
      */
     Destroy(): void;
 }

package/Store/Store/storeAsync.js

@@ -1,14 +1,30 @@
 import { AsyncQueue } from "../../Utils/asyncQueue";
-import { WorkerQueue } from "../Diff/workerQueue";
+import { ChannelClient, ChannelSubscription } from "../Diff/channelClient";
 import { RootOf, Store } from "./store";
 /**
  * StoreAsync class extends the base Store class to provide asynchronous data management operations.
  * This class handles writing, patching, pushing, and splicing data in an asynchronous manner.
  *
- * StoreAsync is designed to work with observable data structures, allowing for efficient updates
- * and notifications when data changes. It is particularly useful for scenarios where asynchronous
- * operations are preferred or required, such as handling large datasets or performing complex diffs
- * without blocking the main thread.
+ * The tree lives in a worker, served by a `HostPublisher`. The store subscribes on construction and
+ * applies every commit the tree posts, whatever caused it: its own batches, other writers, or the
+ * worker's own work. A store created after the tree has committed starts from its committed state.
+ * Without writes it's a read-only view of the tree.
+ *
+ * - Changes made in one tick are sent as one batch, and at most one batch waits behind the one in
+ *   flight. A change's promise resolves on its batch's `jt-ack`, which arrives after the commit's
+ *   posts, so the change has been applied when it resolves.
+ * - A failed batch rejects only its own changes; later batches carry on.
+ *
+ * **Over a lease** (`DiffTreeHub.Open`), the store takes its keyFunc from the lease's endpoint, owns
+ * the lease, and releases it when it's destroyed. When the hub restarts the worker,
+ * the store starts over with the new tree, as when it first subscribed: the tree is the source of
+ * truth, nothing the store wrote is written back, and changes the old tree hadn't acknowledged are
+ * rejected.
+ *
+ * @example
+ * // A store over a hub's lease: it lives as long as the component that holds it
+ * @Inject(DiffTreeHub) hub!: DiffTreeHub;
+ * @Destroy() totals = new StoreAsync(this.hub.Open("totals"));
  *
  * @example
  * // Creating a StoreAsync instance from a bundler-built worker entry file
@@ -28,41 +44,82 @@ import { RootOf, Store } from "./store";
  * // Splicing an array asynchronously
  * await store.Splice("users", 0, 1, { id: 3 });
  *
- * // Cleaning up resources
+ * // Cleaning up resources: the store stops listening; the worker is its creator's to terminate
  * store.Destroy();
+ * worker.terminate();
  *
  * @see Store
  * @see StoreSync
  */
 export class StoreAsync extends Store {
     /**
-     * Creates an instance of StoreAsync.
-     * @param diffWorker A `Worker` running a `DiffTree` connected via `ConnectWorkerToDiffTree`
-     *   (e.g. a bundled `defaultDiffTreeWorker` entry). Any `keyFunc`/routes the diff needs
-     *   must be baked into that worker's own entry file.
-     * @param keyFunc Optional function to generate a key for a given data value, used locally by
-     *   this store to resolve root objects. Pass the same key logic the worker's `DiffTree` was
-     *   constructed with, if any.
+     * Creates an instance of StoreAsync and subscribes to the tree.
+     * @param channel A channel to an `ObservableDiffTree` served by `HostPublisher`: a `Worker` (e.g. a
+     *   bundled `defaultDiffTreeWorker` entry), a `MessagePort`, or a lease from `DiffTreeHub.Open`. Other
+     *   messages may share the channel. Given a lease, the store owns it from then on and releases it
+     *   when it's destroyed, and follows the worker across restarts. A lease on a tree on this thread
+     *   (`DiffTreeHub.OpenLocal`) is for a `StoreSync`, and doesn't compile here.
+     * @param options `keyFunc`, `roots` and `opaque` (`IStoreAsyncOptions`). `keyFunc` is for a plain
+     *   channel: pass the key logic the worker's tree was built with. A lease's is the endpoint's.
+     *   `opaque` is sent to the tree before the store subscribes; over a lease, share it with the tree
+     *   (`IObservableDiffTreeConfig.opaque`) from a file both import.
+     * @throws When `keyFunc` is given with a lease, whose endpoint has its own.
      */
-    constructor(diffWorker, keyFunc) {
-        super(keyFunc);
+    constructor(channel, options = {}) {
+        const lease = IsLease(channel) ? channel : undefined;
+        if (lease && options.keyFunc)
+            throw new Error(`StoreAsync: the endpoint ${lease.name} gives the store its keyFunc; leave it out of the options.`);
+        const keyFunc = lease ? lease.endpoint.keyFunc : options.keyFunc;
+        super(keyFunc, options.opaque);
         this.writeKeySet = new Set();
+        this.asyncQueue = new AsyncQueue();
         this.currentBatch = [];
         this.currentBatchPromise = Promise.resolve();
-        this.workerQueue = new WorkerQueue(diffWorker);
-        this.asyncQueue = new AsyncQueue(true);
+        /** Batches not yet acknowledged, for `Flush` */
+        this.inFlight = new Set();
+        this.options = options;
+        this.lease = lease;
+        if (lease)
+            this.stopLease = lease.OnPort(port => this.Restarted(port));
+        this.subscription = new ChannelSubscription({ roots: options.roots }, (post, first) => this.Apply(post, first));
+        this.client = this.Connect(lease ? lease.port : channel);
+        this.subscription.Connect(this.client);
+    }
+    /**
+     * The hub restarted the lease's worker: the store moves to the new tree's port, keeping its
+     * readers, and starts over as when it first subscribed. The changes the old tree hadn't
+     * acknowledged are rejected, not sent again, and nothing is written back: the new tree's first
+     * state is diffed into the store's roots in place, with the roots the old tree posted that the
+     * new one lacks deleted (`ChannelSubscription`).
+     */
+    Restarted(port) {
+        this.client.RejectBatches(new Error(`${this.lease.name} restarted before this change was acknowledged.`));
+        this.client.Destroy();
+        this.client = this.Connect(port);
+        this.subscription.Connect(this.client);
+    }
+    Connect(channel) {
+        const client = new ChannelClient(channel);
+        this.options.opaque && this.options.opaque.length > 0 && client.MarkOpaque(this.options.opaque);
+        return client;
+    }
+    /** Applies a post. A tree's first state is diffed into the roots in place, its deletes with it. */
+    Apply(post, firstState) {
+        firstState ? this.UpdateRootMapInPlace(post.diff) : this.UpdateRootMap(post.diff);
     }
     async Schedule(method) {
         if (this.currentBatch.length === 0) {
             const batch = this.currentBatch;
-            this.currentBatchPromise = this.asyncQueue.Next(async () => {
+            const sent = this.asyncQueue.Next(async () => {
                 await Promise.resolve();
                 if (batch === this.currentBatch)
                     this.currentBatch = [];
-                // The worker's Commit() diff covers every change in the batch
-                const diff = await this.workerQueue.Push(batch);
-                this.UpdateRootMap(diff);
+                // The batch's commit is applied by the subscription, before its ack arrives
+                await this.client.Batch(batch);
             });
+            this.currentBatchPromise = sent;
+            this.inFlight.add(sent);
+            sent.then(() => this.inFlight.delete(sent), () => this.inFlight.delete(sent));
         }
         this.currentBatch.push(method);
         await this.currentBatchPromise;
@@ -75,8 +132,8 @@ export class StoreAsync extends Store {
      * @param data The data to be written. Can be of any type.
      * @param key Optional key for the data. If not provided, the keyFunc will be used to generate a key.
      * @returns A promise that resolves once the write has been applied to the store.
-     * @throws Will throw an error if no key is provided for the data, or reject with the original
-     *   error if an earlier change failed.
+     * @throws Will throw an error if no key is provided for the data, or reject with the error of
+     *   the batch it was sent in.
      */
     async Write(data, key) {
         key = key || this.keyFunc?.(data);
@@ -98,7 +155,7 @@ export class StoreAsync extends Store {
      * @param patch The patch data to be merged with the existing value.
      * @returns A promise that resolves once the patch has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
-     *   the original error if an earlier change failed.
+     *   the error of the batch it was sent in.
      */
     async Patch(key, patch) {
         if (!this.HasRootOf(key) && !this.writeKeySet.has(RootOf(key)))
@@ -114,7 +171,7 @@ export class StoreAsync extends Store {
      * @param data The data items to be pushed into the array.
      * @returns A promise that resolves once the items have been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
-     *   the original error if an earlier change failed.
+     *   the error of the batch it was sent in.
      */
     async Push(key, ...data) {
         if (!this.HasRootOf(key) && !this.writeKeySet.has(RootOf(key)))
@@ -133,7 +190,7 @@ export class StoreAsync extends Store {
      * @param items Optional elements to insert into the array.
      * @returns A promise that resolves once the splice has been applied to the store.
      * @throws Will throw if the key isn't in the store and has no pending Write, or reject with
-     *   the original error if an earlier change failed.
+     *   the error of the batch it was sent in.
      */
     async Splice(key, start, deleteCount, ...items) {
         if (!this.HasRootOf(key) && !this.writeKeySet.has(RootOf(key)))
@@ -145,20 +202,32 @@ export class StoreAsync extends Store {
     }
     /**
      * Returns a promise that resolves once every change made before this call has been applied
-     * to the store. Changes made after this call are sent in a later batch, so they aren't
-     * waited for and haven't been applied when the promise resolves.
-     * @throws Rejects with the original error if a change made before this call failed.
+     * to the store: when the last batch sent before it is acknowledged, and at once when none is in
+     * flight. Changes made after this call are sent in a later batch, so they aren't waited for and
+     * haven't been applied when the promise resolves.
+     * @throws Rejects with the first error of the batches it waited for.
      */
     async Flush() {
         this.currentBatch = [];
-        return this.asyncQueue.Flush();
+        const pending = Array.from(this.inFlight);
+        const results = await Promise.allSettled(pending);
+        const failed = results.find(result => result.status === "rejected");
+        if (failed)
+            throw failed.reason;
     }
     /**
-     * Destroys the StoreAsync instance, stopping the async queue and cleaning up the diff instance.
-     * This method should be called when the instance is no longer needed to free up resources.
+     * Unsubscribes and stops listening to the channel. Changes not yet acknowledged never settle.
+     * Over a lease, the store then releases it: the last lease on a worker ends it. Over a channel, the
+     * channel stays open: whoever created the worker terminates it.
      */
     Destroy() {
+        this.stopLease?.();
         this.asyncQueue.Stop();
-        this.workerQueue.Destroy();
+        this.subscription.Stop();
+        this.client.Destroy();
+        this.lease?.Release();
     }
 }
+function IsLease(channel) {
+    return typeof channel.OnPort === "function";
+}

package/Store/Store/storeSync.d.ts

@@ -1,5 +1,14 @@
-import { IRouteDefinitions } from "../Diff/utils/diffTree.types";
-import { Store } from "./store";
+import type { ILocalLease } from "../Diff/diffTree.types";
+import { ObservableDiffTree } from "../Diff/observableDiffTree";
+import { IStoreOptions, Store } from "./store";
+/** Options for a `StoreSync` */
+export interface IStoreSyncOptions extends IStoreOptions {
+    /**
+     * The tree's root keys the store holds: exact keys and patterns ending in `*`. Omitted, every
+     * root. With a `keyFunc`, include the entity roots the held roots refer to.
+     */
+    roots?: readonly string[];
+}
 /**
  * StoreSync class extends the base Store class to provide synchronous data management operations.
  * This class handles writing, patching, pushing, and splicing data in a synchronous manner.
@@ -24,24 +33,67 @@ 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 declare class StoreSync extends Store {
     /**
-     * The tree each change is applied to. Its `Commit()` diff keeps the store in sync.
+     * The tree each change is applied to. The store applies every commit it delivers.
      * @private
      */
     private diff;
+    private unsubscribe?;
+    /** The lease the store owns, when it was given one */
+    private lease?;
+    private stopLease?;
+    private roots?;
+    /** Over a lease: the roots delivered and not deleted, to delete the ones a restarted tree doesn't hold */
+    private delivered;
     /**
-     * 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(keyFunc?: (value: any) => string | undefined, routes?: IRouteDefinitions);
+    constructor(tree?: ObservableDiffTree | ILocalLease, options?: IStoreSyncOptions);
+    /**
+     * 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.
+     */
+    get Tree(): ObservableDiffTree;
     /**
      * Writes data to the store synchronously.
      * @param data The data to be written. Can be of any type.
@@ -72,7 +124,20 @@ export declare class StoreSync extends Store {
      */
     Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): void;
     /**
-     * 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(): void;
+    /**
+     * 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`.
+     */
+    private Attach;
+    private Track;
+    /**
+     * Runs projections and commits: the commit's delivery applies everything changed since the
+     * last commit to the store.
      * @private
      */
     private Sync;