effect 4.0.0-beta.31 → 4.0.0-beta.33

package/src/unstable/httpapi/HttpApiError.ts

@@ -1,12 +1,28 @@
 /**
  * @since 4.0.0
  */
+import * as Effect from "../../Effect.ts"
 import * as ErrorReporter from "../../ErrorReporter.ts"
 import { identity } from "../../Function.ts"
 import * as Schema from "../../Schema.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
+import * as HttpServerRespondable from "../http/HttpServerRespondable.ts"
+import * as HttpServerResponse from "../http/HttpServerResponse.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
 
+const badRequestResponse = HttpServerResponse.empty({ status: 400 })
+const unauthorizedResponse = HttpServerResponse.empty({ status: 401 })
+const forbiddenResponse = HttpServerResponse.empty({ status: 403 })
+const notFoundResponse = HttpServerResponse.empty({ status: 404 })
+const methodNotAllowedResponse = HttpServerResponse.empty({ status: 405 })
+const notAcceptableResponse = HttpServerResponse.empty({ status: 406 })
+const requestTimeoutResponse = HttpServerResponse.empty({ status: 408 })
+const conflictResponse = HttpServerResponse.empty({ status: 409 })
+const goneResponse = HttpServerResponse.empty({ status: 410 })
+const internalServerErrorResponse = HttpServerResponse.empty({ status: 500 })
+const notImplementedResponse = HttpServerResponse.empty({ status: 501 })
+const serviceUnavailableResponse = HttpServerResponse.empty({ status: 503 })
+
 /**
  * @category Built-in errors
  * @since 4.0.0
@@ -17,7 +33,10 @@ export class BadRequest extends Schema.ErrorClass<BadRequest>("effect/HttpApiErr
   description: "BadRequest",
   httpApiStatus: 400
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(badRequestResponse)
+  }
   static readonly singleton = new BadRequest()
 }
 
@@ -59,7 +78,10 @@ export class Unauthorized extends Schema.ErrorClass<Unauthorized>("effect/HttpAp
   description: "Unauthorized",
   httpApiStatus: 401
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(unauthorizedResponse)
+  }
 }
 
 /**
@@ -80,7 +102,10 @@ export class Forbidden extends Schema.ErrorClass<Forbidden>("effect/HttpApiError
   description: "Forbidden",
   httpApiStatus: 403
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(forbiddenResponse)
+  }
 }
 
 /**
@@ -101,7 +126,10 @@ export class NotFound extends Schema.ErrorClass<NotFound>("effect/HttpApiError/N
   description: "NotFound",
   httpApiStatus: 404
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notFoundResponse)
+  }
 }
 
 /**
@@ -122,7 +150,10 @@ export class MethodNotAllowed extends Schema.ErrorClass<MethodNotAllowed>("effec
   description: "MethodNotAllowed",
   httpApiStatus: 405
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(methodNotAllowedResponse)
+  }
 }
 
 /**
@@ -143,7 +174,10 @@ export class NotAcceptable extends Schema.ErrorClass<NotAcceptable>("effect/Http
   description: "NotAcceptable",
   httpApiStatus: 406
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notAcceptableResponse)
+  }
 }
 
 /**
@@ -164,7 +198,10 @@ export class RequestTimeout extends Schema.ErrorClass<RequestTimeout>("effect/Ht
   description: "RequestTimeout",
   httpApiStatus: 408
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(requestTimeoutResponse)
+  }
 }
 
 /**
@@ -185,7 +222,10 @@ export class Conflict extends Schema.ErrorClass<Conflict>("effect/HttpApiError/C
   description: "Conflict",
   httpApiStatus: 409
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(conflictResponse)
+  }
 }
 
 /**
@@ -206,7 +246,10 @@ export class Gone extends Schema.ErrorClass<Gone>("effect/HttpApiError/Gone")({
   description: "Gone",
   httpApiStatus: 410
 }) {
-  override readonly [ErrorReporter.ignore] = true
+  override readonly [ErrorReporter.ignore] = true;
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(goneResponse)
+  }
 }
 
 /**
@@ -228,7 +271,11 @@ export class InternalServerError
     description: "InternalServerError",
     httpApiStatus: 500
   })
-{}
+{
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(internalServerErrorResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -247,7 +294,11 @@ export class NotImplemented extends Schema.ErrorClass<NotImplemented>("effect/Ht
 }, {
   description: "NotImplemented",
   httpApiStatus: 501
-}) {}
+}) {
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(notImplementedResponse)
+  }
+}
 
 /**
  * @category NoContent errors
@@ -268,7 +319,11 @@ export class ServiceUnavailable
     description: "ServiceUnavailable",
     httpApiStatus: 503
   })
-{}
+{
+  [HttpServerRespondable.symbol]() {
+    return Effect.succeed(serviceUnavailableResponse)
+  }
+}
 
 /**
  * @category NoContent errors

package/src/unstable/observability/OtlpExporter.ts

@@ -6,10 +6,10 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Fiber from "../../Fiber.ts"
 import * as Num from "../../Number.ts"
+import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as Headers from "../../unstable/http/Headers.ts"
 import * as HttpClient from "../../unstable/http/HttpClient.ts"
 import * as HttpClientError from "../../unstable/http/HttpClientError.ts"
@@ -24,7 +24,10 @@ const policy = Schedule.forever.pipe(
       && error.reason._tag === "StatusCodeError"
       && error.reason.response.status === 429
     ) {
-      const retryAfter = UndefinedOr.map(error.reason.response.headers["retry-after"], Num.parse) ?? 5
+      const retryAfter = Option.fromUndefinedOr(error.reason.response.headers["retry-after"]).pipe(
+        Option.flatMap(Num.parse),
+        Option.getOrElse(() => 5)
+      )
       return Effect.succeed(Duration.seconds(retryAfter))
     }
     return Effect.succeed(Duration.seconds(1))

package/src/unstable/observability/OtlpTracer.ts

@@ -7,6 +7,7 @@ import * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
 import { flow } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
 import type * as ServiceMap from "../../ServiceMap.ts"
 import * as Tracer from "../../Tracer.ts"
@@ -150,7 +151,7 @@ type RemainingSpanImpl = Omit<Tracer.Span, (keyof typeof SpanProto) | "traceId"
 
 const makeSpan = (options: {
   readonly name: string
-  readonly parent: Tracer.AnySpan | undefined
+  readonly parent: Option.Option<Tracer.AnySpan>
   readonly annotations: ServiceMap.ServiceMap<never>
   readonly status: Tracer.SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
@@ -163,8 +164,8 @@ const makeSpan = (options: {
     Object.create(SpanProto),
     options satisfies RemainingSpanImpl
   )
-  if (self.parent) {
-    self.traceId = self.parent.traceId
+  if (Option.isSome(self.parent)) {
+    self.traceId = self.parent.value.traceId
   } else {
     self.traceId = generateId(32)
   }
@@ -249,7 +250,10 @@ const makeOtlpSpan = (self: SpanImpl): OtlpSpan => {
   return {
     traceId: self.traceId,
     spanId: self.spanId,
-    parentSpanId: self.parent ? self.parent.spanId : undefined,
+    parentSpanId: Option.match(self.parent, {
+      onNone: () => undefined,
+      onSome: (parent) => parent.spanId
+    }),
     name: self.name,
     kind: SpanKind[self.kind],
     startTimeUnixNano: String(status.startTime),

package/src/unstable/reactivity/Atom.ts

@@ -607,11 +607,8 @@ function runCallbackSync<R, A, E, ER = never>(
     return undefined
   }
   const runFork = Effect.runForkWith(services)
-  const scheduler = ServiceMap.get(services, Scheduler.Scheduler)
   const fiber = runFork(effect)
-  if ("flush" in scheduler) {
-    ;(scheduler as Scheduler.MixedScheduler).flush()
-  }
+  fiber.currentDispatcher?.flush()
   const result = fiber.pollUnsafe()
   if (result) {
     onExit(result)

package/src/unstable/reactivity/AtomRegistry.ts

@@ -9,7 +9,7 @@ import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
-import type { Scheduler } from "../../Scheduler.ts"
+import type { Scheduler, SchedulerDispatcher } from "../../Scheduler.ts"
 import { MixedScheduler } from "../../Scheduler.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -296,6 +296,7 @@ class RegistryImpl implements AtomRegistry {
   readonly defaultIdleTTL: number | undefined
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
+  readonly dispatcher: SchedulerDispatcher
   onNodeAdded?: ((node: Node<any>) => void) | undefined
   onNodeRemoved?: ((node: Node<any>) => void) | undefined
 
@@ -308,6 +309,7 @@ class RegistryImpl implements AtomRegistry {
     this[TypeId] = TypeId
     this.scheduler = new MixedScheduler("sync", scheduleTask)
     this.schedulerAsync = new MixedScheduler("async", scheduleTask)
+    this.dispatcher = this.schedulerAsync.makeDispatcher()
     this.defaultIdleTTL = defaultIdleTTL
 
     if (timeoutResolution === undefined && defaultIdleTTL !== undefined) {
@@ -427,7 +429,7 @@ class RegistryImpl implements AtomRegistry {
   }
 
   scheduleAtomRemoval(atom: Atom.Atom<any>): void {
-    this.schedulerAsync.scheduleTask(() => {
+    this.dispatcher.scheduleTask(() => {
       const node = this.nodes.get(atomKey(atom))
       if (node !== undefined && node.canBeRemoved) {
         this.removeNode(node)
@@ -436,7 +438,7 @@ class RegistryImpl implements AtomRegistry {
   }
 
   scheduleNodeRemoval(node: NodeImpl<any>): void {
-    this.schedulerAsync.scheduleTask(() => {
+    this.dispatcher.scheduleTask(() => {
       if (node.canBeRemoved) {
         this.removeNode(node)
       }

package/src/unstable/rpc/Rpc.ts

@@ -4,6 +4,7 @@
 import type * as Cause from "../../Cause.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Exit as Exit_ } from "../../Exit.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
@@ -780,14 +781,14 @@ export const exitSchema = <R extends Any>(
   const rpc = self as any as AnyWithProps
   const failures = new Set<Schema.Top>([rpc.errorSchema])
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
-  if (streamSchemas) {
-    failures.add(streamSchemas.error)
+  if (Option.isSome(streamSchemas)) {
+    failures.add(streamSchemas.value.error)
   }
   for (const middleware of rpc.middlewares) {
     failures.add(middleware.error)
   }
   const schema = Schema.Exit(
-    streamSchemas ? Schema.Void : rpc.successSchema,
+    Option.isSome(streamSchemas) ? Schema.Void : rpc.successSchema,
     Schema.Union([...failures]),
     rpc.defectSchema
   )

package/src/unstable/rpc/RpcClient.ts

@@ -366,7 +366,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             resume(exit) {
               resume(exit)
               if (fiber && !fiber.pollUnsafe()) {
-                parentFiber.currentScheduler.scheduleTask(() => {
+                parentFiber.currentDispatcher.scheduleTask(() => {
                   fiber.interruptUnsafe(parentFiber.id)
                 }, 0)
               }
@@ -683,8 +683,8 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       case "Chunk": {
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
-        if (!entry || !entry.schemas.decodeChunk) return Effect.void
-        return entry.schemas.decodeChunk(message.values).pipe(
+        if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
+        return entry.schemas.decodeChunk.value(message.values).pipe(
           Effect.provideServices(entry.context),
           Effect.orDie,
           Effect.flatMap((chunk) =>
@@ -738,9 +738,9 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
 })
 
 interface RpcSchemas {
-  readonly decodeChunk:
-    | ((chunk: ReadonlyArray<unknown>) => Effect.Effect<NonEmptyReadonlyArray<any>, Schema.SchemaError, unknown>)
-    | undefined
+  readonly decodeChunk: Option.Option<
+    (chunk: ReadonlyArray<unknown>) => Effect.Effect<NonEmptyReadonlyArray<any>, Schema.SchemaError, unknown>
+  >
   readonly encodePayload: (payload: any) => Effect.Effect<any, Schema.SchemaError, unknown>
   readonly decodeExit: (encoded: unknown) => Effect.Effect<Exit.Exit<any, any>, Schema.SchemaError, unknown>
 }
@@ -752,9 +752,10 @@ const rpcSchemas = (rpc: Rpc.AnyWithProps) => {
   }
   const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
   entry = {
-    decodeChunk: streamSchemas ?
-      Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success))) :
-      undefined,
+    decodeChunk: Option.map(
+      streamSchemas,
+      (streamSchemas) => Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success)))
+    ),
     encodePayload: Schema.encodeEffect(Schema.toCodecJson(rpc.payloadSchema)),
     decodeExit: Schema.decodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any)))
   }

package/src/unstable/rpc/RpcSchema.ts

@@ -3,6 +3,7 @@
  */
 import * as Cause from "../../Cause.ts"
 import { constUndefined } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
@@ -20,16 +21,16 @@ export function isStreamSchema(schema: Schema.Top): schema is Stream<Schema.Top,
 }
 
 /** @internal */
-export function getStreamSchemas(schema: Schema.Top): {
+export function getStreamSchemas(schema: Schema.Top): Option.Option<{
   readonly success: Schema.Top
   readonly error: Schema.Top
-} | undefined {
+}> {
   return isStreamSchema(schema) ?
-    {
+    Option.some({
       success: schema.success,
       error: schema.error
-    } :
-    undefined
+    }) :
+    Option.none()
 }
 
 /**

package/src/unstable/rpc/RpcSerialization.ts

@@ -37,7 +37,10 @@ export const json: RpcSerialization["Service"] = RpcSerialization.of({
   makeUnsafe: () => {
     const decoder = new TextDecoder()
     return {
-      decode: (bytes) => [JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))],
+      decode: (bytes) => {
+        const decoded = JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))
+        return Array.isArray(decoded) ? decoded : [decoded]
+      },
       encode: (response) => JSON.stringify(response)
     }
   }

package/src/unstable/rpc/RpcServer.ts

@@ -11,7 +11,7 @@ import { constant, constTrue, constVoid, identity } from "../../Function.ts"
 import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
-import type * as Option from "../../Option.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
 import * as Queue from "../../Queue.ts"
@@ -547,7 +547,7 @@ export const make: <Rpcs extends Rpc.Any>(
         decode: Schema.decodeUnknownEffect(Schema.toCodecJson(rpc.payloadSchema)) as any,
         encodeChunk: Schema.encodeUnknownEffect(
           Schema.toCodecJson(
-            Schema.Array(streamSchemas ? streamSchemas.success : Schema.Any)
+            Schema.Array(Option.isSome(streamSchemas) ? streamSchemas.value.success : Schema.Any)
           )
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any))) as any,
@@ -1245,7 +1245,7 @@ export const makeProtocolWorkerRunner: Effect.Effect<
     Effect.tapCause(Effect.logError),
     Effect.onExit(() =>
       Effect.sync(() => {
-        fiber.currentScheduler.scheduleTask(() => fiber.interruptUnsafe(fiber.id), 0)
+        fiber.currentDispatcher.scheduleTask(() => fiber.interruptUnsafe(fiber.id), 0)
       })
     ),
     Effect.forkScoped

package/src/unstable/socket/Socket.ts

@@ -214,7 +214,7 @@ export type SocketErrorReason =
  * @since 4.0.0
  * @category errors
  */
-export class SocketError extends Schema.ErrorClass<SocketError>(SocketErrorTypeId)({
+export class SocketError extends Schema.TaggedErrorClass<SocketError>(SocketErrorTypeId)("SocketError", {
   _tag: Schema.tag("SocketError"),
   reason: SocketErrorReason
 }) {
@@ -243,6 +243,8 @@ export class SocketError extends Schema.ErrorClass<SocketError>(SocketErrorTypeI
   static is(u: unknown): u is SocketError {
     return isSocketError(u)
   }
+
+  override readonly message = this.reason.message
 }
 
 /**
@@ -426,14 +428,16 @@ export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
   readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
-  fromWebSocket(
-    Effect.acquireRelease(
-      (typeof url === "string" ? Effect.succeed(url) : url).pipe(
-        Effect.flatMap((url) => Effect.map(WebSocketConstructor.asEffect(), (f) => f(url, options?.protocols)))
+  WebSocketConstructor.use((makeWs) =>
+    fromWebSocket(
+      Effect.acquireRelease(
+        (typeof url === "string" ? Effect.succeed(url) : url).pipe(
+          Effect.map((url) => makeWs(url, options?.protocols))
+        ),
+        (ws) => Effect.sync(() => ws.close(1000))
       ),
-      (ws) => Effect.sync(() => ws.close(1000))
-    ),
-    options
+      options
+    )
   )
 
 /**
@@ -500,6 +504,7 @@ export const fromWebSocket = <RO>(
           )
         }
         function onClose(event: globalThis.CloseEvent) {
+          const code = typeof event.code === "number" ? event.code : 1001
           ws.removeEventListener("message", onMessage)
           ws.removeEventListener("error", onError)
           Deferred.doneUnsafe(
@@ -507,7 +512,7 @@ export const fromWebSocket = <RO>(
             Effect.fail(
               new SocketError({
                 reason: new SocketCloseError({
-                  code: event.code,
+                  code,
                   closeReason: event.reason
                 })
               })

package/src/unstable/sql/SqlClient.ts

@@ -215,9 +215,11 @@ export const makeWithTransaction = <I, S>(options: {
                 Effect.flatMap(() =>
                   Effect.provideServices(
                     restore(effect),
-                    ServiceMap.add(services, options.transactionService, [conn, id]).pipe(
-                      ServiceMap.add(Tracer.ParentSpan, span)
-                    )
+                    ServiceMap.mutate(services, (services) =>
+                      services.pipe(
+                        ServiceMap.add(options.transactionService, [conn, id]),
+                        ServiceMap.add(Tracer.ParentSpan, span)
+                      ))
                   )
                 ),
                 Effect.exit,

package/src/unstable/workflow/DurableDeferred.ts

@@ -8,7 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Encoding from "../../Encoding.ts"
 import * as Exit from "../../Exit.ts"
 import { dual } from "../../Function.ts"
-import * as Predicate from "../../Predicate.ts"
+import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import * as Getter from "../../SchemaGetter.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -124,12 +124,12 @@ const await_: <Success extends Schema.Top, Error extends Schema.Top>(
   const instance = yield* InstanceTag
   const exit = yield* Workflow.wrapActivityResult(
     engine.deferredResult(self),
-    Predicate.isUndefined
+    Option.isNone
   )
-  if (exit === undefined) {
+  if (Option.isNone(exit)) {
     return yield* Workflow.suspend(instance)
   }
-  return yield* exit as Exit.Exit<any, any>
+  return yield* exit.value as Exit.Exit<any, any>
 })
 
 export {
@@ -241,8 +241,8 @@ export const raceAll = <
   return Effect.gen(function*() {
     const engine = yield* EngineTag
     const exit = yield* engine.deferredResult(deferred)
-    if (exit !== undefined) {
-      return yield* Effect.flatten(exit) as Effect.Effect<any, any, any>
+    if (Option.isSome(exit)) {
+      return yield* Effect.flatten(exit.value) as Effect.Effect<any, any, any>
     }
     return yield* into(Effect.raceAll(options.effects), deferred)
   })

package/src/unstable/workflow/Workflow.ts

@@ -78,7 +78,7 @@ export interface Workflow<
   readonly poll: (
     executionId: string
   ) => Effect.Effect<
-    Result<Success["Type"], Error["Type"]> | undefined,
+    Option.Option<Result<Success["Type"], Error["Type"]>>,
     never,
     WorkflowEngine | Success["DecodingServices"] | Error["DecodingServices"]
   >