effect-zero 0.4.2 → 0.5.0-beta.1

package/src/mutators.ts

@@ -15,7 +15,7 @@ export type AnyMutatorFns<R = any> = {
 };
 
 // biome-ignore lint/suspicious/noExplicitAny: upper bound to allow everything
-export type AnyMutatorSchema = Schema.Schema<any, any, never>;
+export type AnyMutatorSchema = Schema.Codec<any, any>;
 export type AnyMutatorSchemas = Record<string, AnyMutatorSchema | Record<string, AnyMutatorSchema>>;
 
 export type MutatorFns<TSchema extends AnyMutatorSchemas> = {
@@ -71,7 +71,7 @@ export function make(schema: AnyMutatorSchemas, mutators: AnyMutatorFns): AnyMut
   return Rec.map(mutators, (v, name) => {
     return Match.value([v, schema[name]]).pipe(
       Match.when([Predicate.isFunction, Schema.isSchema], ([mutator, schema]) => makeMutator(schema, mutator)),
-      Match.when([Predicate.isRecord, Predicate.isRecord], ([mutator, schema]) =>
+      Match.when([Predicate.isObject, Predicate.isObject], ([mutator, schema]) =>
         Rec.map(mutator, (mutator, name) => makeMutator(Option.getOrThrow(Rec.get(schema, name)), mutator)),
       ),
       Match.orElseAbsurd,

package/src/query.ts

@@ -4,9 +4,9 @@ import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import * as Hash from "effect/Hash";
 import * as Match from "effect/Match";
+import * as Queue from "effect/Queue";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
-import * as Subscribable from "effect/Subscribable";
 import * as QueryResult from "./internal/query-result.js";
 import { prefixId } from "./internal/utils.js";
 import { deepClone, getDefaultSnapshot, getSnapshot } from "./snapshot.js";
@@ -32,15 +32,15 @@ export const make = <
   R2,
 >(options: {
   name: N;
-  payload: Schema.Schema<B, A, R1>;
+  payload: Schema.Codec<B, A, R1, R1>;
   query: (args: NoInfer<B>) => Effect.Effect<ZeroQuery<T, S, R>, E, R2>;
 }) => {
   const runQuery = Effect.fn(function* (args: QueryArgs<A, B>) {
     const { encoded, decoded } = yield* Match.valueTags(args, {
       Encoded: ({ args: encoded }) =>
-        Effect.map(Schema.decode(options.payload)(encoded), (decoded) => ({ encoded, decoded })),
+        Effect.map(Schema.decodeEffect(options.payload)(encoded), (decoded) => ({ encoded, decoded })),
       Decoded: ({ args: decoded }) =>
-        Effect.map(Schema.encode(options.payload)(decoded), (encoded) => ({ encoded, decoded })),
+        Effect.map(Schema.encodeEffect(options.payload)(decoded), (encoded) => ({ encoded, decoded })),
     });
 
     return yield* options.query(decoded).pipe(
@@ -88,8 +88,8 @@ export const stream = <T extends keyof S["tables"] & string, S extends ZeroSchem
       (view) => Effect.sync(() => view.destroy()),
     );
 
-    return Stream.asyncEffect<Parameters<Parameters<(typeof view)["addListener"]>[0]>>((emit) =>
-      Effect.sync(() => view.addListener((...args) => emit.single(args))),
+    return Stream.callback<Parameters<Parameters<(typeof view)["addListener"]>[0]>>((queue) =>
+      Effect.sync(() => view.addListener((...args) => Queue.offerUnsafe(queue, args))),
     ).pipe(
       Stream.mapEffect(([data, resultType, error]) =>
         Effect.sync(() => {
@@ -102,27 +102,15 @@ export const stream = <T extends keyof S["tables"] & string, S extends ZeroSchem
             // TODO: Look into this. It seems like this is difficult but not impossible to model in the Effect paradigm.
             // Likely need some kind of stateful piece between the publisher and and subscriber, allowing the subscriber to swap out
             // the publisher when this function is called.
-            () => Effect.dieMessage("retry not available in `effect-zero`"),
+            () => Effect.die("retry not available in `effect-zero`"),
             error,
           );
         }),
       ),
       Stream.map(QueryResult.make),
     );
-  }).pipe(Stream.unwrapScoped);
+  }).pipe(Stream.unwrap);
 
 export const initialValue = <T extends keyof S["tables"] & string, S extends ZeroSchema, R>(
   query: ZeroQuery<T, S, R>,
 ) => QueryResult.make<R>(getDefaultSnapshot(asQueryInternals(query).format.singular));
-
-export const subscribable = <T extends keyof S["tables"] & string, S extends ZeroSchema, R>(
-  zero: Zero<S>,
-  query: ZeroQuery<T, S, R>,
-) => {
-  return Subscribable.make({
-    get: Effect.promise(() => zero.run(query, { type: "unknown" })).pipe(
-      Effect.map((value) => ({ _tag: "Partial", value }) satisfies QueryResult.QueryResult.Partial<R>),
-    ),
-    changes: stream(zero, query),
-  });
-};

package/src/result.ts

@@ -1,4 +1,3 @@
-import { Result as AtomResult } from "@effect-atom/atom";
 import type { HumanReadable } from "@rocicorp/zero";
 import * as Cause from "effect/Cause";
 import * as Data from "effect/Data";
@@ -7,14 +6,15 @@ import * as Match from "effect/Match";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Struct from "effect/Struct";
+import { AsyncResult } from "effect/unstable/reactivity";
 import type { QueryResult } from "./internal/query-result.js";
 
 /*
 ### Introduction
 
-When using effect-atom with effect-zero, you will often have atoms which contain a type in the form of
+When using `effect/unstable/reactivity` (atoms) with effect-zero, you will often have atoms which contain a type in the form of
 
-`@effect-atom/atom`.Result<`@rocicorp/zero/react`.QueryResult<A>, E>
+`AsyncResult<QueryResult<A>, E>`
 
 However, such a type is not easy to work with.
 The purpose of `effect-zero`.Result is to provide a more convenient type for this use case.
@@ -22,8 +22,8 @@ The purpose of `effect-zero`.Result is to provide a more convenient type for thi
 ### Background
 
 To start, let's analyze the possible states of the original type:
-- The outer `@effect-atom/atom`.Result may be `Initial<_, _>`, `Failure<_, E>`, or `Success<QueryResult, _>`.
-- The inner `@rocicorp/zero/react`.QueryResult may be `unknown<A>`, `complete<A>`, or `error`.
+- The outer `AsyncResult` may be `Initial<_, _>`, `Failure<_, E>`, or `Success<QueryResult, _>`.
+- The inner `QueryResult` may be `unknown<A>`, `complete<A>`, or `error`.
 
 This means that there are 5 total possible states:
 - Initial, representing the state before the query has been executed on either the client or the server.
@@ -43,45 +43,48 @@ On the other hand, `effect-zero`.Result has the following states:
 
 This has a few key benefits:
 - It allows you to deal with errors in a more streamlined way, as now all error states are represented as a `Failure(E | QueryError)`,
-  thus you can use the builtin facilities of `effect-atom`.Result to work with the possible error states.
+  thus you can use the builtin facilities of `AsyncResult` to work with the possible error states.
 - We provide a method `acceptPartialMode` which allows for simplifying the type further by specifying the situations in which you want to accept
   partial results, resulting a further simplified type of `Initial | Success(A) | Failure(E | QueryError)`.
 */
 
-export type Result<A, E = never> = AtomResult.Result<QueryResult.Partial<A> | QueryResult.Complete<A>, E | QueryError>;
+export type Result<A, E = never> = AsyncResult.AsyncResult<
+  QueryResult.Partial<A> | QueryResult.Complete<A>,
+  E | QueryError
+>;
 export namespace Result {
-  export type Initial<A, E = never> = AtomResult.Initial<
+  export type Initial<A, E = never> = AsyncResult.Initial<
     QueryResult.Partial<A> | QueryResult.Complete<A>,
     E | QueryError
   >;
-  export type Failure<A, E = never> = AtomResult.Failure<
+  export type Failure<A, E = never> = AsyncResult.Failure<
     QueryResult.Partial<A> | QueryResult.Complete<A>,
     E | QueryError
   >;
-  export type Success<A, E = never> = AtomResult.Success<
+  export type Success<A, E = never> = AsyncResult.Success<
     QueryResult.Partial<A> | QueryResult.Complete<A>,
     E | QueryError
   >;
 
   // More granular Partial and Complete types
-  export type Partial<A, E = never> = AtomResult.Success<QueryResult.Partial<A>, E | QueryError>;
-  export type Complete<A, E = never> = AtomResult.Success<QueryResult.Complete<A>, E | QueryError>;
+  export type Partial<A, E = never> = AsyncResult.Success<QueryResult.Partial<A>, E | QueryError>;
+  export type Complete<A, E = never> = AsyncResult.Success<QueryResult.Complete<A>, E | QueryError>;
 }
 
 export class QueryError extends Data.TaggedError("QueryError")<{
   readonly details: QueryResult.Error["details"];
 }> {}
 
-export const make = <A, E>(value: AtomResult.Result<QueryResult<A>, E>): Result<A, E> =>
+export const make = <A, E>(value: AsyncResult.AsyncResult<QueryResult<A>, E>): Result<A, E> =>
   Match.valueTags(value, {
-    Initial: () => AtomResult.initial(),
+    Initial: () => AsyncResult.initial(),
     Success: ({ value }) =>
       Match.valueTags(value, {
-        Partial: (value) => AtomResult.success(value),
-        Complete: (value) => AtomResult.success(value),
-        Error: (e) => AtomResult.failure(Cause.fail(new QueryError(e))),
+        Partial: (value) => AsyncResult.success(value),
+        Complete: (value) => AsyncResult.success(value),
+        Error: (e): Result<A, E> => AsyncResult.failure(Cause.fail(new QueryError(e))),
       }),
-    Failure: (e) => AtomResult.failure(e.cause),
+    Failure: (e): Result<A, E> => AsyncResult.failure(e.cause),
   });
 
 // based on: https://github.com/tim-smart/effect-atom/blob/04c15cacda42dd230782f52c0e978400793a502c/packages/atom/src/Result.ts#L424
@@ -124,34 +127,34 @@ export const match: {
 );
 
 export const mapSuccess: {
-  <A, B>(f: (value: A) => B): <E = never>(self: AtomResult.Success<A, E>) => AtomResult.Success<B, E>;
-  <A, B, E = never>(self: AtomResult.Success<A, E>, f: (value: A) => B): AtomResult.Success<B, E>;
-} = Fn.dual(2, <A, B, E = never>(self: AtomResult.Success<A, E>, f: (value: A) => B) => AtomResult.map(self, f));
+  <A, B>(f: (value: A) => B): <E = never>(self: AsyncResult.Success<A, E>) => AsyncResult.Success<B, E>;
+  <A, B, E = never>(self: AsyncResult.Success<A, E>, f: (value: A) => B): AsyncResult.Success<B, E>;
+} = Fn.dual(2, <A, B, E = never>(self: AsyncResult.Success<A, E>, f: (value: A) => B) => AsyncResult.map(self, f));
 
 export const acceptPartialWith: {
   <A, E = never>(
     self: Result<A, E>,
     predicate: (value: HumanReadable<A>) => boolean,
   ):
-    | AtomResult.Initial<HumanReadable<A>, E>
-    | AtomResult.Success<HumanReadable<A>, QueryError | E>
-    | AtomResult.Failure<HumanReadable<A>, QueryError | E>;
+    | AsyncResult.Initial<HumanReadable<A>, E>
+    | AsyncResult.Success<HumanReadable<A>, QueryError | E>
+    | AsyncResult.Failure<HumanReadable<A>, QueryError | E>;
   <A, E = never>(
     self: Result<A, E>,
   ): (
     predicate: (value: HumanReadable<A>) => boolean,
   ) =>
-    | AtomResult.Initial<HumanReadable<A>, E>
-    | AtomResult.Success<HumanReadable<A>, QueryError | E>
-    | AtomResult.Failure<HumanReadable<A>, QueryError | E>;
+    | AsyncResult.Initial<HumanReadable<A>, E>
+    | AsyncResult.Success<HumanReadable<A>, QueryError | E>
+    | AsyncResult.Failure<HumanReadable<A>, QueryError | E>;
 } = Fn.dual(2, <A, E = never>(self: Result<A, E>, predicate: (value: HumanReadable<A>) => boolean) =>
-  AtomResult.match(self, {
+  AsyncResult.match(self, {
     onSuccess: (success) =>
       Predicate.isTagged(success.value, "Partial") && !predicate(success.value.value)
-        ? AtomResult.initial<HumanReadable<A>, E>(success.waiting)
+        ? AsyncResult.initial(success.waiting)
         : mapSuccess(success, Struct.get("value")),
     onFailure: (failure) =>
-      AtomResult.failure<E | QueryError, HumanReadable<A>>(failure.cause, {
+      AsyncResult.failure(failure.cause, {
         waiting: failure.waiting,
         previousSuccess: failure.previousSuccess.pipe(
           Option.flatMap((success) =>
@@ -161,7 +164,7 @@ export const acceptPartialWith: {
           ),
         ),
       }),
-    onInitial: (initial) => AtomResult.initial<HumanReadable<A>, E>(initial.waiting),
+    onInitial: (initial) => AsyncResult.initial(initial.waiting),
   }),
 );
 
@@ -182,9 +185,9 @@ export const acceptPartialMode: {
      **/
     mode: AcceptPartialMode,
   ):
-    | AtomResult.Initial<HumanReadable<A>, E>
-    | AtomResult.Success<HumanReadable<A>, QueryError | E>
-    | AtomResult.Failure<HumanReadable<A>, QueryError | E>;
+    | AsyncResult.Initial<HumanReadable<A>, E>
+    | AsyncResult.Success<HumanReadable<A>, QueryError | E>
+    | AsyncResult.Failure<HumanReadable<A>, QueryError | E>;
   <A, E>(
     /**
      * - `acceptCached` -> Will resolve to the partial result if it is available
@@ -200,9 +203,9 @@ export const acceptPartialMode: {
   ): (
     self: Result<A, E>,
   ) =>
-    | AtomResult.Initial<HumanReadable<A>, E>
-    | AtomResult.Success<HumanReadable<A>, QueryError | E>
-    | AtomResult.Failure<HumanReadable<A>, QueryError | E>;
+    | AsyncResult.Initial<HumanReadable<A>, E>
+    | AsyncResult.Success<HumanReadable<A>, QueryError | E>
+    | AsyncResult.Failure<HumanReadable<A>, QueryError | E>;
 } = Fn.dual(2, <A, E>(self: Result<A, E>, mode: AcceptPartialMode) =>
   Match.value(mode).pipe(
     Match.when("waitForServer", () => acceptPartialWith(self, () => false)),

package/src/server-transaction.ts

@@ -1,42 +1,37 @@
-import type {
-  Schema as ZeroSchema,
-  ServerTransaction as ZeroServerTransaction,
-  Transaction as ZeroTransaction,
-} from "@rocicorp/zero";
+import type { Schema as ZeroSchema, ServerTransaction as ZeroServerTransaction } from "@rocicorp/zero";
 import type { TransactionProviderHooks, ZQLDatabase } from "@rocicorp/zero/server";
 import * as Cause from "effect/Cause";
-import * as Context from "effect/Context";
+import * as Ctx from "effect/Context";
 import * as Data from "effect/Data";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import type { NodeInspectSymbol } from "effect/Inspectable";
 import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
-import * as Runtime from "effect/Runtime";
+import type * as Unify from "effect/Unify";
 import type * as ClientTransaction from "./client-transaction.js";
-import {
-  MutationAlreadyProcessedError,
-  OutOfOrderMutationError,
-  ServerSynchronizationContext,
-  ServerTransactionInput,
-} from "./internal/server.js";
+import { MutationAlreadyProcessedError, OutOfOrderMutationError, ServerTransactionInput } from "./internal/server.js";
+import * as ServerSynchronizationContext from "./internal/server-synchronization-context.js";
 import { prefixId } from "./internal/utils.js";
 
 // Updated to: https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/push-processor.ts
 
-export interface ServerTransactionContext {
-  readonly _tag: unique symbol;
-}
+type _ = NodeInspectSymbol;
+type _Unify = Unify.typeSymbol | Unify.unifySymbol | Unify.ignoreSymbol;
+
+// biome-ignore lint/suspicious/noExplicitAny: any client transaction (its Id literal is irrelevant here)
+export type Context<TSchema extends ZeroSchema, TTransaction> = ReturnType<typeof make<any, TSchema, TTransaction>>;
 
 export const make = <const Id extends string, TSchema extends ZeroSchema, TTransaction>(
   id: Id,
   database: ZQLDatabase<TSchema, TTransaction>,
-  clientTransaction: Context.TagClass<ClientTransaction.ClientTransaction, string, ZeroTransaction<TSchema>>,
+  clientTransaction: ClientTransaction.Context<TSchema>,
 ) => {
-  const ServerTransactionContext = Context.Tag(`${id}/ServerTransactionContext` as const)<
-    ServerTransactionContext,
+  class Context extends Ctx.Service<
+    Context,
     { transaction: ZeroServerTransaction<TSchema, TTransaction>; transactionHooks: TransactionProviderHooks }
-  >();
+  >()(`${id as string}/ServerTransactionContext` as const) {}
 
   const use = <A>(
     fn: (
@@ -44,32 +39,33 @@ export const make = <const Id extends string, TSchema extends ZeroSchema, TTrans
       options: { readonly signal: AbortSignal },
     ) => PromiseLike<A>,
   ) =>
-    Effect.flatMap(ServerTransactionContext, (ctx) =>
-      Effect.tryPromise({
+    Effect.gen(function* () {
+      const ctx = yield* Context;
+      return yield* Effect.tryPromise({
         try: (signal) => fn(ctx.transaction, { signal }),
         catch: (error) => new ServerTransactionError({ cause: Cause.fail(error) }),
-      }),
-    );
+      });
+    });
 
   const execute = Effect.fn(function* <A, E, R>(effect: Effect.Effect<A, E, R>) {
-    const runtime = yield* Effect.runtime<
-      ServerTransactionInput | Exclude<R, ClientTransaction.ClientTransaction | ServerTransactionContext>
+    const ctx = yield* Effect.context<
+      ServerTransactionInput | Exclude<R, (typeof clientTransaction.Context)["Identifier"] | Context>
     >();
-    const result = yield* Deferred.make<A, E | Effect.Effect.Error<typeof checkAndIncrementLastMutationId>>();
+    const result = yield* Deferred.make<A, E | Effect.Error<typeof checkAndIncrementLastMutationId>>();
 
     const transactionInput = yield* ServerTransactionInput;
     yield* Effect.tryPromise({
       try: (signal) =>
         database.transaction(async (transaction, transactionHooks) => {
-          const exit = await Effect.zipRight(checkAndIncrementLastMutationId, effect).pipe(
+          const exit = await Effect.flatMap(checkAndIncrementLastMutationId, () => effect).pipe(
             Effect.provide([
-              Layer.succeed(ServerTransactionContext, { transaction, transactionHooks }),
-              Layer.succeed(clientTransaction, transaction),
+              Layer.succeed(Context, { transaction, transactionHooks }),
+              Layer.succeed(clientTransaction.Context, transaction),
             ]),
-            (effect) => Runtime.runPromiseExit(runtime, effect, { signal }),
+            (effect) => Effect.runPromiseExitWith(ctx)(effect, { signal }),
           );
-          Deferred.unsafeDone(result, exit);
-          return Exit.getOrElse(exit, () => {
+          Deferred.doneUnsafe(result, exit);
+          if (Exit.isFailure(exit)) {
             // This error's purpose is to differentiate between "external" errors
             // that originate from the user-defined mutator code and "internal" errors
             // that originate from our own code and the Zero API.
@@ -78,7 +74,8 @@ export const make = <const Id extends string, TSchema extends ZeroSchema, TTrans
             // are already covered by passing the Exit result to the Deferred, which is why
             // we have the ServerTransactionUserError silenced below in the pipe.
             throw new ServerTransactionUserError();
-          });
+          }
+          return exit.value;
         }, transactionInput),
       catch: (error) => {
         if (ServerTransactionUserError.is(error)) {
@@ -90,11 +87,11 @@ export const make = <const Id extends string, TSchema extends ZeroSchema, TTrans
       },
     }).pipe(Effect.catchTag("ServerTransactionUserError", () => Effect.void));
 
-    return yield* result;
+    return yield* Deferred.await(result);
   }, ServerSynchronizationContext.guard);
 
   const checkAndIncrementLastMutationId = Effect.gen(function* () {
-    const { transactionHooks } = yield* ServerTransactionContext;
+    const { transactionHooks } = yield* Context;
     const { clientID, mutationID: receivedMutationID } = yield* ServerTransactionInput;
 
     const { lastMutationID } = yield* Effect.tryPromise({
@@ -118,7 +115,7 @@ export const make = <const Id extends string, TSchema extends ZeroSchema, TTrans
     }
   });
 
-  return Object.assign(ServerTransactionContext, { use, execute });
+  return { Context, use, execute };
 };
 
 class ServerTransactionError extends Data.TaggedError("ServerTransactionError")<{

package/src/server.ts

@@ -2,27 +2,22 @@ import type { ReadonlyJSONValue, Schema as ZeroSchema } from "@rocicorp/zero";
 import { handleQueryRequest } from "@rocicorp/zero/server";
 import * as Arr from "effect/Array";
 import * as Cause from "effect/Cause";
-import * as Chunk from "effect/Chunk";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fn from "effect/Function";
+import type { NodeInspectSymbol } from "effect/Inspectable";
 import * as Match from "effect/Match";
 import * as Option from "effect/Option";
-import type * as ParseResult from "effect/ParseResult";
 import * as Predicate from "effect/Predicate";
 import * as Rec from "effect/Record";
-import * as Runtime from "effect/Runtime";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as Str from "effect/String";
-import {
-  MutationAlreadyProcessedError,
-  OutOfOrderMutationError,
-  ServerSynchronizationContext,
-  ServerTransactionInput,
-} from "./internal/server.js";
-import { prefixId } from "./internal/utils.js";
+import type * as Unify from "effect/Unify";
+import { MutationAlreadyProcessedError, OutOfOrderMutationError, ServerTransactionInput } from "./internal/server.js";
+import * as ServerSynchronizationContext from "./internal/server-synchronization-context.js";
+import { normalizeArgs, prefixId } from "./internal/utils.js";
 import * as Mutators from "./mutators.js";
 import { type MakeQueryResult, QueryNameSymbol, RunQuerySymbol } from "./query.js";
 import type * as ServerTransaction from "./server-transaction.js";
@@ -33,17 +28,15 @@ import type { TransformRequestMessage } from "./types/queries.js";
 // https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/push-processor.ts
 // https://github.com/rocicorp/mono/blob/3082c9fa061891067b4bd7dc9fe74f798270d8d7/packages/zero-server/src/process-mutations.ts
 
-type ServerTransactionContext<TSchema extends ZeroSchema, TTransaction> = Omit<
-  ReturnType<typeof ServerTransaction.make<string, TSchema, TTransaction>>,
-  "use"
->;
+type _ = NodeInspectSymbol;
+type _Unify = Unify.typeSymbol | Unify.unifySymbol | Unify.ignoreSymbol;
 
 export const processPush = Effect.fn(function* <
   TSchema extends ZeroSchema,
   TTransaction,
   TMutators extends Mutators.AnyMutators,
 >(
-  transaction: ServerTransactionContext<TSchema, TTransaction>,
+  transaction: ServerTransaction.Context<TSchema, TTransaction>,
   mutators: TMutators,
   params: Types.PushParams,
   request: Types.PushBody,
@@ -60,7 +53,7 @@ export const processPush = Effect.fn(function* <
         }
 
         return yield* processMutation<Mutators.ExtractMutatorsRequirements<TMutators>>(mutators, mutation).pipe(
-          Effect.catchAll((e) => processMutationError(transaction, e)),
+          Effect.catch((e) => processMutationError(transaction, e)),
           Effect.map((result) =>
             Types.MutationResponse.make({ id: { id: mutation.id, clientID: mutation.clientID }, result }),
           ),
@@ -70,7 +63,7 @@ export const processPush = Effect.fn(function* <
             clientGroupID: request.clientGroupID,
             upstreamSchema: params.schema,
           }),
-          Effect.provide(ServerSynchronizationContext.Default),
+          Effect.provide(ServerSynchronizationContext.layer),
         );
       }),
     ),
@@ -81,7 +74,7 @@ export const processPush = Effect.fn(function* <
     Stream.runCollect,
   );
 
-  return { mutations: Chunk.toArray(responses) } satisfies Types.PushResponse;
+  return { mutations: responses } satisfies Types.PushResponse;
 });
 
 const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R>, mutation: Types.Mutation) {
@@ -93,17 +86,18 @@ const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R
     Rec.get<string>(namespace),
     Option.flatMap((mutator) =>
       Match.value([mutator, name]).pipe(
-        Match.when([Predicate.isRecord, Predicate.isString], ([mutator, name]) => Rec.get<string>(name)(mutator)),
+        Match.when([Predicate.isObject, Predicate.isString], ([mutator, name]) => Rec.get<string>(name)(mutator)),
         Match.when([Predicate.isFunction, Predicate.isUndefined], ([mutator]) => Option.some(mutator)),
         Match.orElse(() => Option.none()),
       ),
     ),
-    Effect.catchTag("NoSuchElementException", () => new MutatorNotFoundError({ name: mutation.name })),
+    Effect.fromOption,
+    Effect.catchTag("NoSuchElementError", () => Effect.fail(new MutatorNotFoundError({ name: mutation.name }))),
   );
 
-  const args = yield* Schema.decode(mutator[Mutators.MutatorSchemaSymbol])(mutation.args[0]).pipe(
-    Effect.catchTag("ParseError", (e) => new ServerArgsParseError({ cause: Cause.fail(e) })),
-  );
+  const args = yield* Schema.decodeUnknownEffect(mutator[Mutators.MutatorSchemaSymbol])(
+    normalizeArgs(mutation.args[0]),
+  ).pipe(Effect.catchTag("SchemaError", (e) => Effect.fail(new ServerArgsParseError({ cause: Cause.fail(e) }))));
 
   return yield* mutator(args).pipe(
     ServerSynchronizationContext.finalize,
@@ -120,12 +114,12 @@ const processMutation = Effect.fn(function* <R>(mutators: Mutators.AnyMutators<R
     ),
     // Case #5 "Zero transactions then fail" / #6 "Fail before transaction"
     // Catches all errors that are produced before the transaction is executed
-    Effect.catchAllCause((cause) => new MutationUserError({ cause })),
+    Effect.catchCause((cause) => Effect.fail(new MutationUserError({ cause }))),
   );
 });
 
 const processMutationError = Effect.fn(function* <TSchema extends ZeroSchema, TTransaction>(
-  transaction: ServerTransactionContext<TSchema, TTransaction>,
+  transaction: ServerTransaction.Context<TSchema, TTransaction>,
   e: unknown,
 ) {
   const { clientID, mutationID } = yield* ServerTransactionInput;
@@ -144,14 +138,15 @@ const processMutationError = Effect.fn(function* <TSchema extends ZeroSchema, TT
 
   yield* transaction
     .execute(
-      Effect.flatMap(transaction, ({ transactionHooks }) => {
-        return Effect.tryPromise({
+      Effect.gen(function* () {
+        const { transactionHooks } = yield* transaction.Context;
+        return yield* Effect.tryPromise({
           try: () => transactionHooks.writeMutationResult({ id: { id: mutationID, clientID }, result: appError }),
           catch: (error) => new WriteMutationResultError({ cause: Cause.fail(error) }),
         });
       }),
     )
-    .pipe(Effect.catchAllCause(Effect.logError));
+    .pipe(Effect.catchCause(Effect.logError));
 
   yield* Effect.logWarning(`Mutation ${mutationID} for client ${clientID} was retried after an error: ${e}`);
 
@@ -167,7 +162,7 @@ class MutatorNotFoundError extends Data.TaggedError("MutatorNotFoundError")<{
 }> {}
 
 class ServerArgsParseError extends Data.TaggedError("ServerArgsParseError")<{
-  readonly cause: Cause.Cause<ParseResult.ParseError>;
+  readonly cause: Cause.Cause<Schema.SchemaError>;
 }> {}
 
 const MutationUserErrorTypeId = Symbol.for(prefixId("MutationUserError"));
@@ -190,25 +185,29 @@ export const handleQuery = Effect.fn(function* <E, R1, R2>(
   schema: ZeroSchema,
   payload: TransformRequestMessage,
 ) {
-  const runtime = yield* Effect.runtime<R1 | R2>();
+  const ctx = yield* Effect.context<R1 | R2>();
   return yield* Effect.tryPromise({
     try: () =>
       handleQueryRequest(
         (name, args) =>
           Arr.findFirst(queries, (q) => q[QueryNameSymbol] === name).pipe(
-            Effect.catchTag("NoSuchElementException", () => new QueryNotFound({ name })),
+            Effect.fromOption,
+            Effect.catchTag("NoSuchElementError", () => Effect.fail(new QueryNotFound({ name }))),
             Effect.flatMap((query) => query[RunQuerySymbol]({ _tag: "Encoded", args })),
-            (effect) => Runtime.runSyncExit(runtime, effect),
-            Exit.getOrElse((cause) => {
-              throw new QueryUserError<E>({ cause });
-            }),
+            Effect.runSyncExitWith(ctx),
+            (exit) => {
+              if (Exit.isFailure(exit)) {
+                throw new QueryUserError<E>({ cause: exit.cause });
+              }
+              return exit.value;
+            },
           ),
         schema,
         payload as ReadonlyJSONValue,
       ),
     catch: (e) =>
       Option.liftPredicate(e, QueryUserError.is<E>).pipe(
-        Option.flatMap((e) => Cause.failureOption(e.cause)),
+        Option.flatMap((e) => Cause.findErrorOption(e.cause)),
         Option.getOrElse(() => new QueryRequestError({ cause: Cause.fail(e) })),
       ),
   });
@@ -222,7 +221,7 @@ class QueryNotFound extends Data.TaggedError("QueryNotFound")<{ name: string }>
 
 const QueryUserErrorTypeId = Symbol.for(prefixId("QueryUserError"));
 class QueryUserError<E> extends Data.TaggedError("QueryUserError")<{
-  cause: Cause.Cause<E | ParseResult.ParseError | QueryNotFound>;
+  cause: Cause.Cause<E | Schema.SchemaError | QueryNotFound>;
 }> {
   readonly [QueryUserErrorTypeId] = QueryUserErrorTypeId;
   static is<E>(e: unknown): e is QueryUserError<E> {

package/src/types/error.ts

@@ -20,11 +20,11 @@ const PushFailedBase = Schema.Struct({
   message: Schema.String,
 });
 
-export const PushFailedBody = Schema.Union(
+export const PushFailedBody = Schema.Union([
   Schema.Struct({
     ...PushFailedBase.fields,
     origin: Schema.Literal("server"),
-    reason: Schema.Literal("database", "parse", "oooMutation", "unsupportedPushVersion", "internal"),
+    reason: Schema.Literals(["database", "parse", "oooMutation", "unsupportedPushVersion", "internal"]),
   }),
   Schema.Struct({
     ...PushFailedBase.fields,
@@ -36,9 +36,9 @@ export const PushFailedBody = Schema.Union(
   Schema.Struct({
     ...PushFailedBase.fields,
     origin: Schema.Literal("zeroCache"),
-    reason: Schema.Literal("timeout", "parse", "internal"),
+    reason: Schema.Literals(["timeout", "parse", "internal"]),
   }),
-);
+]);
 
 const TransformFailedBase = Schema.Struct({
   kind: Schema.Literal("TransformFailed"),
@@ -50,11 +50,11 @@ const TransformFailedBase = Schema.Struct({
   message: Schema.String,
 });
 
-export const TransformFailedBody = Schema.Union(
+export const TransformFailedBody = Schema.Union([
   Schema.Struct({
     ...TransformFailedBase.fields,
     origin: Schema.Literal("server"),
-    reason: Schema.Literal("database", "parse", "internal"),
+    reason: Schema.Literals(["database", "parse", "internal"]),
   }),
   Schema.Struct({
     ...TransformFailedBase.fields,
@@ -66,6 +66,6 @@ export const TransformFailedBody = Schema.Union(
   Schema.Struct({
     ...TransformFailedBase.fields,
     origin: Schema.Literal("zeroCache"),
-    reason: Schema.Literal("timeout", "parse", "internal"),
+    reason: Schema.Literals(["timeout", "parse", "internal"]),
   }),
-);
+]);