effect 4.0.0-beta.104 → 4.0.0-beta.106

package/src/unstable/http/HttpServerRequest.ts

@@ -436,14 +436,19 @@ export const toClientRequest = (request: HttpServerRequest): HttpClientRequest.H
     Option.getOrElse(toURL(request), () => request.url)
   )
 
-const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody =>
-  hasBody(request.method)
+const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody => {
+  if (!hasBody(request.method)) {
+    return HttpBody.empty
+  }
+  const formData = getFormDataBody(request)
+  return formData === undefined
     ? HttpBody.stream(
       request.stream,
       request.headers["content-type"],
       parseContentLength(request.headers["content-length"])
     )
-    : HttpBody.empty
+    : HttpBody.formData(formData)
+}
 
 const parseContentLength = (contentLength: string | undefined): number | undefined => {
   if (contentLength === undefined) {

package/src/unstable/http/MultipartParser/internal/multipart.ts

@@ -74,7 +74,8 @@ export function make({
     isFile: false,
     fieldChunks: [] as Array<Uint8Array>,
     fieldSize: 0,
-    done: false
+    done: false,
+    stopped: false
   }
 
   function skipBody() {
@@ -88,6 +89,10 @@ export function make({
   const split = Search.make(
     `\r\n--${boundary}`,
     function(index, chunk) {
+      if (state.stopped) {
+        return
+      }
+
       if (index === 0) {
         // data before the first boundary
         skipBody()
@@ -127,12 +132,14 @@ export function make({
 
         state.parts++
         if (state.parts > maxParts) {
-          onError(errMaxParts)
+          state.stopped = true
+          return onError(errMaxParts)
         }
       }
 
       if ((state.partSize += chunk.length) > maxPartSize) {
-        onError(errMaxPartSize)
+        state.stopped = true
+        return onError(errMaxPartSize)
       }
 
       if (state.state === State.headers) {
@@ -199,7 +206,8 @@ export function make({
           } else {
             const buf = chunk.subarray(result.endPosition)
             if ((state.fieldSize += buf.length) > maxFieldSize) {
-              onError(errMaxFieldSize)
+              state.stopped = true
+              return onError(errMaxFieldSize)
             }
             state.fieldChunks.push(buf)
           }
@@ -208,7 +216,8 @@ export function make({
         state.onChunk(chunk)
       } else {
         if ((state.fieldSize += chunk.length) > maxFieldSize) {
-          onError(errMaxFieldSize)
+          state.stopped = true
+          return onError(errMaxFieldSize)
         }
         state.fieldChunks.push(chunk)
       }
@@ -219,6 +228,9 @@ export function make({
 
   return {
     write(chunk: Uint8Array) {
+      if (state.stopped) {
+        return
+      }
       if ((state.totalSize += chunk.length) > maxTotalSize) {
         return onError(errMaxTotalSize)
       }
@@ -226,7 +238,7 @@ export function make({
     },
     end() {
       split.end()
-      if (!state.done) {
+      if (!state.done && !state.stopped) {
         onError(errEndNotReached)
       }
 
@@ -240,6 +252,7 @@ export function make({
       state.fieldChunks = []
       state.fieldSize = 0
       state.done = false
+      state.stopped = false
     }
   } as const
 }

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -1101,10 +1101,10 @@ function toResponseErrorSchema(
     HttpApiSchema.isNoContent(schema.schema.ast)
   )
   const transformation = withHeadersTransformation<HttpApiSchema.withHeaders<unknown, Schema.StringTree>>(
-    (body) =>
-      encodeBody(body).pipe(
+    (body, options) =>
+      encodeBody(body, options).pipe(
         Effect.mapError((error) => error.issue),
-        Effect.flatMap(encodeResponse)
+        Effect.flatMap((body) => encodeResponse(body, options))
       ),
     encodeHeaders
   )
@@ -1167,22 +1167,34 @@ function getResponseTransformation(
   )
 
   return SchemaTransformation.transformOrFail({
-    decode: () => Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" })),
+    decode: (input, options) =>
+      Effect.fail(
+        new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)
+      ),
     encode
   })
 }
 
 function withHeadersTransformation<T = unknown>(
-  encodeBody: (body: unknown) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.Issue, unknown>,
-  encodeHeaders: (headers: unknown) => Effect.Effect<unknown, Schema.SchemaError, unknown>
+  encodeBody: (
+    body: unknown,
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.Issue, unknown>,
+  encodeHeaders: (
+    headers: unknown,
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<unknown, Schema.SchemaError, unknown>
 ): SchemaTransformation.Transformation<T, Response.HttpServerResponse, never, unknown> {
   return SchemaTransformation.transformOrFail<T, Response.HttpServerResponse, never, unknown>({
-    decode: () => Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" })),
-    encode: (value) => {
+    decode: (input, options) =>
+      Effect.fail(
+        new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)
+      ),
+    encode: (value, options) => {
       const pair = value as { readonly body: unknown; readonly headers: unknown }
-      return Effect.flatMap(encodeBody(pair.body), (response) =>
+      return Effect.flatMap(encodeBody(pair.body, options), (response) =>
         Effect.map(
-          encodeHeaders(pair.headers).pipe(Effect.mapError((error) => error.issue)),
+          encodeHeaders(pair.headers, options).pipe(Effect.mapError((error) => error.issue)),
           (headers) => Response.setHeaders(response, headers as any)
         ))
     }
@@ -1193,10 +1205,13 @@ function getResponseEncode<E>(
   status: number,
   encoding: HttpApiSchema.ResponseEncoding,
   isNoContent: boolean
-): (e: E) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.InvalidValue, never> {
+): (
+  e: E,
+  options?: SchemaAST.ParseOptions
+) => Effect.Effect<Response.HttpServerResponse, SchemaIssue.InvalidValue, never> {
   switch (encoding._tag) {
     case "Json": {
-      return ((e) => {
+      return ((e, options) => {
         if (e === undefined || isNoContent) {
           return Effect.succeed(Response.empty({ status }))
         }
@@ -1205,7 +1220,11 @@ function getResponseEncode<E>(
           return Effect.succeed(Response.text(s, { status, contentType: encoding.contentType }))
         } catch {
           return Effect.fail(
-            new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable response body" })
+            new SchemaIssue.InvalidValue(
+              { expected: "a JSON-serializable response body" },
+              e,
+              options
+            )
           )
         }
       })

package/src/unstable/httpapi/HttpApiClient.ts

@@ -1065,41 +1065,59 @@ function getEncodePayloadSchemaFromBody(
   const out = $HttpBody.pipe(Schema.decodeTo(
     schema,
     SchemaTransformation.transformOrFail<unknown, HttpBody.HttpBody>({
-      decode() {
-        return Effect.fail(new SchemaIssue.Forbidden({ message: "Encode only schema" }))
+      decode(input, options) {
+        return Effect.fail(
+          new SchemaIssue.Forbidden({ message: "Encode only schema" }, input, options)
+        )
       },
-      encode(t) {
+      encode(t, options) {
         switch (encoding._tag) {
           case "Multipart":
-            return Effect.fail(new SchemaIssue.Forbidden({ message: "Payload must be a FormData" }))
+            return Effect.fail(
+              new SchemaIssue.Forbidden(
+                { message: "Payload must be a FormData" },
+                t,
+                options
+              )
+            )
           case "Json": {
             try {
               const body = JSON.stringify(t)
               return Effect.succeed(HttpBody.text(body, encoding.contentType))
             } catch {
               return Effect.fail(
-                new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable request body" })
+                new SchemaIssue.InvalidValue(
+                  { expected: "a JSON-serializable request body" },
+                  t,
+                  options
+                )
               )
             }
           }
           case "Text": {
             if (typeof t !== "string") {
               return Effect.fail(
-                new SchemaIssue.InvalidValue({ message: "Expected a string" })
+                new SchemaIssue.InvalidValue({ message: "Expected a string" }, t, options)
               )
             }
             return Effect.succeed(HttpBody.text(t, encoding.contentType))
           }
           case "FormUrlEncoded": {
             if (!Predicate.isObject(t)) {
-              return Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a record" }))
+              return Effect.fail(
+                new SchemaIssue.InvalidValue({ message: "Expected a record" }, t, options)
+              )
             }
             return Effect.succeed(HttpBody.urlParams(UrlParams.fromInput(t as any), encoding.contentType))
           }
           case "Uint8Array": {
             if (!(t instanceof Uint8Array)) {
               return Effect.fail(
-                new SchemaIssue.InvalidValue({ message: "Expected a Uint8Array" })
+                new SchemaIssue.InvalidValue(
+                  { message: "Expected a Uint8Array" },
+                  t,
+                  options
+                )
               )
             }
             return Effect.succeed(HttpBody.uint8Array(t, encoding.contentType))

package/src/unstable/httpapi/OpenApi.ts

@@ -220,7 +220,10 @@ type CompileSchemas = (
 const compileSchemas: CompileSchemas = (asts) =>
   JsonSchema.toMultiDocumentOpenApi3_1(
     InternalToJsonSchemaDocument.toJsonSchemaMultiDocument(
-      InternalToRepresentation.toRepresentations(Arr.map(asts, Schema.toCodecJsonAST))
+      InternalToRepresentation.toRepresentations(
+        Arr.map(asts, Schema.toCodecJsonAST),
+        InternalToJsonSchemaDocument.toRepresentationOptions
+      )
     )
   )
 

package/src/unstable/reactivity/AsyncResult.ts

@@ -1101,7 +1101,7 @@ export const Schema = <
     [success_, Schema_.Cause(error, Schema_.Defect())],
     ([value, cause]) => (input, ast, options) => {
       if (!isAsyncResult(input)) {
-        return Effect.fail(new SchemaIssue.InvalidType(ast))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
       }
       switch (input._tag) {
         case "Initial":
@@ -1111,7 +1111,7 @@ export const Schema = <
             SchemaParser.decodeUnknownEffect(value)(input.value, options),
             {
               onSuccess: (value) => success(value, input),
-              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["value"], issue)])
+              onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "value", issue, input, options)
             }
           )
         case "Failure": {
@@ -1122,9 +1122,14 @@ export const Schema = <
                 {
                   onSuccess: (value) => Option.some(success<A["Type"], E["Type"]>(value, ps)),
                   onFailure: (issue) =>
-                    new SchemaIssue.Composite(ast, [
-                      new SchemaIssue.Pointer(["previousSuccess", "value"], issue)
-                    ])
+                    new SchemaIssue.Composite(
+                      ast,
+                      [
+                        new SchemaIssue.Pointer(["previousSuccess", "value"], issue)
+                      ],
+                      input,
+                      options
+                    )
                 }
               )
             ),
@@ -1132,7 +1137,7 @@ export const Schema = <
           )
           const causeEffect = Effect.mapErrorEager(
             SchemaParser.decodeUnknownEffect(cause)(input.cause, options),
-            (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["cause"], issue)])
+            (issue) => SchemaIssue.makeCompositeAtKey(ast, "cause", issue, input, options)
           )
           return Effect.flatMapEager(
             prevSuccessEffect,

package/src/unstable/reactivity/Atom.ts

@@ -790,7 +790,7 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
 }
 
 /**
- * Factory for `AtomRuntime` values that share a `Layer.MemoMap` and a set of global layers.
+ * Factory for `AtomRuntime` values that share a set of global layers.
  *
  * @category models
  * @since 4.0.0
@@ -801,7 +801,6 @@ export interface RuntimeFactory {
       | Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>
       | ((get: AtomContext) => Layer.Layer<R, E, AtomRegistry | Reactivity.Reactivity>)
   ): AtomRuntime<R, E>
-  readonly memoMap: Layer.MemoMap
   readonly addGlobalLayer: <A, E>(layer: Layer.Layer<A, E, AtomRegistry | Reactivity.Reactivity>) => void
 
   /**
@@ -814,14 +813,40 @@ export interface RuntimeFactory {
 }
 
 /**
- * Creates a `RuntimeFactory` backed by the supplied `Layer.MemoMap`.
+ * A `RuntimeFactory` backed by an atom whose memo map is scoped to each registry.
  *
- * @category constructors
+ * @category models
  * @since 4.0.0
  */
-export const context: (options: {
+export interface RegistryRuntimeFactory extends RuntimeFactory {
+  readonly memoMap: Atom<Layer.MemoMap>
+}
+
+/**
+ * A `RuntimeFactory` backed by a concrete memo map shared across registries.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface SharedRuntimeFactory extends RuntimeFactory {
   readonly memoMap: Layer.MemoMap
-}) => RuntimeFactory = (options) => {
+}
+
+/**
+ * Creates a `RuntimeFactory` backed by a registry-scoped memo map by default,
+ * or by the supplied atom or concrete `Layer.MemoMap`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export function context(): RegistryRuntimeFactory
+export function context(options: { readonly memoMap: Atom<Layer.MemoMap> }): RegistryRuntimeFactory
+export function context(options: { readonly memoMap: Layer.MemoMap }): SharedRuntimeFactory
+export function context(options?: {
+  readonly memoMap: Atom<Layer.MemoMap> | Layer.MemoMap
+}): RegistryRuntimeFactory | SharedRuntimeFactory {
+  const memoMap = options?.memoMap ?? removeTtl(make(() => Layer.makeMemoMapUnsafe()))
+  const resolveMemoMap = (get: AtomContext): Layer.MemoMap => isAtom(memoMap) ? get(memoMap) : memoMap
   let globalLayer: Layer.Layer<any, any, AtomRegistry> = Reactivity.layer
   function factory<E, R>(
     create:
@@ -843,23 +868,25 @@ export const context: (options: {
 
     self.read = function read(get: AtomContext) {
       const layer = get(layerAtom)
-      const build = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, options.memoMap, scope))
+      const build = Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(layer, resolveMemoMap(get), scope))
       return effect(get, build, { uninterruptible: true })
     }
 
     return self
   }
-  factory.memoMap = options.memoMap
+  factory.memoMap = memoMap
   factory.addGlobalLayer = (layer: Layer.Layer<any, any, AtomRegistry | Reactivity.Reactivity>) => {
     globalLayer = Layer.provideMerge(globalLayer, Layer.provide(layer, Reactivity.layer))
   }
-  const reactivityAtom = removeTtl(make(
-    Effect.contextWith((services: Context.Context<Scope.Scope>) =>
-      Layer.buildWithMemoMap(Reactivity.layer, options.memoMap, Context.get(services, Scope.Scope))
-    ).pipe(
-      Effect.map(Context.get(Reactivity.Reactivity))
+  const reactivityAtom = removeTtl(
+    make((get) =>
+      Effect.contextWith((services: Context.Context<Scope.Scope>) =>
+        Layer.buildWithMemoMap(Reactivity.layer, resolveMemoMap(get), Context.get(services, Scope.Scope))
+      ).pipe(
+        Effect.map(Context.get(Reactivity.Reactivity))
+      )
     )
-  ))
+  )
   factory.withReactivity =
     (keys: ReadonlyArray<unknown> | ReadonlyRecord<string, ReadonlyArray<unknown>>) =>
     <A extends Atom<any>>(atom: A): A =>
@@ -871,24 +898,16 @@ export const context: (options: {
         get.subscribe(atom, (value) => get.setSelf(value))
         return get.once(atom)
       }, { initialValueTarget: atom }) as any as A
-  return factory
+  return factory as any
 }
 
 /**
- * Default `Layer.MemoMap` used by the module-level `runtime` factory.
- *
- * @category context
- * @since 4.0.0
- */
-export const defaultMemoMap: Layer.MemoMap = Layer.makeMemoMapUnsafe()
-
-/**
- * Default `RuntimeFactory` created with `defaultMemoMap`.
+ * Default registry-scoped `RuntimeFactory`.
  *
  * @category context
  * @since 4.0.0
  */
-export const runtime: RuntimeFactory = context({ memoMap: defaultMemoMap })
+export const runtime: RegistryRuntimeFactory = context()
 
 /**
  * Returns `Rx.runtime.withReactivity` for refreshing an atom whenever the

package/src/unstable/rpc/RpcClient.ts

@@ -23,6 +23,7 @@ import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Pool from "../../Pool.ts"
+import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
@@ -51,6 +52,8 @@ import * as RpcSerialization from "./RpcSerialization.ts"
 import * as RpcWorker from "./RpcWorker.ts"
 import { withRunClient } from "./Utils.ts"
 
+const isRpcClientError = (u: unknown): u is RpcClientError => Predicate.isTagged(u, "RpcClientError")
+
 /**
  * The object-shaped client generated from a union of RPC definitions, with one
  * method per RPC tag.
@@ -974,7 +977,7 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
             })
           })
         )).pipe(
-          Effect.mapError((cause) => cause instanceof RpcClientError ? cause : httpClientError(cause))
+          Effect.mapError((cause) => isRpcClientError(cause) ? cause : httpClientError(cause))
         )
       if (!hasResponse) {
         return yield* emptyResponseError(request)
@@ -1296,6 +1299,11 @@ export const makeProtocolWorker = (
           undefined
       }).pipe(
         Effect.tapCause((cause) => {
+          for (const [requestId, entry] of entries) {
+            if (entry.worker !== backing) continue
+            entries.delete(requestId)
+            entry.latch.openUnsafe()
+          }
           const error = Cause.findError(cause)
           return broadcast({
             _tag: "ClientProtocolError",

package/src/unstable/rpc/RpcServer.ts

@@ -27,6 +27,7 @@ import * as Pull from "../../Pull.ts"
 import * as Queue from "../../Queue.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
+import * as SchemaIssue from "../../SchemaIssue.ts"
 import * as Scope from "../../Scope.ts"
 import * as Semaphore from "../../Semaphore.ts"
 import { Stdio } from "../../Stdio.ts"
@@ -635,7 +636,7 @@ export const make: <Rpcs extends Rpc.Any>(
       Effect.flatMap((a) => send(client.id, onSuccess(a), collector && collector.clearUnsafe())),
       Effect.catchCause((cause) => {
         client.schemas.delete(requestId)
-        const defect = Cause.squash(Cause.map(cause, (e) => e.issue.toString()))
+        const defect = Cause.squash(Cause.map(cause, (e) => SchemaIssue.defaultFormatter(e.issue)))
         return Effect.andThen(
           sendRequestDefect(client, requestId, encodeDefect, defect),
           server.write(client.id, { _tag: "Interrupt", requestId, interruptors: [] })
@@ -708,7 +709,8 @@ export const make: <Rpcs extends Rpc.Any>(
         return Effect.matchEffect(
           Effect.provideContext(schemas.decode(request.payload), schemas.context),
           {
-            onFailure: (error) => sendRequestDefect(client, requestId, schemas.encodeDefect, error.issue.toString()),
+            onFailure: (error) =>
+              sendRequestDefect(client, requestId, schemas.encodeDefect, SchemaIssue.defaultFormatter(error.issue)),
             onSuccess: (payload) => {
               client.schemas.set(
                 requestId,

package/src/unstable/sql/SqlResolver.ts

@@ -134,7 +134,8 @@ export const ordered = <Req extends Schema.Constraint, Res extends Schema.Constr
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, encodedEntries] = yield* partitionRequests(entries, options.Request)
-      const results = yield* options.execute(inputs as any).pipe(
+      if (!Arr.isArrayNonEmpty(inputs)) return
+      const results = yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       if (results.length !== inputs.length) {
@@ -190,8 +191,9 @@ export const grouped = <Req extends Schema.Constraint, Res extends Schema.Constr
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs] = yield* partitionRequests(entries, options.Request)
+      if (!Arr.isArrayNonEmpty(inputs)) return
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
-      const results = yield* options.execute(inputs as any).pipe(
+      const results = yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
@@ -258,7 +260,8 @@ export const findById = <Id extends Schema.Constraint, Res extends Schema.Constr
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
-      const results = yield* options.execute(inputs as any).pipe(
+      if (!Arr.isArrayNonEmpty(inputs)) return
+      const results = yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
@@ -311,7 +314,8 @@ const void_ = <Req extends Schema.Constraint, _, E, R>(
     key: transactionKey,
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs] = yield* partitionRequests(entries, options.Request)
-      yield* options.execute(inputs as any).pipe(
+      if (!Arr.isArrayNonEmpty(inputs)) return
+      yield* options.execute(inputs).pipe(
         Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
@@ -366,35 +370,39 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
   const len = requests.length
   const inputs = Arr.empty<InE>()
   const byIdMap = MutableHashMap.empty<In, Request.Entry<SqlRequest<In, A, E, R>>>()
-  let entry!: Request.Entry<SqlRequest<In, A, E, R>>
-  const encode = Schema.encodeEffect(schema)
-  const handle = Effect.matchCauseEager({
-    onFailure(cause: Cause.Cause<Schema.SchemaError>) {
-      entry.completeUnsafe(Exit.failCause(cause))
-    },
-    onSuccess(value: InE) {
-      inputs.push(value)
-    }
-  })
 
   for (let i = 0; i < len; i++) {
-    entry = requests[i]
+    const entry = requests[i]
     const existing = MutableHashMap.get(byIdMap, entry.request.payload)
     if (Option.isSome(existing)) {
-      const duplicate = entry
+      const previous = existing.value
       MutableHashMap.set(byIdMap, entry.request.payload, {
-        ...existing.value,
+        ...previous,
         completeUnsafe(exit) {
-          existing.value.completeUnsafe(exit)
-          duplicate.completeUnsafe(exit)
+          previous.completeUnsafe(exit)
+          entry.completeUnsafe(exit)
         }
       })
     } else {
-      yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
       MutableHashMap.set(byIdMap, entry.request.payload, entry)
     }
   }
 
+  const encode = Schema.encodeEffect(schema)
+  for (const [, entry] of byIdMap) {
+    yield* Effect.provideContext(
+      Effect.matchCauseEager(encode(entry.request.payload), {
+        onFailure(cause) {
+          entry.completeUnsafe(Exit.failCause(cause))
+        },
+        onSuccess(value) {
+          inputs.push(value)
+        }
+      }),
+      entry.context
+    )
+  }
+
   return [inputs, byIdMap] as const
 }
 

package/src/unstable/workers/Worker.ts

@@ -165,6 +165,17 @@ export const makePlatform = <W>() =>
         const spawn = (yield* Spawner) as SpawnerFn<W>
         let currentPort: P | undefined
         const buffer: Array<[unknown, ReadonlyArray<unknown> | undefined]> = []
+        const sendToPort = (port: P, message: unknown, transfers?: ReadonlyArray<unknown>) =>
+          Effect.try({
+            try: () => port.postMessage([0, message], transfers as any),
+            catch: (cause) =>
+              new WorkerError({
+                reason: new WorkerSendError({
+                  message: "Failed to send message to worker",
+                  cause
+                })
+              })
+          })
 
         const run = <A, E, R>(
           handler: (_: O) => Effect.Effect<A, E, R>,
@@ -209,7 +220,7 @@ export const makePlatform = <W>() =>
                 currentPort = port
                 if (buffer.length > 0) {
                   for (const [message, transfers] of buffer) {
-                    port.postMessage([0, message], transfers as any)
+                    yield* sendToPort(port, message, transfers)
                   }
                   buffer.length = 0
                 }
@@ -224,19 +235,7 @@ export const makePlatform = <W>() =>
               buffer.push([message, transfers])
               return Effect.void
             }
-            try {
-              currentPort.postMessage([0, message], transfers as any)
-              return Effect.void
-            } catch (cause) {
-              return Effect.fail(
-                new WorkerError({
-                  reason: new WorkerSendError({
-                    message: "Failed to send message to worker",
-                    cause
-                  })
-                })
-              )
-            }
+            return sendToPort(currentPort, message, transfers)
           })
 
         return { run, send }

package/src/unstable/workflow/Workflow.ts

@@ -557,16 +557,13 @@ export class Complete<A, E> extends Data.TaggedClass("Complete")<{
       [Schema.Exit(options.success, options.error, Schema.Defect())],
       ([exit]) => (input, ast, options) => {
         if (!(isResult(input) && input._tag === "Complete")) {
-          return Effect.fail(new SchemaIssue.InvalidType(ast))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
         }
         return Effect.mapBothEager(
           SchemaParser.decodeEffect(exit)(input.exit, options),
           {
             onSuccess: (exit) => new Complete({ exit }),
-            onFailure: (issue) =>
-              new SchemaIssue.Composite(ast, [
-                new SchemaIssue.Pointer(["exit"], issue)
-              ])
+            onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "exit", issue, input, options)
           }
         )
       },