effect-browser 0.3.0-beta.14 → 0.3.0-beta.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-browser",
-  "version": "0.3.0-beta.14",
+  "version": "0.3.0-beta.16",
   "description": "Effect browser sessions, page control, screencast and moments over Playwright and CDP.",
   "license": "MIT",
   "repository": {

package/src/Browser.ts

@@ -492,7 +492,7 @@ export const make = Effect.fn("Browser.make")(function* (
 ) {
   const clock = yield* Clock.Clock;
   const connection = yield* Identity.make;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => BrowserClock.monotonicMillis(clock);
   const { settings, eventHistory, maxPages } = yield* settingsOf(options);
   // Measured on first need: the first capture of any page measures it, and input never waits.
   const mapping = BrowserClock.mapping(now);

package/src/BrowserEvent.ts

@@ -119,8 +119,7 @@ const Button = Schema.Literals(["left", "right", "middle"]);
 
 /** An element's box in viewport CSS pixels; it may lie partly or wholly outside the viewport. */
 export const Box = Schema.Struct({
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   width: Schema.Finite,
   height: Schema.Finite,
 });
@@ -169,8 +168,8 @@ export class Action extends Schema.TaggedClass<Action>()("Action", {
   /** For an action at a point, the box of what it found there. */
   box: Schema.optional(Box),
   text: Schema.optional(Schema.String),
-  x: Schema.optional(Schema.Finite),
-  y: Schema.optional(Schema.Finite),
+  x: Schema.optional(Motion.Point.fields.x),
+  y: Schema.optional(Motion.Point.fields.y),
   ok: Schema.Boolean,
   dispatched: Schema.Boolean,
   error: Schema.optional(Schema.String),
@@ -196,16 +195,14 @@ export class TrackPerformed extends Schema.TaggedClass<TrackPerformed>()("TrackP
   page: Schema.String,
   plan: Sequence,
   dispatched: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   complete: Schema.Boolean,
 }) {}
 
 export class PointerPressed extends Schema.TaggedClass<PointerPressed>()("PointerPressed", {
   at: Schema.Finite,
   page: Schema.String,
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   button: Button,
   clickCount: Schema.Int.check(Schema.isGreaterThan(0)),
 }) {}
@@ -213,8 +210,7 @@ export class PointerPressed extends Schema.TaggedClass<PointerPressed>()("Pointe
 export class PointerReleased extends Schema.TaggedClass<PointerReleased>()("PointerReleased", {
   at: Schema.Finite,
   page: Schema.String,
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   button: Button,
   clickCount: Schema.Int.check(Schema.isGreaterThan(0)),
 }) {}
@@ -222,8 +218,7 @@ export class PointerReleased extends Schema.TaggedClass<PointerReleased>()("Poin
 export class WheelScrolled extends Schema.TaggedClass<WheelScrolled>()("WheelScrolled", {
   at: Schema.Finite,
   page: Schema.String,
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Motion.Point.fields,
   dx: Schema.Finite,
   dy: Schema.Finite,
 }) {}

package/src/Motion.ts

@@ -13,8 +13,7 @@ export const Point = Schema.Struct({ x: Schema.Finite, y: Schema.Finite });
 export type Point = typeof Point.Type;
 
 export const Sample = Schema.Struct({
-  x: Schema.Finite,
-  y: Schema.Finite,
+  ...Point.fields,
   afterMillis: Schema.Finite.check(
     Schema.isGreaterThanOrEqualTo(0),
     Schema.isLessThanOrEqualTo(maximumDurationMillis),

package/src/Page.ts

@@ -27,12 +27,10 @@ import * as Guard from "./internal/input/guard.inpage.ts";
 import { Correlation, FailFast } from "./internal/page/lane.ts";
 import * as Url from "./internal/page/url.ts";
 import type { Window } from "./Moment.ts";
+import * as Motion from "./Motion.ts";
 import { type Snapshot, type SnapshotOptions } from "./Snapshot.ts";
 
-export interface Point {
-  readonly x: number;
-  readonly y: number;
-}
+export type Point = Motion.Point;
 
 /** A ref from a snapshot, such as `"e12"`, or a viewport point. */
 export type Target = string | Point;
@@ -54,7 +52,7 @@ export class Zoom extends Schema.Class<Zoom>("effect-browser/Zoom")({
 
 /** The target as it read before input. Point coordinates are never snapped to another position. */
 export class ResolvedTarget extends Schema.Class<ResolvedTarget>("effect-browser/ResolvedTarget")({
-  point: Schema.Struct({ x: Schema.Finite, y: Schema.Finite }),
+  point: Motion.Point,
   element: Schema.String,
   /** The element's lowercase tag name. */
   tag: Schema.String,
@@ -131,9 +129,7 @@ export interface ScreenshotOptions {
   /** The oldest a reused frame may be, as for `frame`. Defaults to 250 milliseconds. */
   readonly maxAge?: Duration.Input | undefined;
   /** A region of the viewport, captured in CSS pixels at the viewport's own scale; always new. */
-  readonly clip?:
-    | { readonly x: number; readonly y: number; readonly width: number; readonly height: number }
-    | undefined;
+  readonly clip?: Box | undefined;
   /** JPEG quality, 0 to 100. Defaults to 80. */
   readonly quality?: number | undefined;
   /** `"jpeg"`, the default, or `"png"`, which is always a new picture. */
@@ -335,7 +331,7 @@ export class InputRequest extends Schema.Class<InputRequest>("effect-browser/Inp
   target: Schema.optional(Schema.String),
   element: Schema.optional(Schema.String),
   /** Literal pixel targets only; ref coordinates are resolved after the policy allows them. */
-  point: Schema.optional(Schema.Struct({ x: Schema.Finite, y: Schema.Finite })),
+  point: Schema.optional(Motion.Point),
   text: Schema.optional(Schema.String),
   role: Schema.optional(Schema.NullOr(Schema.String)),
   name: Schema.optional(Schema.String),

package/src/Plan.ts

@@ -33,6 +33,7 @@ import {
 } from "./BrowserEvent.ts";
 import { undispatched } from "./internal/page/context.ts";
 import { Ambiguous, choose, Drifted, Missing } from "./internal/reading/choose.ts";
+import { Point as ViewportPoint } from "./Motion.ts";
 import {
   type Found,
   type Page,
@@ -44,8 +45,6 @@ import {
 
 export { Ambiguous, Drifted, Missing } from "./internal/reading/choose.ts";
 
-const ViewportPoint = Schema.Struct({ x: Schema.Finite, y: Schema.Finite });
-
 export const StepAction = Schema.Literals([
   "navigate",
   "back",

package/src/Presentation.ts

@@ -20,6 +20,7 @@ import { Clock, Duration, Effect, Fiber, MutableRef, Option, Semaphore } from "e
 import type { BrowserError } from "./BrowserError.ts";
 import * as Style from "./internal/input/style.ts";
 import { type Internals, internalsOf, viewOf } from "./internal/page/page.ts";
+import { monotonicMillis } from "./internal/pictures/clock.ts";
 import * as Motion from "./Motion.ts";
 import type { Page, Point, Target } from "./Page.ts";
 
@@ -81,7 +82,7 @@ export const make = Effect.fn("Presentation.make")(function* (options: Options =
   const pacing = options.pacing ?? human;
   const clock = yield* Clock.Clock;
   const scope = yield* Effect.scope;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => monotonicMillis(clock);
   const pointer = MutableRef.make(Option.none<Point>());
   const hand = yield* Semaphore.make(1);
 

package/src/Stage.ts

@@ -26,6 +26,7 @@ import { type BrowserError, Closed, consequence, InvalidRequest, Timeout } from
 import type { CaptureStats, Frame, ScreencastOptions } from "./Frame.ts";
 import { failWith, undispatched } from "./internal/page/context.ts";
 import { internalsOf } from "./internal/page/page.ts";
+import { monotonicMillis } from "./internal/pictures/clock.ts";
 import type { Page } from "./Page.ts";
 
 export interface Options extends ScreencastOptions {
@@ -390,7 +391,7 @@ export const make = Effect.fn("Stage.make")(function* (
 ): Effect.fn.Return<Stage, BrowserError, Scope.Scope> {
   const clock = yield* Clock.Clock;
   const owner = yield* Effect.scope;
-  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+  const now = () => monotonicMillis(clock);
   const waited = Duration.fromInput(options.firstFrame ?? Duration.seconds(5));
 
   if (

package/src/Supervisor.ts

@@ -21,6 +21,7 @@
 import {
   Cause,
   Clock,
+  Context,
   DateTime,
   Deferred,
   Duration,
@@ -96,12 +97,24 @@ export interface Opened<A = void> {
 export interface Admission {
   readonly number: number;
   /**
-   * The preceding generation's release once it stops serving. Undefined on the first open and
-   * while a nonexclusive rotation keeps it serving; checked again before each retry.
+   * Every earlier session that stopped serving, including failed attempts and older drains.
+   * Waits for all pending releases; an Unconfirmed end remains visible to later attempts.
+   * Undefined before any release. A still-serving nonexclusive predecessor is excluded.
    */
   readonly after: Effect.Effect<Lifecycle.Released> | undefined;
 }
 
+/**
+ * Optional service supplied during `open`. Providers report failed-attempt cleanup here before
+ * their scope closes; successful generations instead return `Opened.release`. Reporting does
+ * not release resources or replace the original acquisition failure. Terminal `Down` and opening
+ * `Closed` states publish the reported outcomes of their own generation's tries.
+ */
+export class Releasing extends Context.Service<
+  Releasing,
+  { readonly released: (outcome: Lifecycle.Released) => Effect.Effect<void> }
+>()("effect-browser/Supervisor/Releasing") {}
+
 export interface Options<E, R, A = void> {
   /** Opens one generation in the scope it is given. */
   readonly open: Effect.Effect<Opened<A>, E, R>;
@@ -186,9 +199,9 @@ interface Held<A> {
 }
 
 type State<A> = Lifecycle.State<Held<A>, Hold>;
-type Apply<A> = (
-  input: Lifecycle.Input<Held<A>, Hold>,
-) => Effect.Effect<Lifecycle.Step<Held<A>, Hold>>;
+type Input<A> = Lifecycle.Input<Held<A>, Hold>;
+type Step<A> = Lifecycle.Step<Held<A>, Hold>;
+type Apply<A> = (input: Input<A>) => Effect.Effect<Step<A>>;
 
 const superseded = (generation: number, { reason, revokeAt }: Lifecycle.Draining) =>
   new Superseded({ generation, reason, revokeAt });
@@ -201,15 +214,6 @@ const describe = (cause: Cause.Cause<unknown>) => {
   return Predicate.isError(error) ? error.message : String(error);
 };
 
-const unavailable = (
-  resolution: Extract<Lifecycle.Resolution<unknown>, { readonly _tag: "Unavailable" }>,
-) =>
-  new Unavailable({
-    reason: resolution.reason,
-    detail: resolution.detail,
-    cause: resolution.cause,
-  });
-
 const timedOut = () =>
   new Unavailable({ reason: "opening", detail: "no generation opened within the wait" });
 
@@ -234,7 +238,7 @@ const waitFor = <A, H>(
   const result = (resolution: Lifecycle.Resolution<A>) =>
     resolution._tag === "Serve"
       ? Effect.succeed(resolution.live)
-      : Effect.fail(unavailable(resolution));
+      : Effect.fail(new Unavailable(resolution));
 
   return Effect.suspend(() => {
     const current = Lifecycle.resolve(state.value, target);
@@ -277,20 +281,19 @@ const leasing = <A>(
   now: () => number,
   clock: Clock.Clock,
 ) => {
-  const borrow = (hold: Hold, wait: Duration.Duration) =>
-    Effect.gen(function* () {
-      const until = now() + Duration.toMillis(wait);
-
-      for (;;) {
-        const step = yield* apply({ _tag: "Hold", hold });
-
-        if (step.borrowed !== undefined) return step.borrowed;
-        yield* waitFor(state, Duration.millis(Math.max(0, until - now())), clock).pipe(
-          Effect.interruptible,
-        );
-        if (now() >= until) return yield* timedOut();
-      }
-    });
+  const borrow = Effect.fnUntraced(function* (hold: Hold, wait: Duration.Duration) {
+    const until = now() + Duration.toMillis(wait);
+
+    for (;;) {
+      const step = yield* apply({ _tag: "Hold", hold });
+
+      if (step.borrowed !== undefined) return step.borrowed;
+      yield* waitFor(state, Duration.millis(Math.max(0, until - now())), clock).pipe(
+        Effect.interruptible,
+      );
+      if (now() >= until) return yield* timedOut();
+    }
+  });
 
   const leaseOf = (live: Lifecycle.Live<Held<A>>): Lease<A> => ({
     generation: live.number,
@@ -373,11 +376,6 @@ const acquireGeneration = <A, E, R>(
     ),
   );
 
-const changedUntil = <A>(
-  state: SubscriptionRef.SubscriptionRef<State<A>>,
-  predicate: (current: State<A>) => boolean,
-) => SubscriptionRef.changes(state).pipe(Stream.filter(predicate), Stream.runHead, Effect.asVoid);
-
 const watchGeneration = <A>(
   live: Lifecycle.Live<Held<A>>,
   rotateBefore: Duration.Duration | undefined,
@@ -400,59 +398,61 @@ const watchGeneration = <A>(
 };
 
 // After revocation, retained resources and use finalizers let go before the provider.
-const releaseGeneration = <A>(
+const releaseGeneration = Effect.fnUntraced(function* <A>(
   command: Extract<Lifecycle.Command<Held<A>>, { readonly _tag: "Release" | "Leave" }>,
   state: SubscriptionRef.SubscriptionRef<State<A>>,
   apply: Apply<A>,
-) =>
-  Effect.gen(function* () {
-    const { live } = command;
-    const holds = Lifecycle.lookup(state.value, live.number)?.holds ?? [];
-
-    const cleaned = yield* Effect.forEach(
-      holds,
-      (hold) =>
-        Effect.exit(hold._tag === "Retained" ? Scope.close(hold.scope, Exit.void) : Effect.void),
-      { concurrency: 8 },
-    );
+) {
+  const { live } = command;
+
+  const cleaned = yield* Effect.forEach(
+    Lifecycle.lookup(state.value, live.number)?.holds ?? [],
+    (hold) =>
+      Effect.exit(hold._tag === "Retained" ? Scope.close(hold.scope, Exit.void) : Effect.void),
+    { concurrency: 8 },
+  );
 
-    yield* changedUntil(
-      state,
-      (current) => (Lifecycle.lookup(current, live.number)?.holds.size ?? 0) === 0,
-    );
+  yield* SubscriptionRef.changes(state).pipe(
+    Stream.filter((current) => (Lifecycle.lookup(current, live.number)?.holds.size ?? 0) === 0),
+    Stream.runHead,
+  );
 
-    const released =
-      command._tag === "Leave"
-        ? undefined
-        : yield* (live.value.opened.release ?? Effect.succeed(new Lifecycle.Settled())).pipe(
-            Effect.catchCause((cause) =>
-              Effect.succeed(
-                new Lifecycle.Unconfirmed({ detail: `the release failed: ${describe(cause)}` }),
-              ),
+  const released =
+    command._tag === "Leave"
+      ? undefined
+      : yield* (live.value.opened.release ?? Effect.succeed(new Lifecycle.Settled())).pipe(
+          Effect.catchCause((cause) =>
+            Effect.succeed(
+              new Lifecycle.Unconfirmed({ detail: `the release failed: ${describe(cause)}` }),
             ),
-          );
+          ),
+        );
 
-    const closed = yield* Effect.exit(Scope.close(live.value.scope, Exit.void));
+  const closed = yield* Effect.exit(Scope.close(live.value.scope, Exit.void));
 
-    yield* apply({ _tag: "Released", number: live.number, released });
-    if (released !== undefined) yield* Deferred.succeed(live.value.released, released);
-    yield* Exit.asVoidAll([...cleaned, closed]);
-  });
+  yield* apply({ _tag: "Released", number: live.number, released });
+  if (released !== undefined) yield* Deferred.succeed(live.value.released, released);
+  yield* Exit.asVoidAll([...cleaned, closed]);
+});
 
-const openedInput = <A, E>(
-  number: number,
-  exit: Exit.Exit<Held<A>, E>,
-): Lifecycle.Input<Held<A>, Hold> =>
-  Exit.isSuccess(exit)
-    ? { _tag: "Opened", live: { number, value: exit.value } }
-    : Cause.hasInterruptsOnly(exit.cause)
-      ? { _tag: "Abandoned", number }
-      : { _tag: "Failed", number, detail: describe(exit.cause), cause: Cause.squash(exit.cause) };
-
-const admissionAfter = <A>(previous: Lifecycle.Live<Held<A>> | undefined, state: State<A>) =>
-  previous === undefined || (state._tag !== "Retired" && state.serving?.number === previous.number)
+const admissionAfter = <A>(state: State<A>) => {
+  const released = state.released;
+
+  const pending = [...state.draining.values()]
+    .filter((drain) => drain._tag !== "Leaving")
+    .map(({ live }) => live.value.released);
+
+  return pending.length === 0 && released === undefined
     ? undefined
-    : Deferred.await(previous.value.released);
+    : Effect.gen(function* () {
+        let outcome = released;
+
+        for (const release of pending)
+          outcome = Lifecycle.combine(outcome, yield* Deferred.await(release));
+
+        return outcome ?? new Lifecycle.Settled();
+      });
+};
 
 const makeScoped = Effect.fn("Supervisor.make")(function* <E, R, A>(
   options: MakeOptions<E, R, A>,
@@ -462,7 +462,6 @@ const makeScoped = Effect.fn("Supervisor.make")(function* <E, R, A>(
   const context = yield* Effect.context<Exclude<R, Scope.Scope>>();
   const own = yield* Scope.fork(yield* Effect.scope);
   const exclusive = options.exclusive ?? false;
-  const definite = options.definite ?? (() => false);
 
   const reopen: Schedule.Schedule<unknown, E> =
     options.reopen ??
@@ -486,113 +485,116 @@ const makeScoped = Effect.fn("Supervisor.make")(function* <E, R, A>(
   const runOpen = yield* FiberHandle.runtime(opening)();
   const runRelease = yield* FiberMap.runtime(releases)();
 
-  const apply = (
-    input: Lifecycle.Input<Held<A | void>, Hold>,
-  ): Effect.Effect<Lifecycle.Step<Held<A | void>, Hold>> =>
-    applying
-      .withPermit(
-        Effect.gen(function* () {
-          const current = state.value;
-          const step = Lifecycle.transition(current, input, exclusive, now(), handover);
+  const apply: Apply<A | void> = Effect.fnUntraced(
+    function* (input: Input<A | void>) {
+      const current = state.value;
+      const step = Lifecycle.transition(current, input, exclusive, now(), handover);
 
-          if (step.state !== current) yield* SubscriptionRef.set(state, step.state);
-          yield* perform(step);
+      if (step.state !== current) yield* SubscriptionRef.set(state, step.state);
+      yield* perform(step);
+
+      return step;
+    },
+    (effect) => applying.withPermit(effect),
+    Effect.uninterruptible,
+    Effect.provideService(Clock.Clock, clock),
+  );
 
-          return step;
+  const perform = Effect.fnUntraced(function* (step: Step<A | void>): Effect.fn.Return<void> {
+    for (const [number, generation] of step.events)
+      PubSub.publishUnsafe(events, [
+        new Generation({
+          number,
+          at: clock.currentTimeMillisUnsafe(),
+          hostTime: now(),
+          state: generation,
         }),
-      )
-      .pipe(Effect.uninterruptible, Effect.provideService(Clock.Clock, clock));
-
-  const perform = (step: Lifecycle.Step<Held<A | void>, Hold>): Effect.Effect<void> =>
-    Effect.gen(function* () {
-      for (const [number, generation] of step.events)
-        PubSub.publishUnsafe(events, [
-          new Generation({
-            number,
-            at: clock.currentTimeMillisUnsafe(),
-            hostTime: now(),
-            state: generation,
-          }),
-        ]);
-      for (const command of step.commands)
-        switch (command._tag) {
-          case "Open":
-            runOpen(openGeneration(command.number, command.after));
-            break;
-          case "Watch":
-            yield* Effect.forkIn(
-              Effect.provideContext(watchGeneration(command.live, rotateBefore, apply), context),
-              command.live.value.scope,
-            );
-            break;
-          case "Drain": {
-            const ending = superseded(command.live.number, command.ending);
-
-            yield* Deferred.succeed(command.live.value.ending, ending);
-            yield* Effect.forkIn(
-              until(ending.revokeAt, now).pipe(
-                Effect.andThen(
-                  Effect.suspend(() => apply({ _tag: "Revoke", number: command.live.number })),
-                ),
+      ]);
+    for (const command of step.commands)
+      switch (command._tag) {
+        case "Open":
+          runOpen(openGeneration(command.number));
+          break;
+        case "Watch":
+          yield* Effect.forkIn(
+            Effect.provideContext(watchGeneration(command.live, rotateBefore, apply), context),
+            command.live.value.scope,
+          );
+          break;
+        case "Drain": {
+          const ending = superseded(command.live.number, command.ending);
+
+          yield* Deferred.succeed(command.live.value.ending, ending);
+          yield* Effect.forkIn(
+            until(ending.revokeAt, now).pipe(
+              Effect.andThen(
+                Effect.suspend(() => apply({ _tag: "Revoke", number: command.live.number })),
               ),
-              command.live.value.scope,
-            );
-            break;
-          }
-          case "Release":
-          case "Leave":
-            yield* Deferred.succeed(
-              command.live.value.revoked,
-              superseded(command.live.number, command.ending),
-            );
-            runRelease(command.live.number, releaseGeneration(command, state, apply));
-            break;
+            ),
+            command.live.value.scope,
+          );
+          break;
         }
-    });
-
-  const openGeneration = (number: number, previous: Lifecycle.Live<Held<A | void>> | undefined) => {
-    const after = previous === undefined ? undefined : Deferred.await(previous.value.released);
+        case "Release":
+        case "Leave":
+          yield* Deferred.succeed(
+            command.live.value.revoked,
+            superseded(command.live.number, command.ending),
+          );
+          runRelease(command.live.number, releaseGeneration(command, state, apply));
+          break;
+      }
+  });
 
+  const openGeneration = (number: number) => {
     const openOnce = acquireGeneration(
-      Effect.suspend(
-        () =>
-          options.admit?.({ number, after: admissionAfter(previous, state.value) }) ?? Effect.void,
-      ).pipe(Effect.andThen(options.open)),
+      Effect.gen(function* () {
+        const after = admissionAfter(state.value);
+
+        if (exclusive && after !== undefined) yield* after;
+        yield* options.admit?.({ number, after }) ?? Effect.void;
+
+        return yield* options.open.pipe(
+          Effect.provideService(Releasing, {
+            released: (released) =>
+              apply({ _tag: "AttemptReleased", number, released }).pipe(Effect.asVoid),
+          }),
+        );
+      }),
       own,
     ).pipe(Effect.provideContext(context));
 
     return Effect.uninterruptibleMask((restore) =>
       restore(
-        (exclusive && after !== undefined ? after : Effect.void).pipe(
-          Effect.andThen(
-            Effect.retry(openOnce, { schedule: reopen, while: (error) => !definite(error) }),
-          ),
-        ),
+        Effect.retry(openOnce, {
+          schedule: reopen,
+          while: (error) => !options.definite?.(error),
+        }),
       ).pipe(
         Effect.exit,
-        Effect.flatMap((exit) => apply(openedInput(number, exit))),
+        Effect.flatMap((exit) => {
+          if (Exit.isSuccess(exit))
+            return apply({ _tag: "Opened", live: { number, value: exit.value } });
+          const cause = exit.cause;
+
+          return apply(
+            Cause.hasInterruptsOnly(cause)
+              ? { _tag: "Abandoned", number }
+              : { _tag: "Failed", number, detail: describe(cause), cause: Cause.squash(cause) },
+          );
+        }),
       ),
     );
   };
 
-  const use = leasing(state, apply, waitTimeout, now, clock);
-
   const end = yield* Effect.cached(PubSub.publish(events, Exit.void));
 
-  const stop = (input: Lifecycle.Input<Held<A | void>, Hold>) =>
-    apply(input).pipe(
-      Effect.andThen(FiberHandle.clear(opening)),
-      Effect.andThen(FiberMap.awaitEmpty(releases)),
-      Effect.andThen(
-        Effect.suspend(() =>
-          Deferred.isDone(releases.deferred).pipe(
-            Effect.flatMap((failed) => (failed ? FiberMap.join(releases) : Effect.void)),
-          ),
-        ),
-      ),
-      Effect.ensuring(end),
-      Effect.asVoid,
-    );
+  const stop = Effect.fnUntraced(function* (input: Input<A | void>) {
+    yield* apply(input);
+    yield* FiberHandle.clear(opening);
+    yield* FiberMap.awaitEmpty(releases);
+    if (yield* Deferred.isDone(releases.deferred)) yield* FiberMap.join(releases);
+  }, Effect.ensuring(end));
 
   const retire = yield* Effect.cached(stop({ _tag: "Retire" }));
 
@@ -601,7 +603,7 @@ const makeScoped = Effect.fn("Supervisor.make")(function* <E, R, A>(
 
   return {
     browser: Effect.map(waitFor(state, waitTimeout, clock), (live) => live.value.opened.browser),
-    use,
+    use: leasing(state, apply, waitTimeout, now, clock),
     states: Stream.fromPubSubTake(events),
     rotate: apply({ _tag: "Rotate" }).pipe(
       Effect.flatMap(({ reply }) =>