effect 4.0.0-beta.98 → 4.0.0-rc.108

package/src/unstable/cli/internal/lexer.ts

@@ -47,8 +47,14 @@ const lexTokens = (args: ReadonlyArray<string>): ReadonlyArray<Token> => {
     if (!arg.startsWith("-")) {
       tokens.push({ _tag: "Value", value: arg })
     } else if (arg.startsWith("--")) {
-      const [name, value] = arg.slice(2).split("=", 2)
-      tokens.push({ _tag: "LongOption", name, raw: arg, value })
+      const equalIndex = arg.indexOf("=")
+      if (equalIndex !== -1) {
+        const name = arg.slice(2, equalIndex)
+        const value = arg.slice(equalIndex + 1)
+        tokens.push({ _tag: "LongOption", name, raw: arg, value })
+      } else {
+        tokens.push({ _tag: "LongOption", name: arg.slice(2), raw: arg })
+      }
     } else if (arg.length > 1) {
       const flags = arg.slice(1)
       const equalIndex = flags.indexOf("=")

package/src/unstable/cli/internal/parser.ts

@@ -84,7 +84,7 @@ export const parseArgs = (
       }
     }
 
-    const subLex: LexResult = { tokens: result.childTokens, trailingOperands: [] }
+    const subLex: LexResult = { tokens: result.childTokens, trailingOperands: afterEndOfOptions }
     const subParsed = yield* parseArgs(
       subLex,
       result.sub,
@@ -94,7 +94,7 @@ export const parseArgs = (
     const allErrors = [...result.errors, ...(subParsed.errors ?? [])]
     return {
       flags: result.flags,
-      arguments: afterEndOfOptions,
+      arguments: [],
       subcommand: Option.some({ name: result.sub.name, parsedInput: subParsed }),
       ...(allErrors.length > 0 && { errors: allErrors })
     }
@@ -391,6 +391,18 @@ const invalidNegatedFlagValue = (
     kind: "flag"
   })
 
+const missingFlagValue = (spec: FlagParam): CliError.InvalidValue => {
+  const choices = Primitive.getChoiceKeys(spec.primitiveType)
+  return new CliError.InvalidValue({
+    option: spec.name,
+    value: "",
+    expected: choices === undefined
+      ? spec.typeName ?? Primitive.getTypeName(spec.primitiveType)
+      : choices.join(" | "),
+    kind: "flag"
+  })
+}
+
 /**
  * Checks whether a token is a boolean literal value.
  * Recognizes: true/false, yes/no, on/off, 1/0
@@ -497,8 +509,8 @@ const consumeFlagValueWithTokens = (
   }
 
   return {
-    _tag: "Value",
-    value: undefined,
+    _tag: "Error",
+    error: missingFlagValue(spec),
     tokens: []
   }
 }
@@ -814,12 +826,12 @@ const resolveFirstValue = (
   // Not a subcommand. Check if this looks like a typo.
   const expectsArgs = toImpl(command).config.arguments.length > 0
   if (!expectsArgs && subIndex.size > 0) {
-    // Exclude hidden subcommands so a typo cannot reveal a subcommand name
-    // that was intentionally kept out of --help. Hidden commands still
+    // Exclude unlisted subcommands so a typo cannot reveal a subcommand name
+    // that was intentionally kept out of --help. Unlisted commands still
     // resolve via subIndex when invoked by exact name.
     const visibleKeys: Array<string> = []
     for (const [key, sub] of subIndex) {
-      if (!sub.hidden) visibleKeys.push(key)
+      if (!sub.unlisted) visibleKeys.push(key)
     }
     const suggestions = suggest(value, visibleKeys)
     state.errors.push(

package/src/unstable/cli/internal/wizard.ts

@@ -0,0 +1,283 @@
+import * as Console from "../../../Console.ts"
+import * as Effect from "../../../Effect.ts"
+import * as Option from "../../../Option.ts"
+import * as Redacted from "../../../Redacted.ts"
+import type * as Terminal from "../../../Terminal.ts"
+import type * as CliError from "../CliError.ts"
+import type * as Command from "../Command.ts"
+import * as Param from "../Param.ts"
+import * as Primitive from "../Primitive.ts"
+import * as Prompt from "../Prompt.ts"
+import * as Ansi from "./ansi.ts"
+import { toImpl } from "./command.ts"
+
+export interface Options {
+  readonly commandPath?: ReadonlyArray<string> | undefined
+  readonly prefix?: ReadonlyArray<string> | undefined
+}
+
+export const run: (
+  command: Command.Command.Any,
+  options?: Options
+) => Effect.Effect<Array<string>, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+  function*(command, options) {
+    const commandPath = options?.commandPath ?? [command.name]
+    const selected = getCommandAtPath(command, commandPath)
+    const commandLine = [...(options?.prefix ?? commandPath)]
+    yield* logCurrentCommand(commandLine)
+    yield* promptCommand(selected, commandLine, selected === command ? "ROOT" : selected.name)
+    return commandLine
+  }
+)
+
+const getCommandAtPath = (
+  command: Command.Command.Any,
+  commandPath: ReadonlyArray<string>
+): Command.Command.Any => {
+  let current = command
+  for (const name of commandPath.slice(1)) {
+    const child = current.subcommands
+      .flatMap((group) => group.commands)
+      .find((candidate) => candidate.name === name || candidate.alias === name)
+    if (child === undefined) {
+      break
+    }
+    current = child
+  }
+  return current
+}
+
+const promptCommand: (
+  command: Command.Command.Any,
+  commandLine: Array<string>,
+  sectionName: string
+) => Effect.Effect<void, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+  function*(command, commandLine, sectionName) {
+    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"))
+      for (const param of config.flags) {
+        commandLine.push(...yield* promptParam(param))
+      }
+      if (config.arguments.length > 0 || visibleSubcommands.length > 0) {
+        yield* logCurrentCommand(commandLine)
+      }
+    }
+
+    if (config.arguments.length > 0) {
+      yield* Console.log(renderSection(sectionName, "ARGUMENTS"))
+      for (const param of config.arguments) {
+        commandLine.push(...yield* promptParam(param))
+      }
+      if (visibleSubcommands.length > 0) {
+        yield* logCurrentCommand(commandLine)
+      }
+    }
+
+    if (visibleSubcommands.length === 0) {
+      return
+    }
+
+    const child = yield* Prompt.run(Prompt.select({
+      message: "Command",
+      choices: visibleSubcommands.map((command) => ({
+        title: command.name,
+        value: command,
+        ...(command.shortDescription !== undefined
+          ? { description: command.shortDescription }
+          : command.description !== undefined
+          ? { description: command.description }
+          : {})
+      }))
+    }))
+    yield* Console.log()
+    commandLine.push(child.name)
+    if (hasWizardSteps(child)) {
+      yield* logCurrentCommand(commandLine)
+    }
+    yield* promptCommand(child, commandLine, child.name)
+  }
+)
+
+const hasWizardSteps = (command: Command.Command.Any): boolean => {
+  const hasVisibleSubcommands = command.subcommands.some((group) => group.commands.some((child) => !child.unlisted))
+  return hasVisibleSubcommands || toImpl(command).config.orderedParams.length > 0
+}
+
+const promptParam: (
+  param: Param.Any
+) => Effect.Effect<Array<string>, CliError.CliError | Terminal.QuitError, Command.Environment> = Effect.fnUntraced(
+  function*(param) {
+    const single = Param.getUnderlyingSingleOrThrow(param)
+    const metadata = Param.getParamMetadata(param)
+
+    if (metadata.isOptional) {
+      const include = yield* Prompt.run(Prompt.confirm({
+        message: `Set ${renderParamLabel(single)}?`,
+        initial: false
+      }))
+      if (!include) {
+        yield* Console.log()
+        return []
+      }
+    }
+
+    const count = !metadata.isVariadic
+      ? 1
+      : yield* Prompt.run(Prompt.integer({
+        message: `${renderParamLabel(single)} count`,
+        default: Option.getOrElse(metadata.variadicMin, () => 0),
+        min: Option.getOrElse(metadata.variadicMin, () => 0),
+        ...(Option.isSome(metadata.variadicMax) ? { max: metadata.variadicMax.value } : {})
+      }))
+    const values: Array<string> = []
+    for (let i = 0; i < count; i++) {
+      values.push(yield* promptSingle(single))
+    }
+
+    const parsed = single.kind === Param.flagKind
+      ? {
+        flags: { [single.name]: values },
+        arguments: []
+      }
+      : {
+        flags: {},
+        arguments: values
+      }
+    yield* param.parse(parsed)
+    yield* Console.log()
+
+    if (single.kind === Param.argumentKind) {
+      return values
+    }
+    return values.flatMap((value) => [`--${single.name}`, value])
+  }
+)
+
+const promptSingle = (
+  single: Param.Single<Param.ParamKind, unknown>
+): Effect.Effect<string, Terminal.QuitError, Command.Environment> => {
+  const message = renderParamMessage(single)
+  switch (single.primitiveType._tag) {
+    case "Boolean":
+      return Effect.map(
+        Prompt.run(Prompt.confirm({
+          message,
+          label: {
+            confirm: "true",
+            deny: "false"
+          },
+          placeholder: {
+            defaultConfirm: "(T/f)",
+            defaultDeny: "(t/F)"
+          }
+        })),
+        String
+      )
+    case "Choice": {
+      const choices = Primitive.getChoiceKeys(single.primitiveType) ?? []
+      return Prompt.run(Prompt.select({
+        message,
+        choices: choices.map((choice) => ({ title: choice, value: choice }))
+      }))
+    }
+    case "Date":
+      return Effect.map(Prompt.run(Prompt.date({ message })), (date) => date.toISOString())
+    case "Float":
+      return Effect.map(Prompt.run(Prompt.float({ message })), String)
+    case "Integer":
+      return Effect.map(Prompt.run(Prompt.integer({ message })), String)
+    case "Redacted":
+      return Effect.map(Prompt.run(Prompt.password({ message })), Redacted.value)
+    default:
+      return Prompt.run(Prompt.text({ message }))
+  }
+}
+
+const formatName = (single: Param.Single<Param.ParamKind, unknown>): string =>
+  single.kind === Param.flagKind ? `--${single.name}` : single.name
+
+const renderParamMessage = (single: Param.Single<Param.ParamKind, unknown>): string => renderParamLabel(single)
+
+const renderParamLabel = (single: Param.Single<Param.ParamKind, unknown>): string => {
+  const description = Option.getOrUndefined(single.description)?.trim()
+  const label = single.kind === Param.flagKind && description !== undefined && description.length <= 32
+    ? description
+    : humanize(single.name)
+  return single.kind === Param.flagKind ? `${label} (${formatName(single)})` : label
+}
+
+const humanize = (name: string): string => {
+  const words = name.split(/[-_]+/).filter((word) => word.length > 0)
+  if (words.length === 0) return name
+  return [words[0][0].toUpperCase() + words[0].slice(1), ...words.slice(1)].join(" ")
+}
+
+const logCurrentCommand = (commandLine: ReadonlyArray<string>): Effect.Effect<void> =>
+  Console.log(renderCommandBlock("Current command", commandLine, 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)
+  }`
+
+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)
+  }`
+  return [
+    title,
+    ...(summary === undefined || summary.length === 0 ? [] : [summary]),
+    Ansi.annotate("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 renderQuit = (): string => `\n${Ansi.annotate("Wizard cancelled.", Ansi.red)}`
+
+const renderCommandBlock = (
+  label: string,
+  commandLine: ReadonlyArray<string>,
+  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)),
+    ""
+  ].join("\n")
+}
+
+const wrapCommand = (commandLine: ReadonlyArray<string>): Array<string> => {
+  const width = 88
+  const firstIndent = "  $ "
+  const continuationIndent = "    "
+  const args = commandLine.map(formatShellArg)
+  const lines: Array<string> = []
+  let current = firstIndent
+
+  for (const arg of args) {
+    const separator = current === firstIndent || current === continuationIndent ? "" : " "
+    if (current.length + separator.length + arg.length > width && current !== firstIndent) {
+      lines.push(`${current} \\`)
+      current = `${continuationIndent}${arg}`
+    } else {
+      current += `${separator}${arg}`
+    }
+  }
+
+  if (current !== firstIndent) {
+    lines.push(current)
+  }
+  return lines
+}
+
+const formatShellArg = (arg: string): string =>
+  /^[A-Za-z0-9_./:@%+=,-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'"'"'`)}'`

package/src/unstable/cluster/ClusterError.ts

@@ -26,7 +26,7 @@ const TypeId = "~effect/cluster/ClusterError"
  * @since 4.0.0
  */
 export class EntityNotAssignedToRunner
-  extends Schema.ErrorClass<EntityNotAssignedToRunner>(`${TypeId}/EntityNotAssignedToRunner`)({
+  extends Schema.Error<EntityNotAssignedToRunner>(`${TypeId}/EntityNotAssignedToRunner`)({
     _tag: Schema.tag("EntityNotAssignedToRunner"),
     address: EntityAddress
   })
@@ -60,7 +60,7 @@ export class EntityNotAssignedToRunner
  * @category errors
  * @since 4.0.0
  */
-export class MalformedMessage extends Schema.ErrorClass<MalformedMessage>(`${TypeId}/MalformedMessage`)({
+export class MalformedMessage extends Schema.Error<MalformedMessage>(`${TypeId}/MalformedMessage`)({
   _tag: Schema.tag("MalformedMessage"),
   cause: Schema.Defect()
 }) {
@@ -99,7 +99,7 @@ export class MalformedMessage extends Schema.ErrorClass<MalformedMessage>(`${Typ
  * @category errors
  * @since 4.0.0
  */
-export class PersistenceError extends Schema.ErrorClass<PersistenceError>(`${TypeId}/PersistenceError`)({
+export class PersistenceError extends Schema.Error<PersistenceError>(`${TypeId}/PersistenceError`)({
   _tag: Schema.tag("PersistenceError"),
   cause: Schema.Defect()
 }) {
@@ -127,7 +127,7 @@ export class PersistenceError extends Schema.ErrorClass<PersistenceError>(`${Typ
  * @category errors
  * @since 4.0.0
  */
-export class RunnerNotRegistered extends Schema.ErrorClass<RunnerNotRegistered>(`${TypeId}/RunnerNotRegistered`)({
+export class RunnerNotRegistered extends Schema.Error<RunnerNotRegistered>(`${TypeId}/RunnerNotRegistered`)({
   _tag: Schema.tag("RunnerNotRegistered"),
   address: RunnerAddress
 }) {
@@ -145,7 +145,7 @@ export class RunnerNotRegistered extends Schema.ErrorClass<RunnerNotRegistered>(
  * @category errors
  * @since 4.0.0
  */
-export class RunnerUnavailable extends Schema.ErrorClass<RunnerUnavailable>(`${TypeId}/RunnerUnavailable`)({
+export class RunnerUnavailable extends Schema.Error<RunnerUnavailable>(`${TypeId}/RunnerUnavailable`)({
   _tag: Schema.tag("RunnerUnavailable"),
   address: RunnerAddress
 }) {
@@ -181,7 +181,7 @@ export class RunnerUnavailable extends Schema.ErrorClass<RunnerUnavailable>(`${T
  * @category errors
  * @since 4.0.0
  */
-export class MailboxFull extends Schema.ErrorClass<MailboxFull>(`${TypeId}/MailboxFull`)({
+export class MailboxFull extends Schema.Error<MailboxFull>(`${TypeId}/MailboxFull`)({
   _tag: Schema.tag("MailboxFull"),
   address: EntityAddress
 }) {
@@ -214,7 +214,7 @@ export class MailboxFull extends Schema.ErrorClass<MailboxFull>(`${TypeId}/Mailb
  * @since 4.0.0
  */
 export class AlreadyProcessingMessage
-  extends Schema.ErrorClass<AlreadyProcessingMessage>(`${TypeId}/AlreadyProcessingMessage`)({
+  extends Schema.Error<AlreadyProcessingMessage>(`${TypeId}/AlreadyProcessingMessage`)({
     _tag: Schema.tag("AlreadyProcessingMessage"),
     envelopeId: SnowflakeFromString,
     address: EntityAddress

package/src/unstable/cluster/ClusterSchema.ts

@@ -20,7 +20,7 @@ import type { Request } from "./Envelope.ts"
  *
  * The default value is `false`.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Persisted = Context.Reference<boolean>("effect/cluster/ClusterSchema/Persisted", {
@@ -46,7 +46,7 @@ export const Persisted = Context.Reference<boolean>("effect/cluster/ClusterSchem
  * This annotation has transactional behavior only when the configured
  * `MessageStorage` implements it.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const WithTransaction = Context.Reference<boolean>(
@@ -64,7 +64,7 @@ export const WithTransaction = Context.Reference<boolean>(
  * handling only, `"server"` for server-side handling only, or `false` to allow
  * interruption.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Uninterruptible = Context.Reference<boolean | "client" | "server">(
@@ -83,7 +83,7 @@ export const Uninterruptible = Context.Reference<boolean | "client" | "server">(
  * @see {@link Uninterruptible} for the annotation values interpreted by this helper
  * @see {@link isUninterruptibleForClient} for the client-side counterpart
  *
- * @category annotations
+ * @category predicates
  * @since 4.0.0
  */
 export const isUninterruptibleForServer = (context: Context.Context<never>): boolean => {
@@ -108,7 +108,7 @@ export const isUninterruptibleForServer = (context: Context.Context<never>): boo
  * @see {@link Uninterruptible} for the annotation values interpreted by this helper
  * @see {@link isUninterruptibleForServer} for the server-side counterpart
  *
- * @category annotations
+ * @category predicates
  * @since 4.0.0
  */
 export const isUninterruptibleForClient = (context: Context.Context<never>): boolean => {
@@ -123,7 +123,7 @@ export const isUninterruptibleForClient = (context: Context.Context<never>): boo
  *
  * By default, every entity id is assigned to the `"default"` shard group.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const ShardGroup = Context.Reference<(entityId: EntityId) => string>(
@@ -139,7 +139,7 @@ export const ShardGroup = Context.Reference<(entityId: EntityId) => string>(
  *
  * The default value is `true`.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const ClientTracingEnabled = Context.Reference<boolean>("effect/cluster/ClusterSchema/ClientTracingEnabled", {
@@ -159,7 +159,7 @@ export const ClientTracingEnabled = Context.Reference<boolean>("effect/cluster/C
  * This only applies to requests handled by the entity, not to the generated
  * client.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const Dynamic = Context.Reference<

package/src/unstable/cluster/ClusterWorkflowEngine.ts

@@ -83,7 +83,7 @@ export const make = Effect.gen(function*() {
       | Rpc.Rpc<
         "activity",
         Schema.Struct<
-          { name: typeof Schema.String; attempt: typeof Schema.Number; withTransaction: typeof Schema.Boolean }
+          { name: typeof Schema.String; attempt: typeof Schema.Int; withTransaction: typeof Schema.Boolean }
         >,
         Schema.declare<Workflow.Result<any, any>>
       >
@@ -97,7 +97,7 @@ export const make = Effect.gen(function*() {
       | Rpc.Rpc<"deferred", Schema.Struct<{ name: typeof Schema.String; exit: typeof ExitUnknown }>, typeof ExitUnknown>
       | Rpc.Rpc<
         "activity",
-        Schema.Struct<{ name: typeof Schema.String; attempt: typeof Schema.Number }>,
+        Schema.Struct<{ name: typeof Schema.String; attempt: typeof Schema.Int }>,
         Schema.declare<Workflow.Result<any, any>>
       >
       | Rpc.Rpc<"resume">
@@ -127,6 +127,7 @@ export const make = Effect.gen(function*() {
   }>()
   const interruptedActivities = new Set<string>()
   const activityLatches = new Map<string, Latch.Latch>()
+  const deferredState = WorkflowEngine.makeDeferredState()
   const clients = yield* RcMap.make({
     lookup: Effect.fnUntraced(function*(workflowName: string) {
       const entity = entities.get(workflowName)
@@ -167,12 +168,16 @@ export const make = Effect.gen(function*() {
     readonly payload: unknown
   }) {
     const payload = (options.rpc.payloadSchema as any).make(options.payload)
+    const span = yield* Effect.orDie(Effect.currentSpan)
     const envelope = Envelope.makeRequest<any>({
       requestId: yield* sharding.getSnowflake,
       address: options.address,
       tag: options.rpc._tag as any,
       payload,
-      headers: Headers.empty
+      headers: Headers.empty,
+      traceId: span.traceId,
+      spanId: span.spanId,
+      sampled: span.sampled
     })
     yield* sharding.sendOutgoing(
       new Message.OutgoingRequest({
@@ -382,7 +387,7 @@ export const make = Effect.gen(function*() {
                     )
                   }),
                   Workflow.intoResult,
-                  Effect.provideService(WorkflowEngine.WorkflowInstance, instance)
+                  (effect) => deferredState.trackRun(instance, effect)
                 ) as any
               },
 
@@ -430,13 +435,16 @@ export const make = Effect.gen(function*() {
 
               deferred: Effect.fnUntraced(function*(request: Entity.Request<any>) {
                 const payload = request.payload as any
+                yield* deferredState.deferredDone(executionId, payload.name, payload.exit)
                 yield* ensureSuccess(resume(workflow, executionId))
                 return payload.exit
               }),
 
               resume: () => ensureSuccess(resume(workflow, executionId))
             }
-          })
+          }),
+          // Reserve a slot for deferred completions to wake the active run.
+          { concurrency: 2 }
         ) as Effect.Effect<void, never, Scope.Scope>
       ),
 
@@ -545,24 +553,29 @@ export const make = Effect.gen(function*() {
 
     deferredResult: (deferred) =>
       WorkflowEngine.WorkflowInstance.pipe(
-        Effect.flatMap((instance) =>
-          requestReply({
+        Effect.flatMap((instance) => {
+          const exit = deferredState.pendingResult(instance.executionId, deferred.name)
+          if (exit) {
+            return Effect.succeedSome(exit)
+          }
+          return requestReply({
             workflow: instance.workflow,
             entityType: `Workflow/${instance.workflow._tag}`,
             executionId: instance.executionId,
             tag: "deferred",
             id: deferred.name
-          })
-        ),
-        Effect.map((reply) => {
-          if (Option.isNone(reply)) {
-            return Option.none<Exit.Exit<unknown, unknown>>()
-          }
-          const decoded = decodeDeferredWithExit(reply.value as any)
-          return Option.some(
-            decoded.exit._tag === "Success"
-              ? decoded.exit.value
-              : decoded.exit
+          }).pipe(
+            Effect.map((reply) => {
+              if (Option.isNone(reply)) {
+                return Option.none<Exit.Exit<unknown, unknown>>()
+              }
+              const decoded = decodeDeferredWithExit(reply.value as any)
+              return Option.some(
+                decoded.exit._tag === "Success"
+                  ? decoded.exit.value
+                  : decoded.exit
+              )
+            })
           )
         }),
         Effect.retry({
@@ -614,7 +627,10 @@ export const make = Effect.gen(function*() {
             payload: {
               name: options.clock.name,
               workflowName: workflow._tag,
-              wakeUp: DateTime.addDuration(now, options.clock.duration)
+              wakeUp: DateTime.mapEpochMillis(
+                DateTime.addDuration(now, options.clock.duration),
+                Math.ceil
+              )
             }
           })
         ),
@@ -644,7 +660,7 @@ const ExitUnknown = Schema.Exit(AnyOrVoid, AnyOrVoid, Schema.Any)
 const ActivityRpc = Rpc.make("activity", {
   payload: {
     name: Schema.String,
-    attempt: Schema.Number,
+    attempt: Schema.Int,
     withTransaction: Schema.Boolean.pipe(
       Schema.withDecodingDefault(Effect.succeed(false))
     )