diff --git a/apps/react-router-example/app/routes/api.hatchet.runs.ts b/apps/react-router-example/app/routes/api.hatchet.runs.ts
index 82a23599..326a21a2 100644
--- a/apps/react-router-example/app/routes/api.hatchet.runs.ts
+++ b/apps/react-router-example/app/routes/api.hatchet.runs.ts
@@ -7,34 +7,20 @@ import { greetingInput, greetingTask } from "../lib/hatchet/greeting-task.server
 import { withActionEffect } from "../lib/runtime.server.js"
 
 const invalidRequest = () =>
-  Response.json(
-    { ok: false, errors: ["Request body must contain a non-empty name"] },
-    { status: 400 },
-  )
+  Response.json({ ok: false, errors: ["Request body must contain a non-empty name"] }, { status: 400 })
 
 const decodeInput = (request: Request) =>
   Effect.tryPromise({
     try: async (): Promise<unknown> => request.json(),
     catch: invalidRequest,
-  }).pipe(
-    Effect.flatMap(Schema.decodeUnknownEffect(greetingInput)),
-    Effect.mapError(invalidRequest),
-  )
+  }).pipe(Effect.flatMap(Schema.decodeUnknownEffect(greetingInput)), Effect.mapError(invalidRequest))
 
-export const action = Effect.gen(function*() {
+export const action = Effect.gen(function* () {
   const { request } = yield* ActionArgsContext
   if (request.method !== "POST") {
-    return yield* Effect.fail(
-      Response.json(
-        { ok: false, errors: ["Only POST is supported"] },
-        { status: 405 },
-      ),
-    )
+    return yield* Effect.fail(Response.json({ ok: false, errors: ["Only POST is supported"] }, { status: 405 }))
   }
   const input = yield* decodeInput(request)
   const handle = yield* Hatchet.runNoWait(greetingTask, input)
   return Response.json({ ok: true, runId: handle.id }, { status: 202 })
-}).pipe(
-  withBetterAuthGuardAction.with({ redirectOnFail: "/login" }),
-  withActionEffect,
-)
+}).pipe(withBetterAuthGuardAction.with({ redirectOnFail: "/login" }), withActionEffect)
diff --git a/apps/react-router-example/app/routes/hatchet-crons.tsx b/apps/react-router-example/app/routes/hatchet-crons.tsx
index 2a6f617f..4783445a 100644
--- a/apps/react-router-example/app/routes/hatchet-crons.tsx
+++ b/apps/react-router-example/app/routes/hatchet-crons.tsx
@@ -30,35 +30,26 @@ export const actionErrorFromData = (data: unknown): string | undefined => {
   return decoded.success.errors[0]
 }
 
-export const loader = Effect.gen(function*() {
+export const loader = Effect.gen(function* () {
   const crons = yield* Hatchet.listCrons({ taskName: greetingTask.name })
   return yield* httpSuccess({ crons })
-}).pipe(
-  withBetterAuthGuard.with({ redirectOnFail: "/login" }),
-  withLoaderEffect,
-)
+}).pipe(withBetterAuthGuard.with({ redirectOnFail: "/login" }), withLoaderEffect)
 
-export const action = Effect.gen(function*() {
+export const action = Effect.gen(function* () {
   const { request } = yield* ActionArgsContext
-  const formData = yield* Effect.result(
-    Effect.tryPromise(() => request.formData()),
-  )
+  const formData = yield* Effect.result(Effect.tryPromise(() => request.formData()))
   if (Result.isFailure(formData)) {
     return yield* httpFailure("Invalid cron form")
   }
 
   const decoded = yield* Effect.result(
-    Schema.decodeUnknownEffect(cronForm)(
-      Object.fromEntries(formData.success.entries()),
-    ),
+    Schema.decodeUnknownEffect(cronForm)(Object.fromEntries(formData.success.entries())),
   )
   if (Result.isFailure(decoded)) {
     return yield* httpFailure("Invalid cron form")
   }
 
-  const schedule = yield* Effect.result(
-    CronExpression.parse(decoded.success.expression),
-  )
+  const schedule = yield* Effect.result(CronExpression.parse(decoded.success.expression))
   if (Result.isFailure(schedule)) {
     return yield* httpFailure("Invalid cron expression")
   }
@@ -69,50 +60,32 @@ export const action = Effect.gen(function*() {
     input: { name: decoded.success.greetingName },
   })
   return yield* httpRedirect("/hatchet-crons")
-}).pipe(
-  withBetterAuthGuardAction.with({ redirectOnFail: "/login" }),
-  withActionEffect,
-)
+}).pipe(withBetterAuthGuardAction.with({ redirectOnFail: "/login" }), withActionEffect)
 
 interface HatchetCronsScreenProps {
   readonly crons: ReadonlyArray<CronRecord>
   readonly actionError?: string
 }
 
-export function HatchetCronsScreen({
-  crons,
-  actionError,
-}: HatchetCronsScreenProps) {
+export function HatchetCronsScreen({ crons, actionError }: HatchetCronsScreenProps) {
   const [expression, setExpression] = useState(defaultCronSource)
   const schedule = CronExpression.parseResult(expression)
-  const upcoming = Result.isSuccess(schedule)
-    ? CronExpression.nextRuns(schedule.success, 3)
-    : []
+  const upcoming = Result.isSuccess(schedule) ? CronExpression.nextRuns(schedule.success, 3) : []
 
   return (
     <main className="container">
       <article>
         <h2>Hatchet Crons</h2>
-        <p>
-          Create authenticated cron triggers for the registered greeting task.
-        </p>
+        <p>Create authenticated cron triggers for the registered greeting task.</p>
 
         <section aria-labelledby="create-cron-heading">
           <h3 id="create-cron-heading">Create cron</h3>
           <Form method="post">
             <fieldset>
               <label htmlFor="cron-name">Cron name</label>
-              <input
-                id="cron-name"
-                name="name"
-                type="text"
-                required
-                placeholder="weekday-greeting"
-              />
+              <input id="cron-name" name="name" type="text" required placeholder="weekday-greeting" />
 
-              <label htmlFor="cron-expression">
-                Five-field cron expression
-              </label>
+              <label htmlFor="cron-expression">Five-field cron expression</label>
               <input
                 id="cron-expression"
                 name="expression"
@@ -121,50 +94,34 @@ export function HatchetCronsScreen({
                 value={expression}
                 onChange={(event) => setExpression(event.currentTarget.value)}
               />
-              {Result.isFailure(schedule) ?
-                (
-                  <small role="status">
-                    Enter a valid five-field cron expression.
-                  </small>
-                ) :
-                null}
+              {Result.isFailure(schedule) ? (
+                <small role="status">Enter a valid five-field cron expression.</small>
+              ) : null}
 
               <label htmlFor="greeting-name">Greeting name</label>
-              <input
-                id="greeting-name"
-                name="greetingName"
-                type="text"
-                required
-                placeholder="Ada"
-              />
+              <input id="greeting-name" name="greetingName" type="text" required placeholder="Ada" />
             </fieldset>
 
             <section aria-labelledby="cron-preview-heading">
               <h4 id="cron-preview-heading">Next three local occurrences</h4>
-              {upcoming.length === 0 ? <p>Enter a valid expression to preview upcoming runs.</p> : (
+              {upcoming.length === 0 ? (
+                <p>Enter a valid expression to preview upcoming runs.</p>
+              ) : (
                 <ol>
                   {upcoming.map((date) => (
                     <li key={date.toISOString()}>
-                      <time dateTime={date.toISOString()}>
-                        {date.toLocaleString()}
-                      </time>
+                      <time dateTime={date.toISOString()}>{date.toLocaleString()}</time>
                     </li>
                   ))}
                 </ol>
               )}
             </section>
 
-            {actionError ?
-              (
-                <small
-                  role="alert"
-                  aria-live="assertive"
-                  style={{ color: "var(--pico-color-red-500)" }}
-                >
-                  {actionError}
-                </small>
-              ) :
-              null}
+            {actionError ? (
+              <small role="alert" aria-live="assertive" style={{ color: "var(--pico-color-red-500)" }}>
+                {actionError}
+              </small>
+            ) : null}
             <button type="submit" disabled={Result.isFailure(schedule)}>
               Create cron
             </button>
@@ -173,7 +130,9 @@ export function HatchetCronsScreen({
 
         <section aria-labelledby="cron-list-heading">
           <h3 id="cron-list-heading">Cron list</h3>
-          {crons.length === 0 ? <p>No crons found.</p> : (
+          {crons.length === 0 ? (
+            <p>No crons found.</p>
+          ) : (
             <ul>
               {crons.map((cron) => (
                 <li key={cron.id}>
@@ -208,10 +167,5 @@ export default function HatchetCrons({ loaderData }: Route.ComponentProps) {
     )
   }
 
-  return (
-    <HatchetCronsScreen
-      crons={loaderData.data.crons}
-      actionError={actionError}
-    />
-  )
+  return <HatchetCronsScreen crons={loaderData.data.crons} actionError={actionError} />
 }
diff --git a/apps/react-router-example/app/routes/todo-app.tsx b/apps/react-router-example/app/routes/todo-app.tsx
index 00e476e8..b029d121 100644
--- a/apps/react-router-example/app/routes/todo-app.tsx
+++ b/apps/react-router-example/app/routes/todo-app.tsx
@@ -10,19 +10,16 @@ import { AuthService, withBetterAuthGuard, withBetterAuthGuardAction } from "@ef
 import * as PrismaRepository from "./../../prisma/generated/effect/prisma-repository.js"
 import { TodoId, TodoModel } from "./../../prisma/generated/effect/index.js"
 
-export const loader = Effect.gen(function*() {
+export const loader = Effect.gen(function* () {
   const TodoRepo = yield* PrismaRepository.make(TodoModel, {
     modelName: "todo",
     spanPrefix: "Todo",
   })
   const todos = yield* TodoRepo.findMany()
   return yield* httpSuccess({ todos: todos })
-}).pipe(
-  withBetterAuthGuard.with({ redirectOnFail: "/login" }),
-  withLoaderEffect,
-)
+}).pipe(withBetterAuthGuard.with({ redirectOnFail: "/login" }), withLoaderEffect)
 
-export const action = Effect.gen(function*() {
+export const action = Effect.gen(function* () {
   const { request } = yield* ActionArgsContext
   const formData = yield* Effect.tryPromise(() => request.formData())
   const intent = String(formData.get("intent") ?? "create")
@@ -87,10 +84,7 @@ export const action = Effect.gen(function*() {
     },
   })
   return yield* httpRedirect("/todo-app")
-}).pipe(
-  withBetterAuthGuardAction.with({ redirectOnFail: "/login" }),
-  withActionEffect,
-)
+}).pipe(withBetterAuthGuardAction.with({ redirectOnFail: "/login" }), withActionEffect)
 
 export default function TodoApp({ loaderData }: Route.ComponentProps) {
   const actionData = useActionData<typeof action>()
@@ -105,35 +99,16 @@ export default function TodoApp({ loaderData }: Route.ComponentProps) {
           <Form method="post">
             <fieldset>
               <label htmlFor="title">Title</label>
-              <input
-                id="title"
-                name="title"
-                type="text"
-                required
-                placeholder="Title"
-              />
+              <input id="title" name="title" type="text" required placeholder="Title" />
               <label htmlFor="content">Content</label>
-              <textarea
-                id="content"
-                name="content"
-                placeholder="Content"
-                rows={3}
-              />
+              <textarea id="content" name="content" placeholder="Content" rows={3} />
             </fieldset>
             <input type="hidden" name="intent" value="create" />
-            {actionData &&
-                actionData.ok === false &&
-                actionData.errors?.length ?
-              (
-                <small
-                  role="alert"
-                  aria-live="assertive"
-                  style={{ color: "var(--pico-color-red-500)" }}
-                >
-                  {String(actionData.errors[0])}
-                </small>
-              ) :
-              null}
+            {actionData && actionData.ok === false && actionData.errors?.length ? (
+              <small role="alert" aria-live="assertive" style={{ color: "var(--pico-color-red-500)" }}>
+                {String(actionData.errors[0])}
+              </small>
+            ) : null}
             <button type="submit">Add</button>
           </Form>
           <ul>
@@ -155,21 +130,17 @@ export default function TodoApp({ loaderData }: Route.ComponentProps) {
                         {
                           intent: "toggle-status",
                           id: String(todo.id),
-                          status: e.currentTarget.checked
-                            ? "COMPLETED"
-                            : "PENDING",
+                          status: e.currentTarget.checked ? "COMPLETED" : "PENDING",
                         },
                         { method: "post" },
-                      )}
+                      )
+                    }
                   />
                   <div style={{ flex: 1 }}>
                     <strong>{todo.title}</strong>
                     {todo.content ? <span>— {todo.content}</span> : null}
                   </div>
-                  <button
-                    type="button"
-                    onClick={() => setEditingId(String(todo.id))}
-                  >
+                  <button type="button" onClick={() => setEditingId(String(todo.id))}>
                     Update
                   </button>
                   <Form method="post">
@@ -180,51 +151,38 @@ export default function TodoApp({ loaderData }: Route.ComponentProps) {
                     </button>
                   </Form>
                 </div>
-                {editingId === String(todo.id) ?
-                  (
-                    <Form
-                      method="post"
-                      style={{
-                        display: "flex",
-                        gap: "0.75rem",
-                        alignItems: "center",
-                        marginTop: "0.5rem",
+                {editingId === String(todo.id) ? (
+                  <Form
+                    method="post"
+                    style={{
+                      display: "flex",
+                      gap: "0.75rem",
+                      alignItems: "center",
+                      marginTop: "0.5rem",
+                    }}
+                  >
+                    <input type="hidden" name="intent" value="update" />
+                    <input type="hidden" name="id" value={String(todo.id)} />
+                    <input name="title" type="text" defaultValue={todo.title} placeholder="Title" />
+                    <input name="content" type="text" defaultValue={todo.content ?? ""} placeholder="Content" />
+                    <button
+                      type="button"
+                      onClick={(e) => {
+                        const form = (e.currentTarget as HTMLButtonElement).form
+                        if (form) {
+                          const fd = new FormData(form)
+                          submit(fd, { method: "post" })
+                        }
+                        setEditingId(null)
                       }}
                     >
-                      <input type="hidden" name="intent" value="update" />
-                      <input type="hidden" name="id" value={String(todo.id)} />
-                      <input
-                        name="title"
-                        type="text"
-                        defaultValue={todo.title}
-                        placeholder="Title"
-                      />
-                      <input
-                        name="content"
-                        type="text"
-                        defaultValue={todo.content ?? ""}
-                        placeholder="Content"
-                      />
-                      <button
-                        type="button"
-                        onClick={(e) => {
-                          const form = (e.currentTarget as HTMLButtonElement)
-                            .form
-                          if (form) {
-                            const fd = new FormData(form)
-                            submit(fd, { method: "post" })
-                          }
-                          setEditingId(null)
-                        }}
-                      >
-                        Save
-                      </button>
-                      <button type="button" onClick={() => setEditingId(null)}>
-                        Cancel
-                      </button>
-                    </Form>
-                  ) :
-                  null}
+                      Save
+                    </button>
+                    <button type="button" onClick={() => setEditingId(null)}>
+                      Cancel
+                    </button>
+                  </Form>
+                ) : null}
               </li>
             ))}
           </ul>
diff --git a/apps/react-router-example/tests/routes/api.hatchet.runs.test.ts b/apps/react-router-example/tests/routes/api.hatchet.runs.test.ts
index 9826310c..a4b1af70 100644
--- a/apps/react-router-example/tests/routes/api.hatchet.runs.test.ts
+++ b/apps/react-router-example/tests/routes/api.hatchet.runs.test.ts
@@ -5,9 +5,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 const hatchet = vi.hoisted(() => ({ runNoWait: vi.fn() }))
 vi.mock("@effectify/hatchet", async () => {
-  const actual = await vi.importActual<typeof import("@effectify/hatchet")>(
-    "@effectify/hatchet",
-  )
+  const actual = await vi.importActual<typeof import("@effectify/hatchet")>("@effectify/hatchet")
   const Effect = await import("effect/Effect")
   return {
     ...actual,
@@ -21,23 +19,20 @@ vi.mock("../../app/lib/runtime.server.js", async () => {
   const { ActionArgsContext } = await import("@effectify/react-router")
   const Effect = await import("effect/Effect")
   return {
-    withActionEffect: <A, E>(self: Effect.Effect<A, E, ActionArgsContextService>) => (args: ActionFunctionArgs) =>
-      Effect.runPromise(
-        self.pipe(Effect.provideService(ActionArgsContext, args)),
-      ).catch((error: unknown) => {
-        if (error instanceof Response) return error
-        throw error
-      }),
+    withActionEffect:
+      <A, E>(self: Effect.Effect<A, E, ActionArgsContextService>) =>
+      (args: ActionFunctionArgs) =>
+        Effect.runPromise(self.pipe(Effect.provideService(ActionArgsContext, args))).catch((error: unknown) => {
+          if (error instanceof Response) return error
+          throw error
+        }),
   }
 })
 
 import * as Effect from "effect/Effect"
 import { action } from "../../app/routes/api.hatchet.runs.js"
 
-const args = (
-  body: BodyInit,
-  method: "POST" | "PUT" = "POST",
-): ActionFunctionArgs => {
+const args = (body: BodyInit, method: "POST" | "PUT" = "POST"): ActionFunctionArgs => {
   const request = new Request("http://localhost/api/hatchet/runs", {
     body,
     headers: { "content-type": "application/json" },
@@ -80,9 +75,7 @@ describe("POST /api/hatchet/runs", () => {
   })
 
   it("rejects unauthenticated requests before Hatchet.runNoWait", async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      Response.json({ session: null, user: null }),
-    )
+    vi.mocked(fetch).mockResolvedValue(Response.json({ session: null, user: null }))
 
     const response = await action(args(JSON.stringify({ name: "Ada" })))
 
@@ -93,22 +86,20 @@ describe("POST /api/hatchet/runs", () => {
     expect(hatchet.runNoWait).not.toHaveBeenCalled()
   })
 
-  it.each([
-    ["not-json"],
-    [JSON.stringify({})],
-    [JSON.stringify({ name: "" })],
-    [JSON.stringify({ name: 42 })],
-  ])("returns a safe error for invalid Schema input", async (body) => {
-    const response = await action(args(body))
-    expect(response).toBeInstanceOf(Response)
-    if (!(response instanceof Response)) throw new Error("expected Response")
-    expect(response.status).toBe(400)
-    expect(await read(response)).toEqual({
-      ok: false,
-      errors: ["Request body must contain a non-empty name"],
-    })
-    expect(hatchet.runNoWait).not.toHaveBeenCalled()
-  })
+  it.each([["not-json"], [JSON.stringify({})], [JSON.stringify({ name: "" })], [JSON.stringify({ name: 42 })]])(
+    "returns a safe error for invalid Schema input",
+    async (body) => {
+      const response = await action(args(body))
+      expect(response).toBeInstanceOf(Response)
+      if (!(response instanceof Response)) throw new Error("expected Response")
+      expect(response.status).toBe(400)
+      expect(await read(response)).toEqual({
+        ok: false,
+        errors: ["Request body must contain a non-empty name"],
+      })
+      expect(hatchet.runNoWait).not.toHaveBeenCalled()
+    },
+  )
 
   it("rejects non-POST requests before any operation", async () => {
     const response = await action(args(JSON.stringify({ name: "Ada" }), "PUT"))
diff --git a/apps/react-router-example/tests/routes/app-shell.test.tsx b/apps/react-router-example/tests/routes/app-shell.test.tsx
index 3e67f396..d4b81a18 100644
--- a/apps/react-router-example/tests/routes/app-shell.test.tsx
+++ b/apps/react-router-example/tests/routes/app-shell.test.tsx
@@ -19,15 +19,7 @@ describe("react-router example app shell", () => {
   it("keeps route config aligned with navigation and auth entrypoints", () => {
     const routeEntries = JSON.stringify(routes)
 
-    for (
-      const path of [
-        "login",
-        "signup",
-        "todo-app",
-        "hatchet-crons",
-        "chat",
-      ]
-    ) {
+    for (const path of ["login", "signup", "todo-app", "hatchet-crons", "chat"]) {
       expect(routeEntries).toContain(`"path":"${path}"`)
     }
 
diff --git a/apps/react-router-example/tests/routes/hatchet-crons.test.tsx b/apps/react-router-example/tests/routes/hatchet-crons.test.tsx
index 0c2b8257..5ae485e5 100644
--- a/apps/react-router-example/tests/routes/hatchet-crons.test.tsx
+++ b/apps/react-router-example/tests/routes/hatchet-crons.test.tsx
@@ -14,13 +14,9 @@ const hatchet = vi.hoisted(() => ({
 }))
 
 vi.mock("@effectify/hatchet", async () => {
-  const actual = await vi.importActual<typeof import("@effectify/hatchet")>(
-    "@effectify/hatchet",
-  )
+  const actual = await vi.importActual<typeof import("@effectify/hatchet")>("@effectify/hatchet")
   const Effect = await import("effect/Effect")
-  const CronExpression = await import(
-    "../../../../packages/hatchet/src/CronExpression.js"
-  )
+  const CronExpression = await import("../../../../packages/hatchet/src/CronExpression.js")
   return {
     ...actual,
     CronExpression,
@@ -33,70 +29,45 @@ vi.mock("@effectify/hatchet", async () => {
 })
 
 vi.mock("../../app/lib/runtime.server.js", async () => {
-  const {
-    ActionArgsContext,
-    HttpResponseFailure,
-    HttpResponseRedirect,
-    HttpResponseSuccess,
-    LoaderArgsContext,
-  } = await import("@effectify/react-router")
+  const { ActionArgsContext, HttpResponseFailure, HttpResponseRedirect, HttpResponseSuccess, LoaderArgsContext } =
+    await import("@effectify/react-router")
   const Effect = await import("effect/Effect")
 
   const redirectResponse = (to: string) => new Response(null, { status: 302, headers: { Location: to } })
 
   return {
-    withLoaderEffect: <A, E>(
-      self: Effect.Effect<
-        HttpResponse<A> | Response,
-        E,
-        LoaderArgsContextService
-      >,
-    ) =>
-    (args: LoaderFunctionArgs) =>
-      Effect.runPromise(
-        self.pipe(Effect.provideService(LoaderArgsContext, args)),
-      ).then((result) => {
-        if (result instanceof Response) return result
-        if (result instanceof HttpResponseSuccess) {
-          return { ok: true as const, data: result.data }
-        }
-        if (result instanceof HttpResponseFailure) {
-          return Response.json(
-            { ok: false, errors: [String(result.cause)] },
-            { status: 500 },
-          )
-        }
-        if (result instanceof HttpResponseRedirect) {
-          return redirectResponse(result.to)
-        }
-        throw new Error("unexpected loader response")
-      }),
-    withActionEffect: <A, E>(
-      self: Effect.Effect<
-        HttpResponse<A> | Response,
-        E,
-        ActionArgsContextService
-      >,
-    ) =>
-    (args: ActionFunctionArgs) =>
-      Effect.runPromise(
-        self.pipe(Effect.provideService(ActionArgsContext, args)),
-      ).then((result) => {
-        if (result instanceof Response) return result
-        if (result instanceof HttpResponseSuccess) {
-          return { ok: true as const, response: result.data }
-        }
-        if (result instanceof HttpResponseFailure) {
-          return Response.json(
-            { ok: false, errors: [String(result.cause)] },
-            { status: 400 },
-          )
-        }
-        if (result instanceof HttpResponseRedirect) {
-          return redirectResponse(result.to)
-        }
-        throw new Error("unexpected action response")
-      }),
+    withLoaderEffect:
+      <A, E>(self: Effect.Effect<HttpResponse<A> | Response, E, LoaderArgsContextService>) =>
+      (args: LoaderFunctionArgs) =>
+        Effect.runPromise(self.pipe(Effect.provideService(LoaderArgsContext, args))).then((result) => {
+          if (result instanceof Response) return result
+          if (result instanceof HttpResponseSuccess) {
+            return { ok: true as const, data: result.data }
+          }
+          if (result instanceof HttpResponseFailure) {
+            return Response.json({ ok: false, errors: [String(result.cause)] }, { status: 500 })
+          }
+          if (result instanceof HttpResponseRedirect) {
+            return redirectResponse(result.to)
+          }
+          throw new Error("unexpected loader response")
+        }),
+    withActionEffect:
+      <A, E>(self: Effect.Effect<HttpResponse<A> | Response, E, ActionArgsContextService>) =>
+      (args: ActionFunctionArgs) =>
+        Effect.runPromise(self.pipe(Effect.provideService(ActionArgsContext, args))).then((result) => {
+          if (result instanceof Response) return result
+          if (result instanceof HttpResponseSuccess) {
+            return { ok: true as const, response: result.data }
+          }
+          if (result instanceof HttpResponseFailure) {
+            return Response.json({ ok: false, errors: [String(result.cause)] }, { status: 400 })
+          }
+          if (result instanceof HttpResponseRedirect) {
+            return redirectResponse(result.to)
+          }
+          throw new Error("unexpected action response")
+        }),
   }
 })
 
@@ -123,9 +94,7 @@ const loaderArgs = (): LoaderFunctionArgs => {
   }
 }
 
-const actionArgs = (
-  fields: Readonly<Record<string, string>>,
-): ActionFunctionArgs => {
+const actionArgs = (fields: Readonly<Record<string, string>>): ActionFunctionArgs => {
   const url = routeUrl()
   return {
     context: new RouterContextProvider(),
@@ -167,9 +136,7 @@ describe("/hatchet-crons", () => {
     hatchet.listCrons.mockReset().mockReturnValue(Effect.succeed([cron]))
     vi.stubGlobal(
       "fetch",
-      vi
-        .fn()
-        .mockImplementation(() => Promise.resolve(Response.json(authenticatedSession))),
+      vi.fn().mockImplementation(() => Promise.resolve(Response.json(authenticatedSession))),
     )
   })
 
@@ -179,9 +146,7 @@ describe("/hatchet-crons", () => {
   })
 
   it("redirects unauthenticated loaders before listing crons", async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      Response.json({ session: null, user: null }),
-    )
+    vi.mocked(fetch).mockResolvedValue(Response.json({ session: null, user: null }))
 
     const response = expectResponse(await loader(loaderArgs()))
 
@@ -191,9 +156,7 @@ describe("/hatchet-crons", () => {
   })
 
   it("redirects unauthenticated create actions before mutation", async () => {
-    vi.mocked(fetch).mockResolvedValue(
-      Response.json({ session: null, user: null }),
-    )
+    vi.mocked(fetch).mockResolvedValue(Response.json({ session: null, user: null }))
 
     const response = expectResponse(await action(actionArgs(validForm)))
 
@@ -213,12 +176,10 @@ describe("/hatchet-crons", () => {
   })
 
   it("creates a greeting cron with the package CronExpression value", async () => {
-    hatchet.createCron.mockImplementationOnce(
-      (_task: unknown, options: CreateCronOptions) => {
-        expect(CronExpression.source(options.schedule)).toBe("0 9 * * 1-5")
-        return Effect.succeed(cron)
-      },
-    )
+    hatchet.createCron.mockImplementationOnce((_task: unknown, options: CreateCronOptions) => {
+      expect(CronExpression.source(options.schedule)).toBe("0 9 * * 1-5")
+      return Effect.succeed(cron)
+    })
 
     const response = expectResponse(await action(actionArgs(validForm)))
 
@@ -232,9 +193,7 @@ describe("/hatchet-crons", () => {
   })
 
   it("returns clear feedback for a semantically invalid expression", async () => {
-    const response = expectResponse(
-      await action(actionArgs({ ...validForm, expression: "61 9 * * *" })),
-    )
+    const response = expectResponse(await action(actionArgs({ ...validForm, expression: "61 9 * * *" })))
 
     expect(response.status).toBe(400)
     expect(await response.json()).toEqual({
@@ -266,18 +225,15 @@ describe("/hatchet-crons", () => {
         errors: ["Invalid cron expression"],
       }),
     ).toBe("Invalid cron expression")
-    expect(
-      actionErrorFromData({ ok: true, response: undefined }),
-    ).toBeUndefined()
+    expect(actionErrorFromData({ ok: true, response: undefined })).toBeUndefined()
   })
 
   it("renders create, list, and next-three preview without delete or ownership controls", () => {
     vi.useFakeTimers()
     vi.setSystemTime(new Date("2025-01-03T10:00:00.000Z"))
-    const router = createMemoryRouter(
-      [{ path: "/", element: <HatchetCronsScreen crons={[cron]} /> }],
-      { initialEntries: ["/"] },
-    )
+    const router = createMemoryRouter([{ path: "/", element: <HatchetCronsScreen crons={[cron]} /> }], {
+      initialEntries: ["/"],
+    })
     const markup = renderToStaticMarkup(<RouterProvider router={router} />)
 
     expect(markup).toContain("Hatchet Crons")
diff --git a/apps/react-router-example/tests/unit/config/better-auth-options-contract.test.ts b/apps/react-router-example/tests/unit/config/better-auth-options-contract.test.ts
index 24bab21a..79704d11 100644
--- a/apps/react-router-example/tests/unit/config/better-auth-options-contract.test.ts
+++ b/apps/react-router-example/tests/unit/config/better-auth-options-contract.test.ts
@@ -8,9 +8,7 @@ import { authOptionsConfig } from "../../../app/lib/better-auth-options.server.j
 vi.mock("../../../app/lib/prisma.js", () => ({ database: {} }))
 
 const withConfig = (values: Record<string, string>) =>
-  authOptionsConfig.pipe(
-    Effect.provide(ConfigProvider.layer(ConfigProvider.fromUnknown(values))),
-  )
+  authOptionsConfig.pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromUnknown(values))))
 
 describe("Better Auth Effect configuration", () => {
   it("rejects a missing secret with an identifiable configuration error", async () => {
@@ -22,9 +20,7 @@ describe("Better Auth Effect configuration", () => {
 
   it("rejects a whitespace-only secret without rendering it", async () => {
     const suppliedSecret = " \t\n "
-    const error = await Effect.runPromise(
-      withConfig({ BETTER_AUTH_SECRET: suppliedSecret }).pipe(Effect.flip),
-    )
+    const error = await Effect.runPromise(withConfig({ BETTER_AUTH_SECRET: suppliedSecret }).pipe(Effect.flip))
 
     expect(String(error)).not.toContain(suppliedSecret)
     expect(JSON.stringify(error)).not.toContain(suppliedSecret)
@@ -32,43 +28,27 @@ describe("Better Auth Effect configuration", () => {
 
   it("passes a valid secret only to the Better Auth options boundary and preserves the URL", async () => {
     const suppliedSecret = "valid-secret-sentinel"
-    const options = await Effect.runPromise(
-      withConfig({ BETTER_AUTH_SECRET: suppliedSecret }),
-    )
+    const options = await Effect.runPromise(withConfig({ BETTER_AUTH_SECRET: suppliedSecret }))
 
     expect(options.secret).toBe(suppliedSecret)
-    expect(options.baseURL).toBe(
-      process.env.BETTER_AUTH_URL ?? "http://localhost:4200",
-    )
-    expect(JSON.stringify({ baseURL: options.baseURL })).not.toContain(
-      suppliedSecret,
-    )
+    expect(options.baseURL).toBe(process.env.BETTER_AUTH_URL ?? "http://localhost:4200")
+    expect(JSON.stringify({ baseURL: options.baseURL })).not.toContain(suppliedSecret)
   })
 })
 
 describe("Hatchet run README contract", () => {
   it("documents the required local Better Auth secret setup", async () => {
-    const readme = await readFile(
-      new URL("../../../README.md", import.meta.url),
-      "utf8",
-    )
+    const readme = await readFile(new URL("../../../README.md", import.meta.url), "utf8")
 
-    expect(readme).toContain(
-      'export BETTER_AUTH_SECRET="$(openssl rand -base64 32)"',
-    )
+    expect(readme).toContain('export BETTER_AUTH_SECRET="$(openssl rand -base64 32)"')
     expect(readme).toContain("Do not commit the generated value.")
   })
 
   it("documents the current authenticated asynchronous acceptance route", async () => {
-    const readme = await readFile(
-      new URL("../../../README.md", import.meta.url),
-      "utf8",
-    )
+    const readme = await readFile(new URL("../../../README.md", import.meta.url), "utf8")
 
     expect(readme).toContain("Sign in first")
-    expect(readme).toContain(
-      "cookie: better-auth.session_token=<session-cookie>",
-    )
+    expect(readme).toContain("cookie: better-auth.session_token=<session-cookie>")
     expect(readme).toContain("202 Accepted")
     expect(readme).toContain('{ "ok": true, "runId": "..." }')
     expect(readme).toContain("does not await workflow output")
diff --git a/apps/react-router-example/tests/unit/config/hatchet-example-contract.test.ts b/apps/react-router-example/tests/unit/config/hatchet-example-contract.test.ts
index dbda216c..2cc90dd3 100644
--- a/apps/react-router-example/tests/unit/config/hatchet-example-contract.test.ts
+++ b/apps/react-router-example/tests/unit/config/hatchet-example-contract.test.ts
@@ -14,74 +14,51 @@ describe("one-task Hatchet example configuration", () => {
     expect(compose).toContain("${HATCHET_DB_USER:?")
     expect(compose).toContain("${HATCHET_DB_PASSWORD:?")
     expect(compose).toContain("${HATCHET_DB_NAME:?")
-    expect(compose).not.toMatch(
-      /postgresql:\/\/hatchet:hatchet|POSTGRES_(?:DB|PASSWORD|USER):\s*hatchet/,
-    )
+    expect(compose).not.toMatch(/postgresql:\/\/hatchet:hatchet|POSTGRES_(?:DB|PASSWORD|USER):\s*hatchet/)
   })
 
   it("documents direct Compose setup, the Task endpoint, and authenticated cron management", async () => {
     const readme = await appFile("README.md")
-    for (
-      const expected of [
-        "docker compose up -d",
-        "docker compose down",
-        "HATCHET_CLIENT_TOKEN",
-        "/api/hatchet/runs",
-        "/hatchet-crons",
-        "Hatchet.layer",
-        "Hatchet.run",
-        "Hatchet.listCrons",
-        "Hatchet.createCron",
-        "CronExpression",
-      ]
-    ) {
+    for (const expected of [
+      "docker compose up -d",
+      "docker compose down",
+      "HATCHET_CLIENT_TOKEN",
+      "/api/hatchet/runs",
+      "/hatchet-crons",
+      "Hatchet.layer",
+      "Hatchet.run",
+      "Hatchet.listCrons",
+      "Hatchet.createCron",
+      "CronExpression",
+    ]) {
       expect(readme).toContain(expected)
     }
-    for (
-      const removed of [
-        "ensure-hatchet",
-        "hatchet:ensure",
-        "hatchet:up",
-        "dev:hatchet",
-        "HatchetRuntime",
-      ]
-    ) {
+    for (const removed of ["ensure-hatchet", "hatchet:ensure", "hatchet:up", "dev:hatchet", "HatchetRuntime"]) {
       expect(readme).not.toContain(removed)
     }
   })
 
   it("keeps cron route transport inside the Effect and Better Auth integrations", async () => {
     const route = await appFile("app/routes/hatchet-crons.tsx")
-    for (
-      const expected of [
-        "Effect.gen",
-        "ActionArgsContext",
-        "Schema.decodeUnknownEffect",
-        "CronExpression.parse",
-        "CronExpression.nextRuns",
-        "withLoaderEffect",
-        "withActionEffect",
-        "withBetterAuthGuard",
-        "withBetterAuthGuardAction",
-        "Hatchet.listCrons",
-        "Hatchet.createCron",
-      ]
-    ) {
+    for (const expected of [
+      "Effect.gen",
+      "ActionArgsContext",
+      "Schema.decodeUnknownEffect",
+      "CronExpression.parse",
+      "CronExpression.nextRuns",
+      "withLoaderEffect",
+      "withActionEffect",
+      "withBetterAuthGuard",
+      "withBetterAuthGuardAction",
+      "Hatchet.listCrons",
+      "Hatchet.createCron",
+    ]) {
       expect(route).toContain(expected)
     }
-    for (
-      const removed of [
-        "Hatchet.deleteCron",
-        "cron-owner",
-        "additionalMetadata",
-        "pattern=",
-      ]
-    ) {
+    for (const removed of ["Hatchet.deleteCron", "cron-owner", "additionalMetadata", "pattern="]) {
       expect(route).not.toContain(removed)
     }
-    expect(route).not.toMatch(
-      /export\s+(?:async\s+)?function\s+(?:loader|action)/,
-    )
+    expect(route).not.toMatch(/export\s+(?:async\s+)?function\s+(?:loader|action)/)
   })
 
   it("keeps Nx free of app-owned Hatchet orchestration", async () => {
@@ -92,18 +69,13 @@ describe("one-task Hatchet example configuration", () => {
 
   it("keeps the public package external without exposing its SDK", async () => {
     const vite = await appFile("vite.config.ts")
-    expect(vite).toMatch(
-      /ssr:\s*\{[\s\S]*external:[\s\S]*"@effectify\/hatchet"/,
-    )
+    expect(vite).toMatch(/ssr:\s*\{[\s\S]*external:[\s\S]*"@effectify\/hatchet"/)
     expect(vite).not.toContain("@hatchet-dev/typescript-sdk")
   })
 
   it("removes the custom Hatchet orchestration script", async () => {
     await expect(
-      access(
-        new URL("../../../scripts/ensure-hatchet.mjs", import.meta.url),
-        constants.F_OK,
-      ),
+      access(new URL("../../../scripts/ensure-hatchet.mjs", import.meta.url), constants.F_OK),
     ).rejects.toThrow()
   })
 })
diff --git a/apps/react-router-example/tests/unit/config/nx-cypress-target-contract.test.ts b/apps/react-router-example/tests/unit/config/nx-cypress-target-contract.test.ts
index 2196da0a..2c71b734 100644
--- a/apps/react-router-example/tests/unit/config/nx-cypress-target-contract.test.ts
+++ b/apps/react-router-example/tests/unit/config/nx-cypress-target-contract.test.ts
@@ -45,24 +45,15 @@ describe("Nx Cypress target contract", () => {
     }>(resolve(workspaceRoot, "apps/react-router-example/package.json"))
 
     expect(projectJson.targets?.build?.executor).toBe("nx:run-script")
-    expect(projectJson.targets?.build?.dependsOn).toEqual([
-      "typegen",
-      "prisma:generate",
-      "^build",
-    ])
+    expect(projectJson.targets?.build?.dependsOn).toEqual(["typegen", "prisma:generate", "^build"])
     expect(projectJson.targets?.build?.options).toEqual({ script: "build" })
     expect(packageJson.scripts?.build).toBe("react-router build")
   })
 
   it("removes the stale Vite outDir override so build artifacts stay under build/", () => {
-    const viteConfig = readFileSync(
-      resolve(workspaceRoot, "apps/react-router-example/vite.config.ts"),
-      "utf8",
-    )
+    const viteConfig = readFileSync(resolve(workspaceRoot, "apps/react-router-example/vite.config.ts"), "utf8")
 
-    expect(viteConfig).not.toContain(
-      "../../dist/apps/react-app-router-example",
-    )
+    expect(viteConfig).not.toContain("../../dist/apps/react-app-router-example")
     expect(viteConfig).not.toContain("outDir:")
   })
 
@@ -78,9 +69,7 @@ describe("Nx Cypress target contract", () => {
       }
     }>(resolve(workspaceRoot, "apps/react-router-example-e2e/project.json"))
 
-    expect(projectJson.targets?.e2e?.options?.devServerTarget).toBe(
-      "@effectify/react-router-example:start",
-    )
+    expect(projectJson.targets?.e2e?.options?.devServerTarget).toBe("@effectify/react-router-example:start")
     expect(projectJson.targets?.e2e?.options?.port).toBe(3100)
     expect(projectJson.targets?.e2e?.configurations?.manual).toEqual({
       skipServe: true,
diff --git a/apps/react-router-example/tests/unit/lib/hatchet-runtime.test.ts b/apps/react-router-example/tests/unit/lib/hatchet-runtime.test.ts
index c88ec2dd..3fa3a791 100644
--- a/apps/react-router-example/tests/unit/lib/hatchet-runtime.test.ts
+++ b/apps/react-router-example/tests/unit/lib/hatchet-runtime.test.ts
@@ -12,9 +12,7 @@ describe("Effect-native Hatchet architecture", () => {
       appFile("routes/hatchet-crons.tsx"),
       appFile("routes.tsx"),
     ])
-    const combined = [sharedRuntime, task, runRoute, cronRoute, routes].join(
-      "\n",
-    )
+    const combined = [sharedRuntime, task, runRoute, cronRoute, routes].join("\n")
 
     expect(sharedRuntime).toContain("Hatchet.layer({ tasks: [greetingTask] })")
     expect(sharedRuntime).toMatch(/Layer\.mergeAll\([\s\S]*hatchetLayer/)
@@ -31,15 +29,13 @@ describe("Effect-native Hatchet architecture", () => {
     expect(routes.match(/api\/hatchet/g)?.length).toBe(1)
     expect(routes).toContain('route("hatchet-crons"')
 
-    for (
-      const forbidden of [
-        "HatchetRuntime",
-        "ManagedRuntime",
-        "runPromise",
-        "authorize(",
-        "HATCHET_EXAMPLE_API_KEY",
-      ]
-    ) {
+    for (const forbidden of [
+      "HatchetRuntime",
+      "ManagedRuntime",
+      "runPromise",
+      "authorize(",
+      "HATCHET_EXAMPLE_API_KEY",
+    ]) {
       expect(combined).not.toContain(forbidden)
     }
     expect([task, runRoute, cronRoute].join("\n")).not.toContain("process.env")
diff --git a/apps/react-router-example/tests/unit/lib/hatchet-task.test.ts b/apps/react-router-example/tests/unit/lib/hatchet-task.test.ts
index 95e0a7a6..053a4406 100644
--- a/apps/react-router-example/tests/unit/lib/hatchet-task.test.ts
+++ b/apps/react-router-example/tests/unit/lib/hatchet-task.test.ts
@@ -6,15 +6,9 @@ import { describe, expect, it } from "vitest"
 describe("durable greeting task", () => {
   it("defines a stable task name and object input schema", async () => {
     expect(greetingTask.name).toBe("react-router-durable-greeting")
-    await expect(
-      Schema.decodeUnknownPromise(greetingInput)({ name: "Ada" }),
-    ).resolves.toEqual({ name: "Ada" })
-    await expect(
-      Schema.decodeUnknownPromise(greetingInput)("Ada"),
-    ).rejects.toBeInstanceOf(Error)
-    await expect(
-      Schema.decodeUnknownPromise(greetingInput)({ name: "" }),
-    ).rejects.toBeInstanceOf(Error)
+    await expect(Schema.decodeUnknownPromise(greetingInput)({ name: "Ada" })).resolves.toEqual({ name: "Ada" })
+    await expect(Schema.decodeUnknownPromise(greetingInput)("Ada")).rejects.toBeInstanceOf(Error)
+    await expect(Schema.decodeUnknownPromise(greetingInput)({ name: "" })).rejects.toBeInstanceOf(Error)
   })
 
   it("returns a transportable object from the task body", async () => {
diff --git a/apps/react-router-example/tests/unit/lib/runtime.server.test.ts b/apps/react-router-example/tests/unit/lib/runtime.server.test.ts
index 051271bf..f3cc7e3b 100644
--- a/apps/react-router-example/tests/unit/lib/runtime.server.test.ts
+++ b/apps/react-router-example/tests/unit/lib/runtime.server.test.ts
@@ -2,17 +2,15 @@ import { Runtime } from "@effectify/react-router"
 import { type ActionFunctionArgs, type LoaderFunctionArgs, RouterContextProvider } from "react-router"
 import { beforeEach, describe, expect, it, vi } from "vitest"
 
-const { adapterConfigMock, authHandlerMock, prismaLayerMock } = vi.hoisted(
-  () => {
-    process.env.DATABASE_URL = "file:./runtime-contract.db"
-
-    return {
-      adapterConfigMock: vi.fn(),
-      authHandlerMock: vi.fn(),
-      prismaLayerMock: vi.fn(),
-    }
-  },
-)
+const { adapterConfigMock, authHandlerMock, prismaLayerMock } = vi.hoisted(() => {
+  process.env.DATABASE_URL = "file:./runtime-contract.db"
+
+  return {
+    adapterConfigMock: vi.fn(),
+    authHandlerMock: vi.fn(),
+    prismaLayerMock: vi.fn(),
+  }
+})
 
 vi.mock("../../../app/lib/better-auth-options.server.js", async () => {
   const Effect = await import("effect/Effect")
@@ -55,10 +53,7 @@ vi.mock("../../../prisma/generated/effect/index.js", async () => {
   const Context = await import("effect/Context")
   const Layer = await import("effect/Layer")
 
-  class MockPrismaService extends Context.Service<
-    MockPrismaService,
-    { readonly label: "prisma" }
-  >()("Prisma") {}
+  class MockPrismaService extends Context.Service<MockPrismaService, { readonly label: "prisma" }>()("Prisma") {}
 
   return {
     Prisma: Object.assign(MockPrismaService, {
@@ -123,9 +118,7 @@ describe("runtime.server runtime contract", () => {
     )
 
     const request = new Request("https://example.com/api/auth")
-    const response = await loader(makeLoaderArgs(request)).catch(
-      (error) => error,
-    )
+    const response = await loader(makeLoaderArgs(request)).catch((error) => error)
 
     expect(response).toBeInstanceOf(Response)
     expect(response.status).toBe(200)
@@ -158,9 +151,7 @@ describe("runtime.server runtime contract", () => {
       body: new URLSearchParams({ intent: "sign-in" }),
       method: "POST",
     })
-    const response = await action(makeActionArgs(request)).catch(
-      (error) => error,
-    )
+    const response = await action(makeActionArgs(request)).catch((error) => error)
 
     expect(response).toBeInstanceOf(Response)
     expect(response.status).toBe(201)
diff --git a/apps/react-router-example/tsconfig.test.json b/apps/react-router-example/tsconfig.test.json
index 79267129..50e012fb 100644
--- a/apps/react-router-example/tsconfig.test.json
+++ b/apps/react-router-example/tsconfig.test.json
@@ -9,14 +9,7 @@
     "./tests/**/*.jsx"
   ],
   "compilerOptions": {
-    "types": [
-      "node",
-      "vite/client",
-      "@react-router/node",
-      "vitest/globals",
-      "react",
-      "react-dom"
-    ],
+    "types": ["node", "vite/client", "@react-router/node", "vitest/globals", "react", "react-dom"],
     "lib": ["DOM", "DOM.Iterable", "ES2022"],
     "skipLibCheck": true,
     "rootDir": "."
diff --git a/packages/hatchet/project.json b/packages/hatchet/project.json
index 6694b51c..e72d0a8b 100644
--- a/packages/hatchet/project.json
+++ b/packages/hatchet/project.json
@@ -6,22 +6,16 @@
   "targets": {
     "build": {
       "executor": "@nx/js:tsc",
-      "outputs": [
-        "{options.outputPath}"
-      ],
+      "outputs": ["{options.outputPath}"],
       "defaultConfiguration": "production",
       "options": {
         "outputPath": "packages/hatchet/dist",
         "main": "packages/hatchet/src/index.ts",
         "tsConfig": "packages/hatchet/tsconfig.lib.json",
-        "format": [
-          "esm"
-        ],
+        "format": ["esm"],
         "generatePackageJson": false,
         "updateBuildableProjectDepsInPackageJson": false,
-        "additionalEntryPoints": [
-          "packages/hatchet/src/testing/index.ts"
-        ]
+        "additionalEntryPoints": ["packages/hatchet/src/testing/index.ts"]
       },
       "configurations": {
         "development": {},
@@ -37,19 +31,11 @@
     },
     "lint": {
       "executor": "nx-oxlint:lint",
-      "outputs": [
-        "{options.outputFile}"
-      ],
+      "outputs": ["{options.outputFile}"],
       "options": {
-        "lintFilePatterns": [
-          "packages/hatchet/**/*.{ts,tsx,js,jsx}"
-        ]
+        "lintFilePatterns": ["packages/hatchet/**/*.{ts,tsx,js,jsx}"]
       }
     }
   },
-  "tags": [
-    "node",
-    "react",
-    "hatchet"
-  ]
+  "tags": ["node", "react", "hatchet"]
 }
diff --git a/packages/hatchet/scripts/test-cron.ts b/packages/hatchet/scripts/test-cron.ts
index 1a109c9a..4e45366a 100644
--- a/packages/hatchet/scripts/test-cron.ts
+++ b/packages/hatchet/scripts/test-cron.ts
@@ -6,7 +6,7 @@ const greeting = Task.make({
   input: Schema.Struct({ name: Schema.NonEmptyString }),
   fn: ({ name }) => Effect.log(`Hello, ${name}!`),
 })
-const program = Effect.gen(function*() {
+const program = Effect.gen(function* () {
   const schedule = yield* CronExpression.parse("0 9 * * *")
   const cron = yield* Hatchet.createCron(greeting, {
     name: "daily-greeting",
diff --git a/packages/hatchet/scripts/test-schedule.ts b/packages/hatchet/scripts/test-schedule.ts
index abb0cd7f..0b24c957 100644
--- a/packages/hatchet/scripts/test-schedule.ts
+++ b/packages/hatchet/scripts/test-schedule.ts
@@ -8,12 +8,8 @@ const greeting = Task.make({
   fn: ({ name }) => Effect.log(`Hello, ${name}!`),
 })
 
-const program = Effect.gen(function*() {
-  const schedule = yield* Hatchet.schedule(
-    greeting,
-    { name: "Ada" },
-    { _tag: "After", delay: "5 seconds" },
-  )
+const program = Effect.gen(function* () {
+  const schedule = yield* Hatchet.schedule(greeting, { name: "Ada" }, { _tag: "After", delay: "5 seconds" })
   yield* Effect.log("Schedule created", {
     id: schedule.id,
     triggerAt: schedule.triggerAt.toISOString(),
diff --git a/packages/hatchet/scripts/test-workflow.ts b/packages/hatchet/scripts/test-workflow.ts
index 68ebdf27..7dc890df 100644
--- a/packages/hatchet/scripts/test-workflow.ts
+++ b/packages/hatchet/scripts/test-workflow.ts
@@ -16,7 +16,7 @@ const greeting = Task.make({
   fn: ({ message }) => Effect.succeed({ result: "done", message }),
 })
 
-const program = Effect.gen(function*() {
+const program = Effect.gen(function* () {
   const handle = yield* Hatchet.runNoWait(greeting, {
     message: "Hello from Effect",
   })
diff --git a/packages/hatchet/src/CronExpression.ts b/packages/hatchet/src/CronExpression.ts
index 1d4353a2..c355eb46 100644
--- a/packages/hatchet/src/CronExpression.ts
+++ b/packages/hatchet/src/CronExpression.ts
@@ -41,9 +41,7 @@ class Value implements Encoded {
 const normalize = (input: string): string => input.trim().split(/\s+/).filter(Boolean).join(" ")
 
 const parseCron = (source: string): Result.Result<Cron.Cron, unknown> =>
-  source.split(" ").length === 5
-    ? Cron.parse(source)
-    : Result.fail("Hatchet cron expressions require five fields")
+  source.split(" ").length === 5 ? Cron.parse(source) : Result.fail("Hatchet cron expressions require five fields")
 
 const isEncoded = (value: unknown): value is Encoded =>
   Predicate.hasProperty(value, TypeId) &&
@@ -71,24 +69,16 @@ const state = (self: CronExpression): State => {
 const invalid = (originalCause: unknown) => new InvalidCronError({ field: "expression", originalCause })
 
 /** Parses exactly five Hatchet cron fields and preserves their normalized source. */
-export const parseResult = (
-  input: string,
-): Result.Result<CronExpression, InvalidCronError> => {
+export const parseResult = (input: string): Result.Result<CronExpression, InvalidCronError> => {
   if (typeof input !== "string") {
-    return Result.fail(
-      invalid(new TypeError("Cron expression must be a string")),
-    )
+    return Result.fail(invalid(new TypeError("Cron expression must be a string")))
   }
   const source = normalize(input)
-  return Result.map(parseCron(source), (cron) => new Value(source, cron)).pipe(
-    Result.mapError(invalid),
-  )
+  return Result.map(parseCron(source), (cron) => new Value(source, cron)).pipe(Result.mapError(invalid))
 }
 
 /** Effect-native parser for untrusted cron expression boundaries. */
-export const parse = (
-  input: string,
-): Effect.Effect<CronExpression, InvalidCronError> =>
+export const parse = (input: string): Effect.Effect<CronExpression, InvalidCronError> =>
   Result.match(parseResult(input), {
     onFailure: Effect.fail,
     onSuccess: Effect.succeed,
@@ -98,17 +88,10 @@ export const parse = (
 export const source = (self: CronExpression): string => state(self).source
 
 /** Returns the next occurrence strictly after the supplied instant. */
-export const next = (
-  self: CronExpression,
-  after?: DateTime.DateTime.Input,
-): Date => Cron.next(state(self).cron, after)
+export const next = (self: CronExpression, after?: DateTime.DateTime.Input): Date => Cron.next(state(self).cron, after)
 
 /** Returns a finite preview of upcoming occurrences. */
-export const nextRuns = (
-  self: CronExpression,
-  count: number,
-  after?: DateTime.DateTime.Input,
-): ReadonlyArray<Date> => {
+export const nextRuns = (self: CronExpression, count: number, after?: DateTime.DateTime.Input): ReadonlyArray<Date> => {
   if (!Number.isSafeInteger(count) || count <= 0) return []
   const dates: Array<Date> = []
   for (const date of Cron.sequence(state(self).cron, after)) {
diff --git a/packages/hatchet/src/Hatchet.ts b/packages/hatchet/src/Hatchet.ts
index 6c6d140b..4cbd8f97 100644
--- a/packages/hatchet/src/Hatchet.ts
+++ b/packages/hatchet/src/Hatchet.ts
@@ -52,12 +52,10 @@ export type EventJsonValue =
   | string
   | ReadonlyArray<EventJsonValue>
   | {
-    readonly [key: string]: EventJsonValue
-  }
+      readonly [key: string]: EventJsonValue
+    }
 export type EventPayload = { readonly [key: string]: EventJsonValue }
-export type PushEventOptions = Parameters<
-  InstanceType<typeof HatchetClientSdk>["events"]["push"]
->[2]
+export type PushEventOptions = Parameters<InstanceType<typeof HatchetClientSdk>["events"]["push"]>[2]
 export interface EventReceipt<TPayload extends EventPayload> {
   readonly eventId: string
   readonly key: string
@@ -80,12 +78,10 @@ const isJsonValue = (value: unknown, seen: Set<object>): boolean => {
   if (typeof value !== "object" || seen.has(value)) return false
   seen.add(value)
   const valid = Array.isArray(value)
-    ? Array.from(
-      { length: value.length },
-      (_, index) => index in value && isJsonValue(value[index], seen),
-    ).every(Boolean)
-    : isPlainObject(value) &&
-      Object.values(value).every((item) => isJsonValue(item, seen))
+    ? Array.from({ length: value.length }, (_, index) => index in value && isJsonValue(value[index], seen)).every(
+        Boolean,
+      )
+    : isPlainObject(value) && Object.values(value).every((item) => isJsonValue(item, seen))
   seen.delete(value)
   return valid
 }
@@ -97,14 +93,10 @@ export const validateEvent = (
 ): Effect.Effect<void, InvalidEventError> =>
   Effect.suspend(() => {
     if (key.trim().length === 0) {
-      return Effect.fail(
-        new InvalidEventError({ field: "key", reason: "EmptyKey" }),
-      )
+      return Effect.fail(new InvalidEventError({ field: "key", reason: "EmptyKey" }))
     }
     if (/[\u0000-\u001F\u007F-\u009F]/.test(key)) {
-      return Effect.fail(
-        new InvalidEventError({ field: "key", reason: "UnsafeKey" }),
-      )
+      return Effect.fail(new InvalidEventError({ field: "key", reason: "UnsafeKey" }))
     }
     if (!isPlainObject(payload) || !isJsonValue(payload, new Set())) {
       return Effect.fail(
@@ -137,9 +129,7 @@ export const validateEvent = (
     if (
       additionalMetadata !== undefined &&
       (!isPlainObject(additionalMetadata) ||
-        !Object.values(additionalMetadata).every(
-          (value) => typeof value === "string",
-        ))
+        !Object.values(additionalMetadata).every((value) => typeof value === "string"))
     ) {
       return Effect.fail(
         new InvalidEventError({
@@ -148,10 +138,7 @@ export const validateEvent = (
         }),
       )
     }
-    if (
-      priority !== undefined &&
-      (typeof priority !== "number" || !Number.isFinite(priority))
-    ) {
+    if (priority !== undefined && (typeof priority !== "number" || !Number.isFinite(priority))) {
       return Effect.fail(
         new InvalidEventError({
           field: "options",
@@ -162,19 +149,16 @@ export const validateEvent = (
     return scope === undefined || typeof scope === "string"
       ? Effect.void
       : Effect.fail(
-        new InvalidEventError({
-          field: "options",
-          reason: "InvalidOptionValue",
-        }),
-      )
+          new InvalidEventError({
+            field: "options",
+            reason: "InvalidOptionValue",
+          }),
+        )
   })
 
 export interface RunHandle<Output, Error> {
   readonly id: RunId
-  readonly await: Effect.Effect<
-    Output,
-    Error | TaskSchemaError | HatchetSdkError
-  >
+  readonly await: Effect.Effect<Output, Error | TaskSchemaError | HatchetSdkError>
   readonly cancel: Effect.Effect<void, HatchetSdkError>
 }
 
@@ -197,37 +181,22 @@ export interface ListCronOptions {
   readonly limit?: number
 }
 
-export type AcquisitionError =
-  | HatchetConfigError
-  | InvalidHatchetConfiguration
-  | HatchetSdkError
-  | TaskDeclarationError
+export type AcquisitionError = HatchetConfigError | InvalidHatchetConfiguration | HatchetSdkError | TaskDeclarationError
 
 export interface Service {
   readonly pushEvent: <const TPayload extends EventPayload>(
     key: string,
     payload: TPayload,
     options?: PushEventOptions,
-  ) => Effect.Effect<
-    EventReceipt<TPayload>,
-    InvalidEventError | AcquisitionError
-  >
+  ) => Effect.Effect<EventReceipt<TPayload>, InvalidEventError | AcquisitionError>
   readonly run: <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     input: unknown,
-  ) => Effect.Effect<
-    Output,
-    Error | TaskSchemaError | MissingTaskError | AcquisitionError,
-    Requirements
-  >
+  ) => Effect.Effect<Output, Error | TaskSchemaError | MissingTaskError | AcquisitionError, Requirements>
   readonly runNoWait: <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     input: unknown,
-  ) => Effect.Effect<
-    RunHandle<Output, Error>,
-    MissingTaskError | TaskSchemaError | AcquisitionError,
-    Requirements
-  >
+  ) => Effect.Effect<RunHandle<Output, Error>, MissingTaskError | TaskSchemaError | AcquisitionError, Requirements>
   readonly schedule: <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     input: unknown,
@@ -237,42 +206,21 @@ export interface Service {
     MissingTaskError | InvalidTimeError | TaskSchemaError | AcquisitionError,
     Requirements
   >
-  readonly getSchedule: (
-    id: ScheduleId,
-  ) => Effect.Effect<Option.Option<ScheduleRecord>, AcquisitionError>
-  readonly deleteSchedule: (
-    id: ScheduleId,
-  ) => Effect.Effect<boolean, AcquisitionError>
+  readonly getSchedule: (id: ScheduleId) => Effect.Effect<Option.Option<ScheduleRecord>, AcquisitionError>
+  readonly deleteSchedule: (id: ScheduleId) => Effect.Effect<boolean, AcquisitionError>
   readonly cancelRun: (id: RunId) => Effect.Effect<void, AcquisitionError>
-  readonly createCron: <
-    Name extends string,
-    Input,
-    Output,
-    Error,
-    Requirements,
-  >(
+  readonly createCron: <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     options: CreateCronOptions,
-  ) => Effect.Effect<
-    CronRecord,
-    MissingTaskError | InvalidCronError | TaskSchemaError | AcquisitionError,
-    Requirements
-  >
-  readonly getCron: (
-    id: CronId,
-  ) => Effect.Effect<Option.Option<CronRecord>, AcquisitionError>
+  ) => Effect.Effect<CronRecord, MissingTaskError | InvalidCronError | TaskSchemaError | AcquisitionError, Requirements>
+  readonly getCron: (id: CronId) => Effect.Effect<Option.Option<CronRecord>, AcquisitionError>
   readonly listCrons: (
     options?: ListCronOptions,
-  ) => Effect.Effect<
-    ReadonlyArray<CronRecord>,
-    InvalidCronFilterError | AcquisitionError
-  >
+  ) => Effect.Effect<ReadonlyArray<CronRecord>, InvalidCronFilterError | AcquisitionError>
   readonly deleteCron: (id: CronId) => Effect.Effect<boolean, AcquisitionError>
 }
 
-export class Hatchet extends Context.Service<Hatchet, Service>()(
-  "@effectify/hatchet/Hatchet",
-) {}
+export class Hatchet extends Context.Service<Hatchet, Service>()("@effectify/hatchet/Hatchet") {}
 
 const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
   const tasks = Registry.make()
@@ -294,7 +242,7 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
   const ensureTask = <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
   ): Effect.Effect<void, never, Requirements> =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       if (tasks.has(task.name)) return
       const context = yield* Effect.context<Requirements>()
       tasks.add(task, context)
@@ -318,28 +266,20 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
   const mapTaskSchemaError = (taskName: string, phase: "input" | "output") => (issue: unknown) =>
     new TaskSchemaError({ taskName, phase, issue })
 
-  const executeDecoded = <
-    Name extends string,
-    Input,
-    Output,
-    Error,
-    Requirements,
-  >(
+  const executeDecoded = <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     input: Input,
     context: Task.Context,
   ) =>
     Effect.scoped(
-      task._tag === "Durable"
-        ? task.execute(input, { ...context, invocationCount: 0 })
-        : task.execute(input, context),
+      task._tag === "Durable" ? task.execute(input, { ...context, invocationCount: 0 }) : task.execute(input, context),
     ).pipe(
       Effect.tap((output) =>
         task.outputSchema
           ? Schema.encodeUnknownEffect(task.outputSchema)(output).pipe(
-            Effect.mapError(mapTaskSchemaError(task.name, "output")),
-          )
-          : Effect.void
+              Effect.mapError(mapTaskSchemaError(task.name, "output")),
+            )
+          : Effect.void,
       ),
     )
 
@@ -347,44 +287,26 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
     context: Task.Context,
   ) => Effect.Effect<Output, Error | TaskSchemaError, Requirements>
 
-  const prepareInput = <
-    Name extends string,
-    Input,
-    Output,
-    Error,
-    Requirements,
-  >(
+  const prepareInput = <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     input: unknown,
-  ): Effect.Effect<
-    PreparedExecution<Output, Error, Requirements>,
-    TaskSchemaError
-  > => {
+  ): Effect.Effect<PreparedExecution<Output, Error, Requirements>, TaskSchemaError> => {
     if (!task.inputSchema) {
       return Effect.succeed((context: Task.Context) =>
-        Effect.scoped(
-          tasks.run<Output, Error>(task.name, input, context) ??
-            Effect.die("registered task disappeared"),
-        )
+        Effect.scoped(tasks.run<Output, Error>(task.name, input, context) ?? Effect.die("registered task disappeared")),
       )
     }
     return Schema.decodeUnknownEffect(task.inputSchema)(input).pipe(
       Effect.mapError(mapTaskSchemaError(task.name, "input")),
-      Effect.map(
-        (decoded) => (context: Task.Context) => executeDecoded(task, decoded, context),
-      ),
+      Effect.map((decoded) => (context: Task.Context) => executeDecoded(task, decoded, context)),
     )
   }
 
   const runNoWait = <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     input: unknown,
-  ): Effect.Effect<
-    RunHandle<Output, Error>,
-    MissingTaskError | TaskSchemaError | HatchetSdkError,
-    Requirements
-  > =>
-    Effect.gen(function*() {
+  ): Effect.Effect<RunHandle<Output, Error>, MissingTaskError | TaskSchemaError | HatchetSdkError, Requirements> =>
+    Effect.gen(function* () {
       yield* ensureTask(task)
       const prepared = yield* prepareInput(task, input)
       const execution = nextContext()
@@ -392,7 +314,7 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
       const remove = Effect.sync(() => runs.delete(id))
       const registered = yield* Deferred.make<void>()
       return yield* Effect.uninterruptibleMask((restore) =>
-        Effect.gen(function*() {
+        Effect.gen(function* () {
           const fiber = yield* Effect.forkIn(
             Deferred.await(registered).pipe(
               Effect.andThen(prepared(execution.context)),
@@ -406,20 +328,12 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
           const handle = {
             id,
             await: Fiber.join(fiber).pipe(Effect.ensuring(remove)),
-            cancel: Fiber.interrupt(fiber).pipe(
-              Effect.asVoid,
-              Effect.ensuring(remove),
-            ),
+            cancel: Fiber.interrupt(fiber).pipe(Effect.asVoid, Effect.ensuring(remove)),
           }
           return yield* restore(Effect.succeed(handle)).pipe(
-            Effect.onInterrupt(() =>
-              Fiber.interrupt(fiber).pipe(
-                Effect.asVoid,
-                Effect.ensuring(remove),
-              )
-            ),
+            Effect.onInterrupt(() => Fiber.interrupt(fiber).pipe(Effect.asVoid, Effect.ensuring(remove))),
           )
-        })
+        }),
       )
     })
 
@@ -432,12 +346,10 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
     MissingTaskError | InvalidTimeError | TaskSchemaError | HatchetSdkError,
     Requirements
   > =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       yield* ensureTask(task)
       const now = yield* Clock.currentTimeMillis
-      const triggerAt = timing._tag === "At"
-        ? timing.at.getTime()
-        : now + Duration.toMillis(timing.delay)
+      const triggerAt = timing._tag === "At" ? timing.at.getTime() : now + Duration.toMillis(timing.delay)
       if (!Number.isFinite(triggerAt) || triggerAt <= now) {
         return yield* new InvalidTimeError({
           field: timing._tag === "At" ? "at" : "delay",
@@ -457,9 +369,7 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
         Effect.onError((cause) =>
           Cause.hasInterruptsOnly(cause)
             ? Effect.void
-            : Effect.logError(
-              `ScheduledTaskFailure scheduleId=${id} taskName=${task.name}`,
-            )
+            : Effect.logError(`ScheduledTaskFailure scheduleId=${id} taskName=${task.name}`),
         ),
         Effect.ignore,
         Effect.ensuring(Effect.sync(() => schedules.delete(id))),
@@ -472,27 +382,21 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
   const createCron = <Name extends string, Input, Output, Error, Requirements>(
     task: Task.Of<Name, Input, Output, Error, Requirements>,
     options: CreateCronOptions,
-  ): Effect.Effect<
-    CronRecord,
-    MissingTaskError | InvalidCronError | TaskSchemaError | HatchetSdkError,
-    Requirements
-  > =>
-    Effect.gen(function*() {
+  ): Effect.Effect<CronRecord, MissingTaskError | InvalidCronError | TaskSchemaError | HatchetSdkError, Requirements> =>
+    Effect.gen(function* () {
       yield* ensureTask(task)
       yield* CronValidation.validateCreate(options)
       const encoded = task.inputSchema
-        ? yield* Schema.encodeUnknownEffect(task.inputSchema)(
-          options.input,
-        ).pipe(
-          Effect.mapError(
-            (issue) =>
-              new TaskSchemaError({
-                taskName: task.name,
-                phase: "input",
-                issue,
-              }),
-          ),
-        )
+        ? yield* Schema.encodeUnknownEffect(task.inputSchema)(options.input).pipe(
+            Effect.mapError(
+              (issue) =>
+                new TaskSchemaError({
+                  taskName: task.name,
+                  phase: "input",
+                  issue,
+                }),
+            ),
+          )
         : options.input
       const input = yield* CronValidation.validateInput(encoded)
       const record: CronRecord = {
@@ -501,14 +405,10 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
         name: options.name,
         expression: CronExpression.source(options.schedule),
         input,
-        ...(options.additionalMetadata === undefined
-          ? {}
-          : { additionalMetadata: options.additionalMetadata }),
+        ...(options.additionalMetadata === undefined ? {} : { additionalMetadata: options.additionalMetadata }),
         enabled: true,
         method: "DEFAULT",
-        ...(options.priority === undefined
-          ? {}
-          : { priority: options.priority }),
+        ...(options.priority === undefined ? {} : { priority: options.priority }),
       }
       crons.set(record.id, record)
       return record
@@ -516,27 +416,13 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
 
   const listCrons = (
     options: ListCronOptions = {},
-  ): Effect.Effect<
-    ReadonlyArray<CronRecord>,
-    InvalidCronFilterError | HatchetSdkError
-  > =>
-    Effect.gen(function*() {
+  ): Effect.Effect<ReadonlyArray<CronRecord>, InvalidCronFilterError | HatchetSdkError> =>
+    Effect.gen(function* () {
       yield* CronValidation.validateList(options)
       return Array.from(crons.values())
-        .filter(
-          (cron) =>
-            options.taskName === undefined ||
-            cron.taskName === options.taskName,
-        )
-        .filter(
-          (cron) => options.name === undefined || cron.name === options.name,
-        )
-        .slice(
-          options.offset ?? 0,
-          options.limit === undefined
-            ? undefined
-            : (options.offset ?? 0) + options.limit,
-        )
+        .filter((cron) => options.taskName === undefined || cron.taskName === options.taskName)
+        .filter((cron) => options.name === undefined || cron.name === options.name)
+        .slice(options.offset ?? 0, options.limit === undefined ? undefined : (options.offset ?? 0) + options.limit)
     })
 
   return {
@@ -547,9 +433,7 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
             eventId: `event-${nextEventId++}`,
             key,
             payload,
-            ...(options?.additionalMetadata === undefined
-              ? {}
-              : { additionalMetadata: options.additionalMetadata }),
+            ...(options?.additionalMetadata === undefined ? {} : { additionalMetadata: options.additionalMetadata }),
             ...(options?.scope === undefined ? {} : { scope: options.scope }),
           })),
         ),
@@ -559,7 +443,7 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
     schedule,
     getSchedule: (id) => Effect.sync(() => Option.fromNullishOr(schedules.get(id)?.record)),
     deleteSchedule: (id) =>
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const schedule = schedules.get(id)
         if (!schedule || schedule.deleting) return false
         schedule.deleting = true
@@ -586,9 +470,7 @@ const makeInMemoryService = (ownerScope: Scope.Scope): Service => {
   }
 }
 
-export const layerInMemory = Layer.effect(Hatchet)(
-  Effect.map(Scope.Scope, makeInMemoryService),
-)
+export const layerInMemory = Layer.effect(Hatchet)(Effect.map(Scope.Scope, makeInMemoryService))
 
 export interface LayerOptions<Tasks extends ReadonlyArray<Task.Any>> {
   readonly tasks: Tasks
@@ -604,10 +486,10 @@ type Ready = {
 type State =
   | { readonly _tag: "Idle" }
   | {
-    readonly _tag: "Initializing"
-    readonly deferred: Deferred.Deferred<Ready, AcquisitionError>
-    readonly scope: Scope.Closeable
-  }
+      readonly _tag: "Initializing"
+      readonly deferred: Deferred.Deferred<Ready, AcquisitionError>
+      readonly scope: Scope.Closeable
+    }
   | ({ readonly _tag: "Ready" } & Ready)
   | { readonly _tag: "Disposed" }
 
@@ -615,20 +497,17 @@ const initialize = <const Tasks extends ReadonlyArray<Task.Any>>(
   options: LayerOptions<Tasks>,
   scope: Scope.Closeable,
 ): Effect.Effect<Ready, AcquisitionError, Task.Requirements<Tasks[number]>> =>
-  Effect.gen(function*() {
-    const liveOptions = options.options === undefined
-      ? yield* (options.config ?? HatchetConfig.fromEnv).pipe(
-        Effect.mapError(
-          (originalCause) => new HatchetConfigError({ field: "config", originalCause }),
-        ),
-      )
-      : options.options
+  Effect.gen(function* () {
+    const liveOptions =
+      options.options === undefined
+        ? yield* (options.config ?? HatchetConfig.fromEnv).pipe(
+            Effect.mapError((originalCause) => new HatchetConfigError({ field: "config", originalCause })),
+          )
+        : options.options
     const services = yield* Layer.buildWithScope(
       Live.layer<Task.Requirements<Tasks[number]>>(
         liveOptions,
-        options.tasks as ReadonlyArray<
-          Task.Any<Task.Requirements<Tasks[number]>>
-        >,
+        options.tasks as ReadonlyArray<Task.Any<Task.Requirements<Tasks[number]>>>,
       ),
       scope,
     )
@@ -645,7 +524,7 @@ export const layer = <const Tasks extends ReadonlyArray<Task.Any>>(
   options: LayerOptions<Tasks>,
 ): Layer.Layer<Hatchet, never, Task.Requirements<Tasks[number]>> =>
   Layer.effect(Hatchet)(
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const ownerScope = yield* Scope.Scope
       const captured = yield* Effect.context<Task.Requirements<Tasks[number]>>()
       const mutex = yield* Semaphore.make(1)
@@ -669,29 +548,21 @@ export const layer = <const Tasks extends ReadonlyArray<Task.Any>>(
             scope: childScope,
           }
           state = initializing
-          const attempt = Effect.exit(
-            initialize(options, childScope).pipe(
-              Effect.provideContext(captured),
-            ),
-          ).pipe(
+          const attempt = Effect.exit(initialize(options, childScope).pipe(Effect.provideContext(captured))).pipe(
             Effect.flatMap((exit) =>
-              Effect.gen(function*() {
+              Effect.gen(function* () {
                 if (Exit.isFailure(exit)) {
                   yield* Scope.close(childScope, exit)
                 }
                 yield* Deferred.done(deferred, exit)
                 yield* transition(
                   initializing,
-                  Exit.isSuccess(exit)
-                    ? { _tag: "Ready", ...exit.value }
-                    : { _tag: "Idle" },
+                  Exit.isSuccess(exit) ? { _tag: "Ready", ...exit.value } : { _tag: "Idle" },
                 )
-              })
+              }),
             ),
           )
-          return Effect.forkIn(attempt, ownerScope).pipe(
-            Effect.as(Deferred.await(deferred)),
-          )
+          return Effect.forkIn(attempt, ownerScope).pipe(Effect.as(Deferred.await(deferred)))
         }),
       )
 
@@ -718,16 +589,13 @@ export const layer = <const Tasks extends ReadonlyArray<Task.Any>>(
       )
 
       const ready = Effect.flatten(begin)
-      const use = <A, E, R>(
-        operation: (service: Service) => Effect.Effect<A, E, R>,
-      ) => Effect.flatMap(ready, ({ service }) => operation(service))
+      const use = <A, E, R>(operation: (service: Service) => Effect.Effect<A, E, R>) =>
+        Effect.flatMap(ready, ({ service }) => operation(service))
 
       const service = Hatchet.of({
         pushEvent: (key, payload, eventOptions) =>
           validateEvent(key, payload, eventOptions).pipe(
-            Effect.andThen(
-              use((hatchet) => hatchet.pushEvent(key, payload, eventOptions)),
-            ),
+            Effect.andThen(use((hatchet) => hatchet.pushEvent(key, payload, eventOptions))),
           ),
         run: (task, input) => use((hatchet) => hatchet.run(task, input)),
         runNoWait: (task, input) => use((hatchet) => hatchet.runNoWait(task, input)),
@@ -743,14 +611,14 @@ export const layer = <const Tasks extends ReadonlyArray<Task.Any>>(
 
       yield* Effect.addFinalizer(() =>
         mutex.withPermit(
-          Effect.gen(function*() {
+          Effect.gen(function* () {
             const previous = state
             state = { _tag: "Disposed" }
             if (previous._tag === "Ready" || previous._tag === "Initializing") {
               yield* Scope.close(previous.scope, Exit.void)
             }
           }),
-        )
+        ),
       )
       return service
     }),
@@ -760,33 +628,18 @@ export const pushEvent = <const TPayload extends EventPayload>(
   key: string,
   payload: TPayload,
   options?: PushEventOptions,
-): Effect.Effect<
-  EventReceipt<TPayload>,
-  InvalidEventError | AcquisitionError,
-  Hatchet
-> =>
+): Effect.Effect<EventReceipt<TPayload>, InvalidEventError | AcquisitionError, Hatchet> =>
   validateEvent(key, payload, options).pipe(
-    Effect.andThen(
-      Effect.flatMap(Hatchet, (service) => service.pushEvent(key, payload, options)),
-    ),
+    Effect.andThen(Effect.flatMap(Hatchet, (service) => service.pushEvent(key, payload, options))),
   )
 
 export const run = <Name extends string, Input, Output, Error, Requirements>(
   task: Task.Of<Name, Input, Output, Error, Requirements>,
   input: unknown,
-): Effect.Effect<
-  Output,
-  Error | TaskSchemaError | MissingTaskError | AcquisitionError,
-  Hatchet | Requirements
-> => Effect.flatMap(Hatchet, (service) => service.run(task, input))
-
-export const runNoWait = <
-  Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
->(
+): Effect.Effect<Output, Error | TaskSchemaError | MissingTaskError | AcquisitionError, Hatchet | Requirements> =>
+  Effect.flatMap(Hatchet, (service) => service.run(task, input))
+
+export const runNoWait = <Name extends string, Input, Output, Error, Requirements>(
   task: Task.Of<Name, Input, Output, Error, Requirements>,
   input: unknown,
 ): Effect.Effect<
@@ -795,13 +648,7 @@ export const runNoWait = <
   Hatchet | Requirements
 > => Effect.flatMap(Hatchet, (service) => service.runNoWait(task, input))
 
-export const schedule = <
-  Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
->(
+export const schedule = <Name extends string, Input, Output, Error, Requirements>(
   task: Task.Of<Name, Input, Output, Error, Requirements>,
   input: unknown,
   timing: ScheduleTiming,
@@ -811,26 +658,16 @@ export const schedule = <
   Hatchet | Requirements
 > => Effect.flatMap(Hatchet, (service) => service.schedule(task, input, timing))
 
-export const getSchedule = (
-  id: ScheduleId,
-): Effect.Effect<Option.Option<ScheduleRecord>, AcquisitionError, Hatchet> =>
+export const getSchedule = (id: ScheduleId): Effect.Effect<Option.Option<ScheduleRecord>, AcquisitionError, Hatchet> =>
   Effect.flatMap(Hatchet, (service) => service.getSchedule(id))
 
-export const deleteSchedule = (
-  id: ScheduleId,
-): Effect.Effect<boolean, AcquisitionError, Hatchet> => Effect.flatMap(Hatchet, (service) => service.deleteSchedule(id))
-
-export const cancelRun = (
-  id: RunId,
-): Effect.Effect<void, AcquisitionError, Hatchet> => Effect.flatMap(Hatchet, (service) => service.cancelRun(id))
-
-export const createCron = <
-  Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
->(
+export const deleteSchedule = (id: ScheduleId): Effect.Effect<boolean, AcquisitionError, Hatchet> =>
+  Effect.flatMap(Hatchet, (service) => service.deleteSchedule(id))
+
+export const cancelRun = (id: RunId): Effect.Effect<void, AcquisitionError, Hatchet> =>
+  Effect.flatMap(Hatchet, (service) => service.cancelRun(id))
+
+export const createCron = <Name extends string, Input, Output, Error, Requirements>(
   task: Task.Of<Name, Input, Output, Error, Requirements>,
   options: CreateCronOptions,
 ): Effect.Effect<
@@ -839,19 +676,13 @@ export const createCron = <
   Hatchet | Requirements
 > => Effect.flatMap(Hatchet, (service) => service.createCron(task, options))
 
-export const getCron = (
-  id: CronId,
-): Effect.Effect<Option.Option<CronRecord>, AcquisitionError, Hatchet> =>
+export const getCron = (id: CronId): Effect.Effect<Option.Option<CronRecord>, AcquisitionError, Hatchet> =>
   Effect.flatMap(Hatchet, (service) => service.getCron(id))
 
 export const listCrons = (
   options?: ListCronOptions,
-): Effect.Effect<
-  ReadonlyArray<CronRecord>,
-  InvalidCronFilterError | AcquisitionError,
-  Hatchet
-> => Effect.flatMap(Hatchet, (service) => service.listCrons(options))
-
-export const deleteCron = (
-  id: CronId,
-): Effect.Effect<boolean, AcquisitionError, Hatchet> => Effect.flatMap(Hatchet, (service) => service.deleteCron(id))
+): Effect.Effect<ReadonlyArray<CronRecord>, InvalidCronFilterError | AcquisitionError, Hatchet> =>
+  Effect.flatMap(Hatchet, (service) => service.listCrons(options))
+
+export const deleteCron = (id: CronId): Effect.Effect<boolean, AcquisitionError, Hatchet> =>
+  Effect.flatMap(Hatchet, (service) => service.deleteCron(id))
diff --git a/packages/hatchet/src/HatchetConfig.ts b/packages/hatchet/src/HatchetConfig.ts
index 1d00d3f8..9aee26da 100644
--- a/packages/hatchet/src/HatchetConfig.ts
+++ b/packages/hatchet/src/HatchetConfig.ts
@@ -5,20 +5,11 @@ import * as Schema from "effect/Schema"
 export const TlsStrategy = Schema.Literals(["tls", "mtls", "none"])
 export type TlsStrategy = typeof TlsStrategy.Type
 
-export const LogLevel = Schema.Literals([
-  "OFF",
-  "DEBUG",
-  "INFO",
-  "WARN",
-  "ERROR",
-])
+export const LogLevel = Schema.Literals(["OFF", "DEBUG", "INFO", "WARN", "ERROR"])
 export type LogLevel = typeof LogLevel.Type
 
 const PositiveInteger = Schema.Int.check(Schema.isGreaterThan(0))
-const WorkerLabels = Schema.Record(
-  Schema.String,
-  Schema.Union([Schema.String, Schema.Number]),
-)
+const WorkerLabels = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Number]))
 
 export const ClientOptions = Schema.Struct({
   token: Schema.Redacted(Schema.String),
@@ -55,51 +46,28 @@ export const fromEnv: Config.Config<HatchetOptions> = Config.all({
   hostPort: optional(Config.schema(Schema.NonEmptyString, "HATCHET_HOST_PORT")),
   apiUrl: optional(Config.schema(Schema.NonEmptyString, "HATCHET_API_URL")),
   tenantId: optional(Config.schema(Schema.NonEmptyString, "HATCHET_TENANT_ID")),
-  namespace: optional(
-    Config.schema(Schema.NonEmptyString, "HATCHET_NAMESPACE"),
-  ),
+  namespace: optional(Config.schema(Schema.NonEmptyString, "HATCHET_NAMESPACE")),
   logLevel: optional(Config.schema(LogLevel, "HATCHET_LOG_LEVEL")),
   tlsStrategy: optional(Config.schema(TlsStrategy, "HATCHET_TLS_STRATEGY")),
-  workerName: Config.schema(Schema.NonEmptyString, "HATCHET_WORKER_NAME").pipe(
-    Config.withDefault("hatchet-worker"),
-  ),
+  workerName: Config.schema(Schema.NonEmptyString, "HATCHET_WORKER_NAME").pipe(Config.withDefault("hatchet-worker")),
   workerSlots: optional(Config.schema(PositiveInteger, "HATCHET_WORKER_SLOTS")),
-  readyTimeoutMs: optional(
-    Config.schema(PositiveInteger, "HATCHET_WORKER_READY_TIMEOUT_MS"),
-  ),
-  stopTimeoutMs: Config.schema(
-    PositiveInteger,
-    "HATCHET_WORKER_STOP_TIMEOUT_MS",
-  ).pipe(Config.withDefault(5_000)),
+  readyTimeoutMs: optional(Config.schema(PositiveInteger, "HATCHET_WORKER_READY_TIMEOUT_MS")),
+  stopTimeoutMs: Config.schema(PositiveInteger, "HATCHET_WORKER_STOP_TIMEOUT_MS").pipe(Config.withDefault(5_000)),
 }).pipe(
   Config.map((value) => ({
     client: {
       token: value.token,
-      ...(Option.isSome(value.hostPort)
-        ? { hostPort: value.hostPort.value }
-        : {}),
+      ...(Option.isSome(value.hostPort) ? { hostPort: value.hostPort.value } : {}),
       ...(Option.isSome(value.apiUrl) ? { apiUrl: value.apiUrl.value } : {}),
-      ...(Option.isSome(value.tenantId)
-        ? { tenantId: value.tenantId.value }
-        : {}),
-      ...(Option.isSome(value.namespace)
-        ? { namespace: value.namespace.value }
-        : {}),
-      ...(Option.isSome(value.logLevel)
-        ? { logLevel: value.logLevel.value }
-        : {}),
-      ...(Option.isSome(value.tlsStrategy)
-        ? { tlsStrategy: value.tlsStrategy.value }
-        : {}),
+      ...(Option.isSome(value.tenantId) ? { tenantId: value.tenantId.value } : {}),
+      ...(Option.isSome(value.namespace) ? { namespace: value.namespace.value } : {}),
+      ...(Option.isSome(value.logLevel) ? { logLevel: value.logLevel.value } : {}),
+      ...(Option.isSome(value.tlsStrategy) ? { tlsStrategy: value.tlsStrategy.value } : {}),
     },
     worker: {
       name: value.workerName,
-      ...(Option.isSome(value.workerSlots)
-        ? { slots: value.workerSlots.value }
-        : {}),
-      ...(Option.isSome(value.readyTimeoutMs)
-        ? { readyTimeoutMs: value.readyTimeoutMs.value }
-        : {}),
+      ...(Option.isSome(value.workerSlots) ? { slots: value.workerSlots.value } : {}),
+      ...(Option.isSome(value.readyTimeoutMs) ? { readyTimeoutMs: value.readyTimeoutMs.value } : {}),
       stopTimeoutMs: value.stopTimeoutMs,
     },
   })),
diff --git a/packages/hatchet/src/Model.ts b/packages/hatchet/src/Model.ts
index dbb04053..ffe6939a 100644
--- a/packages/hatchet/src/Model.ts
+++ b/packages/hatchet/src/Model.ts
@@ -1,18 +1,12 @@
 import * as Schema from "effect/Schema"
 
-export const RunId = Schema.NonEmptyString.pipe(
-  Schema.brand("@effectify/hatchet/RunId"),
-)
+export const RunId = Schema.NonEmptyString.pipe(Schema.brand("@effectify/hatchet/RunId"))
 export type RunId = typeof RunId.Type
 
-export const ScheduleId = Schema.String.pipe(
-  Schema.brand("@effectify/hatchet/ScheduleId"),
-)
+export const ScheduleId = Schema.String.pipe(Schema.brand("@effectify/hatchet/ScheduleId"))
 export type ScheduleId = typeof ScheduleId.Type
 
-export const CronId = Schema.String.pipe(
-  Schema.brand("@effectify/hatchet/CronId"),
-)
+export const CronId = Schema.String.pipe(Schema.brand("@effectify/hatchet/CronId"))
 export type CronId = typeof CronId.Type
 
 export const ScheduleRecord = Schema.Struct({
@@ -28,9 +22,7 @@ export const CronRecord = Schema.Struct({
   name: Schema.optionalKey(Schema.NonEmptyString),
   expression: Schema.NonEmptyString,
   input: Schema.optionalKey(Schema.Unknown),
-  additionalMetadata: Schema.optionalKey(
-    Schema.Record(Schema.String, Schema.Unknown),
-  ),
+  additionalMetadata: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown)),
   enabled: Schema.Boolean,
   method: Schema.Literals(["DEFAULT", "API"]),
   priority: Schema.optionalKey(Schema.Number),
diff --git a/packages/hatchet/src/RateLimit.ts b/packages/hatchet/src/RateLimit.ts
index 8fb08b90..f226ffbd 100644
--- a/packages/hatchet/src/RateLimit.ts
+++ b/packages/hatchet/src/RateLimit.ts
@@ -1,11 +1,4 @@
-export type Duration =
-  | "second"
-  | "minute"
-  | "hour"
-  | "day"
-  | "week"
-  | "month"
-  | "year"
+export type Duration = "second" | "minute" | "hour" | "day" | "week" | "month" | "year"
 
 export interface Options {
   readonly units: number | string
@@ -25,12 +18,8 @@ export const make = (options: Options): RateLimit =>
     _tag: "RateLimit" as const,
     units: options.units,
     ...(options.key === undefined ? {} : { key: options.key }),
-    ...(options.staticKey === undefined
-      ? {}
-      : { staticKey: options.staticKey }),
-    ...(options.dynamicKey === undefined
-      ? {}
-      : { dynamicKey: options.dynamicKey }),
+    ...(options.staticKey === undefined ? {} : { staticKey: options.staticKey }),
+    ...(options.dynamicKey === undefined ? {} : { dynamicKey: options.dynamicKey }),
     ...(options.limit === undefined ? {} : { limit: options.limit }),
     ...(options.duration === undefined ? {} : { duration: options.duration }),
   })
diff --git a/packages/hatchet/src/Task.ts b/packages/hatchet/src/Task.ts
index 6102f32f..c39b9245 100644
--- a/packages/hatchet/src/Task.ts
+++ b/packages/hatchet/src/Task.ts
@@ -34,107 +34,55 @@ export const DurableContext = {
 
 export type Kind = "Ordinary" | "Durable"
 
-export interface Task<
-  out Name extends string,
-  out Input,
-  out Output,
-  out Error,
-  out Requirements,
-> {
+export interface Task<out Name extends string, out Input, out Output, out Error, out Requirements> {
   readonly _tag: "Ordinary"
   readonly name: Name
   readonly rateLimits: ReadonlyArray<RateLimit.RateLimit>
   readonly triggers: ReadonlyArray<Trigger.Trigger>
   readonly inputSchema: Schema.Codec<Input, unknown, never, never> | undefined
-  readonly outputSchema:
-    | Schema.Codec<Output, unknown, never, never>
-    | undefined
-  execute(
-    input: Input,
-    context: Context,
-  ): Effect.Effect<Output, Error, Requirements>
+  readonly outputSchema: Schema.Codec<Output, unknown, never, never> | undefined
+  execute(input: Input, context: Context): Effect.Effect<Output, Error, Requirements>
 }
 
-export interface DurableTask<
-  out Name extends string,
-  out Input,
-  out Output,
-  out Error,
-  out Requirements,
-> {
+export interface DurableTask<out Name extends string, out Input, out Output, out Error, out Requirements> {
   readonly _tag: "Durable"
   readonly name: Name
   readonly rateLimits: ReadonlyArray<RateLimit.RateLimit>
   readonly triggers: ReadonlyArray<Trigger.Trigger>
   readonly inputSchema: Schema.Codec<Input, unknown, never, never> | undefined
-  readonly outputSchema:
-    | Schema.Codec<Output, unknown, never, never>
-    | undefined
-  execute(
-    input: Input,
-    context: DurableContext,
-  ): Effect.Effect<Output, Error, Requirements>
+  readonly outputSchema: Schema.Codec<Output, unknown, never, never> | undefined
+  execute(input: Input, context: DurableContext): Effect.Effect<Output, Error, Requirements>
 }
 
 export type Of<Name extends string, Input, Output, Error, Requirements> =
   | Task<Name, Input, Output, Error, Requirements>
   | DurableTask<Name, Input, Output, Error, Requirements>
 
-export type Any<Requirements = unknown> = Of<
-  string,
-  unknown,
-  unknown,
-  unknown,
-  Requirements
->
+export type Any<Requirements = unknown> = Of<string, unknown, unknown, unknown, Requirements>
 
 export type Declaration<Requirements = unknown> = Any<Requirements>
 
 export type Requirements<T> = T extends Of<string, unknown, unknown, unknown, infer R> ? R : never
 
-export interface MakeOptions<
-  Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
-> {
+export interface MakeOptions<Name extends string, Input, Output, Error, Requirements> {
   readonly name: Name
   readonly input?: Schema.Codec<Input, unknown, never, never>
   readonly output?: Schema.Codec<Output, unknown, never, never>
   readonly rateLimits?: ReadonlyArray<RateLimit.RateLimit>
   readonly triggers?: ReadonlyArray<Trigger.Trigger>
-  readonly fn: (
-    input: Input,
-    context: Context,
-  ) => Effect.Effect<Output, Error, Requirements>
+  readonly fn: (input: Input, context: Context) => Effect.Effect<Output, Error, Requirements>
 }
 
-export interface DurableOptions<
-  Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
-> {
+export interface DurableOptions<Name extends string, Input, Output, Error, Requirements> {
   readonly name: Name
   readonly input?: Schema.Codec<Input, unknown, never, never>
   readonly output?: Schema.Codec<Output, unknown, never, never>
   readonly rateLimits?: ReadonlyArray<RateLimit.RateLimit>
   readonly triggers?: ReadonlyArray<Trigger.Trigger>
-  readonly fn: (
-    input: Input,
-    context: DurableContext,
-  ) => Effect.Effect<Output, Error, Requirements>
+  readonly fn: (input: Input, context: DurableContext) => Effect.Effect<Output, Error, Requirements>
 }
 
-export const make = <
-  const Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
->(
+export const make = <const Name extends string, Input, Output, Error, Requirements>(
   options: MakeOptions<Name, Input, Output, Error, Requirements>,
 ): Task<Name, Input, Output, Error, Requirements> => ({
   _tag: "Ordinary",
@@ -146,13 +94,7 @@ export const make = <
   execute: options.fn,
 })
 
-export const durable = <
-  const Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
->(
+export const durable = <const Name extends string, Input, Output, Error, Requirements>(
   options: DurableOptions<Name, Input, Output, Error, Requirements>,
 ): DurableTask<Name, Input, Output, Error, Requirements> => ({
   _tag: "Durable",
diff --git a/packages/hatchet/src/clients/workflows.ts b/packages/hatchet/src/clients/workflows.ts
index 0f4c05d8..f3e42e56 100644
--- a/packages/hatchet/src/clients/workflows.ts
+++ b/packages/hatchet/src/clients/workflows.ts
@@ -23,10 +23,8 @@ export type WorkflowTarget = Parameters<WorkflowsClient["delete"]>[0]
  * @param name - The name of the workflow to get
  * @returns Effect that resolves with the workflow details
  */
-export const getWorkflow = <O = unknown>(
-  name: string,
-): Effect.Effect<O, HatchetWorkflowError, HatchetClientService> =>
-  Effect.gen(function*() {
+export const getWorkflow = <O = unknown>(name: string): Effect.Effect<O, HatchetWorkflowError, HatchetClientService> =>
+  Effect.gen(function* () {
     const client = yield* getHatchetClient()
     const result = yield* Effect.tryPromise({
       try: () => client.workflows.get(name),
@@ -52,7 +50,7 @@ export type ListWorkflowsOpts = Parameters<WorkflowsClient["list"]>[0]
 export const listWorkflows = <O = unknown>(
   options?: ListWorkflowsOpts,
 ): Effect.Effect<O[], HatchetWorkflowError, HatchetClientService> =>
-  Effect.gen(function*() {
+  Effect.gen(function* () {
     const client = yield* getHatchetClient()
     const result = yield* Effect.tryPromise({
       try: () => client.workflows.list(options),
@@ -69,7 +67,7 @@ export const listWorkflows = <O = unknown>(
 export const deleteWorkflow = (
   workflow: WorkflowTarget,
 ): Effect.Effect<void, HatchetWorkflowError, HatchetClientService> =>
-  Effect.gen(function*() {
+  Effect.gen(function* () {
     const client = yield* getHatchetClient()
 
     yield* Effect.tryPromise({
diff --git a/packages/hatchet/src/internal/cron-validation.ts b/packages/hatchet/src/internal/cron-validation.ts
index 08ba435e..67fb6823 100644
--- a/packages/hatchet/src/internal/cron-validation.ts
+++ b/packages/hatchet/src/internal/cron-validation.ts
@@ -29,12 +29,8 @@ const filterError = (field: InvalidCronFilterError["field"]) =>
     field,
     originalCause: "invalid cron filter value",
   })
-export const validateCreate = (
-  options: CreateCronOptions,
-): Effect.Effect<void, InvalidCronError> => {
-  const fields: ReadonlyArray<
-    readonly [InvalidCronError["field"], Schema.Top, unknown]
-  > = [
+export const validateCreate = (options: CreateCronOptions): Effect.Effect<void, InvalidCronError> => {
+  const fields: ReadonlyArray<readonly [InvalidCronError["field"], Schema.Top, unknown]> = [
     ["name", NonBlank, options.name],
     ["priority", Priority, options.priority],
   ]
@@ -46,15 +42,9 @@ export const validateCreate = (
   return Effect.void
 }
 export const validateInput = (input: unknown) =>
-  Schema.decodeUnknownEffect(TransportObject)(input).pipe(
-    Effect.mapError(() => cronError("input")),
-  )
-export const validateList = (
-  options: ListCronOptions,
-): Effect.Effect<void, InvalidCronFilterError> => {
-  const fields: ReadonlyArray<
-    readonly [InvalidCronFilterError["field"], Schema.Top, unknown]
-  > = [
+  Schema.decodeUnknownEffect(TransportObject)(input).pipe(Effect.mapError(() => cronError("input")))
+export const validateList = (options: ListCronOptions): Effect.Effect<void, InvalidCronFilterError> => {
+  const fields: ReadonlyArray<readonly [InvalidCronFilterError["field"], Schema.Top, unknown]> = [
     ["taskName", NonBlank, options.taskName],
     ["name", NonBlank, options.name],
     ["offset", Offset, options.offset],
diff --git a/packages/hatchet/src/internal/declaration-validation.ts b/packages/hatchet/src/internal/declaration-validation.ts
index 672e098d..3be33f84 100644
--- a/packages/hatchet/src/internal/declaration-validation.ts
+++ b/packages/hatchet/src/internal/declaration-validation.ts
@@ -3,11 +3,7 @@ import type * as Trigger from "../Trigger.js"
 import { TaskDeclarationError } from "../Error.js"
 import type * as Task from "../Task.js"
 
-const invalid = (
-  taskName: string,
-  field: string,
-  index?: number,
-): TaskDeclarationError =>
+const invalid = (taskName: string, field: string, index?: number): TaskDeclarationError =>
   new TaskDeclarationError({
     taskName,
     field,
@@ -54,10 +50,7 @@ const validateText = (
   }
 }
 
-export const rateLimits = (
-  taskName: string,
-  values: ReadonlyArray<RateLimitValue>,
-): ReadonlyArray<RateLimitValue> => {
+export const rateLimits = (taskName: string, values: ReadonlyArray<RateLimitValue>): ReadonlyArray<RateLimitValue> => {
   for (const [index, value] of values.entries()) {
     validateNumberOrExpression(taskName, index, "units", value.units)
     if (value.limit !== undefined) {
@@ -73,16 +66,10 @@ export const rateLimits = (
   return values
 }
 
-export const triggers = (
-  taskName: string,
-  values: ReadonlyArray<Trigger.Trigger>,
-): ReadonlyArray<Trigger.Trigger> => {
+export const triggers = (taskName: string, values: ReadonlyArray<Trigger.Trigger>): ReadonlyArray<Trigger.Trigger> => {
   for (const [index, value] of values.entries()) {
     if (value._tag === "Event") {
-      if (
-        value.event.trim().length === 0 ||
-        /[\u0000-\u001f\u007f]/.test(value.event)
-      ) {
+      if (value.event.trim().length === 0 || /[\u0000-\u001f\u007f]/.test(value.event)) {
         throw invalid(taskName, "event", index)
       }
       continue
diff --git a/packages/hatchet/src/internal/registry.ts b/packages/hatchet/src/internal/registry.ts
index 8f1b8853..d1768dd2 100644
--- a/packages/hatchet/src/internal/registry.ts
+++ b/packages/hatchet/src/internal/registry.ts
@@ -25,44 +25,33 @@ export interface Registry {
   readonly has: (name: string) => boolean
 }
 
-const makeStoredTask = <
-  Name extends string,
-  Input,
-  Output,
-  Error,
-  Requirements,
->(
+const makeStoredTask = <Name extends string, Input, Output, Error, Requirements>(
   task: Task.Of<Name, Input, Output, Error, Requirements>,
   context: Context.Context<Requirements>,
 ): StoredTask => ({
   run: (input, taskContext) =>
-    Effect.gen(function*() {
+    Effect.gen(function* () {
       const taskScope = yield* Scope.Scope
       const decoded = task.inputSchema
         ? yield* Schema.decodeUnknownEffect(task.inputSchema)(input).pipe(
-          Effect.mapError(
-            (issue) =>
-              new TaskSchemaError({
-                taskName: task.name,
-                phase: "input",
-                issue,
-              }),
-          ),
-        )
+            Effect.mapError(
+              (issue) =>
+                new TaskSchemaError({
+                  taskName: task.name,
+                  phase: "input",
+                  issue,
+                }),
+            ),
+          )
         : (input as Input)
       const output = yield* (
         task._tag === "Durable"
           ? task.execute(decoded, {
-            ...taskContext,
-            invocationCount: "invocationCount" in taskContext
-              ? taskContext.invocationCount
-              : 0,
-          })
+              ...taskContext,
+              invocationCount: "invocationCount" in taskContext ? taskContext.invocationCount : 0,
+            })
           : task.execute(decoded, taskContext)
-      ).pipe(
-        Effect.provideService(Scope.Scope, taskScope),
-        Effect.provideContext(context),
-      )
+      ).pipe(Effect.provideService(Scope.Scope, taskScope), Effect.provideContext(context))
       if (task.outputSchema) {
         yield* Schema.encodeUnknownEffect(task.outputSchema)(output).pipe(
           Effect.mapError(
@@ -87,18 +76,11 @@ export const make = (): Registry => {
     add: (task, context) => {
       tasks.set(task.name, makeStoredTask(task, context))
     },
-    run: <Output, Error>(
-      name: string,
-      input: unknown,
-      taskContext: Task.Context | Task.DurableContext,
-    ) => {
+    run: <Output, Error>(name: string, input: unknown, taskContext: Task.Context | Task.DurableContext) => {
       const task = tasks.get(name)
       // The heterogeneous map erases task-specific I/O/E/R only here. Public callers
       // retain those parameters through the declarative Task identity.
-      return task?.run(input, taskContext) as Effect.Effect<
-        Output,
-        Error | TaskSchemaError
-      >
+      return task?.run(input, taskContext) as Effect.Effect<Output, Error | TaskSchemaError>
     },
   }
 }
diff --git a/packages/hatchet/src/internal/sdk-declaration.ts b/packages/hatchet/src/internal/sdk-declaration.ts
index 573a7b1f..8220340c 100644
--- a/packages/hatchet/src/internal/sdk-declaration.ts
+++ b/packages/hatchet/src/internal/sdk-declaration.ts
@@ -3,9 +3,7 @@ import type * as RateLimit from "../RateLimit.js"
 import * as CronExpression from "../CronExpression.js"
 import type * as Trigger from "../Trigger.js"
 
-export const rateLimitDuration = (
-  duration: RateLimit.Duration,
-): RateLimitDuration => {
+export const rateLimitDuration = (duration: RateLimit.Duration): RateLimitDuration => {
   switch (duration) {
     case "second":
       return RateLimitDuration.SECOND
@@ -41,17 +39,12 @@ export const rateLimits = (
     ...(value.staticKey === undefined ? {} : { staticKey: value.staticKey }),
     ...(value.dynamicKey === undefined ? {} : { dynamicKey: value.dynamicKey }),
     ...(value.limit === undefined ? {} : { limit: value.limit }),
-    ...(value.duration === undefined
-      ? {}
-      : { duration: rateLimitDuration(value.duration) }),
+    ...(value.duration === undefined ? {} : { duration: rateLimitDuration(value.duration) }),
   }))
 
 export const on = (
   values: ReadonlyArray<Trigger.Trigger>,
-):
-  | { readonly event?: Array<string>; readonly cron?: Array<string> }
-  | undefined =>
-{
+): { readonly event?: Array<string>; readonly cron?: Array<string> } | undefined => {
   const event: Array<string> = []
   const cron: Array<string> = []
   for (const value of values) {
@@ -63,7 +56,7 @@ export const on = (
   return event.length === 0 && cron.length === 0
     ? undefined
     : {
-      ...(event.length === 0 ? {} : { event }),
-      ...(cron.length === 0 ? {} : { cron }),
-    }
+        ...(event.length === 0 ? {} : { event }),
+        ...(cron.length === 0 ? {} : { cron }),
+      }
 }
diff --git a/packages/hatchet/src/testing/mock-context.ts b/packages/hatchet/src/testing/mock-context.ts
index e8fc8a56..afdc9c88 100644
--- a/packages/hatchet/src/testing/mock-context.ts
+++ b/packages/hatchet/src/testing/mock-context.ts
@@ -11,23 +11,15 @@ import { HatchetStepContext, type HatchetTaskContext } from "../core/context.js"
 
 type MockHatchetTaskContext<I, U extends Record<string, unknown>> = Pick<
   HatchetTaskContext<I, U>,
-  | "input"
-  | "taskName"
-  | "workflowName"
-  | "workflowRunId"
-  | "retryCount"
-  | "parentOutput"
-  | "log"
-  | "logger"
+  "input" | "taskName" | "workflowName" | "workflowRunId" | "retryCount" | "parentOutput" | "log" | "logger"
 >
 
 const toHatchetTaskContext = <I, U extends Record<string, unknown>>(
   context: MockHatchetTaskContext<I, U>,
 ): HatchetTaskContext<I, U> => context as unknown as HatchetTaskContext<I, U>
 
-const createProvidedMockLayer = (
-  mockContext: HatchetTaskContext,
-): Layer.Layer<HatchetStepContext, never, never> => Layer.succeed(HatchetStepContext, mockContext)
+const createProvidedMockLayer = (mockContext: HatchetTaskContext): Layer.Layer<HatchetStepContext, never, never> =>
+  Layer.succeed(HatchetStepContext, mockContext)
 
 /**
  * Creates a mock HatchetStepContext for testing.
@@ -35,10 +27,7 @@ const createProvidedMockLayer = (
  * @param options - Optional configuration for the mock context
  * @returns A mock context object
  */
-export const createMockContext = <
-  I = unknown,
-  U extends Record<string, unknown> = Record<string, never>,
->(
+export const createMockContext = <I = unknown, U extends Record<string, unknown> = Record<string, never>>(
   options: {
     readonly input?: I
     readonly taskName?: string
@@ -85,20 +74,16 @@ export const createMockContext = <
  * @param mockContext - The mock context to provide
  * @returns A Layer that provides the mock context
  */
-export const createMockLayer = (
-  mockContext: HatchetTaskContext,
-): Layer.Layer<HatchetStepContext, never, never> => createProvidedMockLayer(mockContext)
+export const createMockLayer = (mockContext: HatchetTaskContext): Layer.Layer<HatchetStepContext, never, never> =>
+  createProvidedMockLayer(mockContext)
 
 /**
  * Creates a Layer with a default mock context.
  *
  * @returns A Layer with default mock context
  */
-export const createDefaultMockLayer = (): Layer.Layer<
-  HatchetStepContext,
-  never,
-  never
-> => createProvidedMockLayer(createMockContext())
+export const createDefaultMockLayer = (): Layer.Layer<HatchetStepContext, never, never> =>
+  createProvidedMockLayer(createMockContext())
 
 /**
  * Runs an Effect with a mock HatchetStepContext using provide.
diff --git a/packages/hatchet/tests/types/declarative-task-api.ts b/packages/hatchet/tests/types/declarative-task-api.ts
index a6c93289..e57f75b4 100644
--- a/packages/hatchet/tests/types/declarative-task-api.ts
+++ b/packages/hatchet/tests/types/declarative-task-api.ts
@@ -3,10 +3,9 @@ import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
 import { RateLimit, Task, TaskDeclarationError, Trigger } from "@effectify/hatchet"
 
-class Dependency extends Context.Service<
-  Dependency,
-  { readonly value: string }
->()("@effectify/hatchet/test/DeclarativeDependency") {}
+class Dependency extends Context.Service<Dependency, { readonly value: string }>()(
+  "@effectify/hatchet/test/DeclarativeDependency",
+) {}
 
 class Failure {
   readonly _tag = "Failure" as const
@@ -20,9 +19,7 @@ const ordinary: Task.Task<"ordinary", Input, Output, Failure, Dependency> = Task
   input: Schema.Struct({ value: Schema.Number }),
   output: Schema.Struct({ rendered: Schema.String }),
   fn: (input): Effect.Effect<Output, Failure, Dependency> =>
-    input.value > 0
-      ? Effect.map(Dependency, ({ value }) => ({ rendered: value }))
-      : Effect.fail(new Failure()),
+    input.value > 0 ? Effect.map(Dependency, ({ value }) => ({ rendered: value })) : Effect.fail(new Failure()),
 })
 
 const durable = Task.durable({
diff --git a/packages/hatchet/tests/types/run-no-wait.ts b/packages/hatchet/tests/types/run-no-wait.ts
index c44fff04..2a185c79 100644
--- a/packages/hatchet/tests/types/run-no-wait.ts
+++ b/packages/hatchet/tests/types/run-no-wait.ts
@@ -24,9 +24,7 @@ const task = Task.make({
   input: Schema.Struct({ value: Schema.Finite }),
   output: Schema.String,
   fn: ({ value }): Effect.Effect<string, TaskFailure, Prefix> =>
-    value > 0
-      ? Effect.map(Prefix, ({ value: prefix }) => `${prefix}${value}`)
-      : Effect.fail(new TaskFailure()),
+    value > 0 ? Effect.map(Prefix, ({ value: prefix }) => `${prefix}${value}`) : Effect.fail(new TaskFailure()),
 })
 
 const dispatched = Hatchet.runNoWait(task, { value: 1 })
@@ -36,7 +34,7 @@ const exactDispatch: Effect.Effect<
   Hatchet.Hatchet | Prefix
 > = dispatched
 
-const program = Effect.gen(function*() {
+const program = Effect.gen(function* () {
   const handle = yield* Hatchet.runNoWait(task, { value: 1 })
   const id: RunId = handle.id
   const output: string = yield* handle.await
@@ -45,15 +43,10 @@ const program = Effect.gen(function*() {
 })
 
 const prefixLayer = Layer.succeed(Prefix, { value: "typed-" })
-const hatchetLayer: Layer.Layer<Hatchet.Hatchet, never, Prefix> = Hatchet.layer(
-  {
-    tasks: [task],
-  },
-)
-const appLayer = Layer.merge(
-  prefixLayer,
-  hatchetLayer.pipe(Layer.provide(prefixLayer)),
-)
+const hatchetLayer: Layer.Layer<Hatchet.Hatchet, never, Prefix> = Hatchet.layer({
+  tasks: [task],
+})
+const appLayer = Layer.merge(prefixLayer, hatchetLayer.pipe(Layer.provide(prefixLayer)))
 const runnable: Effect.Effect<
   { readonly id: RunId; readonly output: string },
   TaskFailure | TaskSchemaError | MissingTaskError | Hatchet.AcquisitionError
diff --git a/packages/hatchet/tests/types/task-schema-free.ts b/packages/hatchet/tests/types/task-schema-free.ts
index 70f7e3df..30b2fccf 100644
--- a/packages/hatchet/tests/types/task-schema-free.ts
+++ b/packages/hatchet/tests/types/task-schema-free.ts
@@ -45,12 +45,14 @@ Hatchet.layerInMemory()
 // @ts-expect-error Task input remains the inferred Input type.
 const invalidInput: Parameters<typeof task.execute>[0] = { value: "wrong" }
 
-type TaskOutput = ReturnType<typeof task.execute> extends Effect.Effect<infer Output, infer _Error, infer _Requirements>
-  ? Output
-  : never
-type TaskRequirements = ReturnType<typeof task.execute> extends
-  Effect.Effect<infer _Output, infer _Error, infer Requirements> ? Requirements
-  : never
+type TaskOutput =
+  ReturnType<typeof task.execute> extends Effect.Effect<infer Output, infer _Error, infer _Requirements>
+    ? Output
+    : never
+type TaskRequirements =
+  ReturnType<typeof task.execute> extends Effect.Effect<infer _Output, infer _Error, infer Requirements>
+    ? Requirements
+    : never
 
 // @ts-expect-error Task output remains Output rather than this incompatible shape.
 const wrongOutput: TaskOutput = { wrong: "wrong" }
diff --git a/packages/hatchet/tests/unit/cron.test.ts b/packages/hatchet/tests/unit/cron.test.ts
index 15e929ac..80c666d8 100644
--- a/packages/hatchet/tests/unit/cron.test.ts
+++ b/packages/hatchet/tests/unit/cron.test.ts
@@ -10,12 +10,8 @@ const task = Task.make({
   input: Schema.Struct({ count: Schema.NumberFromString }),
   fn: () => Effect.void,
 })
-const run = <A, E>(
-  effect: Effect.Effect<A, E, Hatchet.Hatchet | Scope.Scope>,
-) =>
-  Effect.runPromise(
-    Effect.scoped(effect.pipe(Effect.provide(Hatchet.layerInMemory))),
-  )
+const run = <A, E>(effect: Effect.Effect<A, E, Hatchet.Hatchet | Scope.Scope>) =>
+  Effect.runPromise(Effect.scoped(effect.pipe(Effect.provide(Hatchet.layerInMemory))))
 const validSchedule = Effect.runSync(CronExpression.parse("0 9 * * 1-5"))
 const valid: CreateCronOptions = {
   name: "daily",
@@ -24,17 +20,11 @@ const valid: CreateCronOptions = {
 }
 const invalidPriority: CreateCronOptions = { ...valid, priority: 1 }
 Reflect.set(invalidPriority, "priority", 4)
-type Case = readonly [
-  string,
-  Effect.Effect<unknown, { readonly field: string }>,
-]
+type Case = readonly [string, Effect.Effect<unknown, { readonly field: string }>]
 const validationCases: ReadonlyArray<Case> = [
   ["name", CronValidation.validateCreate({ ...valid, name: "  " })],
   ["priority", CronValidation.validateCreate(invalidPriority)],
-  [
-    "input",
-    CronValidation.validateInput({ secret: "raw-secret", value: new Date() }),
-  ],
+  ["input", CronValidation.validateInput({ secret: "raw-secret", value: new Date() })],
   ["taskName", CronValidation.validateList({ taskName: " " })],
   ["name", CronValidation.validateList({ name: "" })],
   ["offset", CronValidation.validateList({ offset: -0.5 })],
@@ -43,9 +33,7 @@ const validationCases: ReadonlyArray<Case> = [
 ]
 describe("CronExpression", () => {
   it("parses a Hatchet-compatible five-field expression", async () => {
-    const schedule = await Effect.runPromise(
-      CronExpression.parse("0 9 * * 1-5"),
-    )
+    const schedule = await Effect.runPromise(CronExpression.parse("0 9 * * 1-5"))
 
     expect(CronExpression.source(schedule)).toBe("0 9 * * 1-5")
   })
@@ -54,9 +42,7 @@ describe("CronExpression", () => {
     ["semantic invalidity", "61 9 * * *"],
     ["six fields", "0 0 9 * * *"],
   ])("rejects %s", async (_case, source) => {
-    const error = await Effect.runPromise(
-      CronExpression.parse(source).pipe(Effect.flip),
-    )
+    const error = await Effect.runPromise(CronExpression.parse(source).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "InvalidCronError",
@@ -64,14 +50,8 @@ describe("CronExpression", () => {
     })
   })
 
-  it.each([
-    null,
-    {},
-    42,
-  ])("rejects non-string runtime input %j", async (input) => {
-    const result = Reflect.apply(CronExpression.parseResult, undefined, [
-      input,
-    ])
+  it.each([null, {}, 42])("rejects non-string runtime input %j", async (input) => {
+    const result = Reflect.apply(CronExpression.parseResult, undefined, [input])
     expect(Result.isFailure(result)).toBe(true)
     if (Result.isFailure(result)) {
       expect(result.failure).toMatchObject({
@@ -89,9 +69,7 @@ describe("CronExpression", () => {
   })
 
   it("preserves a normalized source string", async () => {
-    const schedule = await Effect.runPromise(
-      CronExpression.parse("  0   9  *  *   1-5  "),
-    )
+    const schedule = await Effect.runPromise(CronExpression.parse("  0   9  *  *   1-5  "))
 
     expect(CronExpression.source(schedule)).toBe("0 9 * * 1-5")
     expect(Object.keys(schedule)).toEqual([])
@@ -99,21 +77,15 @@ describe("CronExpression", () => {
   })
 
   it("validates values at runtime without exposing internal state", () => {
-    expect(() => Reflect.apply(CronExpression.source, undefined, [{}])).toThrow(
-      "Invalid CronExpression value",
-    )
+    expect(() => Reflect.apply(CronExpression.source, undefined, [{}])).toThrow("Invalid CronExpression value")
   })
 
   it("previews deterministic next occurrences", async () => {
     const schedule = await Effect.runPromise(CronExpression.parse("* * * * *"))
     const after = new Date("2025-01-01T12:00:30.000Z")
 
-    expect(CronExpression.next(schedule, after).toISOString()).toBe(
-      "2025-01-01T12:01:00.000Z",
-    )
-    expect(
-      CronExpression.nextRuns(schedule, 3, after).map((date) => date.toISOString()),
-    ).toEqual([
+    expect(CronExpression.next(schedule, after).toISOString()).toBe("2025-01-01T12:01:00.000Z")
+    expect(CronExpression.nextRuns(schedule, 3, after).map((date) => date.toISOString())).toEqual([
       "2025-01-01T12:01:00.000Z",
       "2025-01-01T12:02:00.000Z",
       "2025-01-01T12:03:00.000Z",
@@ -122,16 +94,14 @@ describe("CronExpression", () => {
 })
 
 describe("cron validation and lifecycle", () => {
-  it.each(
-    validationCases,
-  )("attributes invalid %s values without exposing input", async (field, effect) => {
+  it.each(validationCases)("attributes invalid %s values without exposing input", async (field, effect) => {
     const error = await Effect.runPromise(Effect.flip(effect))
     expect(error).toMatchObject({ field })
     expect(JSON.stringify(error)).not.toContain("raw-secret")
   })
   it("creates distinct records and applies deterministic lifecycle operations", async () => {
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const first = yield* Hatchet.createCron(task, valid)
         const duplicate = yield* Hatchet.createCron(task, valid)
         expect(duplicate.id).not.toBe(first.id)
@@ -145,14 +115,8 @@ describe("cron validation and lifecycle", () => {
             limit: 1,
           }),
         ).toEqual([duplicate])
-        expect(yield* Hatchet.listCrons({ name: "daily" })).toEqual([
-          first,
-          duplicate,
-        ])
-        expect([
-          yield* Hatchet.deleteCron(first.id),
-          yield* Hatchet.deleteCron(first.id),
-        ]).toEqual([true, false])
+        expect(yield* Hatchet.listCrons({ name: "daily" })).toEqual([first, duplicate])
+        expect([yield* Hatchet.deleteCron(first.id), yield* Hatchet.deleteCron(first.id)]).toEqual([true, false])
         expect((yield* Hatchet.getCron(first.id))._tag).toBe("None")
       }),
     )
diff --git a/packages/hatchet/tests/unit/events.test.ts b/packages/hatchet/tests/unit/events.test.ts
index 99b06122..1877aba2 100644
--- a/packages/hatchet/tests/unit/events.test.ts
+++ b/packages/hatchet/tests/unit/events.test.ts
@@ -5,11 +5,7 @@ import { Hatchet } from "@effectify/hatchet"
 describe("Hatchet.pushEvent", () => {
   it("validates JSON-object events before side effects and echoes valid in-memory events", async () => {
     const invalid = await Effect.runPromise(
-      Hatchet.pushEvent(" ", { value: "ok" }).pipe(
-        Effect.flip,
-        Effect.provide(Hatchet.layerInMemory),
-        Effect.scoped,
-      ),
+      Hatchet.pushEvent(" ", { value: "ok" }).pipe(Effect.flip, Effect.provide(Hatchet.layerInMemory), Effect.scoped),
     )
     expect(invalid).toMatchObject({
       _tag: "InvalidEventError",
@@ -40,11 +36,9 @@ describe("Hatchet.pushEvent", () => {
   it("rejects sparse JSON arrays without advancing the in-memory event counter", async () => {
     const payload = { nested: ["value"] }
     delete payload.nested[0]
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const service = yield* Hatchet.Hatchet
-      const failure = yield* service
-        .pushEvent("invalid", payload)
-        .pipe(Effect.flip)
+      const failure = yield* service.pushEvent("invalid", payload).pipe(Effect.flip)
       const receipt = yield* service.pushEvent("valid", { ok: true })
       return { failure, receipt }
     }).pipe(Effect.provide(Hatchet.layerInMemory), Effect.scoped)
diff --git a/packages/hatchet/tests/unit/hatchet-config.test.ts b/packages/hatchet/tests/unit/hatchet-config.test.ts
index b6cc81d2..13e8fd0e 100644
--- a/packages/hatchet/tests/unit/hatchet-config.test.ts
+++ b/packages/hatchet/tests/unit/hatchet-config.test.ts
@@ -7,17 +7,11 @@ import * as Schema from "effect/Schema"
 import { CronRecord, HatchetConfig, InvalidHatchetConfiguration, ScheduleRecord } from "@effectify/hatchet"
 
 const load = (env: Record<string, string>) =>
-  Effect.runPromise(
-    HatchetConfig.fromEnv.pipe(
-      Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env }))),
-    ),
-  )
+  Effect.runPromise(HatchetConfig.fromEnv.pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env })))))
 
 const loadExit = (env: Record<string, string>) =>
   Effect.runPromiseExit(
-    HatchetConfig.fromEnv.pipe(
-      Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env }))),
-    ),
+    HatchetConfig.fromEnv.pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env })))),
   )
 
 describe("HatchetConfig", () => {
@@ -40,20 +34,12 @@ describe("HatchetConfig", () => {
       field: "client",
       message: "SDK construction failed",
     })
-    const encoded = Schema.encodeUnknownSync(InvalidHatchetConfiguration)(
-      error,
-    )
+    const encoded = Schema.encodeUnknownSync(InvalidHatchetConfiguration)(error)
     expect(JSON.stringify(encoded)).not.toContain(secret)
     expect(encoded).not.toHaveProperty("originalCause")
   })
 
-  it.each(
-    [
-      "tls",
-      "mtls",
-      "none",
-    ] as const,
-  )("accepts the %s TLS literal", async (tlsStrategy) => {
+  it.each(["tls", "mtls", "none"] as const)("accepts the %s TLS literal", async (tlsStrategy) => {
     const config = await load({
       HATCHET_CLIENT_TOKEN: "token",
       HATCHET_TLS_STRATEGY: tlsStrategy,
diff --git a/packages/hatchet/tests/unit/hatchet-runtime.test.ts b/packages/hatchet/tests/unit/hatchet-runtime.test.ts
index 44ee076e..f3d0acad 100644
--- a/packages/hatchet/tests/unit/hatchet-runtime.test.ts
+++ b/packages/hatchet/tests/unit/hatchet-runtime.test.ts
@@ -18,11 +18,9 @@ const sdk = vi.hoisted(() => {
   const stop = vi.fn(async () => {
     events.push("stop")
   })
-  const registerWorkflows = vi.fn(
-    async (tasks: ReadonlyArray<{ readonly name: string }>) => {
-      events.push(`register:${tasks.map((task) => task.name).join(",")}`)
-    },
-  )
+  const registerWorkflows = vi.fn(async (tasks: ReadonlyArray<{ readonly name: string }>) => {
+    events.push(`register:${tasks.map((task) => task.name).join(",")}`)
+  })
   const worker = vi.fn(async (_name?: string, _options?: unknown) => {
     events.push("worker")
     return { registerWorkflows, start, waitUntilReady, stop }
@@ -100,9 +98,7 @@ const directLayer = () =>
 
 const runtimeOf = <E>(layer: Layer.Layer<Hatchet.Hatchet, E>) => ManagedRuntime.make(layer)
 
-const configuredTasks = (
-  options: unknown,
-): ReadonlyArray<{ readonly name: string }> => {
+const configuredTasks = (options: unknown): ReadonlyArray<{ readonly name: string }> => {
   if (
     typeof options !== "object" ||
     options === null ||
@@ -113,10 +109,7 @@ const configuredTasks = (
   }
   return options.workflows.filter(
     (value): value is { readonly name: string } =>
-      typeof value === "object" &&
-      value !== null &&
-      "name" in value &&
-      typeof value.name === "string",
+      typeof value === "object" && value !== null && "name" in value && typeof value.name === "string",
   )
 }
 
@@ -171,15 +164,9 @@ describe("Hatchet lazy Layer", () => {
 
   it("acquires only lazy package state and does not read config or construct the SDK", async () => {
     const provider = ConfigProvider.fromEnv({ env: {} })
-    const runtime = runtimeOf(
-      Hatchet.layer({ tasks: [first] }).pipe(
-        Layer.provide(ConfigProvider.layer(provider)),
-      ),
-    )
+    const runtime = runtimeOf(Hatchet.layer({ tasks: [first] }).pipe(Layer.provide(ConfigProvider.layer(provider))))
 
-    await expect(
-      runtime.runPromise(Effect.as(Hatchet.Hatchet, "ready")),
-    ).resolves.toBe("ready")
+    await expect(runtime.runPromise(Effect.as(Hatchet.Hatchet, "ready"))).resolves.toBe("ready")
     expect(sdk.init).not.toHaveBeenCalled()
     expect(sdk.worker).not.toHaveBeenCalled()
 
@@ -232,9 +219,7 @@ describe("Hatchet lazy Layer", () => {
       Hatchet.schedule(scheduledTask, { value: 1 }, { _tag: "At", at: triggerAt }),
     )
     const missing = await runtime.runPromise(Hatchet.getSchedule(schedule.id))
-    await expect(
-      runtime.runPromise(Hatchet.deleteSchedule(schedule.id)),
-    ).resolves.toBe(true)
+    await expect(runtime.runPromise(Hatchet.deleteSchedule(schedule.id))).resolves.toBe(true)
     await runtime.runPromise(Hatchet.cancelRun(makeRunId("run-1")))
 
     expect(sdk.scheduled.create).toHaveBeenCalledExactlyOnceWith(scheduledTask.name, {
@@ -282,9 +267,7 @@ describe("Hatchet lazy Layer", () => {
     expect(sdk.worker).toHaveBeenCalledTimes(1)
     expect(sdk.stop).toHaveBeenCalledTimes(1)
 
-    await expect(
-      runtime.runPromise(Hatchet.runNoWait(first, {})),
-    ).resolves.toMatchObject({ id: "run-1" })
+    await expect(runtime.runPromise(Hatchet.runNoWait(first, {}))).resolves.toMatchObject({ id: "run-1" })
     expect(sdk.worker).toHaveBeenCalledTimes(2)
     await runtime.dispose()
     await runtime.dispose()
diff --git a/packages/hatchet/tests/unit/live-sdk-port.test.ts b/packages/hatchet/tests/unit/live-sdk-port.test.ts
index d22a257e..514f532a 100644
--- a/packages/hatchet/tests/unit/live-sdk-port.test.ts
+++ b/packages/hatchet/tests/unit/live-sdk-port.test.ts
@@ -25,11 +25,9 @@ const sdk = vi.hoisted(() => {
   const stop = vi.fn(async () => {
     events.push("stop")
   })
-  const registerWorkflows = vi.fn(
-    async (tasks: ReadonlyArray<{ readonly name: string }>) => {
-      events.push(`declarations:${tasks.map((task) => task.name).join(",")}`)
-    },
-  )
+  const registerWorkflows = vi.fn(async (tasks: ReadonlyArray<{ readonly name: string }>) => {
+    events.push(`declarations:${tasks.map((task) => task.name).join(",")}`)
+  })
   const worker = vi.fn(async (_name?: string, _options?: unknown) => {
     events.push("worker")
     return { registerWorkflows, start, waitUntilReady, stop }
@@ -142,10 +140,7 @@ const createDailyCron = (schedule: CronExpression.CronExpression) =>
 
 type CallbackDeclaration = {
   readonly name: string
-  readonly fn: (
-    input: unknown,
-    taskContext: ReturnType<typeof context>,
-  ) => Promise<{ readonly value: string }>
+  readonly fn: (input: unknown, taskContext: ReturnType<typeof context>) => Promise<{ readonly value: string }>
 }
 
 type DurableCallbackDeclaration = {
@@ -166,9 +161,7 @@ const isCallbackDeclaration = (value: unknown): value is CallbackDeclaration =>
   "fn" in value &&
   typeof value.fn === "function"
 
-const configuredWorkflows = (
-  options: unknown,
-): ReadonlyArray<CallbackDeclaration> => {
+const configuredWorkflows = (options: unknown): ReadonlyArray<CallbackDeclaration> => {
   if (
     typeof options !== "object" ||
     options === null ||
@@ -195,9 +188,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       sdk.events.push("stop")
     })
     sdk.registerWorkflows.mockImplementation(async (tasks) => {
-      sdk.events.push(
-        `declarations:${tasks.map((task) => task.name).join(",")}`,
-      )
+      sdk.events.push(`declarations:${tasks.map((task) => task.name).join(",")}`)
     })
     sdk.worker.mockImplementation(async (_name, options) => {
       sdk.events.push("worker")
@@ -217,15 +208,10 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
   })
 
-  it.each([
-    "",
-    "   ",
-  ])("rejects an empty or whitespace token before SDK initialization", async (token) => {
+  it.each(["", "   "])("rejects an empty or whitespace token before SDK initialization", async (token) => {
     const runtime = ManagedRuntime.make(layer(token))
 
-    const error = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "InvalidHatchetConfiguration",
@@ -239,18 +225,11 @@ describe("live SDK adapter behind Hatchet.layer", () => {
   it("loads declarations and starts one worker before the first operation", async () => {
     const runtime = ManagedRuntime.make(layer())
 
-    const handle = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }),
-    )
+    const handle = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))
     await expect(runtime.runPromise(handle.await)).resolves.toBe("DONE")
     await runtime.runPromise(handle.cancel)
 
-    expect(sdk.events.slice(0, 4)).toEqual([
-      "worker",
-      "declarations:upper,durable-upper",
-      "start",
-      "ready",
-    ])
+    expect(sdk.events.slice(0, 4)).toEqual(["worker", "declarations:upper,durable-upper", "start", "ready"])
     expect(sdk.runNoWait).toHaveBeenCalledWith({ value: "done" })
     expect(sdk.cancel).toHaveBeenCalledOnce()
     expect(sdk.task).toHaveBeenCalledExactlyOnceWith({
@@ -273,9 +252,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
 
   it("shares one cancellation outcome across repeated evaluations", async () => {
     const runtime = ManagedRuntime.make(layer())
-    const successful = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }),
-    )
+    const successful = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))
 
     await runtime.runPromise(successful.cancel)
     await runtime.runPromise(successful.cancel)
@@ -283,14 +260,9 @@ describe("live SDK adapter behind Hatchet.layer", () => {
 
     const rejection = new Error("cancel rejected")
     sdk.cancel.mockRejectedValueOnce(rejection)
-    const failing = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }),
-    )
+    const failing = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))
     const concurrent = await runtime.runPromise(
-      Effect.all(
-        [failing.cancel.pipe(Effect.flip), failing.cancel.pipe(Effect.flip)],
-        { concurrency: "unbounded" },
-      ),
+      Effect.all([failing.cancel.pipe(Effect.flip), failing.cancel.pipe(Effect.flip)], { concurrency: "unbounded" }),
     )
     const repeated = await runtime.runPromise(failing.cancel.pipe(Effect.flip))
 
@@ -300,21 +272,17 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     await runtime.dispose()
   })
 
-  it.each(
-    [
-      ["rejection", "Unavailable"],
-      ["empty ID", "Unknown"],
-    ] as const,
-  )("compensates a run ID %s without replacing its error", async (kind, reason) => {
+  it.each([
+    ["rejection", "Unavailable"],
+    ["empty ID", "Unknown"],
+  ] as const)("compensates a run ID %s without replacing its error", async (kind, reason) => {
     const runIdFailure = Object.assign(new Error("run-id-token"), {
       status: 503,
     })
     const cancelFailure = new Error("cancel-token")
     if (kind === "empty ID") sdk.cancel.mockRejectedValueOnce(cancelFailure)
     let rejectRunId: ((reason: unknown) => void) | undefined
-    const runId = kind === "empty ID"
-      ? Promise.resolve("")
-      : new Promise<string>((_, reject) => (rejectRunId = reject))
+    const runId = kind === "empty ID" ? Promise.resolve("") : new Promise<string>((_, reject) => (rejectRunId = reject))
     sdk.runNoWait.mockResolvedValueOnce({
       runId,
       output: Promise.resolve({ value: "DONE" }),
@@ -322,9 +290,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     const runtime = ManagedRuntime.make(layer())
 
-    const failure = runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }).pipe(Effect.flip),
-    )
+    const failure = runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }).pipe(Effect.flip))
     await vi.waitFor(() => expect(sdk.runNoWait).toHaveBeenCalledOnce())
     rejectRunId?.(runIdFailure)
     const error = await failure
@@ -371,11 +337,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     const runtime = ManagedRuntime.make(layer())
 
     await expect(
-      runtime.runPromise(
-        Hatchet.run(upper, { value: "first" }).pipe(
-          Effect.timeout("100 millis"),
-        ),
-      ),
+      runtime.runPromise(Hatchet.run(upper, { value: "first" }).pipe(Effect.timeout("100 millis"))),
     ).resolves.toBe("FIRST")
     expect(sdk.registerWorkflows).toHaveBeenCalledOnce()
 
@@ -383,9 +345,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
   })
 
   it("returns the handle before output and permits independent Effect work", async () => {
-    let resolveOutput:
-      | ((value: { readonly value: string }) => void)
-      | undefined
+    let resolveOutput: ((value: { readonly value: string }) => void) | undefined
     const output = new Promise<{ readonly value: string }>((resolve) => {
       resolveOutput = resolve
     })
@@ -396,9 +356,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     const runtime = ManagedRuntime.make(layer())
 
-    const handle = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }),
-    )
+    const handle = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))
     expect(sdk.cancel).not.toHaveBeenCalled()
     const independent = await runtime.runPromise(Effect.succeed("independent"))
     resolveOutput?.({ value: "DONE" })
@@ -411,20 +369,14 @@ describe("live SDK adapter behind Hatchet.layer", () => {
   it("retains input and output Schema error phases", async () => {
     const runtime = ManagedRuntime.make(layer())
 
-    const inputError = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: 42 }).pipe(Effect.flip),
-    )
+    const inputError = await runtime.runPromise(Hatchet.runNoWait(upper, { value: 42 }).pipe(Effect.flip))
     sdk.runNoWait.mockResolvedValueOnce({
       runId: Promise.resolve("run-invalid-output"),
       output: Promise.resolve({ value: "" }),
       cancel: sdk.cancel,
     })
-    const handle = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }),
-    )
-    const outputError = await runtime.runPromise(
-      handle.await.pipe(Effect.flip),
-    )
+    const handle = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))
+    const outputError = await runtime.runPromise(handle.await.pipe(Effect.flip))
 
     expect(inputError).toMatchObject({
       _tag: "TaskSchemaError",
@@ -442,40 +394,30 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     const runtime = ManagedRuntime.make(layer())
 
     sdk.runNoWait.mockRejectedValueOnce(new Error(secret))
-    const dispatchError = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }).pipe(Effect.flip),
-    )
+    const dispatchError = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }).pipe(Effect.flip))
     expect(sdk.cancel).not.toHaveBeenCalled()
 
     let rejectOutput: ((reason: unknown) => void) | undefined
-    const output = new Promise<{ readonly value: string }>(
-      (_resolve, reject) => {
-        rejectOutput = reject
-      },
-    )
+    const output = new Promise<{ readonly value: string }>((_resolve, reject) => {
+      rejectOutput = reject
+    })
     sdk.cancel.mockRejectedValueOnce(new Error(secret))
     sdk.runNoWait.mockResolvedValueOnce({
       runId: Promise.resolve("run-failing"),
       output,
       cancel: sdk.cancel,
     })
-    const handle = await runtime.runPromise(
-      Hatchet.runNoWait(upper, { value: "done" }),
-    )
+    const handle = await runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))
     const resultFailure = runtime.runPromise(handle.await.pipe(Effect.flip))
     rejectOutput?.(new Error(secret))
     const resultError = await resultFailure
-    const cancelError = await runtime.runPromise(
-      handle.cancel.pipe(Effect.flip),
-    )
+    const cancelError = await runtime.runPromise(handle.cancel.pipe(Effect.flip))
 
-    for (
-      const [error, operation] of [
-        [dispatchError, "task.runNoWait"],
-        [resultError, "run.output"],
-        [cancelError, "run.cancel"],
-      ] as const
-    ) {
+    for (const [error, operation] of [
+      [dispatchError, "task.runNoWait"],
+      [resultError, "run.output"],
+      [cancelError, "run.cancel"],
+    ] as const) {
       expect(error).toMatchObject({ _tag: "HatchetSdkError", operation })
       expect(JSON.stringify(error)).not.toContain(secret)
     }
@@ -487,9 +429,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     await runtime.runPromise(Hatchet.runNoWait(upper, { value: "warm" }))
 
     const declaration = sdk.task.mock.calls[0]?.[0]
-    await expect(
-      declaration.fn({ value: "callback" }, context()),
-    ).resolves.toEqual({
+    await expect(declaration.fn({ value: "callback" }, context())).resolves.toEqual({
       value: "CALLBACK",
     })
 
@@ -501,8 +441,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     await runtime.runPromise(Hatchet.runNoWait(upper, { value: "warm" }))
 
     expect(sdk.durableTask).toHaveBeenCalledOnce()
-    const declaration = sdk.durableTask.mock
-      .calls[0]?.[0] as DurableCallbackDeclaration
+    const declaration = sdk.durableTask.mock.calls[0]?.[0] as DurableCallbackDeclaration
     await expect(
       declaration.fn(
         { value: "callback" },
@@ -523,9 +462,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     const runtime = ManagedRuntime.make(layer())
 
-    await expect(
-      runtime.runPromise(Hatchet.runNoWait(unknown, undefined)),
-    ).rejects.toMatchObject({
+    await expect(runtime.runPromise(Hatchet.runNoWait(unknown, undefined))).rejects.toMatchObject({
       _tag: "MissingTaskError",
       taskName: "unknown-durable",
     })
@@ -536,8 +473,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
   it("reports durable input Schema failures without invoking the handler", async () => {
     const runtime = ManagedRuntime.make(layer())
     await runtime.runPromise(Hatchet.runNoWait(upper, { value: "warm" }))
-    const declaration = sdk.durableTask.mock
-      .calls[0]?.[0] as DurableCallbackDeclaration
+    const declaration = sdk.durableTask.mock.calls[0]?.[0] as DurableCallbackDeclaration
 
     await expect(
       declaration.fn(
@@ -567,8 +503,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       }),
     )
     await runtime.runPromise(Hatchet.runNoWait(interrupted, {}))
-    const declaration = sdk.durableTask.mock
-      .calls[0]?.[0] as DurableCallbackDeclaration
+    const declaration = sdk.durableTask.mock.calls[0]?.[0] as DurableCallbackDeclaration
     const controller = new AbortController()
 
     const result = declaration.fn(
@@ -602,9 +537,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       }),
     )
 
-    await expect(
-      runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" })),
-    ).rejects.toMatchObject({
+    await expect(runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))).rejects.toMatchObject({
       _tag: "TaskDeclarationError",
       taskName: "upper",
       field: "name",
@@ -629,9 +562,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     ])
     const runtime = ManagedRuntime.make(invalidLayer)
 
-    await expect(
-      runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" })),
-    ).rejects.toMatchObject({
+    await expect(runtime.runPromise(Hatchet.runNoWait(upper, { value: "done" }))).rejects.toMatchObject({
       _tag: "TaskDeclarationError",
       field: "_tag",
       reason: "InvalidKind",
@@ -660,14 +591,10 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     sdk.crons.get.mockRejectedValueOnce({ response: { status: 404 } })
     sdk.crons.delete.mockRejectedValueOnce({ response: { status: 404 } })
-    await expect(
-      runtime.runPromise(Hatchet.getCron(created.id)),
-    ).resolves.toMatchObject({
+    await expect(runtime.runPromise(Hatchet.getCron(created.id))).resolves.toMatchObject({
       _tag: "None",
     })
-    await expect(
-      runtime.runPromise(Hatchet.deleteCron(created.id)),
-    ).resolves.toBe(false)
+    await expect(runtime.runPromise(Hatchet.deleteCron(created.id))).resolves.toBe(false)
     expect(sdk.crons.list).not.toHaveBeenCalled()
 
     await runtime.dispose()
@@ -680,10 +607,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     const runtime = ManagedRuntime.make(layer())
     sdk.crons.create.mockRejectedValueOnce(failure)
     sdk.crons.list.mockResolvedValueOnce({
-      rows: [
-        cronRow("cron-recovered"),
-        { ...cronRow("cron-unrelated"), name: "other-cron" },
-      ],
+      rows: [cronRow("cron-recovered"), { ...cronRow("cron-unrelated"), name: "other-cron" }],
     })
     const schedule = await Effect.runPromise(CronExpression.parse("0 0 * * *"))
 
@@ -704,21 +628,17 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     await runtime.dispose()
   })
 
-  it.each(
-    [
-      ["authorization", 401, "Unauthorized"],
-      ["validation", 422, "InvalidResponse"],
-    ] as const,
-  )("preserves a definitive %s cron create failure", async (_kind, status, reason) => {
+  it.each([
+    ["authorization", 401, "Unauthorized"],
+    ["validation", 422, "InvalidResponse"],
+  ] as const)("preserves a definitive %s cron create failure", async (_kind, status, reason) => {
     const runtime = ManagedRuntime.make(layer())
     sdk.crons.create.mockRejectedValueOnce({
       response: { status, data: "create-secret" },
     })
     const schedule = await Effect.runPromise(CronExpression.parse("0 0 * * *"))
 
-    const error = await runtime.runPromise(
-      createDailyCron(schedule).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(createDailyCron(schedule).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "HatchetSdkError",
@@ -739,9 +659,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     const schedule = await Effect.runPromise(CronExpression.parse("0 0 * * *"))
 
-    const error = await runtime.runPromise(
-      createDailyCron(schedule).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(createDailyCron(schedule).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "HatchetSdkError",
@@ -769,9 +687,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     const schedule = await Effect.runPromise(CronExpression.parse("0 0 * * *"))
 
-    const error = await runtime.runPromise(
-      createDailyCron(schedule).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(createDailyCron(schedule).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "HatchetSdkError",
@@ -798,9 +714,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     sdk.crons.list.mockResolvedValueOnce({ rows: [] })
 
     const cronId = makeCronId("cron-42")
-    await expect(runtime.runPromise(Hatchet.deleteCron(cronId))).resolves.toBe(
-      false,
-    )
+    await expect(runtime.runPromise(Hatchet.deleteCron(cronId))).resolves.toBe(false)
     expect(sdk.crons.delete).toHaveBeenCalledExactlyOnceWith(cronId)
     expect(sdk.crons.list).toHaveBeenCalledExactlyOnceWith({
       offset: 0,
@@ -819,9 +733,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       rows: [{ metadata: { id: "cron-42" } }],
     })
 
-    const error = await runtime.runPromise(
-      Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "HatchetSdkError",
@@ -845,9 +757,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
     sdk.crons.list.mockResolvedValueOnce(response)
 
-    const error = await runtime.runPromise(
-      Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "HatchetSdkError",
@@ -855,9 +765,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       resourceId: "cron-42",
       reason: "Unavailable",
     })
-    expect(JSON.stringify(error)).not.toMatch(
-      /delete-secret|verification-secret/,
-    )
+    expect(JSON.stringify(error)).not.toMatch(/delete-secret|verification-secret/)
     await runtime.dispose()
   })
 
@@ -870,9 +778,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       response: { status: 503, data: "list-secret" },
     })
 
-    const error = await runtime.runPromise(
-      Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip),
-    )
+    const error = await runtime.runPromise(Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip))
 
     expect(error).toMatchObject({
       _tag: "HatchetSdkError",
@@ -890,16 +796,13 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     })
 
     const error = await Effect.runPromise(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const listStarted = yield* Deferred.make<void>()
         sdk.crons.list.mockImplementationOnce(() => {
           Effect.runSync(Deferred.succeed(listStarted, undefined))
           return new Promise<unknown>(() => undefined)
         })
-        const fiber = yield* Hatchet.deleteCron(makeCronId("cron-42")).pipe(
-          Effect.flip,
-          Effect.forkChild,
-        )
+        const fiber = yield* Hatchet.deleteCron(makeCronId("cron-42")).pipe(Effect.flip, Effect.forkChild)
         yield* Deferred.await(listStarted)
         expect(sdk.crons.list).toHaveBeenCalledExactlyOnceWith({
           offset: 0,
@@ -907,10 +810,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
         })
         yield* TestClock.adjust("5 seconds")
         return yield* Fiber.join(fiber)
-      }).pipe(
-        Effect.provide(Layer.merge(layer(), TestClock.layer())),
-        Effect.scoped,
-      ),
+      }).pipe(Effect.provide(Layer.merge(layer(), TestClock.layer())), Effect.scoped),
     )
 
     expect(error).toMatchObject({
@@ -922,17 +822,16 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     expect(JSON.stringify(error)).not.toContain("delete-secret")
   })
 
-  it.each(
-    [
-      ["offset", -1],
-      ["limit", 0],
-    ] as const,
-  )("rejects invalid cron %s before the SDK call", async (field, value) => {
+  it.each([
+    ["offset", -1],
+    ["limit", 0],
+  ] as const)("rejects invalid cron %s before the SDK call", async (field, value) => {
     const runtime = ManagedRuntime.make(layer())
 
-    await expect(
-      runtime.runPromise(Hatchet.listCrons({ [field]: value })),
-    ).rejects.toMatchObject({ _tag: "InvalidCronFilterError", field })
+    await expect(runtime.runPromise(Hatchet.listCrons({ [field]: value }))).rejects.toMatchObject({
+      _tag: "InvalidCronFilterError",
+      field,
+    })
     expect(sdk.crons.list).not.toHaveBeenCalled()
     await runtime.dispose()
   })
@@ -946,15 +845,9 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       scope: "tenant-a",
     }
 
-    const receipt = await runtime.runPromise(
-      Hatchet.pushEvent("customer.updated", payload, options),
-    )
+    const receipt = await runtime.runPromise(Hatchet.pushEvent("customer.updated", payload, options))
 
-    expect(sdk.pushEvent).toHaveBeenCalledExactlyOnceWith(
-      "customer.updated",
-      payload,
-      options,
-    )
+    expect(sdk.pushEvent).toHaveBeenCalledExactlyOnceWith("customer.updated", payload, options)
     expect(receipt).toEqual({
       eventId: "event-42",
       key: "customer.updated",
@@ -975,9 +868,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     const runtime = ManagedRuntime.make(layer())
 
     const error = await runtime.runPromise(
-      Reflect.apply(Hatchet.pushEvent, undefined, [key, payload, options]).pipe(
-        Effect.flip,
-      ),
+      Reflect.apply(Hatchet.pushEvent, undefined, [key, payload, options]).pipe(Effect.flip),
     )
 
     expect(error).toMatchObject({ _tag: "InvalidEventError" })
@@ -991,13 +882,9 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     const runtime = ManagedRuntime.make(layer())
     const secret = "event-sdk-secret"
     sdk.pushEvent.mockRejectedValueOnce(new Error(secret))
-    const rejection = await runtime.runPromise(
-      Hatchet.pushEvent("customer.updated", { ok: true }).pipe(Effect.flip),
-    )
+    const rejection = await runtime.runPromise(Hatchet.pushEvent("customer.updated", { ok: true }).pipe(Effect.flip))
     sdk.pushEvent.mockResolvedValueOnce({ eventId: "" })
-    const malformed = await runtime.runPromise(
-      Hatchet.pushEvent("customer.updated", { ok: true }).pipe(Effect.flip),
-    )
+    const malformed = await runtime.runPromise(Hatchet.pushEvent("customer.updated", { ok: true }).pipe(Effect.flip))
 
     expect(rejection).toMatchObject({
       _tag: "HatchetSdkError",
@@ -1021,23 +908,17 @@ describe("live SDK adapter behind Hatchet.layer", () => {
     const failure = new Error("scope-failure")
 
     const close = await Effect.runPromise(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const scope = yield* Scope.make()
-        const context = yield* Layer.buildWithScope(scope)(
-          Layer.merge(layer(), Logger.layer([logger])),
-        )
-        yield* Hatchet.pushEvent("customer.updated", { ok: true }).pipe(
-          Effect.provide(context),
-        )
+        const context = yield* Layer.buildWithScope(scope)(Layer.merge(layer(), Logger.layer([logger])))
+        yield* Hatchet.pushEvent("customer.updated", { ok: true }).pipe(Effect.provide(context))
         return yield* Scope.close(scope, Exit.fail(failure)).pipe(Effect.exit)
       }),
     )
 
     expect(Exit.isFailure(close)).toBe(true)
     expect(sdk.stop).toHaveBeenCalledOnce()
-    expect(logs.join("\\n")).toContain(
-      "Hatchet worker stop failed during failed scope cleanup",
-    )
+    expect(logs.join("\\n")).toContain("Hatchet worker stop failed during failed scope cleanup")
     expect(logs.join("\\n")).toContain("worker.stop")
     expect(logs.join("\\n")).not.toContain(secret)
   })
@@ -1047,9 +928,7 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       rows: ids.map((id) => ({ metadata: { id } })),
       ...(pagination === undefined ? {} : { pagination }),
     })
-    const full = page(
-      Array.from({ length: 100 }, (_, index) => `other-${index}`),
-    )
+    const full = page(Array.from({ length: 100 }, (_, index) => `other-${index}`))
     const paginated = [
       page([], { current_page: 1, next_page: 2, num_pages: 2 }),
       page(["cron-42"], { current_page: 2, num_pages: 2 }),
@@ -1058,23 +937,15 @@ describe("live SDK adapter behind Hatchet.layer", () => {
       [paginated, false, [0, 100]],
       [[page([], { current_page: 1, num_pages: 1 })], true, [0]],
       [[full, page([])], true, [0, 100]],
-      [
-        [page([], { current_page: 1, next_page: "2", num_pages: 2 })],
-        false,
-        [0],
-      ],
+      [[page([], { current_page: 1, next_page: "2", num_pages: 2 })], false, [0]],
       [[page([], { current_page: 1, next_page: 1, num_pages: 2 })], false, [0]],
       [[full, full], false, [0, 100], 2],
     ] as const
     for (const [responses, absent, offsets, maxPages] of cases) {
       const list = vi.fn()
       for (const response of responses) list.mockResolvedValueOnce(response)
-      await expect(verifyCronAbsent(list, "cron-42", maxPages)).resolves.toBe(
-        absent,
-      )
-      expect(list.mock.calls.map(([query]) => query)).toEqual(
-        offsets.map((offset) => ({ offset, limit: 100 })),
-      )
+      await expect(verifyCronAbsent(list, "cron-42", maxPages)).resolves.toBe(absent)
+      expect(list.mock.calls.map(([query]) => query)).toEqual(offsets.map((offset) => ({ offset, limit: 100 })))
     }
   })
 })
diff --git a/packages/hatchet/tests/unit/package-contract.test.ts b/packages/hatchet/tests/unit/package-contract.test.ts
index c50e7698..7839a80e 100644
--- a/packages/hatchet/tests/unit/package-contract.test.ts
+++ b/packages/hatchet/tests/unit/package-contract.test.ts
@@ -13,12 +13,8 @@ const runNode = (source: string): string =>
 
 describe("published package contract", () => {
   it("resolves the built testing subpath without exposing testing helpers from the root", () => {
-    expect(
-      existsSync(new URL("../../dist/src/testing/index.js", import.meta.url)),
-    ).toBe(true)
-    expect(
-      existsSync(new URL("../../dist/src/testing/index.d.ts", import.meta.url)),
-    ).toBe(true)
+    expect(existsSync(new URL("../../dist/src/testing/index.js", import.meta.url))).toBe(true)
+    expect(existsSync(new URL("../../dist/src/testing/index.d.ts", import.meta.url))).toBe(true)
 
     const output = runNode(`
       import * as root from "@effectify/hatchet"
diff --git a/packages/hatchet/tests/unit/public-api-source-contract.test.ts b/packages/hatchet/tests/unit/public-api-source-contract.test.ts
index 590ed4c2..ebb727dd 100644
--- a/packages/hatchet/tests/unit/public-api-source-contract.test.ts
+++ b/packages/hatchet/tests/unit/public-api-source-contract.test.ts
@@ -9,10 +9,7 @@ const publicSourceFiles = [
   "../../src/Error.ts",
   "../../src/Model.ts",
 ].map((path) => new URL(path, import.meta.url))
-const exampleSourceFile = new URL(
-  "../../scripts/test-workflow.ts",
-  import.meta.url,
-)
+const exampleSourceFile = new URL("../../scripts/test-workflow.ts", import.meta.url)
 
 const forbiddenManualLifecycleSymbols = [
   "RegisteredTask",
@@ -27,10 +24,7 @@ describe("public API source contract", () => {
     for (const sourceFile of publicSourceFiles) {
       const source = readFileSync(sourceFile, "utf8")
       for (const forbidden of forbiddenManualLifecycleSymbols) {
-        expect(
-          source,
-          `${sourceFile.pathname} contains ${forbidden}`,
-        ).not.toContain(forbidden)
+        expect(source, `${sourceFile.pathname} contains ${forbidden}`).not.toContain(forbidden)
       }
     }
   })
diff --git a/packages/hatchet/tests/unit/rate-limit.test.ts b/packages/hatchet/tests/unit/rate-limit.test.ts
index cb3ea842..ed6eb330 100644
--- a/packages/hatchet/tests/unit/rate-limit.test.ts
+++ b/packages/hatchet/tests/unit/rate-limit.test.ts
@@ -5,17 +5,15 @@ import * as SdkDeclaration from "../../src/internal/sdk-declaration.js"
 
 describe("RateLimit", () => {
   it("creates frozen package-owned values without retaining unknown fields", () => {
-    const limit = RateLimit.make(
-      {
-        units: 1,
-        limit: "input.limit",
-        key: "email",
-        staticKey: "transactional",
-        dynamicKey: "input.tenant",
-        duration: "minute",
-        extra: "ignored",
-      } as RateLimit.Options & { readonly extra: string },
-    )
+    const limit = RateLimit.make({
+      units: 1,
+      limit: "input.limit",
+      key: "email",
+      staticKey: "transactional",
+      dynamicKey: "input.tenant",
+      duration: "minute",
+      extra: "ignored",
+    } as RateLimit.Options & { readonly extra: string })
 
     expect(limit).toEqual({
       _tag: "RateLimit",
@@ -30,19 +28,12 @@ describe("RateLimit", () => {
     expect(limit).not.toHaveProperty("extra")
   })
 
-  it.each(
-    [
-      "second",
-      "minute",
-      "hour",
-      "day",
-      "week",
-      "month",
-      "year",
-    ] as const,
-  )("maps %s through the internal SDK adapter", (duration) => {
-    expect(SdkDeclaration.rateLimitDuration(duration)).toBeDefined()
-  })
+  it.each(["second", "minute", "hour", "day", "week", "month", "year"] as const)(
+    "maps %s through the internal SDK adapter",
+    (duration) => {
+      expect(SdkDeclaration.rateLimitDuration(duration)).toBeDefined()
+    },
+  )
 
   it("preserves duplicate declarations and all supported key fields", () => {
     const limit = RateLimit.make({
@@ -54,29 +45,24 @@ describe("RateLimit", () => {
       duration: "year",
     })
 
-    expect(Declarations.rateLimits("task", [limit, limit])).toEqual([
-      limit,
-      limit,
-    ])
+    expect(Declarations.rateLimits("task", [limit, limit])).toEqual([limit, limit])
   })
 
-  it.each(
-    [
-      ["units", 0],
-      ["units", Number.POSITIVE_INFINITY],
-      ["units", 1.5],
-      ["units", "  "],
-      ["units", true],
-      ["limit", 0],
-      ["limit", "  "],
-      ["limit", false],
-      ["duration", "fortnight"],
-      ["duration", 1],
-      ["key", ""],
-      ["staticKey", " "],
-      ["dynamicKey", " "],
-    ] as const,
-  )("rejects invalid runtime %s value %j", (field, value) => {
+  it.each([
+    ["units", 0],
+    ["units", Number.POSITIVE_INFINITY],
+    ["units", 1.5],
+    ["units", "  "],
+    ["units", true],
+    ["limit", 0],
+    ["limit", "  "],
+    ["limit", false],
+    ["duration", "fortnight"],
+    ["duration", 1],
+    ["key", ""],
+    ["staticKey", " "],
+    ["dynamicKey", " "],
+  ] as const)("rejects invalid runtime %s value %j", (field, value) => {
     const limit = Reflect.apply(RateLimit.make, undefined, [
       {
         units: 1,
diff --git a/packages/hatchet/tests/unit/run-no-wait.test.ts b/packages/hatchet/tests/unit/run-no-wait.test.ts
index 46f67229..959f9b67 100644
--- a/packages/hatchet/tests/unit/run-no-wait.test.ts
+++ b/packages/hatchet/tests/unit/run-no-wait.test.ts
@@ -9,9 +9,7 @@ import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import { Hatchet, Task } from "@effectify/hatchet"
 
-class Prefix extends Context.Service<Prefix, { readonly value: string }>()(
-  "@effectify/hatchet/test/RunNoWaitPrefix",
-) {}
+class Prefix extends Context.Service<Prefix, { readonly value: string }>()("@effectify/hatchet/test/RunNoWaitPrefix") {}
 
 class TaskFailure {
   readonly _tag = "TaskFailure" as const
@@ -34,7 +32,7 @@ describe("Hatchet.runNoWait in-memory", () => {
           Effect.tap(() => Deferred.succeed(completed, undefined)),
         ),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, { value: 21 })
       yield* Deferred.await(started)
       const completedAtDispatch = yield* Deferred.poll(completed)
@@ -60,7 +58,7 @@ describe("Hatchet.runNoWait in-memory", () => {
       output: Schema.Struct({ at: Schema.DateFromString }),
       fn: () => Effect.succeed({ at: new Date("2030-01-01T00:00:00.000Z") }),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, undefined)
       const noWait = yield* handle.await
       const waited = yield* Hatchet.run(task, undefined)
@@ -91,28 +89,20 @@ describe("Hatchet.runNoWait in-memory", () => {
       }),
       fn: () => Effect.succeed({ value: -1 }),
     })
-    const program = Effect.gen(function*() {
-      const inputExit = yield* Effect.exit(
-        Hatchet.runNoWait(invalidInput, { value: "wrong" }),
-      )
+    const program = Effect.gen(function* () {
+      const inputExit = yield* Effect.exit(Hatchet.runNoWait(invalidInput, { value: "wrong" }))
       const handle = yield* Hatchet.runNoWait(invalidOutput, undefined)
       const outputExit = yield* Effect.exit(handle.await)
       return { inputExit, outputExit }
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    const { inputExit, outputExit } = await Effect.runPromise(
-      Effect.scoped(program),
-    )
+    const { inputExit, outputExit } = await Effect.runPromise(Effect.scoped(program))
 
     expect(invocations).toBe(0)
     expect(Exit.isFailure(inputExit)).toBe(true)
     expect(Exit.isFailure(outputExit)).toBe(true)
     if (Exit.isFailure(inputExit)) {
-      expect(
-        inputExit.cause.reasons
-          .filter(Cause.isFailReason)
-          .map((reason) => reason.error),
-      ).toEqual([
+      expect(inputExit.cause.reasons.filter(Cause.isFailReason).map((reason) => reason.error)).toEqual([
         expect.objectContaining({
           _tag: "TaskSchemaError",
           phase: "input",
@@ -121,11 +111,7 @@ describe("Hatchet.runNoWait in-memory", () => {
       ])
     }
     if (Exit.isFailure(outputExit)) {
-      expect(
-        outputExit.cause.reasons
-          .filter(Cause.isFailReason)
-          .map((reason) => reason.error),
-      ).toEqual([
+      expect(outputExit.cause.reasons.filter(Cause.isFailReason).map((reason) => reason.error)).toEqual([
         expect.objectContaining({
           _tag: "TaskSchemaError",
           phase: "output",
@@ -139,21 +125,14 @@ describe("Hatchet.runNoWait in-memory", () => {
     const task = Task.make({
       name: "no-wait-requirement",
       fn: (value: number): Effect.Effect<string, TaskFailure, Prefix> =>
-        value > 0
-          ? Effect.map(Prefix, ({ value: prefix }) => `${prefix}${value}`)
-          : Effect.fail(new TaskFailure()),
+        value > 0 ? Effect.map(Prefix, ({ value: prefix }) => `${prefix}${value}`) : Effect.fail(new TaskFailure()),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, 7)
       return yield* handle.await
-    }).pipe(
-      Effect.provide(Layer.succeed(Prefix, { value: "captured-" })),
-      Effect.provide(Hatchet.layerInMemory),
-    )
-
-    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toBe(
-      "captured-7",
-    )
+    }).pipe(Effect.provide(Layer.succeed(Prefix, { value: "captured-" })), Effect.provide(Hatchet.layerInMemory))
+
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toBe("captured-7")
   })
 
   it("interrupts outstanding work through the handle and runs its finalizer", async () => {
@@ -166,7 +145,7 @@ describe("Hatchet.runNoWait in-memory", () => {
           Effect.andThen(Effect.never),
         ),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, undefined)
       yield* Deferred.await(started)
       yield* handle.cancel
@@ -192,7 +171,7 @@ describe("Hatchet.runNoWait in-memory", () => {
           Effect.andThen(Effect.never),
         ),
     })
-    const dispatch = Effect.gen(function*() {
+    const dispatch = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, undefined)
       yield* Deferred.await(started)
       return handle.id
diff --git a/packages/hatchet/tests/unit/schedule.test.ts b/packages/hatchet/tests/unit/schedule.test.ts
index 358287f8..7cb56f7e 100644
--- a/packages/hatchet/tests/unit/schedule.test.ts
+++ b/packages/hatchet/tests/unit/schedule.test.ts
@@ -10,9 +10,8 @@ import { TestClock } from "effect/testing"
 import { Hatchet, Task } from "@effectify/hatchet"
 
 const layer = Layer.merge(Hatchet.layerInMemory, TestClock.layer())
-const run = <A, E>(
-  effect: Effect.Effect<A, E, Hatchet.Hatchet | Scope.Scope>,
-) => Effect.runPromise(Effect.scoped(effect.pipe(Effect.provide(layer))))
+const run = <A, E>(effect: Effect.Effect<A, E, Hatchet.Hatchet | Scope.Scope>) =>
+  Effect.runPromise(Effect.scoped(effect.pipe(Effect.provide(layer))))
 
 describe("Hatchet scheduling lifecycle", () => {
   it("rejects invalid timing and schema input before storing", async () => {
@@ -23,7 +22,7 @@ describe("Hatchet scheduling lifecycle", () => {
       fn: () => Effect.sync(() => (executions += 1)),
     })
     const result = await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const timings = yield* Effect.forEach(
           [
             { _tag: "At" as const, at: new Date(Number.NaN) },
@@ -33,24 +32,14 @@ describe("Hatchet scheduling lifecycle", () => {
           (timing) => Effect.exit(Hatchet.schedule(task, { name: "Ada" }, timing)),
         )
         const invalidInput = yield* Effect.exit(
-          Hatchet.schedule(
-            task,
-            { name: "" },
-            { _tag: "After", delay: "1 second" },
-          ),
+          Hatchet.schedule(task, { name: "" }, { _tag: "After", delay: "1 second" }),
         )
         yield* TestClock.adjust("1 second")
-        const valid = yield* Hatchet.schedule(
-          task,
-          { name: "Ada" },
-          { _tag: "After", delay: "1 second" },
-        )
+        const valid = yield* Hatchet.schedule(task, { name: "Ada" }, { _tag: "After", delay: "1 second" })
         return { timings, invalidInput, valid }
       }),
     )
-    expect(
-      result.timings.every((exit) => String(exit).includes("InvalidTimeError")),
-    ).toBe(true)
+    expect(result.timings.every((exit) => String(exit).includes("InvalidTimeError"))).toBe(true)
     expect(String(result.invalidInput)).toContain("TaskSchemaError")
     expect(result.valid.id).toBe("schedule-1")
     expect(executions).toBe(0)
@@ -60,9 +49,7 @@ describe("Hatchet scheduling lifecycle", () => {
     let decodes = 0
     let executions = 0
     let collisions = 0
-    const input = Schema.Struct({ value: Schema.Number }).check(
-      Schema.makeFilter(() => (decodes += 1) > 0),
-    )
+    const input = Schema.Struct({ value: Schema.Number }).check(Schema.makeFilter(() => (decodes += 1) > 0))
     const task = Task.make({
       name: "registry-stable",
       input,
@@ -73,16 +60,13 @@ describe("Hatchet scheduling lifecycle", () => {
       fn: () => Effect.sync(() => (collisions += 1)),
     })
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         yield* Hatchet.run(collision, undefined)
         const handle = yield* Hatchet.runNoWait(task, { value: 1 })
         yield* handle.await
         yield* Effect.forEach([1, 2, 3], (value) =>
-          Hatchet.schedule(
-            task,
-            { value },
-            { _tag: "After", delay: "1 second" },
-          ))
+          Hatchet.schedule(task, { value }, { _tag: "After", delay: "1 second" }),
+        )
         yield* TestClock.adjust("1 second")
       }),
     )
@@ -96,21 +80,16 @@ describe("Hatchet scheduling lifecycle", () => {
     let executions = 0
     const task = Task.make({
       name: "deadline-schedule",
-      fn: () =>
-        Effect.sync(() => (executions += 1)).pipe(
-          Effect.andThen(Deferred.succeed(fired, undefined)),
-        ),
+      fn: () => Effect.sync(() => (executions += 1)).pipe(Effect.andThen(Deferred.succeed(fired, undefined))),
     })
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const record = yield* Hatchet.schedule(task, undefined, {
           _tag: "After",
           delay: "1 second",
         })
         yield* TestClock.adjust("999 millis")
-        expect(yield* Hatchet.getSchedule(record.id)).toEqual(
-          Option.some(record),
-        )
+        expect(yield* Hatchet.getSchedule(record.id)).toEqual(Option.some(record))
         expect(executions).toBe(0)
         yield* TestClock.adjust("1 millis")
         yield* Deferred.await(fired)
@@ -137,16 +116,14 @@ describe("Hatchet scheduling lifecycle", () => {
         ),
     })
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const record = yield* Hatchet.schedule(task, undefined, {
           _tag: "After",
           delay: "1 second",
         })
         yield* TestClock.adjust("1 second")
         yield* Deferred.await(started)
-        expect(yield* Hatchet.getSchedule(record.id)).toEqual(
-          Option.some(record),
-        )
+        expect(yield* Hatchet.getSchedule(record.id)).toEqual(Option.some(record))
         expect(yield* Hatchet.deleteSchedule(record.id)).toBe(true)
         yield* Deferred.await(finalized)
         expect(interrupted).toBe(true)
@@ -167,7 +144,7 @@ describe("Hatchet scheduling lifecycle", () => {
     })
     await Effect.runPromise(
       Effect.scoped(
-        Effect.gen(function*() {
+        Effect.gen(function* () {
           const record = yield* Hatchet.schedule(task, undefined, {
             _tag: "After",
             delay: "1 second",
@@ -192,7 +169,7 @@ describe("Hatchet scheduling lifecycle", () => {
       fn: () => Effect.sync(() => (executions += 1)),
     })
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const after = yield* Hatchet.schedule(task, undefined, {
           _tag: "After",
           delay: "2 seconds",
diff --git a/packages/hatchet/tests/unit/task-core.test.ts b/packages/hatchet/tests/unit/task-core.test.ts
index 07ede7aa..60d140ef 100644
--- a/packages/hatchet/tests/unit/task-core.test.ts
+++ b/packages/hatchet/tests/unit/task-core.test.ts
@@ -11,9 +11,7 @@ import * as Schema from "effect/Schema"
 import { Hatchet, Task } from "@effectify/hatchet"
 import { makeRunId } from "../../src/Model.js"
 
-class Prefix extends Context.Service<Prefix, { readonly value: string }>()(
-  "@effectify/hatchet/test/Prefix",
-) {}
+class Prefix extends Context.Service<Prefix, { readonly value: string }>()("@effectify/hatchet/test/Prefix") {}
 class TypedFailure {
   readonly _tag = "TypedFailure" as const
 }
@@ -25,18 +23,12 @@ describe("Task public type contracts", () => {
       input: Schema.Struct({ value: Schema.Number }),
       output: Schema.String,
       fn: (input): Effect.Effect<string, TypedFailure, Prefix> =>
-        input.value > 0
-          ? Effect.succeed(String(input.value))
-          : Effect.fail(new TypedFailure()),
+        input.value > 0 ? Effect.succeed(String(input.value)) : Effect.fail(new TypedFailure()),
     })
 
     expectTypeOf(task.name).toEqualTypeOf<"typed-contract">()
-    expectTypeOf(task.execute).parameters.toMatchTypeOf<
-      [{ readonly value: number }, Task.Context]
-    >()
-    expectTypeOf(task.execute).returns.toEqualTypeOf<
-      Effect.Effect<string, TypedFailure, Prefix>
-    >()
+    expectTypeOf(task.execute).parameters.toMatchTypeOf<[{ readonly value: number }, Task.Context]>()
+    expectTypeOf(task.execute).returns.toEqualTypeOf<Effect.Effect<string, TypedFailure, Prefix>>()
   })
 })
 
@@ -46,16 +38,13 @@ describe("Task.make direct Effect execution", () => {
       name: "greet",
       fn: (name: string, context) => Effect.succeed(`${name}:${Option.getOrThrow(context.workflowRunId)}`),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const first = yield* Hatchet.run(task, "Ada")
       const second = yield* Hatchet.run(task, "Grace")
       return [first, second]
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toEqual([
-      "Ada:run-1",
-      "Grace:run-2",
-    ])
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toEqual(["Ada:run-1", "Grace:run-2"])
   })
 
   it("captures task requirements from the native Effect program", async () => {
@@ -68,9 +57,7 @@ describe("Task.make direct Effect execution", () => {
       Effect.provide(Hatchet.layerInMemory),
     )
 
-    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toBe(
-      "captured",
-    )
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toBe("captured")
   })
 
   it("dispatches a durable task through the in-memory registry exactly once", async () => {
@@ -86,13 +73,7 @@ describe("Task.make direct Effect execution", () => {
     })
 
     await expect(
-      Effect.runPromise(
-        Effect.scoped(
-          Hatchet.run(task, { value: 3 }).pipe(
-            Effect.provide(Hatchet.layerInMemory),
-          ),
-        ),
-      ),
+      Effect.runPromise(Effect.scoped(Hatchet.run(task, { value: 3 }).pipe(Effect.provide(Hatchet.layerInMemory)))),
     ).resolves.toBe("3:0")
     expect(invocations).toBe(1)
   })
@@ -106,23 +87,19 @@ describe("Task.make direct Effect execution", () => {
       name: "defect",
       fn: () => Effect.die("unexpected defect"),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const typedExit = yield* Effect.exit(Hatchet.run(typed, undefined))
       const defectExit = yield* Effect.exit(Hatchet.run(defective, undefined))
       return { defectExit, typedExit }
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    const { defectExit, typedExit } = await Effect.runPromise(
-      Effect.scoped(program),
-    )
+    const { defectExit, typedExit } = await Effect.runPromise(Effect.scoped(program))
     expect(Exit.isFailure(typedExit)).toBe(true)
     expect(Exit.isFailure(defectExit)).toBe(true)
     if (Exit.isFailure(typedExit)) {
-      expect(
-        typedExit.cause.reasons
-          .filter(Cause.isFailReason)
-          .map((reason) => reason.error),
-      ).toEqual([new TypedFailure()])
+      expect(typedExit.cause.reasons.filter(Cause.isFailReason).map((reason) => reason.error)).toEqual([
+        new TypedFailure(),
+      ])
     }
     if (Exit.isFailure(defectExit)) {
       expect(Cause.hasDies(defectExit.cause)).toBe(true)
@@ -143,9 +120,7 @@ describe("Schema input and output boundaries", () => {
     await expect(
       Effect.runPromise(
         Effect.scoped(
-          Hatchet.run(task, { at: "2030-01-01T00:00:00.000Z" }).pipe(
-            Effect.provide(Hatchet.layerInMemory),
-          ),
+          Hatchet.run(task, { at: "2030-01-01T00:00:00.000Z" }).pipe(Effect.provide(Hatchet.layerInMemory)),
         ),
       ),
     ).resolves.toBe("2030-01-01T00:00:00.000Z")
@@ -167,9 +142,7 @@ describe("Schema input and output boundaries", () => {
       Effect.provide(Hatchet.layerInMemory),
     )
 
-    await expect(
-      Effect.runPromise(Effect.scoped(result)),
-    ).resolves.toMatchObject({
+    await expect(Effect.runPromise(Effect.scoped(result))).resolves.toMatchObject({
       _tag: "TaskSchemaError",
       phase: "input",
       taskName: "schema-input",
@@ -190,17 +163,13 @@ describe("Schema input and output boundaries", () => {
       }),
       fn: () => Effect.succeed({ value: -1 }),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const value = yield* Hatchet.run(valid, undefined)
-      const failure = yield* Hatchet.run(invalid, undefined).pipe(
-        Effect.catchTag("TaskSchemaError", Effect.succeed),
-      )
+      const failure = yield* Hatchet.run(invalid, undefined).pipe(Effect.catchTag("TaskSchemaError", Effect.succeed))
       return { failure, value }
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    await expect(
-      Effect.runPromise(Effect.scoped(program)),
-    ).resolves.toMatchObject({
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toMatchObject({
       failure: {
         _tag: "TaskSchemaError",
         phase: "output",
@@ -218,18 +187,14 @@ describe("no-wait execution", () => {
       name: "fire-and-forget-success",
       fn: () => Deferred.succeed(completed, undefined),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, undefined)
       yield* Deferred.await(completed)
       yield* Effect.yieldNow
-      return yield* Hatchet.cancelRun(handle.id).pipe(
-        Effect.catchTag("HatchetSdkError", Effect.succeed),
-      )
+      return yield* Hatchet.cancelRun(handle.id).pipe(Effect.catchTag("HatchetSdkError", Effect.succeed))
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    await expect(
-      Effect.runPromise(Effect.scoped(program)),
-    ).resolves.toMatchObject({
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toMatchObject({
       _tag: "HatchetSdkError",
       operation: "run.cancel",
     })
@@ -239,23 +204,16 @@ describe("no-wait execution", () => {
     const completed = Deferred.makeUnsafe<void>()
     const task = Task.make({
       name: "fire-and-forget-failure",
-      fn: () =>
-        Deferred.succeed(completed, undefined).pipe(
-          Effect.andThen(Effect.fail(new TypedFailure())),
-        ),
+      fn: () => Deferred.succeed(completed, undefined).pipe(Effect.andThen(Effect.fail(new TypedFailure()))),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, undefined)
       yield* Deferred.await(completed)
       yield* Effect.yieldNow
-      return yield* Hatchet.cancelRun(handle.id).pipe(
-        Effect.catchTag("HatchetSdkError", Effect.succeed),
-      )
+      return yield* Hatchet.cancelRun(handle.id).pipe(Effect.catchTag("HatchetSdkError", Effect.succeed))
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    await expect(
-      Effect.runPromise(Effect.scoped(program)),
-    ).resolves.toMatchObject({
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.toMatchObject({
       _tag: "HatchetSdkError",
       operation: "run.cancel",
     })
@@ -266,11 +224,9 @@ describe("no-wait execution", () => {
       name: "interrupted-submission",
       fn: () => Effect.never,
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       for (let index = 1; index <= 64; index += 1) {
-        const submission = yield* Effect.forkChild(
-          Hatchet.runNoWait(task, undefined),
-        )
+        const submission = yield* Effect.forkChild(Hatchet.runNoWait(task, undefined))
         yield* Fiber.interrupt(submission)
       }
       return yield* Effect.forEach(
@@ -285,9 +241,7 @@ describe("no-wait execution", () => {
       )
     }).pipe(Effect.provide(Hatchet.layerInMemory))
 
-    await expect(
-      Effect.runPromise(Effect.scoped(program)),
-    ).resolves.not.toContain("retained")
+    await expect(Effect.runPromise(Effect.scoped(program))).resolves.not.toContain("retained")
   })
 
   it("returns an observable handle whose cancellation interrupts work", async () => {
@@ -296,7 +250,7 @@ describe("no-wait execution", () => {
       name: "wait",
       fn: () => Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
     })
-    const program = Effect.gen(function*() {
+    const program = Effect.gen(function* () {
       const handle = yield* Hatchet.runNoWait(task, undefined)
       yield* Deferred.await(started)
       yield* handle.cancel
diff --git a/packages/hatchet/tests/unit/time-capabilities.test.ts b/packages/hatchet/tests/unit/time-capabilities.test.ts
index 4f0c1b22..1cc9a5ee 100644
--- a/packages/hatchet/tests/unit/time-capabilities.test.ts
+++ b/packages/hatchet/tests/unit/time-capabilities.test.ts
@@ -14,24 +14,18 @@ const task = Task.make({
     }),
 })
 
-const run = <A, E>(
-  effect: Effect.Effect<A, E, Hatchet.Hatchet | Scope.Scope>,
-) =>
-  Effect.runPromise(
-    Effect.scoped(effect.pipe(Effect.provide(Hatchet.layerInMemory))),
-  )
+const run = <A, E>(effect: Effect.Effect<A, E, Hatchet.Hatchet | Scope.Scope>) =>
+  Effect.runPromise(Effect.scoped(effect.pipe(Effect.provide(Hatchet.layerInMemory))))
 
 describe("time capabilities with public Task identity", () => {
   it("creates, reads, and idempotently deletes a pending schedule", async () => {
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const schedule = yield* Hatchet.schedule(task, "Ada", {
           _tag: "After",
           delay: "5 minutes",
         })
-        expect(yield* Hatchet.getSchedule(schedule.id)).toEqual(
-          Option.some(schedule),
-        )
+        expect(yield* Hatchet.getSchedule(schedule.id)).toEqual(Option.some(schedule))
         expect(yield* Hatchet.deleteSchedule(schedule.id)).toBe(true)
         expect(yield* Hatchet.deleteSchedule(schedule.id)).toBe(false)
       }),
@@ -40,7 +34,7 @@ describe("time capabilities with public Task identity", () => {
 
   it("rejects invalid and past timing", async () => {
     const outcomes = await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const invalidDelay = yield* Effect.exit(
           Hatchet.schedule(task, undefined, {
             _tag: "After",
@@ -63,7 +57,7 @@ describe("time capabilities with public Task identity", () => {
   it("cancels a direct local run independently from schedules", async () => {
     const waiting = Task.make({ name: "waiting", fn: () => Effect.never })
     const exit = await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const handle = yield* Hatchet.runNoWait(waiting, undefined)
         yield* handle.cancel
         return yield* Effect.exit(handle.await)
@@ -92,7 +86,7 @@ describe("storage-only cron", () => {
         }),
     })
     await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const daily = yield* CronExpression.parse("0 9 * * 1-5")
         const other = yield* CronExpression.parse("0 10 * * *")
         const first = yield* Hatchet.createCron(counted, {
@@ -115,7 +109,7 @@ describe("storage-only cron", () => {
 
   it("validates cron expressions, schema input, and pagination", async () => {
     const outcomes = await run(
-      Effect.gen(function*() {
+      Effect.gen(function* () {
         const expression = yield* Effect.exit(CronExpression.parse("bad"))
         const schedule = yield* CronExpression.parse("0 9 * * *")
         const input = yield* Effect.exit(
diff --git a/packages/hatchet/tests/unit/trigger.test.ts b/packages/hatchet/tests/unit/trigger.test.ts
index 672cced3..0dd90fca 100644
--- a/packages/hatchet/tests/unit/trigger.test.ts
+++ b/packages/hatchet/tests/unit/trigger.test.ts
@@ -37,13 +37,7 @@ describe("Trigger", () => {
     expect(SdkDeclaration.on([])).toBeUndefined()
   })
 
-  it.each([
-    "",
-    "  ",
-    "event\u0000name",
-  ])("rejects invalid event %j", (event) => {
-    expect(() => Declarations.triggers("task", [Trigger.event(event)])).toThrow(
-      "event",
-    )
+  it.each(["", "  ", "event\u0000name"])("rejects invalid event %j", (event) => {
+    expect(() => Declarations.triggers("task", [Trigger.event(event)])).toThrow("event")
   })
 })
diff --git a/packages/react/router-better-auth/src/lib/handlers.ts b/packages/react/router-better-auth/src/lib/handlers.ts
index 246337e1..b1570cd3 100644
--- a/packages/react/router-better-auth/src/lib/handlers.ts
+++ b/packages/react/router-better-auth/src/lib/handlers.ts
@@ -4,27 +4,21 @@ import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 
 const withAuthHandler = (request: Request) =>
-  Effect.gen(function*() {
+  Effect.gen(function* () {
     const auth = yield* AuthService.AuthServiceContext
     return yield* Effect.promise(() => auth.auth.handler(request))
   })
 
-const getLoaderRequest = Effect.gen(function*() {
+const getLoaderRequest = Effect.gen(function* () {
   const ctx = yield* LoaderArgsContext
   return ctx.request
 })
 
-const getActionRequest = Effect.gen(function*() {
+const getActionRequest = Effect.gen(function* () {
   const ctx = yield* ActionArgsContext
   return ctx.request
 })
 
-export const betterAuthLoader = pipe(
-  getLoaderRequest,
-  Effect.flatMap(withAuthHandler),
-)
+export const betterAuthLoader = pipe(getLoaderRequest, Effect.flatMap(withAuthHandler))
 
-export const betterAuthAction = pipe(
-  getActionRequest,
-  Effect.flatMap(withAuthHandler),
-)
+export const betterAuthAction = pipe(getActionRequest, Effect.flatMap(withAuthHandler))
diff --git a/packages/react/router-better-auth/tests/auth-guard.test.ts b/packages/react/router-better-auth/tests/auth-guard.test.ts
index 16c75199..2f71293a 100644
--- a/packages/react/router-better-auth/tests/auth-guard.test.ts
+++ b/packages/react/router-better-auth/tests/auth-guard.test.ts
@@ -10,12 +10,9 @@ const request = new Request("https://example.test/todo-app", {
 })
 
 const sessionResponse = (session: unknown) =>
-  new Response(
-    JSON.stringify({ session, user: session ? { id: "user-1" } : null }),
-    {
-      headers: { "Content-Type": "application/json" },
-    },
-  )
+  new Response(JSON.stringify({ session, user: session ? { id: "user-1" } : null }), {
+    headers: { "Content-Type": "application/json" },
+  })
 
 const loaderArgs = { request, params: {}, context: {} }
 const actionArgs = { request, params: {}, context: {} }
@@ -61,12 +58,10 @@ describe("Better Auth guard compatibility", () => {
     vi.restoreAllMocks()
   })
 
-  it.each(
-    [
-      ["loader", runLoaderGuard],
-      ["action", runActionGuard],
-    ] as const,
-  )("preserves redirect status, location, and cookies for an unauthorized %s", async (_name, run) => {
+  it.each([
+    ["loader", runLoaderGuard],
+    ["action", runActionGuard],
+  ] as const)("preserves redirect status, location, and cookies for an unauthorized %s", async (_name, run) => {
     vi.mocked(fetch).mockResolvedValue(sessionResponse(null))
 
     const result = await run()
@@ -76,12 +71,10 @@ describe("Better Auth guard compatibility", () => {
     expect(result.headers.get("Set-Cookie")).toBe("returnTo=/todo-app")
   })
 
-  it.each(
-    [
-      ["loader", runLoaderGuard, 201, "loader-ok"],
-      ["action", runActionGuard, 202, "action-ok"],
-    ] as const,
-  )("preserves successful %s responses", async (_name, run, status, body) => {
+  it.each([
+    ["loader", runLoaderGuard, 201, "loader-ok"],
+    ["action", runActionGuard, 202, "action-ok"],
+  ] as const)("preserves successful %s responses", async (_name, run, status, body) => {
     vi.mocked(fetch).mockResolvedValue(sessionResponse({ id: "session-1" }))
 
     const result = await run()
diff --git a/packages/react/router-better-auth/tsconfig.no-build.json b/packages/react/router-better-auth/tsconfig.no-build.json
index d3105bdb..4cd2fb1c 100644
--- a/packages/react/router-better-auth/tsconfig.no-build.json
+++ b/packages/react/router-better-auth/tsconfig.no-build.json
@@ -8,9 +8,5 @@
       "@effectify/react-router": ["../router/src/index.ts"]
     }
   },
-  "include": [
-    "src/**/*.ts",
-    "../../node/better-auth/src/**/*.ts",
-    "../router/src/**/*.ts"
-  ]
+  "include": ["src/**/*.ts", "../../node/better-auth/src/**/*.ts", "../router/src/**/*.ts"]
 }
diff --git a/packages/react/router-better-auth/vitest.config.ts b/packages/react/router-better-auth/vitest.config.ts
index f74f800d..f903bc41 100644
--- a/packages/react/router-better-auth/vitest.config.ts
+++ b/packages/react/router-better-auth/vitest.config.ts
@@ -7,10 +7,7 @@ export default defineConfig({
   plugins: [nxViteTsPaths()],
   resolve: {
     alias: {
-      "@effectify/node-better-auth": resolve(
-        __dirname,
-        "../../node/better-auth/src/index.ts",
-      ),
+      "@effectify/node-better-auth": resolve(__dirname, "../../node/better-auth/src/index.ts"),
       "@effectify/react-router": resolve(__dirname, "../router/src/index.ts"),
     },
     conditions: ["@effectify/source"],
diff --git a/packages/react/router/src/lib/runtime.ts b/packages/react/router/src/lib/runtime.ts
index 65191e59..11dcd673 100644
--- a/packages/react/router/src/lib/runtime.ts
+++ b/packages/react/router/src/lib/runtime.ts
@@ -20,76 +20,68 @@ const failure = <E>(cause: Cause.Cause<E>): E | undefined => {
 export const make = <R, E>(layer: Layer.Layer<R, E, never>) => {
   const runtime = ManagedRuntime.make(layer)
 
-  const withLoaderEffect = <A, B>(
-    self: Effect.Effect<HttpResponse<A> | Response, B, R | LoaderArgsContext>,
-  ) =>
-  (args: LoaderFunctionArgs) => {
-    const runnable = pipe(
-      self,
-      Effect.provide(Layer.succeed(LoaderArgsContext)(args)),
-      Effect.tapCause((cause) => Effect.logError("Loader effect failed", Cause.squash(cause))),
-    )
-    return runtime.runPromiseExit(runnable).then(
-      Exit.match({
-        onFailure: (cause) => {
-          const error = failure(cause)
-          if (error instanceof Response || error instanceof Error) {
-            throw error
-          }
-          throw jsonResponse(
-            { ok: false, errors: ["Internal server error"] },
-            500,
-          )
-        },
-        onSuccess: (result) => {
-          if (result instanceof Response) throw result
-          return matchHttpResponse<A>()({
-            HttpResponseSuccess: ({ data }) => ({ ok: true as const, data }),
-            HttpResponseFailure: ({ cause }) => {
-              throw jsonResponse({ ok: false, errors: [String(cause)] }, 500)
-            },
-            HttpResponseRedirect: ({ to, init = {} }) => redirect(to, init),
-          })(result)
-        },
-      }),
-    )
-  }
+  const withLoaderEffect =
+    <A, B>(self: Effect.Effect<HttpResponse<A> | Response, B, R | LoaderArgsContext>) =>
+    (args: LoaderFunctionArgs) => {
+      const runnable = pipe(
+        self,
+        Effect.provide(Layer.succeed(LoaderArgsContext)(args)),
+        Effect.tapCause((cause) => Effect.logError("Loader effect failed", Cause.squash(cause))),
+      )
+      return runtime.runPromiseExit(runnable).then(
+        Exit.match({
+          onFailure: (cause) => {
+            const error = failure(cause)
+            if (error instanceof Response || error instanceof Error) {
+              throw error
+            }
+            throw jsonResponse({ ok: false, errors: ["Internal server error"] }, 500)
+          },
+          onSuccess: (result) => {
+            if (result instanceof Response) throw result
+            return matchHttpResponse<A>()({
+              HttpResponseSuccess: ({ data }) => ({ ok: true as const, data }),
+              HttpResponseFailure: ({ cause }) => {
+                throw jsonResponse({ ok: false, errors: [String(cause)] }, 500)
+              },
+              HttpResponseRedirect: ({ to, init = {} }) => redirect(to, init),
+            })(result)
+          },
+        }),
+      )
+    }
 
-  const withActionEffect = <A, B>(
-    self: Effect.Effect<HttpResponse<A> | Response, B, R | ActionArgsContext>,
-  ) =>
-  (args: ActionFunctionArgs) => {
-    const runnable = pipe(
-      self,
-      Effect.provide(Layer.succeed(ActionArgsContext)(args)),
-      Effect.tapCause((cause) => Effect.logError("Action effect failed", Cause.squash(cause))),
-    )
-    return runtime.runPromiseExit(runnable).then(
-      Exit.match({
-        onFailure: (cause) => {
-          const error = failure(cause)
-          if (error instanceof Response || error instanceof Error) {
-            throw error
-          }
-          return jsonResponse(
-            { ok: false, errors: ["Internal server error"] },
-            400,
-          )
-        },
-        onSuccess: (result) => {
-          if (result instanceof Response) throw result
-          return matchHttpResponse<A>()({
-            HttpResponseSuccess: ({ data }) => ({
-              ok: true as const,
-              response: data,
-            }),
-            HttpResponseFailure: ({ cause }) => jsonResponse({ ok: false, errors: [String(cause)] }, 400),
-            HttpResponseRedirect: ({ to, init = {} }) => redirect(to, init),
-          })(result)
-        },
-      }),
-    )
-  }
+  const withActionEffect =
+    <A, B>(self: Effect.Effect<HttpResponse<A> | Response, B, R | ActionArgsContext>) =>
+    (args: ActionFunctionArgs) => {
+      const runnable = pipe(
+        self,
+        Effect.provide(Layer.succeed(ActionArgsContext)(args)),
+        Effect.tapCause((cause) => Effect.logError("Action effect failed", Cause.squash(cause))),
+      )
+      return runtime.runPromiseExit(runnable).then(
+        Exit.match({
+          onFailure: (cause) => {
+            const error = failure(cause)
+            if (error instanceof Response || error instanceof Error) {
+              throw error
+            }
+            return jsonResponse({ ok: false, errors: ["Internal server error"] }, 400)
+          },
+          onSuccess: (result) => {
+            if (result instanceof Response) throw result
+            return matchHttpResponse<A>()({
+              HttpResponseSuccess: ({ data }) => ({
+                ok: true as const,
+                response: data,
+              }),
+              HttpResponseFailure: ({ cause }) => jsonResponse({ ok: false, errors: [String(cause)] }, 400),
+              HttpResponseRedirect: ({ to, init = {} }) => redirect(to, init),
+            })(result)
+          },
+        }),
+      )
+    }
 
   return { withLoaderEffect, withActionEffect }
 }
diff --git a/packages/react/router/tests/runtime.test.ts b/packages/react/router/tests/runtime.test.ts
index b8c635c3..b1f0ca33 100644
--- a/packages/react/router/tests/runtime.test.ts
+++ b/packages/react/router/tests/runtime.test.ts
@@ -33,12 +33,8 @@ const runtimeWithLogs = () => {
 describe("React Router runtime migration contracts", () => {
   it("keeps normal loader and action payloads serializable", async () => {
     const runtime = make(Layer.empty)
-    const loader = runtime.withLoaderEffect(
-      Effect.succeed(new HttpResponseSuccess({ data: { id: "loader" } })),
-    )
-    const action = runtime.withActionEffect(
-      Effect.succeed(new HttpResponseSuccess({ data: { id: "action" } })),
-    )
+    const loader = runtime.withLoaderEffect(Effect.succeed(new HttpResponseSuccess({ data: { id: "loader" } })))
+    const action = runtime.withActionEffect(Effect.succeed(new HttpResponseSuccess({ data: { id: "action" } })))
 
     await expect(loader(loaderArgs())).resolves.toEqual({
       ok: true,
@@ -57,22 +53,13 @@ describe("React Router runtime migration contracts", () => {
       status: 307,
     }
     const loader = runtime.withLoaderEffect(
-      Effect.succeed(
-        new HttpResponseRedirect({ to: "/login", init: redirectInit }),
-      ),
+      Effect.succeed(new HttpResponseRedirect({ to: "/login", init: redirectInit })),
     )
     const action = runtime.withActionEffect(
-      Effect.succeed(
-        new HttpResponseRedirect({ to: "/login", init: redirectInit }),
-      ),
+      Effect.succeed(new HttpResponseRedirect({ to: "/login", init: redirectInit })),
     )
 
-    for (
-      const result of [
-        await loader(loaderArgs()),
-        await action(actionArgs()),
-      ]
-    ) {
+    for (const result of [await loader(loaderArgs()), await action(actionArgs())]) {
       expect(result).toBeInstanceOf(Response)
       if (!(result instanceof Response)) {
         throw new Error("expected redirect Response")
@@ -85,9 +72,7 @@ describe("React Router runtime migration contracts", () => {
 
   it("keeps loader failure status and JSON body explicit", async () => {
     const runtime = make(Layer.empty)
-    const loader = runtime.withLoaderEffect(
-      Effect.succeed(new HttpResponseFailure({ cause: "unavailable" })),
-    )
+    const loader = runtime.withLoaderEffect(Effect.succeed(new HttpResponseFailure({ cause: "unavailable" })))
 
     await expect(loader(loaderArgs())).rejects.toMatchObject({ status: 500 })
     await expect(loader(loaderArgs())).rejects.toMatchObject({
@@ -107,9 +92,7 @@ describe("React Router runtime migration contracts", () => {
 
   it("uses a decodable Response for action failures that need an HTTP status", async () => {
     const runtime = make(Layer.empty)
-    const action = runtime.withActionEffect(
-      Effect.succeed(new HttpResponseFailure({ cause: "invalid" })),
-    )
+    const action = runtime.withActionEffect(Effect.succeed(new HttpResponseFailure({ cause: "invalid" })))
 
     const result = await action(actionArgs())
     expect(result).toBeInstanceOf(Response)
@@ -134,15 +117,9 @@ describe("React Router runtime migration contracts", () => {
       headers: { "Set-Cookie": "session=expired" },
     })
 
-    await expect(
-      runtime.withActionEffect(Effect.succeed(successful))(actionArgs()),
-    ).rejects.toBe(successful)
-    await expect(
-      runtime.withLoaderEffect(Effect.fail(failed))(loaderArgs()),
-    ).rejects.toBe(failed)
-    await expect(
-      runtime.withActionEffect(Effect.fail(failed))(actionArgs()),
-    ).rejects.toBe(failed)
+    await expect(runtime.withActionEffect(Effect.succeed(successful))(actionArgs())).rejects.toBe(successful)
+    await expect(runtime.withLoaderEffect(Effect.fail(failed))(loaderArgs())).rejects.toBe(failed)
+    await expect(runtime.withActionEffect(Effect.fail(failed))(actionArgs())).rejects.toBe(failed)
     expect(successful.headers.get("set-cookie")).toBe("created=yes")
     expect(failed.headers.get("set-cookie")).toBe("session=expired")
   })
@@ -152,23 +129,14 @@ describe("React Router runtime migration contracts", () => {
     const loaderError = new Error("loader failed")
     const actionError = new Error("action failed")
 
-    await expect(
-      runtime.withLoaderEffect(Effect.fail(loaderError))(loaderArgs()),
-    ).rejects.toBe(loaderError)
-    await expect(
-      runtime.withActionEffect(Effect.fail(actionError))(actionArgs()),
-    ).rejects.toBe(actionError)
+    await expect(runtime.withLoaderEffect(Effect.fail(loaderError))(loaderArgs())).rejects.toBe(loaderError)
+    await expect(runtime.withActionEffect(Effect.fail(actionError))(actionArgs())).rejects.toBe(actionError)
   })
 
   it("reports loader defects and interruptions before the generic 500 contract", async () => {
     const { logs, runtime } = runtimeWithLogs()
 
-    for (
-      const effect of [
-        Effect.die(new Error("loader defect")),
-        Effect.interrupt,
-      ]
-    ) {
+    for (const effect of [Effect.die(new Error("loader defect")), Effect.interrupt]) {
       await runtime
         .withLoaderEffect(effect)(loaderArgs())
         .then(
@@ -192,12 +160,7 @@ describe("React Router runtime migration contracts", () => {
   it("reports action defects and interruptions before the generic 400 contract", async () => {
     const { logs, runtime } = runtimeWithLogs()
 
-    for (
-      const effect of [
-        Effect.die(new Error("action defect")),
-        Effect.interrupt,
-      ]
-    ) {
+    for (const effect of [Effect.die(new Error("action defect")), Effect.interrupt]) {
       const result = await runtime.withActionEffect(effect)(actionArgs())
       expect(result).toBeInstanceOf(Response)
       if (!(result instanceof Response)) {