@evolu/common 8.10.0 → 8.12.0

package/dist/src/Resource.d.ts

@@ -1,5 +1,29 @@
 /**
- * Concurrency-safe helpers for efficient reuse of disposable resources.
+ * Concurrency-safe helpers for efficient reuse and replacement of disposable
+ * resources.
+ *
+ * ## Replacement policies
+ *
+ * Replacing a live resource has two policies.
+ *
+ * Exclusive replacement disposes the current resource and then creates the
+ * next, so at most one exists and there is an observable gap with none.
+ * {@link ResettableResource} implements it. Leases do not fit this policy: a
+ * reset is requested precisely when holders are stuck on a dead resource, so
+ * waiting for them inverts the purpose, and revoking them is safe only when the
+ * resource's own API is total after disposal, in which case a lease adds
+ * nothing.
+ *
+ * Overlapping replacement creates the next generation first and disposes the
+ * previous one when its last lease is released, so work in progress finishes on
+ * the generation it started with. It keeps the old generation when creation
+ * fails, at the cost of both existing for a while. It is not implemented. It
+ * belongs on {@link SharedResource} as an invalidate operation: mark the current
+ * generation stale, stop leasing it, dispose it on its last release, and create
+ * the next on the next acquire. Before that can ship,
+ * {@link SharedResourceByKey} must stop removing a key when its resource is
+ * disposed, and {@link SharedResourceByKeyWithClaims} must stop keeping one
+ * resource object per key for the lifetime of its claims.
  *
  * @module
  */
@@ -27,6 +51,7 @@ import { type DistributiveOmit } from "./Types.ts";
  * APIs let that error propagate as a defect. The purpose of resource helpers is
  * to guarantee cleanup and prevent leaks.
  *
+ * @see {@link ResettableResource}
  * @see {@link SharedResource}
  * @see {@link createSharedResource}
  */
@@ -278,6 +303,131 @@ export interface SharedResourceOptions {
  * the Run tree.
  */
 export declare const createSharedResource: <T extends Resource, D>(create: Task<T, never, D>, { idleDisposeAfter, onDisposed }?: SharedResourceOptions) => Task<SharedResource<T>, never, D>;
+/**
+ * A {@link Resource} reset in place.
+ *
+ * Holds one current resource and resets it on request: the current resource is
+ * disposed first, then `create` runs again. At most one resource exists, and
+ * there is an observable gap with none. Consumers keep the ResettableResource
+ * and read the current resource through {@link ResettableResource.get | get}, so
+ * a reset needs no re-registration. A resource that cannot reset itself is the
+ * case for it. One that can, as `WebSocket.reconnect` does, keeps a stable
+ * identity and needs no wrapper.
+ *
+ * The ResettableResource keeps a stable identity while its current resource
+ * changes. {@link SharedResourceByKeyWithClaims} can retain it directly;
+ * consumers read the current resource through `get`.
+ *
+ * Repeated async disposal calls await the same cleanup and preserve any
+ * disposal failure.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   assertEqual,
+ *   assertSame,
+ *   createRun,
+ *   createResettableResource,
+ *   ok,
+ *   type Task,
+ * } from "@evolu/common";
+ *
+ * interface Connection extends Disposable {
+ *   readonly id: number;
+ *   readonly isClosed: () => boolean;
+ * }
+ *
+ * let nextId = 1;
+ * const createConnection: Task<Connection> = () => {
+ *   const id = nextId++;
+ *   let isClosed = false;
+ *   return ok({
+ *     id,
+ *     isClosed: () => isClosed,
+ *     [Symbol.dispose]: () => {
+ *       isClosed = true;
+ *     },
+ *   });
+ * };
+ *
+ * await using run = createRun();
+ * await using connection = await run.ok(
+ *   createResettableResource(createConnection),
+ * );
+ * const first = connection.get();
+ * assertEqual(first?.id, 1);
+ *
+ * await run.ok(connection.reset(first));
+ * assertSame(first?.isClosed(), true);
+ * assertEqual(connection.get()?.id, 2);
+ * ```
+ */
+export interface ResettableResource<T extends Resource> extends AsyncDisposable {
+    /**
+     * Returns the current resource, or `undefined` when there is none: while a
+     * reset is in progress, after a reset whose creation aborted, and after
+     * disposal. Callers treat every absence alike, as the resource's own
+     * not-ready state.
+     */
+    readonly get: () => BorrowedResource<T> | undefined;
+    /**
+     * Resets the current resource: disposes it, then creates the next one.
+     *
+     * A reset is requested because `observed` misbehaved, and it runs only while
+     * `observed` is still current or there is no current resource. A request that
+     * finds a different resource current returns without resetting, so every
+     * observer of one dead resource shares one reset, however late its request
+     * arrives. An `observed` of `undefined` is an observation of absence, as
+     * {@link ResettableResource.get | get} returns during a reset: the request
+     * runs only while nothing is current, so it retries an aborted creation and
+     * skips once a replacement exists.
+     *
+     * Resets are serialized. Owner disposal aborts a pending reset with
+     * `runDisposedAbortReason`, and a resource that `create` returns after
+     * disposal started is disposed and never becomes current.
+     *
+     * Resets follow the resource-owned {@link Run}'s lifecycle: an abort request
+     * can cancel them, and calling reset after that Run starts disposal is a
+     * programmer error. Aborting the caller's {@link Fiber} does not cancel a
+     * started reset; dependencies remain those captured at creation.
+     */
+    readonly reset: (observed: BorrowedResource<T> | undefined) => Task<void>;
+}
+/**
+ * Creates {@link ResettableResource}.
+ *
+ * The first resource is created before this Task returns; if that creation
+ * aborts, nothing is left running. If the caller's Fiber aborts during initial
+ * creation, this Task waits for creation to settle, disposes any created
+ * resource, and returns the abort instead of a resource.
+ *
+ * The `create` Task must not fail: the previous resource is already disposed
+ * when it runs, so a failure would leave nothing to fall back to. Handle
+ * recoverable failures inside `create`, or return a resource whose state models
+ * them.
+ *
+ * The resource's own API must model its not-ready state, as a reconnecting
+ * connection models "connecting": `get` returns `undefined` during a reset, and
+ * callers treat that absence the same way. A resource whose API assumes
+ * readiness gains nothing here; every caller would rebuild that state around
+ * it.
+ *
+ * As with {@link createSharedResource}, a returned resource must be live and
+ * independently owned, and `create` runs on a Run created from the Run that
+ * executes this Task, so dependencies are captured at creation time.
+ *
+ * Every successful `create` invocation must return a fresh object identity,
+ * never one returned earlier. A reset skips when the observed resource is no
+ * longer current, and that comparison is by identity; a reused object makes a
+ * stale observation match the replacement and reset it again.
+ *
+ * A reset runs `create` and the resource's disposer while holding a
+ * non-reentrant lock. Neither may directly or transitively await another
+ * {@link ResettableResource.reset | reset} of this ResettableResource, because
+ * that reset waits for the same lock.
+ */
+export declare const createResettableResource: <T extends Resource, D>(create: Task<T, never, D>) => Task<ResettableResource<T>, never, D>;
 /**
  * Shared {@link Resource}s keyed by logical identity.
  *
@@ -487,6 +637,11 @@ export declare function createSharedResourceByKey<K, T extends Resource, D, L =
  * leases by key and the application does not need to associate those leases
  * with logical owners.
  *
+ * One resource object per key is kept for the lifetime of its claims, and
+ * callbacks receive that object. A {@link ResettableResource} can be retained
+ * directly because its identity is stable; consumers read its current resource
+ * through {@link ResettableResource.get | get}.
+ *
  * Two accounts can share a relay connection while one also uses a local-network
  * transport:
  *

package/dist/src/Resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Resource.d.ts","sourceRoot":"","sources":["../../src/Resource.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Resource.d.ts","sourceRoot":"","sources":["../../src/Resource.ts"],"names":[],"mappings":"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"}

package/dist/src/Resource.js

@@ -1,5 +1,29 @@
 /**
- * Concurrency-safe helpers for efficient reuse of disposable resources.
+ * Concurrency-safe helpers for efficient reuse and replacement of disposable
+ * resources.
+ *
+ * ## Replacement policies
+ *
+ * Replacing a live resource has two policies.
+ *
+ * Exclusive replacement disposes the current resource and then creates the
+ * next, so at most one exists and there is an observable gap with none.
+ * {@link ResettableResource} implements it. Leases do not fit this policy: a
+ * reset is requested precisely when holders are stuck on a dead resource, so
+ * waiting for them inverts the purpose, and revoking them is safe only when the
+ * resource's own API is total after disposal, in which case a lease adds
+ * nothing.
+ *
+ * Overlapping replacement creates the next generation first and disposes the
+ * previous one when its last lease is released, so work in progress finishes on
+ * the generation it started with. It keeps the old generation when creation
+ * fails, at the cost of both existing for a while. It is not implemented. It
+ * belongs on {@link SharedResource} as an invalidate operation: mark the current
+ * generation stale, stop leasing it, dispose it on its last release, and create
+ * the next on the next acquire. Before that can ship,
+ * {@link SharedResourceByKey} must stop removing a key when its resource is
+ * disposed, and {@link SharedResourceByKeyWithClaims} must stop keeping one
+ * resource object per key for the lifetime of its claims.
  *
  * @module
  */
@@ -256,6 +280,124 @@ export const createSharedResource = (create, { idleDisposeAfter, onDisposed } =
     }, sharedResourceHandle);
     return ok(sharedResource);
 };
+/**
+ * Creates {@link ResettableResource}.
+ *
+ * The first resource is created before this Task returns; if that creation
+ * aborts, nothing is left running. If the caller's Fiber aborts during initial
+ * creation, this Task waits for creation to settle, disposes any created
+ * resource, and returns the abort instead of a resource.
+ *
+ * The `create` Task must not fail: the previous resource is already disposed
+ * when it runs, so a failure would leave nothing to fall back to. Handle
+ * recoverable failures inside `create`, or return a resource whose state models
+ * them.
+ *
+ * The resource's own API must model its not-ready state, as a reconnecting
+ * connection models "connecting": `get` returns `undefined` during a reset, and
+ * callers treat that absence the same way. A resource whose API assumes
+ * readiness gains nothing here; every caller would rebuild that state around
+ * it.
+ *
+ * As with {@link createSharedResource}, a returned resource must be live and
+ * independently owned, and `create` runs on a Run created from the Run that
+ * executes this Task, so dependencies are captured at creation time.
+ *
+ * Every successful `create` invocation must return a fresh object identity,
+ * never one returned earlier. A reset skips when the observed resource is no
+ * longer current, and that comparison is by identity; a reused object makes a
+ * stale observation match the replacement and reset it again.
+ *
+ * A reset runs `create` and the resource's disposer while holding a
+ * non-reentrant lock. Neither may directly or transitively await another
+ * {@link ResettableResource.reset | reset} of this ResettableResource, because
+ * that reset waits for the same lock.
+ */
+export const createResettableResource = (create) => async (run) => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { leakDetector } = run.deps;
+        let current;
+        const disposer = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
+        const resettableResourceRun = disposer.use(run.create());
+        const mutex = createMutex();
+        const resettableResourceHandle = {};
+        const resetFrom = (observed) => mutex.withLock(async (run) => {
+            // A resource other than the observed one is current. An aborted
+            // creation leaves no current resource, so a queued request still runs.
+            if (current !== undefined && current !== observed) {
+                return ok();
+            }
+            const previous = current;
+            await disposeCurrent();
+            const next = await run.ok(create);
+            assert(next !== previous, "ResettableResource create must return a fresh object identity.");
+            // A resource returned after disposal started is disposed here, so
+            // `get` never exposes it while owner finalization runs.
+            if (run.signal.aborted) {
+                const env_4 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const _next = __addDisposableResource(env_4, next, true);
+                }
+                catch (e_4) {
+                    env_4.error = e_4;
+                    env_4.hasError = true;
+                }
+                finally {
+                    const result_3 = __disposeResources(env_4);
+                    if (result_3)
+                        await result_3;
+                }
+            }
+            run.signal.throwIfAborted();
+            current = next;
+            return ok();
+        });
+        const disposeCurrent = async () => {
+            const env_5 = { stack: [], error: void 0, hasError: false };
+            try {
+                const _resource = __addDisposableResource(env_5, current, true);
+                current = undefined;
+            }
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
+            }
+            finally {
+                const result_4 = __disposeResources(env_5);
+                if (result_4)
+                    await result_4;
+            }
+        };
+        resettableResourceRun.defer(() => {
+            leakDetector.untrack(resettableResourceHandle);
+        });
+        resettableResourceRun.defer(disposeCurrent);
+        await resettableResourceRun.ok(resetFrom(undefined));
+        // The caller can abort independently of the resource-owned Run.
+        run.signal.throwIfAborted();
+        const resettableResource = {
+            get: () => current,
+            reset: (observed) => () => resettableResourceRun(resetFrom(observed)),
+            [Symbol.asyncDispose]: () => resettableResourceRun[Symbol.asyncDispose](),
+        };
+        leakDetector.track(resettableResource, {
+            name: "ResettableResource",
+            isLeaked: () => resettableResourceRun.getState().type === "Running",
+        }, resettableResourceHandle);
+        disposer.move();
+        return ok(resettableResource);
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_3);
+        if (result_2)
+            await result_2;
+    }
+};
 export function createSharedResourceByKey(create, { idleDisposeAfter, lookup = identity, onDisposed, } = {}) {
     return (run) => {
         const sharedResourceByKeyRun = run.create();
@@ -287,21 +429,21 @@ export function createSharedResourceByKey(create, { idleDisposeAfter, lookup = i
         // SharedResource disposals are aborted and awaited before the registered
         // SharedResources are disposed.
         disposer.defer(async () => {
-            const env_3 = { stack: [], error: void 0, hasError: false };
+            const env_6 = { stack: [], error: void 0, hasError: false };
             try {
-                const keyDisposer = __addDisposableResource(env_3, new AsyncDisposableStack(), true);
+                const keyDisposer = __addDisposableResource(env_6, new AsyncDisposableStack(), true);
                 for (const sharedResource of sharedResourcesByKey.values())
                     keyDisposer.use(sharedResource);
                 sharedResourcesByKey.clear();
             }
-            catch (e_3) {
-                env_3.error = e_3;
-                env_3.hasError = true;
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
             }
             finally {
-                const result_2 = __disposeResources(env_3);
-                if (result_2)
-                    await result_2;
+                const result_5 = __disposeResources(env_6);
+                if (result_5)
+                    await result_5;
             }
         });
         disposer.use(sharedResourceByKeyRun);
@@ -346,23 +488,23 @@ export function createSharedResourceByKey(create, { idleDisposeAfter, lookup = i
                 return ok(lease);
             })),
             use: (key, callback) => async (run) => {
-                const env_4 = { stack: [], error: void 0, hasError: false };
+                const env_7 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const lease = __addDisposableResource(env_4, await run.ok(sharedResourceByKey.acquire(key)), false);
+                    const lease = __addDisposableResource(env_7, await run.ok(sharedResourceByKey.acquire(key)), false);
                     return await run(callback(lease.resource, lease.created));
                 }
-                catch (e_4) {
-                    env_4.error = e_4;
-                    env_4.hasError = true;
+                catch (e_7) {
+                    env_7.error = e_7;
+                    env_7.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_4);
+                    __disposeResources(env_7);
                 }
             },
             forEachCurrent: (callback) => async (run) => {
-                const env_5 = { stack: [], error: void 0, hasError: false };
+                const env_8 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const leaseDisposer = __addDisposableResource(env_5, new DisposableStack(), false);
+                    const leaseDisposer = __addDisposableResource(env_8, new DisposableStack(), false);
                     const leasesByKey = [];
                     // oxlint-disable-next-line unicorn/no-useless-spread -- Snapshot keys because each acquisition awaits and can mutate the registry.
                     for (const [key] of [...sharedResourcesByKey]) {
@@ -375,12 +517,12 @@ export function createSharedResourceByKey(create, { idleDisposeAfter, lookup = i
                         callback(lease.resource, key);
                     return ok();
                 }
-                catch (e_5) {
-                    env_5.error = e_5;
-                    env_5.hasError = true;
+                catch (e_8) {
+                    env_8.error = e_8;
+                    env_8.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_5);
+                    __disposeResources(env_8);
                 }
             },
             snapshot: () => {
@@ -423,7 +565,7 @@ export function createSharedResourceByKey(create, { idleDisposeAfter, lookup = i
  * happen later when `idleDisposeAfter` is configured.
  */
 export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter, resourceLookup = identity, claimLookup = identity, onFirstClaimAdded, onLastClaimRemoved, } = {}) => async (run) => {
-    const env_6 = { stack: [], error: void 0, hasError: false };
+    const env_9 = { stack: [], error: void 0, hasError: false };
     try {
         const sharedResourceByKeyWithClaimsRun = run.create();
         const { leakDetector } = run.deps;
@@ -446,7 +588,7 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                 sharedResourceByKeyWithClaimsRun.panic(defect);
             }
         };
-        const disposer = __addDisposableResource(env_6, new AsyncDisposableStack(), true);
+        const disposer = __addDisposableResource(env_9, new AsyncDisposableStack(), true);
         // Explicit disposal stops claim operations and runs their finalizers before
         // disposing the keyed registry. The nested stack is empty if keyed-registry
         // creation fails. Both internal Runs attach to the root, whose disposal
@@ -454,12 +596,12 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
         const sharedResourceByKeyDisposer = disposer.use(new AsyncDisposableStack());
         disposer.use(sharedResourceByKeyWithClaimsRun);
         const releaseClaimLease = (heldClaimLease, notifyTransition = true) => {
-            const env_7 = { stack: [], error: void 0, hasError: false };
+            const env_10 = { stack: [], error: void 0, hasError: false };
             try {
                 if (!heldClaimLeases.delete(heldClaimLease))
                     return false;
                 leakDetector.untrack(heldClaimLease);
-                const _resourceLeases = __addDisposableResource(env_7, heldClaimLease.resourceLeases, false);
+                const _resourceLeases = __addDisposableResource(env_10, heldClaimLease.resourceLeases, false);
                 for (const resourceKey of heldClaimLease.resourceKeys) {
                     const decremented = claimResourceRelation.decrement(heldClaimLease.claim, resourceKey);
                     if (decremented.count > 0)
@@ -477,18 +619,18 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                 }
                 return true;
             }
-            catch (e_7) {
-                env_7.error = e_7;
-                env_7.hasError = true;
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
             }
             finally {
-                __disposeResources(env_7);
+                __disposeResources(env_10);
             }
         };
         const drainClaimLeases = () => {
-            const env_8 = { stack: [], error: void 0, hasError: false };
+            const env_11 = { stack: [], error: void 0, hasError: false };
             try {
-                const disposer = __addDisposableResource(env_8, new DisposableStack(), false);
+                const disposer = __addDisposableResource(env_11, new DisposableStack(), false);
                 disposer.defer(() => {
                     claimResourceRelation.clear();
                     resourcesByKey.clear();
@@ -499,12 +641,12 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                     });
                 }
             }
-            catch (e_8) {
-                env_8.error = e_8;
-                env_8.hasError = true;
+            catch (e_11) {
+                env_11.error = e_11;
+                env_11.hasError = true;
             }
             finally {
-                __disposeResources(env_8);
+                __disposeResources(env_11);
             }
         };
         sharedResourceByKeyWithClaimsRun.defer(() => {
@@ -523,13 +665,13 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                 ...resourceKeys.slice(1),
             ];
             return sharedResourceByKeyWithClaimsRun(async (run) => {
-                const env_9 = { stack: [], error: void 0, hasError: false };
+                const env_12 = { stack: [], error: void 0, hasError: false };
                 try {
                     assert(createLookupSet({
                         lookup: resourceLookup,
                         values: resourceKeysSnapshot,
                     }).size === resourceKeysSnapshot.length, "resourceKeys must not contain lookup duplicates.");
-                    const resourceLeases = __addDisposableResource(env_9, new DisposableStack(), false);
+                    const resourceLeases = __addDisposableResource(env_12, new DisposableStack(), false);
                     const [firstResourceKey, ...remainingResourceKeys] = resourceKeysSnapshot;
                     // acquire releases a transferred lease before surfacing owner abort,
                     // so a throwing await cannot leave ownership uncollected.
@@ -572,10 +714,10 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                         isLeaked: () => heldClaimLeases.has(heldClaimLease),
                     }, heldClaimLease);
                     try {
-                        const env_10 = { stack: [], error: void 0, hasError: false };
+                        const env_13 = { stack: [], error: void 0, hasError: false };
                         try {
                             let succeeded = false;
-                            const compensations = __addDisposableResource(env_10, new DisposableStack(), false);
+                            const compensations = __addDisposableResource(env_13, new DisposableStack(), false);
                             for (const [claim, resource, resourceKey,] of firstClaimTransitions) {
                                 onFirstClaimAdded?.(claim, resource, resourceKey);
                                 // oxlint-disable-next-line eslint/no-loop-func -- Captures this iteration's block-scoped transition values for rollback.
@@ -587,12 +729,12 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                             }
                             succeeded = true;
                         }
-                        catch (e_9) {
-                            env_10.error = e_9;
-                            env_10.hasError = true;
+                        catch (e_12) {
+                            env_13.error = e_12;
+                            env_13.hasError = true;
                         }
                         finally {
-                            __disposeResources(env_10);
+                            __disposeResources(env_13);
                         }
                     }
                     catch (defect) {
@@ -601,33 +743,33 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
                     }
                     return ok(project(claimLease, resources));
                 }
-                catch (e_10) {
-                    env_9.error = e_10;
-                    env_9.hasError = true;
+                catch (e_13) {
+                    env_12.error = e_13;
+                    env_12.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_9);
+                    __disposeResources(env_12);
                 }
             });
         };
         const sharedResourceByKeyWithClaims = {
             claim: (claim, resourceKeys) => acquireClaim(claim, resourceKeys, (claimLease) => claimLease),
             use: (claim, resourceKeys, callback) => async (run) => {
-                const env_11 = { stack: [], error: void 0, hasError: false };
+                const env_14 = { stack: [], error: void 0, hasError: false };
                 try {
                     const acquired = await run.ok(acquireClaim(claim, resourceKeys, (claimLease, resources) => ({
                         claimLease,
                         resources,
                     })));
-                    const _claimLease = __addDisposableResource(env_11, acquired.claimLease, false);
+                    const _claimLease = __addDisposableResource(env_14, acquired.claimLease, false);
                     return await run(callback(acquired.resources));
                 }
-                catch (e_11) {
-                    env_11.error = e_11;
-                    env_11.hasError = true;
+                catch (e_14) {
+                    env_14.error = e_14;
+                    env_14.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_11);
+                    __disposeResources(env_14);
                 }
             },
             getClaimsForResource: (resourceKey) => new Set(claimResourceRelation.getAs(resourceKey)),
@@ -668,26 +810,13 @@ export const createSharedResourceByKeyWithClaims = (create, { idleDisposeAfter,
         }, sharedResourceByKeyWithClaimsHandle);
         return ok(sharedResourceByKeyWithClaims);
     }
-    catch (e_6) {
-        env_6.error = e_6;
-        env_6.hasError = true;
+    catch (e_9) {
+        env_9.error = e_9;
+        env_9.hasError = true;
     }
     finally {
-        const result_3 = __disposeResources(env_6);
-        if (result_3)
-            await result_3;
+        const result_6 = __disposeResources(env_9);
+        if (result_6)
+            await result_6;
     }
 };
-// TODO: Add a lease-based reloadable resource when a concrete use case needs
-// resource swapping. A ResourceRef-style get/set API is unsafe because set can
-// dispose a resource still held by a caller of get. Model resource generations
-// explicitly and distinguish two replacement policies, probably as separate
-// APIs rather than a boolean option:
-// - Overlapping: create and validate the replacement, publish it to new leases,
-//   then dispose the old generation after its existing leases drain. This
-//   supports zero-downtime reload and keeps the old generation when creation
-//   fails, but both generations temporarily exist.
-// - Exclusive: stop or queue new leases, drain and dispose the old generation,
-//   then create and publish the replacement. This guarantees at most one live
-//   resource, but introduces downtime and leaves no valid resource when creation
-//   fails unless the owner retries or recreates the old configuration.