effect 4.0.2 → 4.0.3

package/src/cli/internal/ansi.ts

@@ -105,9 +105,32 @@ export const blackBright = `${ESC}90m`
  */
 export const cyanBright = `${ESC}96m`
 
-export const annotate = (text: string, ...styles: Array<string | Array<string>>) => {
-  const flat = styles.flat()
-  return `${flat.join("")}${text}${reset}`
+/**
+ * Wraps `text` in the given styles followed by a reset. When `colors` is
+ * `false` the text is returned unchanged, so callers gate color and style
+ * escapes in one place while cursor and erase controls stay untouched.
+ *
+ * @internal
+ */
+export const annotate = (colors: boolean, text: string, ...styles: Array<string | Array<string>>): string => {
+  if (!colors) return text
+  return `${styles.flat().join("")}${text}${reset}`
+}
+
+/**
+ * Detects whether CLI output should use color and style escapes: stdout must
+ * be a TTY and `NO_COLOR` must be unset or empty.
+ *
+ * @internal
+ */
+export const detectColors = (): boolean => {
+  const globalProcess = (globalThis as any).process
+  return typeof globalProcess === "object" &&
+    globalProcess !== null &&
+    typeof globalProcess.stdout === "object" &&
+    globalProcess.stdout !== null &&
+    globalProcess.stdout.isTTY === true &&
+    !globalProcess.env?.NO_COLOR
 }
 
 export const combine = (...styles: Array<string>): Array<string> => styles

package/src/cli/internal/completions/powershell.ts

@@ -0,0 +1,322 @@
+/**
+ * Static PowerShell completion script generator.
+ *
+ * Produces a self-contained completion script from a `CommandDescriptor`,
+ * without invoking the CLI at runtime. The script sticks to Windows
+ * PowerShell 5.1 syntax and APIs.
+ *
+ * @internal
+ */
+import type * as Completions from "../../Completions.ts"
+
+/**
+ * Encode non-ASCII and control characters as `[char]` code units. Windows
+ * PowerShell 5.1 can misread BOM-less UTF-8 as ANSI, turning some bytes into
+ * PowerShell quote delimiters.
+ */
+const quotePs = (s: string): string => {
+  const parts: Array<string> = []
+  let literal = ""
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i)
+    if (code >= 0x20 && code < 0x80) {
+      literal += s[i] === "'" ? "''" : s[i]
+      continue
+    }
+    if (literal !== "" || parts.length === 0) parts.push(`'${literal}'`)
+    literal = ""
+    parts.push(`[char]0x${code.toString(16).toUpperCase().padStart(4, "0")}`)
+  }
+  if (literal !== "" || parts.length === 0) parts.push(`'${literal}'`)
+  return parts.length === 1 ? parts[0] : `(${parts.join(" + ")})`
+}
+
+const psArray = (items: ReadonlyArray<string>): string => `@(${items.map(quotePs).join(", ")})`
+
+const psOptional = (s: string | undefined): string => s ? quotePs(s) : "$null"
+
+const sanitize = (s: string): string => s.replace(/[^a-zA-Z0-9_]/g, "_")
+
+const flagForms = (flag: Completions.FlagDescriptor): Array<string> => [
+  `--${flag.name}`,
+  ...flag.aliases.map((alias) => alias.length === 1 ? `-${alias}` : `--${alias}`)
+]
+
+const valueFields = (type: Completions.FlagType | Completions.ArgumentType): string =>
+  `values = ${psArray(type._tag === "Choice" ? type.values : [])}; ` +
+  `pathType = ${type._tag === "Path" ? quotePs(type.pathType) : "$null"}`
+
+const flagEntry = (flag: Completions.FlagDescriptor): string =>
+  `@{ name = ${quotePs(flag.name)}; forms = ${psArray(flagForms(flag))}; ` +
+  `takesValue = $${flag.type._tag !== "Boolean"}; ${valueFields(flag.type)}; ` +
+  `description = ${psOptional(flag.description)} }`
+
+const argumentEntry = (argument: Completions.ArgumentDescriptor): string =>
+  `@{ name = ${quotePs(argument.name)}; variadic = $${argument.variadic}; ${valueFields(argument.type)}; ` +
+  `description = ${psOptional(argument.description)} }`
+
+const pushList = (lines: Array<string>, field: string, entries: ReadonlyArray<string>): void => {
+  if (entries.length === 0) {
+    lines.push(`  ${field} = @()`)
+    return
+  }
+  lines.push(`  ${field} = @(`)
+  for (const entry of entries) {
+    lines.push(`    ${entry}`)
+  }
+  lines.push(`  )`)
+}
+
+/**
+ * Emit one context per subcommand path. Subcommands are case-sensitive, so
+ * contexts go in an ordinal hashtable instead of a hash literal, whose keys
+ * ignore case.
+ */
+const generateContexts = (
+  dataName: string,
+  descriptor: Completions.CommandDescriptor,
+  path: ReadonlyArray<string>,
+  lines: Array<string>,
+  seen: Set<string>
+): void => {
+  const key = path.join(" ")
+  if (seen.has(key)) return
+  seen.add(key)
+  lines.push(`${dataName}[${quotePs(key)}] = @{`)
+  pushList(
+    lines,
+    "subcommands",
+    descriptor.subcommands.map((sub) =>
+      `@{ name = ${quotePs(sub.name)}; description = ${psOptional(sub.description)} }`
+    )
+  )
+  pushList(lines, "flags", descriptor.flags.map(flagEntry))
+  pushList(lines, "arguments", descriptor.arguments.map(argumentEntry))
+  lines.push(`}`)
+  for (const sub of descriptor.subcommands) {
+    generateContexts(dataName, sub, [...path, sub.name], lines, seen)
+  }
+}
+
+/**
+ * Replay the committed words with the CLI lexer and parser rules: `--`, short
+ * flag clusters, inline values, boolean literals, negative numbers, and
+ * subcommand selection by the first value only.
+ */
+const completer = (dataName: string): string =>
+  String.raw`  param($wordToComplete, $commandAst, $cursorPosition)
+
+  $spec = ${dataName}
+  $results = [System.Collections.Generic.List[System.Management.Automation.CompletionResult]]::new()
+  $booleanLiterals = @('true', 'yes', 'on', '1', 'y', 'false', 'no', 'off', '0', 'n')
+
+  $index = {
+    param($context)
+    $lookup = [hashtable]::new([System.StringComparer]::Ordinal)
+    foreach ($flag in $context.flags) {
+      foreach ($form in $flag.forms) { $lookup[$form] = $flag }
+    }
+    $lookup
+  }
+
+  $add = {
+    param([string]$value, [string]$type, $tooltip, [string]$typed, [string]$textPrefix)
+    if (-not $value.StartsWith($typed, [System.StringComparison]::OrdinalIgnoreCase)) { return }
+    $text = $value
+    if ($value -notmatch '^[\w./:%+=\\-]+$') { $text = "'" + ($value -replace "['\u2018-\u201b]", '$0$0') + "'" }
+    $text = $textPrefix + $text
+    $label = $value
+    if (-not $label) { $label = $text }
+    if (-not $tooltip) { $tooltip = $label }
+    $results.Add([System.Management.Automation.CompletionResult]::new($text, $label, $type, $tooltip))
+  }
+
+  $addValues = {
+    param($entry, [string]$typed, [string]$textPrefix)
+    foreach ($value in $entry.values) {
+      if ($textPrefix -eq '' -and (& $optionLike $value)) { continue }
+      & $add $value 'ParameterValue' $entry.description $typed $textPrefix
+    }
+    if ($entry.pathType) {
+      foreach ($file in [System.Management.Automation.CompletionCompleters]::CompleteFilename($typed)) {
+        if ($entry.pathType -eq 'directory' -and $file.ResultType -ne 'ProviderContainer') { continue }
+        $results.Add([System.Management.Automation.CompletionResult]::new($textPrefix + $file.CompletionText, $file.ListItemText, $file.ResultType, $file.ToolTip))
+      }
+    }
+  }
+
+  $addFlags = {
+    param([string]$typed)
+    foreach ($flag in $context.flags) {
+      if ($used.ContainsKey($flag.name)) { continue }
+      foreach ($form in $flag.forms) {
+        & $add $form 'ParameterName' $flag.description $typed ''
+      }
+      if (-not $flag.takesValue) {
+        $tooltip = $null
+        if ($flag.description) { $tooltip = 'Disable ' + $flag.name }
+        & $add ('--no-' + $flag.name) 'ParameterName' $tooltip $typed ''
+      }
+    }
+  }
+
+  # As in the CLI lexer, nothing after '--' is an option, and negative numbers
+  # and a lone '-' are values.
+  $optionLike = {
+    param([string]$word)
+    -not $endOfOptions -and $word -match '^-.' -and $word -notmatch '^-(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$'
+  }
+
+  # A typed value that has no candidates completes to itself, so the engine
+  # does not fall back to listing files.
+  $keepTyped = {
+    if ($results.Count -eq 0 -and $current) {
+      $results.Add([System.Management.Automation.CompletionResult]::new($current, $current, 'ParameterValue', $current))
+    }
+  }
+
+  $path = ''
+  $context = $spec[$path]
+  $lookup = & $index $context
+  $used = [hashtable]::new([System.StringComparer]::Ordinal)
+  $pending = $null
+  $endOfOptions = $false
+  $position = 0
+
+  # The engine strips the quotes from a quoted word.
+  $typed = [string]$wordToComplete
+  if ($typed -match '^([''"])(.*?)\1?$') { $typed = $Matches[2] }
+  $current = $null
+
+  $elements = $commandAst.CommandElements
+  for ($i = 1; $i -lt $elements.Count; $i++) {
+    $element = $elements[$i]
+    $word = $element.Extent.Text
+    if ($element -is [System.Management.Automation.Language.StringConstantExpressionAst]) { $word = $element.Value }
+    if ($element.Extent.EndOffset -ge $cursorPosition) {
+      if ($element -is [System.Management.Automation.Language.ConstantExpressionAst] -and $element.Extent.StartOffset -le $cursorPosition) {
+        $current = $element.Extent.Text
+        if ($element.Extent.EndOffset -eq $cursorPosition) { $typed = $word }
+      }
+      break
+    }
+
+    # A flag takes the next word as its value unless it is an option or '--';
+    # a boolean flag only takes a boolean literal.
+    $isOption = & $optionLike $word
+    if ($null -ne $pending) {
+      $flag = $pending
+      $pending = $null
+      if ($flag.takesValue) {
+        if (-not $isOption) { continue }
+      } elseif ($booleanLiterals -ccontains $word) { continue }
+    }
+    if ($endOfOptions) { $position++; continue }
+    if ($word -ceq '--') { $endOfOptions = $true; continue }
+
+    if ($isOption) {
+      $hasValue = $word.Contains('=')
+      if ($hasValue) {
+        $forms = @($word.Substring(0, $word.IndexOf('=')))
+      } elseif ($word.StartsWith('--')) {
+        $forms = @($word)
+      } else {
+        $forms = @(foreach ($char in $word.Substring(1).ToCharArray()) { '-' + $char })
+      }
+      foreach ($form in $forms) {
+        $pending = $null
+        $flag = $lookup[$form]
+        if ($null -eq $flag) {
+          if ($form.StartsWith('--no-')) {
+            $name = $form.Substring(5)
+            $flag = $lookup['--' + $name]
+            if ($null -ne $flag -and -not $flag.takesValue -and $flag.name -ceq $name) { $used[$name] = $true }
+          }
+          continue
+        }
+        $used[$flag.name] = $true
+        if (-not $hasValue) { $pending = $flag }
+      }
+      continue
+    }
+
+    if ($position -eq 0 -and $context.subcommands.name -ccontains $word) {
+      if ($path) { $path = $path + ' ' + $word } else { $path = $word }
+      $context = $spec[$path]
+      $lookup = & $index $context
+      $used = [hashtable]::new([System.StringComparer]::Ordinal)
+      continue
+    }
+    $position++
+  }
+
+  $typedIsOption = & $optionLike $typed
+  if ($null -ne $pending -and $pending.takesValue -and -not $typedIsOption) {
+    & $addValues $pending $typed ''
+    & $keepTyped
+    return $results
+  }
+
+  if ($typedIsOption) {
+    if ($typed -match '^(-[^=]+)=(.*)$') {
+      $form = $Matches[1]
+      $flag = $lookup[$form]
+      if ($null -ne $flag -and $flag.takesValue) {
+        & $addValues $flag $Matches[2] ($form + '=')
+        & $keepTyped
+      }
+    } else {
+      & $addFlags $typed
+    }
+    return $results
+  }
+
+  if (-not $endOfOptions -and $position -eq 0) {
+    foreach ($sub in $context.subcommands) {
+      & $add $sub.name 'Command' $sub.description $typed ''
+    }
+  }
+
+  $arguments = $context.arguments
+  if ($position -lt $arguments.Count) {
+    & $addValues $arguments[$position] $typed ''
+  } elseif ($arguments.Count -gt 0 -and $arguments[-1].variadic) {
+    & $addValues $arguments[-1] $typed ''
+  }
+
+  if (-not $endOfOptions) {
+    & $addFlags $typed
+  }
+  return $results`
+
+/** @internal */
+export const generate = (
+  executableName: string,
+  descriptor: Completions.CommandDescriptor
+): string => {
+  const dataName = `$global:_${sanitize(executableName)}_Completions`
+  const lines: Array<string> = []
+
+  lines.push(`###-begin-${executableName}-completions-###`)
+  lines.push(`#`)
+  lines.push(`# Static completion script for PowerShell`)
+  lines.push(`#`)
+  lines.push(`# Installation:`)
+  // `>>` on Windows PowerShell 5.1 appends UTF-16LE to the profile, so the
+  // script goes in its own file.
+  lines.push(`#   ${executableName} --completions powershell > ${executableName}-completion.ps1`)
+  lines.push(`#   then add this line to your $PROFILE (use the full path to the file):`)
+  lines.push(`#   . <PATH>\\${executableName}-completion.ps1`)
+  lines.push(`#`)
+  lines.push(``)
+  lines.push(`${dataName} = [hashtable]::new([System.StringComparer]::Ordinal)`)
+  generateContexts(dataName, descriptor, [], lines, new Set())
+  lines.push(``)
+  lines.push(`Register-ArgumentCompleter -Native -CommandName ${quotePs(executableName)} -ScriptBlock {`)
+  lines.push(completer(dataName))
+  lines.push(`}`)
+  lines.push(``)
+  lines.push(`###-end-${executableName}-completions-###`)
+
+  return lines.join("\n")
+}

package/src/cli/internal/completions/zsh.ts

@@ -14,6 +14,8 @@ import type * as Completions from "../../Completions.ts"
 
 const escapeZsh = (s: string): string => s.replace(/\\/g, "\\\\").replace(/'/g, "'\\''").replace(/:/g, "\\:")
 
+const escapeZshExplanation = (s: string): string => escapeZsh(s).replace(/]/g, "\\]")
+
 /** Escape choices for the second parse of a Zsh `_arguments` action. */
 const escapeZshChoice = (s: string): string => s.replace(/[^A-Za-z0-9_.,/@%+-]/gu, "\\$&").replace(/'/g, "'\\''")
 
@@ -69,7 +71,7 @@ const argAction = (type: Completions.ArgumentType): string => {
  */
 const flagSpecs = (flag: Completions.FlagDescriptor): Array<string> => {
   const specs: Array<string> = []
-  const desc = flag.description ? `[${escapeZsh(flag.description)}]` : ""
+  const desc = flag.description ? `[${escapeZshExplanation(flag.description)}]` : ""
   const action = valueAction(flag.type)
   const excl = `(${allForms(flag).join(" ")})`
 
@@ -84,7 +86,7 @@ const flagSpecs = (flag: Completions.FlagDescriptor): Array<string> => {
 
   // Boolean negation
   if (flag.type._tag === "Boolean") {
-    const negDesc = flag.description ? `[${escapeZsh(`Disable ${flag.name}`)}]` : ""
+    const negDesc = flag.description ? `[${escapeZshExplanation(`Disable ${flag.name}`)}]` : ""
     specs.push(`'${excl}--no-${flag.name}${negDesc}'`)
   }
 

package/src/cli/internal/wizard.ts

@@ -34,8 +34,9 @@ export const run: (
     const commandPath = options?.commandPath ?? [command.name]
     const selected = getCommandAtPath(command, commandPath)
     const commandLine = (options?.prefix ?? commandPath).map((value) => commandLineArg(value))
-    yield* logCurrentCommand(commandLine)
-    yield* promptCommand(selected, commandLine, selected === command ? "ROOT" : selected.name)
+    const { colors } = yield* Prompt.Theme
+    yield* logCurrentCommand(commandLine, colors)
+    yield* promptCommand(selected, commandLine, selected === command ? "ROOT" : selected.name, colors)
     return {
       args: commandLine.map((arg) => arg.value),
       displayArgs: commandLine.map((arg) => arg.displayValue)
@@ -63,30 +64,31 @@ const getCommandAtPath = (
 const promptCommand: (
   command: Command.Command.Any,
   commandLine: Array<CommandLineArg>,
-  sectionName: string
+  sectionName: string,
+  colors: boolean
 ) => Effect.Effect<void, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
-  function*(command, commandLine, sectionName) {
+  function*(command, commandLine, sectionName, colors) {
     const impl = toImpl(command)
     const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.unlisted))
     const config = visibleSubcommands.length === 0 ? impl.config : impl.contextConfig
 
     if (config.flags.length > 0) {
-      yield* Console.log(renderSection(sectionName, "FLAGS"))
+      yield* Console.log(renderSection(sectionName, "FLAGS", colors))
       for (const param of config.flags) {
         commandLine.push(...yield* promptParam(param))
       }
       if (config.arguments.length > 0 || visibleSubcommands.length > 0) {
-        yield* logCurrentCommand(commandLine)
+        yield* logCurrentCommand(commandLine, colors)
       }
     }
 
     if (config.arguments.length > 0) {
-      yield* Console.log(renderSection(sectionName, "ARGUMENTS"))
+      yield* Console.log(renderSection(sectionName, "ARGUMENTS", colors))
       for (const param of config.arguments) {
         commandLine.push(...yield* promptParam(param))
       }
       if (visibleSubcommands.length > 0) {
-        yield* logCurrentCommand(commandLine)
+        yield* logCurrentCommand(commandLine, colors)
       }
     }
 
@@ -109,9 +111,9 @@ const promptCommand: (
     yield* Console.log()
     commandLine.push(commandLineArg(child.name))
     if (hasWizardSteps(child)) {
-      yield* logCurrentCommand(commandLine)
+      yield* logCurrentCommand(commandLine, colors)
     }
-    yield* promptCommand(child, commandLine, child.name)
+    yield* promptCommand(child, commandLine, child.name, colors)
   }
 )
 
@@ -244,41 +246,47 @@ const humanize = (name: string): string => {
   return [words[0][0].toUpperCase() + words[0].slice(1), ...words.slice(1)].join(" ")
 }
 
-const logCurrentCommand = (commandLine: ReadonlyArray<CommandLineArg>): Effect.Effect<void> =>
-  Console.log(renderCommandBlock("Current command", commandLine.map((arg) => arg.displayValue), Ansi.magenta))
+const logCurrentCommand = (commandLine: ReadonlyArray<CommandLineArg>, colors: boolean): Effect.Effect<void> =>
+  Console.log(renderCommandBlock("Current command", commandLine.map((arg) => arg.displayValue), colors, Ansi.magenta))
 
-const renderSection = (commandName: string, section: string): string =>
-  `${Ansi.annotate(commandName.toUpperCase(), Ansi.bold, Ansi.cyanBright)} ${Ansi.annotate("·", Ansi.blackBright)} ${
-    Ansi.annotate(section, Ansi.bold, Ansi.white)
-  }`
+const renderSection = (commandName: string, section: string, colors: boolean): string =>
+  `${Ansi.annotate(colors, commandName.toUpperCase(), Ansi.bold, Ansi.cyanBright)} ${
+    Ansi.annotate(colors, "·", Ansi.blackBright)
+  } ${Ansi.annotate(colors, section, Ansi.bold, Ansi.white)}`
 
-export const renderIntroduction = (name: string, version: string, summary: string | undefined): string => {
-  const title = `${Ansi.annotate(name, Ansi.bold, Ansi.cyanBright)} ${Ansi.annotate(`v${version}`, Ansi.white)} ${
-    Ansi.annotate("· Command wizard", Ansi.bold, Ansi.white)
-  }`
+export const renderIntroduction = (
+  name: string,
+  version: string,
+  summary: string | undefined,
+  colors: boolean
+): string => {
+  const title = `${Ansi.annotate(colors, name, Ansi.bold, Ansi.cyanBright)} ${
+    Ansi.annotate(colors, `v${version}`, Ansi.white)
+  } ${Ansi.annotate(colors, "· Command wizard", Ansi.bold, Ansi.white)}`
   return [
     title,
     ...(summary === undefined || summary.length === 0 ? [] : [summary]),
-    Ansi.annotate("Build a command interactively. Press Ctrl+C to cancel.", Ansi.blackBright),
+    Ansi.annotate(colors, "Build a command interactively. Press Ctrl+C to cancel.", Ansi.blackBright),
     ""
   ].join("\n")
 }
 
-export const renderCompletion = (commandLine: ReadonlyArray<string>): string =>
-  renderCommandBlock("Command ready", commandLine, Ansi.cyanBright, Ansi.green)
+export const renderCompletion = (commandLine: ReadonlyArray<string>, colors: boolean): string =>
+  renderCommandBlock("Command ready", commandLine, colors, Ansi.cyanBright, Ansi.green)
 
-export const renderQuit = (): string => `\n${Ansi.annotate("Wizard cancelled.", Ansi.red)}`
+export const renderQuit = (colors: boolean): string => `\n${Ansi.annotate(colors, "Wizard cancelled.", Ansi.red)}`
 
 const renderCommandBlock = (
   label: string,
   commandLine: ReadonlyArray<string>,
+  colors: boolean,
   commandColor: string,
   labelColor: string = Ansi.white
 ): string => {
   const lines = wrapCommand(commandLine)
   return [
-    Ansi.annotate(label, Ansi.bold, labelColor),
-    ...lines.map((line) => Ansi.annotate(line, commandColor)),
+    Ansi.annotate(colors, label, Ansi.bold, labelColor),
+    ...lines.map((line) => Ansi.annotate(colors, line, commandColor)),
     ""
   ].join("\n")
 }

package/src/cluster/ClusterSchema.ts

@@ -62,11 +62,22 @@ export const Persisted = Context.Reference<boolean>("effect/cluster/ClusterSchem
  * The default value is `false`. When `true`, entity handling wraps server
  * writes with the configured storage transaction.
  *
+ * Persisted requests deliver terminal replies and mark requests processed only
+ * after commit or clean rollback. Success replies are saved in the transaction;
+ * failures are saved after rollback. If commit reports failure, a stored success
+ * reply is recovered. Otherwise, commit or rollback failures retry the request
+ * without delivering a reply. Handlers must tolerate retries.
+ *
  * **Gotchas**
  *
  * This annotation has transactional behavior only when the configured
  * `MessageStorage` implements it.
  *
+ * Stream chunks are saved and delivered immediately, even if the transaction
+ * later rolls back. A handler returning a `Deferred` commits before its reply
+ * is saved. Non-persisted requests save no reply; successes are delivered when
+ * the handler exits, and failures after the transaction exits.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
@@ -95,6 +106,27 @@ export const Uninterruptible = Context.Reference<boolean | "client" | "server">(
   { defaultValue: constFalse }
 )
 
+/**
+ * Annotation that interrupts a cluster request when entity termination starts,
+ * rather than waiting for the termination grace period to expire.
+ *
+ * **Details**
+ *
+ * The default value is `false`. Use for long-lived requests that cannot finish
+ * on their own. Persisted requests resume under the next owner without saving
+ * the interruption as a reply. Non-persisted requests receive an interrupt exit.
+ *
+ * Server-side `Uninterruptible` takes precedence over this annotation.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export const InterruptOnTermination = Context.Reference<boolean>(
+  "effect/cluster/ClusterSchema/InterruptOnTermination",
+  { defaultValue: constFalse }
+)
+
 /**
  * Returns whether the `Uninterruptible` annotation applies to server-side
  * request handling for the provided context.

package/src/cluster/ClusterWorkflowEngine.ts

@@ -15,7 +15,6 @@ import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
 import * as Fiber from "../Fiber.ts"
 import * as Headers from "../http/Headers.ts"
-import * as Latch from "../Latch.ts"
 import * as Layer from "../Layer.ts"
 import * as Option from "../Option.ts"
 import * as PrimaryKey from "../PrimaryKey.ts"
@@ -132,7 +131,6 @@ export const make = Effect.gen(function*() {
     readonly context: Context.Context<any>
   }>()
   const interruptedActivities = new Set<string>()
-  const activityLatches = new Map<string, Latch.Latch>()
   const deferredState = WorkflowEngine.makeDeferredState()
   // Rebuilds share an activation; overlapping activations have separate results.
   // Weak keys do not retain scopes, but contexts captured by clients, activities,
@@ -476,23 +474,19 @@ export const make = Effect.gen(function*() {
                 const activityId = `${executionId}/${payload.name}`
                 const instance = WorkflowEngine.WorkflowInstance.initial(workflow, executionId)
                 interruptedActivities.delete(activityId)
-                return Effect.gen(function*() {
-                  let entry = activities.get(activityId)
-                  while (!entry) {
-                    const latch = Latch.makeUnsafe()
-                    activityLatches.set(activityId, latch)
-                    yield* latch.await
-                    entry = activities.get(activityId)
-                  }
-                  const context = entry.context.pipe(
-                    Context.add(WorkflowEngine.WorkflowInstance, instance),
-                    Context.add(CurrentActivationScope, activation),
-                    Context.add(Activity.CurrentAttempt, payload.attempt)
-                  )
-                  return yield* entry.activity.executeEncoded.pipe(
-                    Effect.provideContext(context)
-                  )
-                }).pipe(
+                const entry = activities.get(activityId)
+                if (!entry) {
+                  // Replay may never register a losing race activity. Answer it
+                  // without waiting; a later registration can reset this reply.
+                  return Effect.succeed(new Workflow.Suspended({})).pipe(Rpc.wrap({ fork: true }))
+                }
+                const context = entry.context.pipe(
+                  Context.add(WorkflowEngine.WorkflowInstance, instance),
+                  Context.add(CurrentActivationScope, activation),
+                  Context.add(Activity.CurrentAttempt, payload.attempt)
+                )
+                return entry.activity.executeEncoded.pipe(
+                  Effect.provideContext(context),
                   Workflow.intoResult,
                   Effect.catchCause((cause) => {
                     // we only want to store interrupts as suspends when the
@@ -633,11 +627,6 @@ export const make = Effect.gen(function*() {
         while (true) {
           if (!activities.has(activityId)) {
             activities.set(activityId, { activity, context: services })
-            const latch = activityLatches.get(activityId)
-            if (latch) {
-              yield* latch.open
-              activityLatches.delete(activityId)
-            }
           }
           const result = yield* Effect.orDie(
             client.activity({