effect-start 0.28.0 → 0.29.0

package/src/RouteSse.ts

@@ -5,46 +5,37 @@ import * as Stream from "effect/Stream"
 import type * as Utils from "effect/Utils"
 import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
-import * as StreamExtra from "./StreamExtra.ts"
-import type * as Values from "./Values.ts"
+import * as StreamExtra from "./_StreamExtra.ts"
+import type * as Values from "./_Values.ts"
 
 const HEARTBEAT_INTERVAL = Duration.seconds(5)
 const HEARTBEAT = ": <3\n\n"
 
-export interface SseEvent {
-  data?: string | undefined
-  type?: string
-  retry?: number
+interface SseEvent {
+  readonly [key: string]: unknown
+  readonly _tag?: string
+  readonly data?: string | undefined
+  readonly type?: string
+  readonly retry?: number
 }
 
-export type SseTaggedEvent = {
-  readonly _tag: string
-}
-
-export type SseEventInput = SseEvent | SseTaggedEvent
-
-function isTaggedEvent(event: SseEventInput): event is SseTaggedEvent {
-  return Object.hasOwn(event, "_tag") && typeof event["_tag"] === "string"
-}
-
-function formatSseEvent(event: SseEventInput): string {
-  if (isTaggedEvent(event)) {
+function formatSseEvent(event: SseEvent): string {
+  if (event._tag) {
     const json = JSON.stringify(event)
     return `event: ${event._tag}\ndata: ${json}\n\n`
   }
 
-  const e = event as SseEvent
   let result = ""
-  if (e.type) {
-    result += `event: ${e.type}\n`
+  if (event.type) {
+    result += `event: ${event.type}\n`
   }
-  if (typeof e.data === "string") {
-    for (const line of e.data.split("\n")) {
+  if (typeof event.data === "string") {
+    for (const line of event.data.split("\n")) {
       result += `data: ${line}\n`
     }
   }
-  if (e.retry !== undefined) {
-    result += `retry: ${e.retry}\n`
+  if (event.retry !== undefined) {
+    result += `retry: ${event.retry}\n`
   }
   if (result === "") {
     return ""
@@ -52,18 +43,18 @@ function formatSseEvent(event: SseEventInput): string {
   return result + "\n"
 }
 
-export type SseHandlerInput<B, E, R> =
-  | Stream.Stream<SseEventInput, E, R>
-  | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+type SseHandlerInput<B, E, R> =
+  | Stream.Stream<SseEvent, E, R>
+  | Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
   | ((
       context: Values.Simplify<B>,
       next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<string>,
     ) =>
-      | Stream.Stream<SseEventInput, E, R>
-      | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+      | Stream.Stream<SseEvent, E, R>
+      | Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
       | Generator<
           Utils.YieldWrap<Effect.Effect<unknown, E, R>>,
-          Stream.Stream<SseEventInput, E, R>,
+          Stream.Stream<SseEvent, E, R>,
           unknown
         >)
 
@@ -81,24 +72,24 @@ export function sse<
       E,
       R
     > = (ctx, _next) => {
-      const getStream = (): Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> => {
+      const getStream = (): Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R> => {
         if (typeof handler === "function") {
           const result = (handler as Function)(ctx, _next)
           if (StreamExtra.isStream(result)) {
-            return Effect.succeed(result as Stream.Stream<SseEventInput, E, R>)
+            return Effect.succeed(result as Stream.Stream<SseEvent, E, R>)
           }
           if (Effect.isEffect(result)) {
-            return result as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+            return result as Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
           }
           return Effect.gen(function* () {
             return yield* result
-          }) as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+          }) as Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
         }
         if (StreamExtra.isStream(handler)) {
-          return Effect.succeed(handler as Stream.Stream<SseEventInput, E, R>)
+          return Effect.succeed(handler as Stream.Stream<SseEvent, E, R>)
         }
         if (Effect.isEffect(handler)) {
-          return handler as Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R>
+          return handler as Effect.Effect<Stream.Stream<SseEvent, E, R>, E, R>
         }
         return Effect.succeed(Stream.empty)
       }

package/src/RouteTree.ts

@@ -1,9 +1,9 @@
 import * as Predicate from "effect/Predicate"
-import * as PathPattern from "./PathPattern.ts"
+import * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import type * as RouteMount from "./RouteMount.ts"
 
-const TypeId: unique symbol = Symbol.for("effect-start/RouteTree")
+const TypeId = "~effect-start/RouteTree" as const
 const RouteTreeRoutes: unique symbol = Symbol()
 
 type MethodRoute = Route.Route.With<{ method: string }>

package/src/RouteTrie.ts

@@ -1,4 +1,4 @@
-import * as PathPattern from "./PathPattern.ts"
+import * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 
 export interface Node {

package/src/Socket.ts

@@ -1,50 +1,40 @@
 /*
  * Adapted from @effect/platform
  */
+import * as Data from "effect/Data"
 import * as Predicate from "effect/Predicate"
-import * as PlatformError from "./PlatformError.ts"
 
-export const SocketErrorTypeId: unique symbol = Symbol.for("@effect/platform/Socket/SocketError")
-
-export type SocketErrorTypeId = typeof SocketErrorTypeId
+const SocketErrorTypeId: unique symbol = Symbol.for("@effect/platform/Socket/SocketError")
 
 export const isSocketError = (u: unknown): u is SocketError =>
   Predicate.hasProperty(u, SocketErrorTypeId)
 
-export type SocketError = SocketGenericError | SocketCloseError
-
-export class SocketGenericError extends PlatformError.TypeIdError(
-  SocketErrorTypeId,
-  "SocketError",
-)<{
-  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout"
-  readonly cause: unknown
-}> {
-  get message() {
-    return `An error occurred during ${this.reason}`
-  }
-}
-
-export class SocketCloseError extends PlatformError.TypeIdError(SocketErrorTypeId, "SocketError")<{
-  readonly reason: "Close"
-  readonly code: number
+export class SocketError extends Data.TaggedError("SocketError")<{
+  readonly reason: "Write" | "Read" | "Open" | "OpenTimeout" | "Close"
+  readonly cause?: unknown
+  readonly code?: number | undefined
   readonly closeReason?: string | undefined
 }> {
-  static is(u: unknown): u is SocketCloseError {
+  readonly [SocketErrorTypeId]: typeof SocketErrorTypeId = SocketErrorTypeId
+
+  static isClose(u: unknown): u is SocketError & { reason: "Close" } {
     return isSocketError(u) && u.reason === "Close"
   }
 
   static isClean(isClean: (code: number) => boolean) {
-    return function (u: unknown): u is SocketCloseError {
-      return SocketCloseError.is(u) && isClean(u.code)
+    return function (u: unknown): u is SocketError & { reason: "Close" } {
+      return SocketError.isClose(u) && u.code !== undefined && isClean(u.code)
     }
   }
 
   get message() {
-    if (this.closeReason) {
-      return `${this.reason}: ${this.code}: ${this.closeReason}`
+    if (this.reason === "Close") {
+      if (this.closeReason) {
+        return `${this.reason}: ${this.code}: ${this.closeReason}`
+      }
+      return `${this.reason}: ${this.code}`
     }
-    return `${this.reason}: ${this.code}`
+    return `An error occurred during ${this.reason}`
   }
 }
 

package/src/Start.ts

@@ -9,26 +9,14 @@ import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
-import type * as ChildProcess from "./ChildProcess.ts"
+import type * as ChildProcess from "./_ChildProcess.ts"
 import * as MutableRef from "effect/MutableRef"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
 import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.ts"
 import * as PlatformRuntime from "./PlatformRuntime.ts"
-import * as StartApp from "./StartApp.ts"
-
-export function layer<
-  Layers extends [Layer.Layer<never, any, any>, ...Array<Layer.Layer<never, any, any>>],
->(
-  ...layers: Layers
-): Layer.Layer<
-  { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
-  { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
-> {
-  return Layer.mergeAll(...layers)
-}
+import * as StartApp from "./_StartApp.ts"
 
 /**
  * Bundles layers together, wiring their dependencies automatically.
@@ -96,18 +84,6 @@ type OrderedPack<
     ]
   : []
 
-/**
- * Like `pack`, but accepts layers in any order.
- *
- * ```ts
- * // These all produce the same result:
- * Start.build(LoggerLive, DatabaseLive, UserRepoLive)
- * Start.build(UserRepoLive, DatabaseLive, LoggerLive)
- * ```
- *
- * @since 1.0.0
- * @category constructors
- */
 type BuildSuccess<Layers extends readonly Layer.Layer.Any[]> = {
   [K in keyof Layers]: Layer.Layer.Success<Layers[K]>
 }[number]
@@ -121,6 +97,18 @@ type BuildContext<Layers extends readonly Layer.Layer.Any[]> = Exclude<
   { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
 >
 
+/**
+ * Like `pack`, but accepts layers in any order.
+ *
+ * ```ts
+ * // These all produce the same result:
+ * Start.build(LoggerLive, DatabaseLive, UserRepoLive)
+ * Start.build(UserRepoLive, DatabaseLive, LoggerLive)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
 export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
   ...layers: Layers
 ): Layer.Layer<BuildSuccess<Layers>, BuildError<Layers>, BuildContext<Layers>> {
@@ -170,26 +158,19 @@ export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<L
   )
 }
 
-export type PlatformServices =
-  | BunServer.BunServer
-  | FileSystem.FileSystem
-  | ChildProcess.ChildProcessSpawner
-  | StartApp.StartApp
-
-export const Live: Layer.Layer<
-  Exclude<PlatformServices, BunServer.BunServer>,
-  never,
-  never
-> = Layer.mergeAll(
-  NodeFileSystem.layer,
-  BunChildProcessSpawner.layer,
-  Layer.effect(
-    StartApp.StartApp,
-    Deferred.make<BunServer.BunServer>().pipe(Effect.map((server) => ({ server }))),
-  ),
-)
-
-export function serve<ROut, E, RIn extends PlatformServices>(
+export function layerDev() {
+  return Layer.mergeAll(NodeFileSystem.layer, BunChildProcessSpawner.layer)
+}
+
+export function serve<
+  ROut,
+  E,
+  RIn extends
+    | BunServer.BunServer
+    | FileSystem.FileSystem
+    | ChildProcess.ChildProcessSpawner
+    | StartApp.StartApp,
+>(
   load: () => Promise<{
     default: Layer.Layer<ROut, E, RIn>
   }>,
@@ -201,7 +182,18 @@ export function serve<ROut, E, RIn extends PlatformServices>(
     Layer.unwrapEffect,
   )
 
-  const appLayerResolved = Function.pipe(appLayer, Layer.provideMerge(Live))
+  const appLayerResolved = Function.pipe(
+    appLayer,
+    Layer.provideMerge(
+      Layer.mergeAll(
+        layerDev(),
+        Layer.effect(
+          StartApp.StartApp,
+          Deferred.make<BunServer.BunServer>().pipe(Effect.map((server) => ({ server }))),
+        ),
+      ),
+    ),
+  )
 
   const composed = Function.pipe(
     BunServer.layerStart(),

package/src/System.ts

@@ -1,75 +1,51 @@
+/*
+ * Adapted from @effect/platform
+ */
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
-import * as NNet from "node:net"
+import * as ChildProcess from "./_ChildProcess.ts"
 
-import * as ChildProcess from "./ChildProcess.ts"
-import * as PlatformError from "./PlatformError.ts"
+export type Spawner = ChildProcess.ChildProcessSpawner
 
-export const cwd: Effect.Effect<string> = Effect.sync(() => process.cwd())
+export type SystemErrorReason =
+  | "AlreadyExists"
+  | "BadArgument"
+  | "BadResource"
+  | "Busy"
+  | "InvalidData"
+  | "NotFound"
+  | "PermissionDenied"
+  | "TimedOut"
+  | "UnexpectedEof"
+  | "Unknown"
+  | "WouldBlock"
+  | "WriteZero"
 
-export const randomFreePort: Effect.Effect<number, PlatformError.SystemError> = Effect.async<
-  number,
-  PlatformError.SystemError
->((resume) => {
-  const server = NNet.createServer()
-  server.unref()
-  server.on("error", (err) =>
-    resume(
-      Effect.fail(
-        new PlatformError.SystemError({
-          reason: "Unknown",
-          module: "System",
-          method: "randomFreePort",
-          description: err.message,
-          cause: err,
-        }),
-      ),
-    ),
-  )
-  server.listen(0, "127.0.0.1", () => {
-    const address = server.address()
-    if (!address || typeof address === "string") {
-      server.close(() =>
-        resume(
-          Effect.fail(
-            new PlatformError.SystemError({
-              reason: "Unknown",
-              module: "System",
-              method: "randomFreePort",
-              description: "Failed to allocate a free port",
-            }),
-          ),
-        ),
-      )
-      return
-    }
-    const port = address.port
-    server.close((err) => {
-      if (err) {
-        resume(
-          Effect.fail(
-            new PlatformError.SystemError({
-              reason: "Unknown",
-              module: "System",
-              method: "randomFreePort",
-              description: err.message,
-              cause: err,
-            }),
-          ),
-        )
-        return
-      }
-      resume(Effect.succeed(port))
-    })
-  })
-})
+export class SystemError extends Data.TaggedError("SystemError")<{
+  reason: SystemErrorReason
+  module: string
+  method: string
+  description?: string | undefined
+  syscall?: string | undefined
+  pathOrDescriptor?: string | number | undefined
+  cause?: unknown
+}> {
+  get message(): string {
+    return `${this.reason}: ${this.module}.${this.method}${
+      this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
+    }${this.description ? `: ${this.description}` : ""}`
+  }
+}
+
+export const cwd: Effect.Effect<string> = Effect.sync(() => process.cwd())
 
-export const which = (name: string): Effect.Effect<string, PlatformError.SystemError> =>
+export const which = (name: string): Effect.Effect<string, SystemError> =>
   Effect.flatMap(
     Effect.try({
       try: () => Bun.which(name),
       catch: (err) =>
-        new PlatformError.SystemError({
+        new SystemError({
           reason: "Unknown",
           module: "System",
           method: "which",
@@ -80,7 +56,7 @@ export const which = (name: string): Effect.Effect<string, PlatformError.SystemE
     (path) =>
       path === null
         ? Effect.fail(
-            new PlatformError.SystemError({
+            new SystemError({
               reason: "NotFound",
               module: "System",
               method: "which",
@@ -95,6 +71,6 @@ export const spawn = (
   options?: ChildProcess.Command.Options,
 ): Effect.Effect<
   ChildProcess.ChildProcessHandle,
-  PlatformError.PlatformError,
+  SystemError,
   ChildProcess.ChildProcessSpawner | Scope.Scope
 > => ChildProcess.spawn(ChildProcess.make(cmd, options))

package/src/{ChildProcess.ts → _ChildProcess.ts}

@@ -13,16 +13,14 @@ import type * as Sink from "effect/Sink"
 import type * as Stream from "effect/Stream"
 import * as Utils from "effect/Utils"
 
-import type * as PlatformError from "./PlatformError.ts"
+import type * as System from "./System.ts"
 
-const TypeId: unique symbol = Symbol.for("effect-start/ChildProcess/Command")
-
-type TypeId = typeof TypeId
+const TypeId = "~effect-start/ChildProcess/Command" as const
 
 type Stdio = "pipe" | "inherit" | "ignore"
 
 export interface Command extends Pipeable.Pipeable {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly cmd: readonly [string, ...Array<string>]
   readonly cwd?: string
   readonly env?: Record<string, string>
@@ -31,11 +29,7 @@ export interface Command extends Pipeable.Pipeable {
   readonly stderr?: Stdio
   readonly detached?: boolean
   [Symbol.iterator](): Effect.EffectGenerator<
-    Effect.Effect<
-      ChildProcessHandle,
-      PlatformError.PlatformError,
-      ChildProcessSpawner | Scope.Scope
-    >
+    Effect.Effect<ChildProcessHandle, System.SystemError, ChildProcessSpawner | Scope.Scope>
   >
 }
 
@@ -116,12 +110,12 @@ export interface KillOptions {
 
 export interface ChildProcessHandle {
   readonly pid: number
-  readonly exitCode: Effect.Effect<number, PlatformError.PlatformError>
-  readonly isRunning: Effect.Effect<boolean, PlatformError.PlatformError>
-  readonly kill: (options?: KillOptions) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly stdin: Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
-  readonly stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError>
-  readonly stderr: Stream.Stream<Uint8Array, PlatformError.PlatformError>
+  readonly exitCode: Effect.Effect<number, System.SystemError>
+  readonly isRunning: Effect.Effect<boolean, System.SystemError>
+  readonly kill: (options?: KillOptions) => Effect.Effect<void, System.SystemError>
+  readonly stdin: Sink.Sink<void, Uint8Array, never, System.SystemError>
+  readonly stdout: Stream.Stream<Uint8Array, System.SystemError>
+  readonly stderr: Stream.Stream<Uint8Array, System.SystemError>
 }
 
 export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessSpawner")<
@@ -129,14 +123,11 @@ export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessS
   {
     readonly spawn: (
       command: Command,
-    ) => Effect.Effect<ChildProcessHandle, PlatformError.PlatformError, Scope.Scope>
+    ) => Effect.Effect<ChildProcessHandle, System.SystemError, Scope.Scope>
   }
 >() {}
 
 export const spawn = (
   command: Command,
-): Effect.Effect<
-  ChildProcessHandle,
-  PlatformError.PlatformError,
-  ChildProcessSpawner | Scope.Scope
-> => Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command))
+): Effect.Effect<ChildProcessHandle, System.SystemError, ChildProcessSpawner | Scope.Scope> =>
+  Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command))

package/src/{Development.ts → _Development.ts}

@@ -7,7 +7,7 @@ import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as PubSub from "effect/PubSub"
 import * as Stream from "effect/Stream"
-import type * as PlatformError from "./PlatformError.ts"
+import type * as System from "./System.ts"
 
 export type DevelopmentEvent =
   | FileSystem.WatchEvent
@@ -37,19 +37,15 @@ export class Development extends Context.Tag("effect-start/Development")<
 
 const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/
 
-export const filterSourceFiles = (event: FileSystem.WatchEvent): boolean => {
+const filterSourceFiles = (event: FileSystem.WatchEvent): boolean => {
   return SOURCE_FILENAME.test(event.path)
 }
 
-export const filterDirectory = (event: FileSystem.WatchEvent): boolean => {
-  return event.path.endsWith("/")
-}
-
-export const watchSource = (opts?: {
+const watchSource = (opts?: {
   path?: string
   recursive?: boolean
   filter?: (event: FileSystem.WatchEvent) => boolean
-}): Stream.Stream<FileSystem.WatchEvent, PlatformError.PlatformError, FileSystem.FileSystem> => {
+}): Stream.Stream<FileSystem.WatchEvent, System.SystemError, FileSystem.FileSystem> => {
   const baseDir = opts?.path ?? process.cwd()
   const customFilter = opts?.filter
 
@@ -70,7 +66,7 @@ export const watchSource = (opts?: {
   )
 }
 
-export const watch = (opts?: {
+const watch = (opts?: {
   path?: string
   recursive?: boolean
   filter?: (event: FileSystem.WatchEvent) => boolean
@@ -98,7 +94,7 @@ export const watch = (opts?: {
     return { events: devState.pubsub! } satisfies DevelopmentService
   })
 
-export const layerWatch = (opts?: {
+export const layer = (opts?: {
   path?: string
   recursive?: boolean
   filter?: (event: FileSystem.WatchEvent) => boolean
@@ -106,15 +102,14 @@ export const layerWatch = (opts?: {
 
 export const option = Effect.serviceOption(Development)
 
-export const stream = (): Stream.Stream<DevelopmentEvent> =>
-  Stream.unwrap(
-    Function.pipe(
-      option,
-      Effect.map(
-        Option.match({
-          onNone: () => Stream.empty,
-          onSome: (dev) => Stream.fromPubSub(dev.events),
-        }),
-      ),
+export const events: Stream.Stream<DevelopmentEvent> = Stream.unwrap(
+  Function.pipe(
+    option,
+    Effect.map(
+      Option.match({
+        onNone: () => Stream.empty,
+        onSome: (dev) => Stream.fromPubSub(dev.events),
+      }),
     ),
-  )
+  ),
+)

package/src/{Docker.ts → _Docker.ts}

@@ -5,7 +5,7 @@ import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
 import * as Stream from "effect/Stream"
 
-import type * as ChildProcess from "./ChildProcess.ts"
+import type * as ChildProcess from "./_ChildProcess.ts"
 import * as System from "./System.ts"
 
 export class DockerError extends Data.TaggedError("DockerError")<{

package/src/{Http.ts → _Http.ts}

@@ -1,5 +1,3 @@
-import * as Values from "./Values.ts"
-
 export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS"
 
 type Respondable = Response | Promise<Response>
@@ -8,32 +6,6 @@ export type WebHandler = (request: Request) => Respondable
 
 export type WebMiddleware = (request: Request, next: WebHandler) => Respondable
 
-export function fetch(
-  handler: WebHandler,
-  init: Omit<RequestInit, "body"> &
-    ({ url: string } | { path: `/${string}` }) & {
-      body?: RequestInit["body"] | Record<string, unknown>
-    },
-): Promise<Response> {
-  const url = "path" in init ? `http://localhost${init.path}` : init.url
-
-  const isPlain = Values.isPlainObject(init.body)
-
-  const headers = new Headers(init.headers)
-  if (isPlain && !headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json")
-  }
-
-  const body = isPlain ? JSON.stringify(init.body) : init.body
-
-  const request = new Request(url, {
-    ...init,
-    headers,
-    body: body as BodyInit,
-  })
-  return Promise.resolve(handler(request))
-}
-
 export function createAbortableRequest(
   init: Omit<RequestInit, "signal"> & ({ url: string } | { path: `/${string}` }),
 ): { request: Request; abort: () => void } {