effect 4.0.0-rc.118 → 4.0.1

package/src/testing/TestSchema.ts

@@ -7,14 +7,22 @@
  * `Decoding` and `Encoding` can be used directly when a test only needs one
  * direction.
  *
+ * Methods with an `Effect` suffix return lazy assertions that use the calling
+ * fiber's services. The Promise-returning methods can be used with any test
+ * runner.
+ *
+ * @stability unstable
  * @since 4.0.0
  */
 import * as assert from "node:assert"
 import { isDeepStrictEqual } from "node:util"
 import * as Arbitrary from "../Arbitrary.ts"
+import * as Cause from "../Cause.ts"
 import type * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
+import * as Exit from "../Exit.ts"
 import { pipe } from "../Function.ts"
+import * as InternalSchemaCause from "../internal/schema/cause.ts"
 import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
 import * as SchemaAST from "../SchemaAST.ts"
@@ -26,6 +34,32 @@ function assertPropertyPassed<A, E>(result: Arbitrary.CheckResult<A, E>): void {
   if (failure !== undefined) assert.fail(failure)
 }
 
+const schemaResult = Effect.fnUntraced(function*<A, R>(
+  effect: Effect.Effect<A, SchemaIssue.Issue, R>
+): Effect.fn.Return<Result.Result<A, string>, never, R> {
+  const exit = yield* Effect.exit(effect)
+  if (Exit.isSuccess(exit)) {
+    return Result.succeed(exit.value)
+  }
+  const issue = InternalSchemaCause.getSchemaIssue(exit.cause)
+  if (issue !== undefined) {
+    return Result.fail(SchemaIssue.defaultFormatter(issue))
+  }
+  return yield* Effect.failCause(Cause.fromReasons<never>(exit.cause.reasons.map((reason) =>
+    Cause.isFailReason(reason)
+      ? Cause.makeDieReason(reason.error).annotate(Cause.reasonAnnotations(reason))
+      : reason
+  )))
+})
+
+const assertResult = Effect.fnUntraced(function*<A, R>(
+  parse: () => Effect.Effect<A, SchemaIssue.Issue, R>,
+  expected: Result.Result<A, string>
+) {
+  const result = yield* schemaResult(parse())
+  assert.deepStrictEqual(result, expected)
+})
+
 /**
  * Provides schema test assertions for decoding, encoding, make, arbitrary generation, and round-trip verification.
  *
@@ -51,6 +85,7 @@ function assertPropertyPassed<A, E>(result: Arbitrary.CheckResult<A, E>): void {
  *
  * @see {@link Decoding}
  * @see {@link Encoding}
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
@@ -77,9 +112,21 @@ export class Asserts<S extends Schema.Constraint> {
    * const fieldsB = { name: Schema.String }
    * TestSchema.Asserts.ast.fields.equals(fieldsA, fieldsB) // => undefined
    * ```
+   *
+   * @stability unstable
    */
   static ast = {
+    /**
+     * Groups schema field comparisons.
+     *
+     * @stability unstable
+     */
     fields: {
+      /**
+       * Asserts that schema fields have equal AST structures.
+       *
+       * @stability unstable
+       */
       equals: (a: Schema.Struct.Fields, b: Schema.Struct.Fields) => {
         assert.deepStrictEqual(
           Object.fromEntries(Reflect.ownKeys(a).map((key) => [key, SchemaAST.getAST(a[key])])),
@@ -87,19 +134,39 @@ export class Asserts<S extends Schema.Constraint> {
         )
       }
     },
+    /**
+     * Groups tuple element comparisons.
+     *
+     * @stability unstable
+     */
     elements: {
+      /**
+       * Asserts that tuple elements have equal AST structures.
+       *
+       * @stability unstable
+       */
       equals: (a: Schema.Tuple.Elements, b: Schema.Tuple.Elements) => {
         assert.deepStrictEqual(a.map(SchemaAST.getAST), b.map(SchemaAST.getAST))
       }
     }
   } as const
 
+  /**
+   * Schema used by these assertions.
+   *
+   * @stability unstable
+   */
   readonly schema: S
+  /**
+   * Creates assertions for a schema.
+   *
+   * @stability unstable
+   */
   constructor(schema: S) {
     this.schema = schema
   }
   /**
-   * Returns an object with `succeed` and `fail` helpers for testing the schema's `make` operation.
+   * Returns Promise and Effect assertions for the schema's `make` operation.
    *
    * **When to use**
    *
@@ -109,6 +176,8 @@ export class Asserts<S extends Schema.Constraint> {
    * **Details**
    *
    * `succeed(input)` asserts make returns the input unchanged. `succeed(input, expected)` asserts make returns `expected`. `fail(input, message)` asserts make fails with `message`.
+   * `succeedEffect` and `failEffect` return lazy effects with the same assertions.
+   * Assertion mismatches are defects in the returned effects.
    *
    * **Example** (Testing make)
    *
@@ -123,31 +192,52 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * @see {@link decoding} for assertions against decoded input
    * @see {@link encoding} for assertions against encoded output
+   * @stability unstable
    */
   make(options?: Schema.MakeOptions) {
     const makeEffect = SchemaParser.makeEffect(this.schema)
+    function succeedEffect(input: S["Type"]): Effect.Effect<void>
+    function succeedEffect(input: S["~type.make.in"], expected: S["Type"]): Effect.Effect<void>
+    function succeedEffect(input: S["~type.make.in"], expected?: S["Type"]): Effect.Effect<void> {
+      return assertResult(
+        () => makeEffect(input, options),
+        Result.succeed(arguments.length === 1 ? input : expected)
+      )
+    }
     async function succeed(input: S["Type"]): Promise<void>
     async function succeed(input: S["~type.make.in"], expected: S["Type"]): Promise<void>
     async function succeed(input: S["~type.make.in"], expected?: S["Type"]) {
-      const r = await Effect.runPromise(
-        makeEffect(input, options).pipe(
-          Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-          Effect.result
-        )
-      )
-      expected = arguments.length === 1 ? input : expected
-      assert.deepStrictEqual(r, Result.succeed(expected))
+      return Effect.runPromise(succeedEffect(input, arguments.length === 1 ? input : expected))
+    }
+    function failEffect(input: unknown, message: string): Effect.Effect<void> {
+      return assertResult(() => makeEffect(input, options), Result.fail(message))
     }
     return {
+      /**
+       * Asserts that construction succeeds with the input or the explicit expected value.
+       *
+       * @stability unstable
+       */
       succeed,
+      /**
+       * Returns a lazy construction success assertion whose mismatches are defects.
+       *
+       * @stability unstable
+       */
+      succeedEffect,
+      /**
+       * Returns a lazy assertion that construction fails with the expected issue message.
+       *
+       * @stability unstable
+       */
+      failEffect,
+      /**
+       * Asserts that construction fails with the expected issue message.
+       *
+       * @stability unstable
+       */
       async fail(input: unknown, message: string) {
-        const r = await Effect.runPromise(
-          makeEffect(input, options).pipe(
-            Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-            Effect.result
-          )
-        )
-        assert.deepStrictEqual(r, Result.fail(message))
+        return Effect.runPromise(failEffect(input, message))
       }
     }
   }
@@ -171,29 +261,67 @@ export class Asserts<S extends Schema.Constraint> {
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.String)
-   * await asserts.verifyLosslessTransformation({ seed: 1, runs: 20 }) // => undefined
+   * await asserts.verifyRoundTrip({ seed: 1, runs: 20 }) // => undefined
    * ```
    *
    * @see {@link arbitrary} for checking that generated values satisfy the schema
+   * @see {@link verifyRoundTripEffect} for the Effect variant
+   * @stability unstable
    */
-  verifyLosslessTransformation<S extends Schema.ConstraintCodec<unknown, unknown>>(
+  verifyRoundTrip<S extends Schema.ConstraintCodec<unknown, unknown>>(
     this: Asserts<S>,
     options?: Arbitrary.CheckOptions
   ): Promise<void> {
-    const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
-    const encodeEffect = SchemaParser.encodeEffect(this.schema)
-    const arbitrary = Arbitrary.schema(this.schema)
-    return Effect.runPromise(Arbitrary.checkEffect(
-      arbitrary,
-      (value) =>
-        encodeEffect(value).pipe(
-          Effect.flatMapEager((encoded) => decodeUnknownEffect(encoded)),
-          Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-          Effect.result,
-          Effect.mapEager((result) => isDeepStrictEqual(result, Result.succeed(value)))
-        ),
-      options
-    )).then(assertPropertyPassed)
+    return Effect.runPromise(this.verifyRoundTripEffect(options))
+  }
+  /**
+   * Returns a lazy property-based assertion that generated values survive an
+   * encode-then-decode round trip.
+   *
+   * **When to use**
+   *
+   * Use to check round trips with the calling fiber's decoding and encoding services.
+   *
+   * **Details**
+   *
+   * Assertion mismatches are defects containing the shrunk input and replay token.
+   * Schema defects and interruption propagate without becoming assertion failures.
+   *
+   * **Example** (Composing round-trip assertions)
+   *
+   * ```ts import.meta.vitest
+   * import { Effect, Schema } from "effect"
+   * import { TestSchema } from "effect/testing"
+   *
+   * const asserts = new TestSchema.Asserts(Schema.NumberFromString)
+   * const test = Effect.gen(function*() {
+   *   yield* asserts.decoding().succeedEffect("42", 42)
+   *   yield* asserts.verifyRoundTripEffect({ seed: 1, runs: 20 })
+   * })
+   * await Effect.runPromise(test) // => undefined
+   * ```
+   *
+   * @see {@link verifyRoundTrip} for the Promise variant
+   * @stability unstable
+   */
+  verifyRoundTripEffect(
+    options?: Arbitrary.CheckOptions
+  ): Effect.Effect<void, never, S["DecodingServices"] | S["EncodingServices"]> {
+    return Effect.suspend(() => {
+      const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
+      const encodeEffect = SchemaParser.encodeEffect(this.schema)
+      const arbitrary = Arbitrary.schema(this.schema)
+      return Arbitrary.checkEffect(
+        arbitrary,
+        (value) =>
+          Effect.suspend(() => encodeEffect(value)).pipe(
+            Effect.flatMapEager((encoded) => decodeUnknownEffect(encoded)),
+            schemaResult,
+            Effect.mapEager((result) => isDeepStrictEqual(result, Result.succeed(value)))
+          ),
+        options
+      ).pipe(Effect.mapEager(assertPropertyPassed))
+    })
   }
   /**
    * Returns a {@link Decoding} instance for this schema with helpers for decoding assertions.
@@ -220,6 +348,7 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * @see {@link Decoding}
    * @see {@link encoding} for assertions in the opposite direction
+   * @stability unstable
    */
   decoding(options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
@@ -250,6 +379,7 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * @see {@link Encoding}
    * @see {@link decoding} for assertions in the opposite direction
+   * @stability unstable
    */
   encoding(options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
@@ -279,11 +409,17 @@ export class Asserts<S extends Schema.Constraint> {
    * asserts.arbitrary().verifyGeneration({ seed: 1, runs: 20 }) // => undefined
    * ```
    *
-   * @see {@link verifyLosslessTransformation} for property-based round-trip checks
+   * @see {@link verifyRoundTrip} for property-based round-trip checks
+   * @stability unstable
    */
   arbitrary<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>) {
     const schema = this.schema
     return {
+      /**
+       * Asserts that generated values satisfy the schema's predicate.
+       *
+       * @stability unstable
+       */
       verifyGeneration(options?: Arbitrary.CheckOptions): void {
         const is = Schema.is(schema)
         const arbitrary = Arbitrary.schema(schema)
@@ -302,7 +438,12 @@ export class Asserts<S extends Schema.Constraint> {
  *
  * **Details**
  *
- * All assertions are async and use `assert.deepStrictEqual` internally. `succeed(input)` asserts the decoded output equals `input`; `succeed(input, expected)` asserts it equals `expected`; `fail(input, message)` asserts decoding fails and the stringified issue equals `message`. `provide(key, impl)` returns a new `Decoding` with the service injected into the decoding context.
+ * `succeed` and `fail` return Promises. `succeedEffect` and `failEffect` return lazy
+ * effects that preserve required decoding services. All assertions use
+ * `assert.deepStrictEqual` internally. With one argument, success assertions
+ * compare the output to the input; with two, they compare it to `expected`.
+ * Failure assertions compare the formatted schema issue to `message`.
+ * `provide(key, impl)` returns a new `Decoding` with the service injected.
  *
  * **Example** (Decoding with service provision)
  *
@@ -317,18 +458,39 @@ export class Asserts<S extends Schema.Constraint> {
  *
  * @see {@link Asserts}
  * @see {@link Encoding}
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
 export class Decoding<S extends Schema.Constraint> {
+  /**
+   * Schema used by these decoding assertions.
+   *
+   * @stability unstable
+   */
   readonly schema: S
+  /**
+   * Decoder used by these assertions, preserving schema issues and required services.
+   *
+   * @stability unstable
+   */
   readonly decodeUnknownEffect: (
     input: unknown,
     options?: SchemaAST.ParseOptions
   ) => Effect.Effect<S["Type"], SchemaIssue.Issue, S["DecodingServices"]>
+  /**
+   * Parsing options used by these assertions.
+   *
+   * @stability unstable
+   */
   readonly options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
   } | undefined
+  /**
+   * Creates decoding assertions for a schema and optional parsing options.
+   *
+   * @stability unstable
+   */
   constructor(schema: S, options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }) {
@@ -355,7 +517,9 @@ export class Decoding<S extends Schema.Constraint> {
    * await decoding.succeed("1", 1) // => undefined
    * ```
    *
+   * @see {@link succeedEffect} for the Effect variant
    * @see {@link fail} for asserting decoding failures
+   * @stability unstable
    */
   async succeed<S extends Schema.ConstraintDecoder<unknown, never>>(
     this: Decoding<S>,
@@ -371,14 +535,31 @@ export class Decoding<S extends Schema.Constraint> {
     input: unknown,
     expected?: S["Type"]
   ) {
-    const r = await Effect.runPromise(
-      this.decodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-        Effect.result
-      )
+    return Effect.runPromise(this.succeedEffect(input, arguments.length === 1 ? input : expected))
+  }
+  /**
+   * Returns a lazy assertion that decoding succeeds with the input or the
+   * explicit expected value.
+   *
+   * **When to use**
+   *
+   * Use to assert decoding in an Effect test while preserving required decoding services.
+   *
+   * **Details**
+   *
+   * Assertion mismatches are defects. The decoder uses the calling fiber's services.
+   *
+   * @see {@link succeed} for the Promise variant
+   * @see {@link failEffect} for asserting decoding failures
+   * @stability unstable
+   */
+  succeedEffect(input: unknown): Effect.Effect<void, never, S["DecodingServices"]>
+  succeedEffect(input: unknown, expected: S["Type"]): Effect.Effect<void, never, S["DecodingServices"]>
+  succeedEffect(input: unknown, expected?: S["Type"]): Effect.Effect<void, never, S["DecodingServices"]> {
+    return assertResult(
+      () => this.decodeUnknownEffect(input, this.options?.parseOptions),
+      Result.succeed(arguments.length === 1 ? input : expected)
     )
-    expected = arguments.length === 1 ? input : expected
-    assert.deepStrictEqual(r, Result.succeed(expected))
   }
   /**
    * Asserts that decoding `input` fails and the stringified issue equals
@@ -398,20 +579,32 @@ export class Decoding<S extends Schema.Constraint> {
    * await decoding.fail(42, "Expected string") // => undefined
    * ```
    *
+   * @see {@link failEffect} for the Effect variant
    * @see {@link succeed} for asserting successful decoding
+   * @stability unstable
    */
   async fail<S extends Schema.ConstraintDecoder<unknown, never>>(
     this: Decoding<S>,
     input: unknown,
     message: string
   ) {
-    const r = await Effect.runPromise(
-      this.decodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-        Effect.result
-      )
-    )
-    assert.deepStrictEqual(r, Result.fail(message))
+    return Effect.runPromise(this.failEffect(input, message))
+  }
+  /**
+   * Returns a lazy assertion that decoding fails with the expected issue message.
+   *
+   * **Details**
+   *
+   * Assertion mismatches are defects. Schema defects and interruption propagate
+   * without satisfying the assertion. Required decoding services come from the
+   * calling fiber.
+   *
+   * @see {@link fail} for the Promise variant
+   * @see {@link succeedEffect} for asserting decoding success
+   * @stability unstable
+   */
+  failEffect(input: unknown, message: string): Effect.Effect<void, never, S["DecodingServices"]> {
+    return assertResult(() => this.decodeUnknownEffect(input, this.options?.parseOptions), Result.fail(message))
   }
   /**
    * Returns a new {@link Decoding} instance with the given service injected into the decoding effect context.
@@ -421,6 +614,7 @@ export class Decoding<S extends Schema.Constraint> {
    * Use when the schema's decoder requires a service dependency.
    *
    * @see {@link Encoding.provide}
+   * @stability unstable
    */
   provide<Id, Service>(
     service: Context.Key<Id, Service>,
@@ -442,7 +636,12 @@ export class Decoding<S extends Schema.Constraint> {
  *
  * **Details**
  *
- * All assertions are async and use `assert.deepStrictEqual` internally. `succeed(input)` asserts the encoded output equals `input`; `succeed(input, expected)` asserts it equals `expected`; `fail(input, message)` asserts encoding fails and the stringified issue equals `message`. `provide(key, impl)` returns a new `Encoding` with the service injected into the encoding context.
+ * `succeed` and `fail` return Promises. `succeedEffect` and `failEffect` return lazy
+ * effects that preserve required encoding services. All assertions use
+ * `assert.deepStrictEqual` internally. With one argument, success assertions
+ * compare the output to the input; with two, they compare it to `expected`.
+ * Failure assertions compare the formatted schema issue to `message`.
+ * `provide(key, impl)` returns a new `Encoding` with the service injected.
  *
  * **Example** (Encoding assertions)
  *
@@ -457,18 +656,39 @@ export class Decoding<S extends Schema.Constraint> {
  * @see {@link Asserts}
  * @see {@link Decoding}
  *
+ * @stability unstable
  * @category testing
  * @since 4.0.0
  */
 export class Encoding<S extends Schema.Constraint> {
+  /**
+   * Schema used by these encoding assertions.
+   *
+   * @stability unstable
+   */
   readonly schema: S
+  /**
+   * Encoder used by these assertions, preserving schema issues and required services.
+   *
+   * @stability unstable
+   */
   readonly encodeUnknownEffect: (
     input: unknown,
     options?: SchemaAST.ParseOptions
   ) => Effect.Effect<S["Encoded"], SchemaIssue.Issue, S["EncodingServices"]>
+  /**
+   * Parsing options used by these assertions.
+   *
+   * @stability unstable
+   */
   readonly options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
   } | undefined
+  /**
+   * Creates encoding assertions for a schema and optional parsing options.
+   *
+   * @stability unstable
+   */
   constructor(schema: S, options?: {
     readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }) {
@@ -495,7 +715,9 @@ export class Encoding<S extends Schema.Constraint> {
    * await encoding.succeed(1, "1") // => undefined
    * ```
    *
+   * @see {@link succeedEffect} for the Effect variant
    * @see {@link fail} for asserting encoding failures
+   * @stability unstable
    */
   async succeed<S extends Schema.ConstraintEncoder<unknown, never>>(
     this: Encoding<S>,
@@ -511,14 +733,31 @@ export class Encoding<S extends Schema.Constraint> {
     input: unknown,
     expected?: S["Encoded"]
   ) {
-    const r = await Effect.runPromise(
-      this.encodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-        Effect.result
-      )
+    return Effect.runPromise(this.succeedEffect(input, arguments.length === 1 ? input : expected))
+  }
+  /**
+   * Returns a lazy assertion that encoding succeeds with the input or the
+   * explicit expected value.
+   *
+   * **When to use**
+   *
+   * Use to assert encoding in an Effect test while preserving required encoding services.
+   *
+   * **Details**
+   *
+   * Assertion mismatches are defects. The encoder uses the calling fiber's services.
+   *
+   * @see {@link succeed} for the Promise variant
+   * @see {@link failEffect} for asserting encoding failures
+   * @stability unstable
+   */
+  succeedEffect(input: unknown): Effect.Effect<void, never, S["EncodingServices"]>
+  succeedEffect(input: unknown, expected: S["Encoded"]): Effect.Effect<void, never, S["EncodingServices"]>
+  succeedEffect(input: unknown, expected?: S["Encoded"]): Effect.Effect<void, never, S["EncodingServices"]> {
+    return assertResult(
+      () => this.encodeUnknownEffect(input, this.options?.parseOptions),
+      Result.succeed(arguments.length === 1 ? input : expected)
     )
-    expected = arguments.length === 1 ? input : expected
-    assert.deepStrictEqual(r, Result.succeed(expected))
   }
   /**
    * Asserts that encoding `input` fails and the stringified issue equals
@@ -538,20 +777,32 @@ export class Encoding<S extends Schema.Constraint> {
    * await encoding.fail("not-a-number", "Expected number") // => undefined
    * ```
    *
+   * @see {@link failEffect} for the Effect variant
    * @see {@link succeed} for asserting successful encoding
+   * @stability unstable
    */
   async fail<S extends Schema.ConstraintEncoder<unknown, never>>(
     this: Encoding<S>,
     input: unknown,
     message: string
   ) {
-    const r = await Effect.runPromise(
-      this.encodeUnknownEffect(input, this.options?.parseOptions).pipe(
-        Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-        Effect.result
-      )
-    )
-    assert.deepStrictEqual(r, Result.fail(message))
+    return Effect.runPromise(this.failEffect(input, message))
+  }
+  /**
+   * Returns a lazy assertion that encoding fails with the expected issue message.
+   *
+   * **Details**
+   *
+   * Assertion mismatches are defects. Schema defects and interruption propagate
+   * without satisfying the assertion. Required encoding services come from the
+   * calling fiber.
+   *
+   * @see {@link fail} for the Promise variant
+   * @see {@link succeedEffect} for asserting encoding success
+   * @stability unstable
+   */
+  failEffect(input: unknown, message: string): Effect.Effect<void, never, S["EncodingServices"]> {
+    return assertResult(() => this.encodeUnknownEffect(input, this.options?.parseOptions), Result.fail(message))
   }
   /**
    * Returns a new {@link Encoding} instance with the given service injected into the encoding effect context.
@@ -561,6 +812,7 @@ export class Encoding<S extends Schema.Constraint> {
    * Use when the schema's encoder requires a service dependency.
    *
    * @see {@link Decoding.provide}
+   * @stability unstable
    */
   provide<Id, Service>(
     service: Context.Key<Id, Service>,

package/src/testing/index.ts

@@ -15,6 +15,7 @@ export * as TestClock from "./TestClock.ts"
 export * as TestConsole from "./TestConsole.ts"
 
 /**
+ * @stability unstable
  * @since 4.0.0
  */
 export * as TestSchema from "./TestSchema.ts"

package/src/workflow/DurableDeferred.ts

@@ -253,7 +253,7 @@ export const into: {
           Effect.provideService(effect, InstanceTag, instance),
           Effect.fnUntraced(function*(exit) {
             if (Exit.isFailure(exit)) {
-              const [reasons, interrupts] = Arr.partition(
+              const [interrupts, reasons] = Arr.partition(
                 exit.cause.reasons,
                 Filter.fromPredicate(Cause.isInterruptReason)
               )

package/src/workflow/Workflow.ts

@@ -711,7 +711,7 @@ export const intoResult = <A, E, R>(
       Effect.matchCauseEffect({
         onSuccess: (value) => Effect.succeed(new Complete({ exit: Exit.succeed(value) })),
         onFailure: (cause): Effect.Effect<Result<A, E>> => {
-          const [reasons, interrupts] = Arr.partition(
+          const [interrupts, reasons] = Arr.partition(
             cause.reasons,
             Filter.fromPredicate(Cause.isInterruptReason)
           )

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()