effect 4.0.0 → 4.0.1

package/src/internal/effect.ts

@@ -50,7 +50,7 @@ import type { Primitive } from "./core.ts"
 import {
   args,
   causeAnnotate,
-  causeDie,
+  causeCombine,
   causeEmpty,
   causeFromReasons,
   CauseImpl,
@@ -238,48 +238,6 @@ export const causeAnnotations = <E>(
   return Context.makeUnsafe(map)
 }
 
-const dedupeReasons = <E>(
-  self: ReadonlyArray<Cause.Reason<E>>,
-  that: ReadonlyArray<Cause.Reason<E>>
-): Array<Cause.Reason<E>> => {
-  // Keep deduplication local so causeCombine does not retain Array.ts in the core bundle.
-  // Snapshot both arrays before invoking user-defined hash or equality methods.
-  const buckets = new Map<number, Array<Cause.Reason<E>>>()
-  const out: Array<Cause.Reason<E>> = []
-  for (const reason of self.concat(that)) {
-    const hash = Hash.hash(reason)
-    const bucket = buckets.get(hash)
-    if (bucket === undefined) {
-      buckets.set(hash, [reason])
-    } else if (bucket.some((previous) => Equal.equals(previous, reason))) {
-      continue
-    } else {
-      bucket.push(reason)
-    }
-    out.push(reason)
-  }
-  return out
-}
-
-/** @internal */
-export const causeCombine: {
-  <E2>(that: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E | E2>
-  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>): Cause.Cause<E | E2>
-} = dual(
-  2,
-  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>): Cause.Cause<E | E2> => {
-    if (self.reasons.length === 0) {
-      return that as Cause.Cause<E | E2>
-    } else if (that.reasons.length === 0) {
-      return self as Cause.Cause<E | E2>
-    }
-    const newCause = new CauseImpl<E | E2>(
-      dedupeReasons<E | E2>(self.reasons, that.reasons)
-    )
-    return Equal.equals(self, newCause) ? self : newCause
-  }
-)
-
 /** @internal */
 export const causeMap: {
   <E, E2>(f: (error: NoInfer<E>) => E2): (self: Cause.Cause<E>) => Cause.Cause<E2>
@@ -504,6 +462,21 @@ const fiberVariance = {
 
 const fiberIdStore = { id: 0 }
 
+interface AsyncContext {
+  runInAsyncScope<This, Arg, R>(fn: (this: This, arg: Arg) => R, thisArg: This, arg: Arg): R
+}
+
+const AsyncResource: (new(type: string) => AsyncContext) | undefined = (() => {
+  try {
+    return (globalThis as any).process?.getBuiltinModule?.("node:async_hooks")?.AsyncResource
+  } catch {
+    return undefined
+  }
+})()
+
+const captureAsyncContext = (): AsyncContext | undefined =>
+  AsyncResource === undefined ? undefined : new AsyncResource("effect/Fiber")
+
 /** @internal */
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
@@ -526,6 +499,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     this._running = false
     this._deferredInterrupt = false
     this._parent = undefined
+    this._asyncContext = undefined
     this.cache.runtimeMetrics?.recordFiberStart(this.context)
   }
 
@@ -545,6 +519,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   declare _running: boolean
   declare _deferredInterrupt: boolean
   declare _parent: FiberImpl<any, any> | undefined
+  declare _asyncContext: AsyncContext | undefined
 
   // set in setContext
   declare context: Context.Context<never>
@@ -605,6 +580,10 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   evaluate(effect: Primitive): void {
     if (this._exit) {
       return
+    } else if (this._asyncContext !== undefined) {
+      const asyncContext = this._asyncContext
+      this._asyncContext = undefined
+      return asyncContext.runInAsyncScope(this.evaluate, this, effect)
     } else if (this._yielded !== undefined) {
       const yielded = this._yielded as () => void
       this._yielded = undefined
@@ -612,6 +591,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     }
     const exit = this.runLoop(effect)
     if (exit === Yield) {
+      this._asyncContext = captureAsyncContext()
       return
     }
     // the interruptChildren middleware is added in Effect.forkChild, so it can be
@@ -1122,20 +1102,22 @@ export const tryPromise = <A, E = Cause.UnknownError>(
     ? ((cause: unknown) => new UnknownError(cause, "An error occurred in Effect.tryPromise"))
     : options.catch
   return callbackOptions<A, E>(function(resume, signal) {
-    const failWithCatch = (cause: unknown) => {
-      try {
-        resume(fail(internalCall(() => catcher(cause)) as E))
-      } catch (err) {
-        resume(die(err))
-      }
-    }
+    // Defer the catcher until the fiber restores its async context.
+    const failWithCatch = (cause: unknown) =>
+      suspend(() => {
+        try {
+          return fail(internalCall(() => catcher(cause)) as E)
+        } catch (err) {
+          return die(err)
+        }
+      })
     try {
       f(signal!).then(
         (a) => resume(succeed(a)),
-        failWithCatch
+        (e) => resume(failWithCatch(e))
       )
     } catch (err) {
-      failWithCatch(err)
+      resume(failWithCatch(err))
     }
   }, f.length !== 0)
 }
@@ -4457,48 +4439,78 @@ export const cachedInvalidateWithTTL: {
   self: Effect.Effect<A, E, R>,
   ttl: Duration.Input | ((exit: Exit.Exit<A, E>) => Duration.Input)
 ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]> =>
-  sync(() => {
-    const ttlMillis = typeof ttl === "function"
-      ? (exit: Exit.Exit<A, E>) => Duration.toMillis(Duration.fromInputUnsafe(ttl(exit)))
-      : constant(Duration.toMillis(Duration.fromInputUnsafe(ttl)))
-    const latch = makeLatchUnsafe(false)
-    let expiresAt = 0
-    let running = false
-    let exit: Exit.Exit<A, E> | undefined
-    const wait = flatMap(latch.await, () => exit!)
-    return [
-      withFiber((fiber) => {
-        const clock = fiber.getRef(ClockRef)
-        const now = expiresAt === Infinity ? 0 : clock.currentTimeMillisUnsafe()
-        if (running || now < expiresAt) return exit ?? wait
-        running = true
-        latch.closeUnsafe()
-        exit = undefined
-        onExitUnsafe<A, E>(fiber, (exit_) =>
-          sync(() => {
-            try {
-              const duration = ttlMillis(exit_)
-              expiresAt = clock.currentTimeMillisUnsafe() + duration
-              exit = exit_
-            } catch (error) {
-              const cause = causeDie(error)
-              // Publish the same combined cause that onExit returns to the owner.
-              exit = exitFailCause(exitIsFailure(exit_) ? causeCombine(exit_.cause, cause) : cause)
-              throw error
-            } finally {
-              running = false
-              latch.openUnsafe()
-            }
-          }))
-        return self
-      }),
-      sync(() => {
-        expiresAt = 0
-        latch.closeUnsafe()
-        exit = undefined
-      })
-    ]
-  }))
+  sync(() =>
+    makeCachedUnsafe(
+      self,
+      typeof ttl === "function"
+        ? (exit: Exit.Exit<A, E>) => Duration.toMillis(Duration.fromInputUnsafe(ttl(exit)))
+        : constant(Duration.toMillis(Duration.fromInputUnsafe(ttl)))
+    )
+  ))
+
+const infiniteTTL = constant(Infinity)
+
+interface CachedRun<A, E> {
+  fiber: FiberImpl<A, E> | undefined
+  awaiters: number
+}
+
+const makeCachedUnsafe = <A, E, R>(
+  self: Effect.Effect<A, E, R>,
+  ttlMillis: (exit: Exit.Exit<A, E>) => number
+): [Effect.Effect<A, E, R>, Effect.Effect<void>] => {
+  let expiresAt = 0
+  let exit: Exit.Exit<A, E> | undefined
+  let current: CachedRun<A, E> | undefined
+
+  const join = (fiber: Fiber.Fiber<unknown, unknown>, run: CachedRun<A, E>): Effect.Effect<A, E> => {
+    run.awaiters++
+    onExitUnsafe(fiber, () => {
+      // Abandon the run once every caller has left, unless it already finished.
+      if (--run.awaiters > 0 || current !== run) return
+      // Detach it first so new callers start a fresh run instead of joining
+      // one that is being interrupted.
+      current = undefined
+      return fiberInterrupt(run.fiber!)
+    })
+    return fiberJoin(run.fiber!)
+  }
+
+  return [
+    withFiber((fiber) => {
+      if (current !== undefined) return join(fiber, current)
+      if (
+        exit !== undefined &&
+        (expiresAt === Infinity || fiber.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)
+      ) {
+        return exit
+      }
+      exit = undefined
+      const clock = fiber.getRef(ClockRef)
+      const run: CachedRun<A, E> = { fiber: undefined, awaiters: 0 }
+      current = run
+      run.fiber = forkUnsafe(
+        fiber,
+        onExitPrimitive(self, (exit_) => {
+          // An abandoned run must not overwrite or clear a replacement run.
+          if (current !== run) return
+          current = undefined
+          // Interruption is abandonment, so it is never cached.
+          if (exitHasInterrupts(exit_)) return
+          const duration = ttlMillis(exit_)
+          expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration
+          exit = exit_
+        }),
+        true,
+        true
+      )
+      return run.fiber._exit ?? join(fiber, run)
+    }),
+    sync(() => {
+      exit = undefined
+    })
+  ]
+}
 
 /** @internal */
 export const cachedWithTTL: {
@@ -4525,23 +4537,7 @@ export const cachedWithTTL: {
 
 /** @internal */
 export const cached = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Effect.Effect<A, E, R>> =>
-  sync(() => {
-    const latch = makeLatchUnsafe(false)
-    let started = false
-    let exit: Exit.Exit<A, E> | undefined
-    const wait = flatMap(latch.await, () => exit!)
-    return withFiber((fiber) => {
-      if (exit !== undefined) return exit
-      if (started) return wait
-      started = true
-      onExitUnsafe<A, E>(fiber, (result) =>
-        sync(() => {
-          exit = result
-          latch.openUnsafe()
-        }))
-      return self
-    })
-  })
+  sync(() => makeCachedUnsafe(self, infiniteTTL)[0])
 
 // ----------------------------------------------------------------------------
 // interruption
@@ -5531,6 +5527,8 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   if (immediate) {
     child.evaluate(effect as any)
   } else {
+    // Preserve the fork context rather than the dispatcher's context.
+    child._asyncContext = captureAsyncContext()
     parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
   }
   if (!daemon && !child._exit) {

package/src/internal/rcRef.ts

@@ -7,17 +7,26 @@ import { identity } from "../Function.ts"
 import { pipeArguments } from "../Pipeable.ts"
 import type * as RcRef from "../RcRef.ts"
 import * as Scope from "../Scope.ts"
-import * as Semaphore from "../Semaphore.ts"
 
 const TypeId = "~effect/RcRef"
 
-type State<A> = State.Empty | State.Acquired<A> | State.Closed
+type State<A> = State.Empty | State.Acquiring<A> | State.Acquired<A> | State.Closed
 
 declare namespace State {
   interface Empty {
     readonly _tag: "Empty"
   }
 
+  interface Acquiring<A> {
+    readonly _tag: "Acquiring"
+    // Assigned as soon as the acquisition is forked.
+    fiber: Fiber.Fiber<Acquired<A>, unknown>
+    awaiters: number
+    // Set once references are allocated to the waiters, which can happen
+    // before the acquisition fiber exits.
+    acquired: Acquired<A> | undefined
+  }
+
   interface Acquired<A> {
     readonly _tag: "Acquired"
     readonly value: A
@@ -48,7 +57,6 @@ class RcRefImpl<A, E> implements RcRef.RcRef<A, E> {
   }
 
   state: State<A> = stateEmpty
-  readonly semaphore = Semaphore.makeUnsafe(1)
   readonly acquire: Effect.Effect<A, E>
   readonly context: Context.Context<never>
   readonly scope: Scope.Scope
@@ -85,11 +93,11 @@ export const make = <A, E, R>(options: {
     )
     return Effect.as(
       Scope.addFinalizerExit(scope, () => {
-        const close = ref.state._tag === "Acquired"
-          ? Scope.close(ref.state.scope, Exit.void)
-          : Effect.void
+        const state = ref.state
         ref.state = stateClosed
-        return close
+        if (state._tag === "Acquired") return Scope.close(state.scope, Exit.void)
+        if (state._tag === "Acquiring") return Fiber.interrupt(state.fiber)
+        return Effect.void
       }),
       ref
     )
@@ -110,40 +118,82 @@ const getState = <A, E>(
         ? Effect.as(Fiber.interrupt(state.fiber), state)
         : Effect.succeed(state)
     }
+    case "Acquiring": {
+      const state = self.state
+      state.awaiters++
+      return awaitAcquiring(self, state, restore)
+    }
     case "Empty": {
-      return self.semaphore.withPermit(
-        Effect.suspend(() => {
-          if (self.state._tag !== "Empty") {
-            return getState(self, restore)
+      // The caller that starts the acquisition counts as its first awaiter.
+      const acquiring: State.Acquiring<A> = {
+        _tag: "Acquiring",
+        fiber: undefined as any,
+        awaiters: 1,
+        acquired: undefined
+      }
+      self.state = acquiring
+      const scope = Scope.makeUnsafe()
+      // Acquire on a detached fiber so the acquisition is shared by every
+      // caller and only interrupted once all of them have been interrupted.
+      const acquire = Effect.provideContext(
+        self.acquire as Effect.Effect<A, E>,
+        Context.add(self.context, Scope.Scope, scope)
+      ).pipe(
+        Effect.flatMap((value) => {
+          // The ref was closed, or the acquisition was abandoned.
+          if (self.state !== acquiring) {
+            return Effect.interrupt
+          }
+          const state: State.Acquired<A> = {
+            _tag: "Acquired",
+            value,
+            scope,
+            fiber: undefined,
+            // Every caller still waiting holds a reference.
+            refCount: acquiring.awaiters,
+            invalidated: false
           }
-          const scope = Scope.makeUnsafe()
-          return restore(Effect.provideContext(
-            self.acquire as Effect.Effect<A, E>,
-            Context.add(self.context, Scope.Scope, scope)
-          )).pipe(
-            Effect.flatMap((value) => {
-              if (self.state._tag === "Closed") {
-                return Effect.interrupt
-              }
-              const state: State.Acquired<A> = {
-                _tag: "Acquired",
-                value,
-                scope,
-                fiber: undefined,
-                refCount: 1,
-                invalidated: false
-              }
-              self.state = state
-              return Effect.succeed(state)
-            }),
-            Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)
-          )
+          self.state = state
+          acquiring.acquired = state
+          return Effect.succeed(state)
+        }),
+        Effect.onExit((exit) => {
+          if (Exit.isSuccess(exit)) return Effect.void
+          if (self.state === acquiring) self.state = stateEmpty
+          return Scope.close(scope, exit)
         })
       )
+      acquiring.fiber = Effect.runForkWith(Fiber.getCurrent()!.context)(acquire)
+      return awaitAcquiring(self, acquiring, restore)
     }
   }
 }
 
+const awaitAcquiring = <A, E>(
+  self: RcRefImpl<A, E>,
+  acquiring: State.Acquiring<A>,
+  restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
+): Effect.Effect<State.Acquired<A>, E> =>
+  Effect.onExit(
+    restore(Fiber.join(acquiring.fiber)) as Effect.Effect<State.Acquired<A>, E>,
+    (exit) => {
+      const acquired = acquiring.acquired
+      if (acquired !== undefined) {
+        // The acquisition counted this caller as a reference, possibly before
+        // its fiber exited. Release it if the caller was interrupted before it
+        // could register its finalizer.
+        return Exit.isFailure(exit) ? release(self, acquired) : Effect.void
+      }
+      // Abandon the acquisition once every caller has left, unless it already
+      // failed (a failed acquisition allocated no references).
+      if (--acquiring.awaiters > 0 || self.state !== acquiring) return Effect.void
+      // Detach it first so new callers start a fresh acquisition instead of
+      // joining one that is being interrupted.
+      self.state = stateEmpty
+      return Fiber.interrupt(acquiring.fiber)
+    }
+  )
+
 /** @internal */
 export const get = <A, E>(self_: RcRef.RcRef<A, E>): Effect.Effect<A, E, Scope.Scope> => {
   const self = self_ as RcRefImpl<A, E>

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -1067,13 +1067,15 @@ function translateJsonSchemaMultiDocument(
         )
       case "ignore":
         return undefined
-      case "apply":
+      case "apply": {
+        let regex: RegExp
         try {
-          globalThis.RegExp(pattern, jsonSchemaPatternFlags)
+          regex = globalThis.RegExp(pattern, jsonSchemaPatternFlags)
         } catch {
           throw errorWithPath("Cannot import pattern using ECMAScript Unicode mode.", path)
         }
-        return jsonSchemaFilter("effect/schema/isPattern", { source: pattern, flags: jsonSchemaPatternFlags })
+        return jsonSchemaFilter("effect/schema/isPattern", { source: regex.source, flags: regex.flags })
+      }
     }
   }
 

package/src/rpc/RpcClient.ts

@@ -454,9 +454,11 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     const id = generateRequestId()
 
     const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+    const queue = yield* Queue.bounded<any, any>(streamBufferSize)
     yield* Scope.addFinalizerExit(
       scope,
       (exit) => {
+        Queue.shutdownUnsafe(queue)
         if (!entries.has(id)) return Effect.void
         entries.delete(id)
         return sendInterrupt(
@@ -469,7 +471,6 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       }
     )
 
-    const queue = yield* Queue.bounded<any, any>(streamBufferSize)
     entries.set(id, {
       _tag: "Queue",
       rpc,
@@ -671,6 +672,12 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
   }
   const entries = new Map<RequestId, ClientEntry>()
 
+  const interruptRequest = (requestId: RequestId): Effect.Effect<void, RpcClientError> => {
+    if (!entries.has(requestId)) return Effect.void
+    entries.delete(requestId)
+    return send(clientId, { _tag: "Interrupt", requestId }) as Effect.Effect<void, RpcClientError>
+  }
+
   const { client, write } = yield* makeNoSerialization(group, {
     ...options,
     supportsAck,
@@ -711,13 +718,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           }) as Effect.Effect<void, RpcClientError>
         }
         case "Interrupt": {
-          const entry = entries.get(message.requestId)
-          if (!entry) return Effect.void
-          entries.delete(message.requestId)
-          return send(clientId, {
-            _tag: "Interrupt",
-            requestId: message.requestId
-          }) as Effect.Effect<void, RpcClientError>
+          return interruptRequest(message.requestId)
         }
         case "Eof": {
           return Effect.void
@@ -732,19 +733,22 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
         if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
-        return entry.schemas.decodeChunk.value(message.values).pipe(
-          Effect.provideContext(entry.context),
-          Effect.orDie,
-          Effect.flatMap((chunk) =>
-            write({ _tag: "Chunk", clientId: 0, requestId: RequestId(message.requestId), values: chunk })
-          ),
-          Effect.onError((cause) =>
-            write({
-              _tag: "Exit",
-              clientId: 0,
-              requestId: RequestId(message.requestId),
-              exit: Exit.failCause(cause)
-            })
+        const decodeChunk = entry.schemas.decodeChunk.value
+        return Effect.uninterruptibleMask((restore) =>
+          restore(
+            decodeChunk(message.values).pipe(
+              Effect.provideContext(entry.context),
+              Effect.orDie,
+              Effect.flatMap((chunk) => write({ _tag: "Chunk", clientId: 0, requestId, values: chunk }))
+            )
+          ).pipe(
+            Effect.onError((cause) =>
+              write({ _tag: "Exit", clientId: 0, requestId, exit: Exit.failCause(cause) }).pipe(
+                Effect.andThen(Cause.hasInterrupts(cause) ? Effect.void : Effect.ignore(interruptRequest(requestId)))
+              )
+            ),
+            // a decode failure only ends its own request; interruption still propagates
+            Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), () => Effect.void)
           )
         ) as Effect.Effect<void>
       }
@@ -768,7 +772,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       case "ClientProtocolError": {
         const exit = Exit.fail(message.error)
         return Effect.forEach(
-          entries.keys(),
+          Array.from(entries.keys()),
           (requestId) => write({ _tag: "Exit", clientId: 0, requestId, exit: exit as any })
         )
       }

package/src/rpc/RpcServer.ts

@@ -1392,13 +1392,14 @@ export const makeProtocolStdio = Effect.gen(function*() {
       Effect.sandbox,
       Effect.tapError(Effect.logError),
       Effect.retry(Schedule.spaced(500)),
-      Effect.ensuring(Effect.forkDetach(Fiber.interrupt(fiber), { startImmediately: true })),
+      Effect.andThen(() => writeRequest(0, constEof)),
       Effect.forkScoped
     )
 
     yield* Stream.fromQueue(queue).pipe(
       Stream.run(stdio.stdout()),
       Effect.retry(Schedule.spaced(500)),
+      Effect.ensuring(Effect.forkDetach(Fiber.interrupt(fiber), { startImmediately: true })),
       Effect.forkScoped
     )
 

package/src/rpc/Utils.ts

@@ -1,10 +1,5 @@
 /**
- * Helps RPC protocol services buffer messages until their receive loop starts.
- *
- * Client and server protocol constructors use these helpers to expose a stable
- * service before the active receiver is installed. Writes made before `run`
- * starts are buffered with their current `Context`, then replayed once the
- * receiver is ready.
+ * Buffers RPC protocol messages until their receive loop starts.
  *
  * @stability unstable
  * @since 4.0.0
@@ -16,9 +11,8 @@ import type { Protocol } from "./RpcClient.ts"
 import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
- * Builds a service with a `run` method that buffers writes until `run` installs
- * a writer, replays buffered writes with their original contexts, and restores
- * the previous writer when the run ends.
+ * Buffers writes until `run` replays them with their original contexts and
+ * installs the writer. Restores the previous writer when `run` ends.
  *
  * @stability unstable
  * @category services
@@ -43,12 +37,12 @@ export const withRun = <
       run(f) {
         return semaphore.withPermits(1)(Effect.gen(function*() {
           const prev = write
-          write = f
 
           for (const [args, context] of buffer) {
             yield* Effect.provideContext(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
+          write = f
 
           return yield* Effect.onExit(Effect.never, () => {
             write = prev

package/src/workflow/WorkflowEngine.ts

@@ -274,6 +274,9 @@ export class WorkflowInstance extends Context.Service<
     /** Deferred names this run parked on; their completions preempt the run. */
     readonly awaitedDeferreds: Set<string>
 
+    /** Deferred names this run completed itself; their completions need not wake it. */
+    readonly completedDeferreds: Set<string>
+
     readonly activityState: {
       count: number
       readonly latch: Latch.Latch
@@ -294,6 +297,7 @@ export class WorkflowInstance extends Context.Service<
       abandoned: false,
       cause: undefined,
       awaitedDeferreds: new Set(),
+      completedDeferreds: new Set(),
       activityState: {
         count: 0,
         latch: Latch.makeUnsafe()