@@ -1,6 +1,5 @@
 import * as KeyedLock from "@t3tools/shared/KeyedLock";
 import type * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
 
 export interface KeyedSerialExecutor<Key> {
   readonly withLock: <A, E, R>(key: Key, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
@@ -10,8 +9,5 @@ export interface KeyedSerialExecutor<Key> {
  * Serializes work that targets the same domain identity without coupling
  * unrelated identities to a process-wide mutex.
  */
-export const makeKeyedSerialExecutor = <Key>(): Effect.Effect<
-  KeyedSerialExecutor<Key>,
-  never,
-  Scope.Scope
-> => KeyedLock.make<Key>();
+export const makeKeyedSerialExecutor = <Key>(): Effect.Effect<KeyedSerialExecutor<Key>> =>
+  KeyedLock.make<Key>();
@@ -7,7 +7,6 @@ import {
 } from "@t3tools/contracts";
 import { ServerProviderUpdateError } from "@t3tools/contracts";
 import * as Cause from "effect/Cause";
-import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
@@ -224,27 +223,24 @@ const makeTestRunner = (
     })),
   },
 ) =>
-  // Built in the test's scope: the runner must stay open while the test uses it.
-  Layer.build(
-    ProviderMaintenanceRunner.layer.pipe(
-      Layer.provide(
-        Layer.mergeAll(
-          Layer.succeed(ProviderRegistry.ProviderRegistry, registry),
-          Layer.succeed(ModelManifest.ModelManifest, {
-            current: Effect.succeed(manifest),
-            refresh: Effect.succeed(manifest),
-            forceRefresh: Effect.succeed(manifest),
-            refreshInBackground: Effect.void,
-          }),
-          // Fresh per runner so a version cached by one test cannot leak into another.
-          Layer.sync(ProviderVersionCache, () => new Map()),
+  Effect.service(ProviderMaintenanceRunner.ProviderMaintenanceRunner).pipe(
+    Effect.provide(
+      ProviderMaintenanceRunner.layer.pipe(
+        Layer.provide(
+          Layer.mergeAll(
+            Layer.succeed(ProviderRegistry.ProviderRegistry, registry),
+            Layer.succeed(ModelManifest.ModelManifest, {
+              current: Effect.succeed(manifest),
+              refresh: Effect.succeed(manifest),
+              forceRefresh: Effect.succeed(manifest),
+              refreshInBackground: Effect.void,
+            }),
+            // Fresh per runner so a version cached by one test cannot leak into another.
+            Layer.sync(ProviderVersionCache, () => new Map()),
+          ),
         ),
       ),
     ),
-  ).pipe(
-    Effect.map((context) =>
-      Context.get(context, ProviderMaintenanceRunner.ProviderMaintenanceRunner),
-    ),
   );
 
 describe("providerMaintenanceRunner", () => {
 
@@ -96,6 +96,14 @@ describe("KeyedLock", () => {
     }),
   );
 
+  it.effect("keeps working after the scope that made it closes", () =>
+    Effect.gen(function* () {
+      // Services built per request hand their lock to work that outlives the build.
+      const lock = yield* Effect.scoped(KeyedLock.make<string>());
+      assert.strictEqual(yield* lock.withLock("key", Effect.succeed("ran")), "ran");
+    }),
+  );
+
   it.effect("runs the effect in the caller's scope", () =>
     Effect.gen(function* () {
       const lock = yield* KeyedLock.make<string>();
 
@@ -1,7 +1,4 @@
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as RcMap from "effect/RcMap";
-import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
 
 export interface KeyedLock<Key> {
@@ -11,28 +8,47 @@ export interface KeyedLock<Key> {
   readonly activeKeys: Effect.Effect<ReadonlyArray<Key>>;
 }
 
+interface LockEntry {
+  readonly semaphore: Semaphore.Semaphore;
+  users: number;
+}
+
 /**
  * Mutual exclusion per key. A key's lock exists only while someone holds or
  * waits on it, so locks for keys that come and go never accumulate. Not
  * reentrant: taking a key while already holding it deadlocks.
  *
- * Keys compare by `Equal` (by value for strings and numbers). The lock lives as
- * long as the scope it is made in; after that scope closes, `withLock`
- * interrupts.
+ * Keys compare like `Map` keys (by value for strings and numbers). The lock is
+ * not tied to a scope, so it keeps working for as long as anyone references it.
  */
-export const make = <Key>(): Effect.Effect<KeyedLock<Key>, never, Scope.Scope> =>
-  Effect.map(RcMap.make({ lookup: (_key: Key) => Semaphore.make(1) }), (locks) => ({
-    // The handle on the key's lock lives in its own scope, so `effect` still
-    // runs in (and adds finalizers to) the caller's scope, not the lock's.
-    withLock: (key, effect) =>
-      Effect.acquireUseRelease(
-        Scope.make(),
-        (handle) =>
-          RcMap.get(locks, key).pipe(
-            Scope.provide(handle),
-            Effect.flatMap((semaphore) => semaphore.withPermit(effect)),
-          ),
-        (handle) => Scope.close(handle, Exit.void),
-      ),
-    activeKeys: RcMap.keys(locks).pipe(Effect.map((keys) => Array.from(keys))),
-  }));
+export const make = <Key>(): Effect.Effect<KeyedLock<Key>> =>
+  Effect.sync(() => {
+    const locks = new Map<Key, LockEntry>();
+
+    const acquire = (key: Key) =>
+      Effect.sync(() => {
+        let entry = locks.get(key);
+        if (entry === undefined) {
+          entry = { semaphore: Semaphore.makeUnsafe(1), users: 0 };
+          locks.set(key, entry);
+        }
+        entry.users += 1;
+        return entry;
+      });
+
+    const release = (key: Key, entry: LockEntry) =>
+      Effect.sync(() => {
+        entry.users -= 1;
+        if (entry.users === 0) locks.delete(key);
+      });
+
+    return {
+      withLock: (key, effect) =>
+        Effect.acquireUseRelease(
+          acquire(key),
+          (entry) => entry.semaphore.withPermit(effect),
+          (entry) => release(key, entry),
+        ),
+      activeKeys: Effect.sync(() => Array.from(locks.keys())),
+    };
+  });