effect-start 0.28.0 → 0.30.0

package/src/Fetch.ts

@@ -1,12 +1,12 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Schedule from "effect/Schedule"
+import * as Stream from "effect/Stream"
 import * as Entity from "./Entity.ts"
 
-const TypeId: unique symbol = Symbol.for("effect-start/FetchClient")
-type TypeId = typeof TypeId
+const TypeId = "~effect-start/FetchClient" as const
 
-export type FetchEntity = Entity.Entity<Effect.Effect<Uint8Array, FetchError, never>, FetchError>
+export type FetchEntity = Entity.Entity<Stream.Stream<Uint8Array, FetchError, never>, FetchError>
 
 export class FetchError extends Data.TaggedError("FetchError")<{
   readonly reason: "Network" | "Status"
@@ -28,7 +28,7 @@ const tryFetch: Middleware = (request) =>
       try: () => globalThis.fetch(request),
       catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
     }),
-    (response) => Entity.fromResponse(response, request) as FetchEntity,
+    (response) => Entity.fromResponse<FetchError>(response, request),
   )
 
 const defaultMiddleware: ReadonlyArray<Middleware> = [tryFetch]
@@ -64,7 +64,7 @@ function withTrace<E, R>(
 }
 
 export interface FetchClient<E = never, R = never> {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly middleware: ReadonlyArray<Middleware<any, any>>
   readonly fetch: (
     input: string | URL | Request,
@@ -172,6 +172,20 @@ const ClientProto: any = {
   use,
 }
 
+type WebHandler = (request: Request) => Response | Promise<Response>
+
+export function fromHandler(handler: WebHandler): FetchClient {
+  const transport: Middleware = (request) =>
+    Effect.map(
+      Effect.tryPromise({
+        try: () => Promise.resolve(handler(request)),
+        catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
+      }),
+      (response) => Entity.fromResponse<FetchError>(response, request),
+    )
+  return use(transport)
+}
+
 export function filterStatus(
   predicate: (status: number) => boolean,
   options?: {
@@ -269,3 +283,85 @@ export function retry(options: {
     )
   }) as Middleware
 }
+
+interface SseEvent {
+  data?: string | undefined
+  type?: string
+  retry?: number
+  id?: string
+}
+
+export function sse(_options?: {
+  readonly retry?: Schedule.Schedule<any, any, any>
+}): (entity: FetchEntity) => Stream.Stream<SseEvent, FetchError> {
+  return (entity) => {
+    const contentType = entity.headers["content-type"] ?? ""
+    if (!contentType.includes("text/event-stream")) {
+      return Stream.fail(
+        new FetchError({
+          reason: "Status",
+          cause: new Error(`Expected content-type text/event-stream, got: ${contentType}`),
+          response: entity,
+        }),
+      )
+    }
+
+    const byteStream = entity.body as Stream.Stream<Uint8Array, FetchError, never>
+    const decoder = new TextDecoder()
+    const empty = {
+      partial: "",
+      eventType: undefined as string | undefined,
+      dataLines: [] as Array<string>,
+      retryMs: undefined as number | undefined,
+      lastEventId: undefined as string | undefined,
+    }
+    type Acc = typeof empty
+
+    return byteStream.pipe(
+      Stream.mapAccum(empty, (acc, chunk: Uint8Array): [Acc, Array<string>] => {
+        const text = acc.partial + decoder.decode(chunk, { stream: true })
+        const parts = text.split("\n")
+        const partial = parts.pop()!
+        const lines = parts.map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l))
+        return [{ ...acc, partial }, lines]
+      }),
+      Stream.flatMap(Stream.fromIterable),
+      Stream.mapAccum(empty, (acc, line: string): [Acc, SseEvent | undefined] => {
+        if (line === "") {
+          if (acc.dataLines.length > 0) {
+            const event: SseEvent = { data: acc.dataLines.join("\n") }
+            if (acc.eventType !== undefined) event.type = acc.eventType
+            if (acc.retryMs !== undefined) event.retry = acc.retryMs
+            if (acc.lastEventId !== undefined) event.id = acc.lastEventId
+            return [{ ...empty, lastEventId: acc.lastEventId }, event]
+          }
+          return [{ ...empty, lastEventId: acc.lastEventId }, undefined]
+        }
+
+        if (line.startsWith(":")) return [acc, undefined]
+
+        const colonIdx = line.indexOf(":")
+        const field = colonIdx === -1 ? line : line.slice(0, colonIdx)
+        let value = colonIdx === -1 ? "" : line.slice(colonIdx + 1)
+        if (value.startsWith(" ")) value = value.slice(1)
+
+        switch (field) {
+          case "event":
+            return [{ ...acc, eventType: value }, undefined]
+          case "data":
+            return [{ ...acc, dataLines: [...acc.dataLines, value] }, undefined]
+          case "retry": {
+            const n = parseInt(value, 10)
+            if (!isNaN(n)) return [{ ...acc, retryMs: n }, undefined]
+            return [acc, undefined]
+          }
+          case "id":
+            return [{ ...acc, lastEventId: value }, undefined]
+          default:
+            return [acc, undefined]
+        }
+      }),
+      Stream.filter((event): event is SseEvent => event !== undefined),
+    )
+  }
+}

package/src/FileRouter.ts

@@ -8,11 +8,10 @@ import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
 import * as Development from "./Development.ts"
-import * as FilePathPattern from "./FilePathPattern.ts"
 import * as FileRouterCodegen from "./FileRouterCodegen.ts"
 import * as NodeUtils from "./node/NodeUtils.ts"
-import type * as PathPattern from "./PathPattern.ts"
-import type * as PlatformError from "./PlatformError.ts"
+import * as PathPattern from "./_PathPattern.ts"
+import type * as System from "./System.ts"
 import * as Route from "./Route.ts"
 import * as RouteTree from "./RouteTree.ts"
 
@@ -32,15 +31,12 @@ export type FileRoutes = {
   [path: PathPattern.PathPattern]: [LazyRouteModule, ...LazyRouteModule[]]
 }
 
-export type Segment = FilePathPattern.Segment
-
 export type FileRoute = {
   handle: "route" | "layer"
   // eg. `/about/route.tsx`, `/users/[userId]/route.tsx`, `/(admin)/users/route.tsx`
   modulePath: `/${string}`
-  // eg. `/about`, `/users/[userId]`, `/users` (groups stripped)
-  routePath: `/${string}`
-  segments: Array<Segment>
+  // eg. `/about`, `/users/:userId`, `/users` (groups stripped)
+  routePath: PathPattern.PathPattern
 }
 
 /**
@@ -52,40 +48,26 @@ export type FileRoute = {
  */
 export type OrderedFileRoutes = Array<FileRoute>
 
-const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/
+const ROUTE_PATH_REGEX = /^(.*\/)?(route|layer)\.(jsx?|tsx?)$/
 
 export function parseRoute(path: string): FileRoute | null {
-  const segs = FilePathPattern.segments(path)
-
-  const lastSeg = segs.at(-1)
-  const handleMatch =
-    lastSeg?._tag === "LiteralSegment" && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/)
-  const handle = handleMatch ? (handleMatch[1] as "route" | "layer") : null
-
-  if (!handle) {
-    return null
-  }
-
-  const pathSegments = segs.slice(0, -1)
-
-  const validated = FilePathPattern.validate(FilePathPattern.format(pathSegments))
-  if (Either.isLeft(validated)) {
+  const normalizedPath = path.replace(/^\/+/, "")
+  const matched = normalizedPath.match(ROUTE_PATH_REGEX)
+  if (!matched) {
     return null
   }
 
-  const restIndex = pathSegments.findIndex((seg) => seg._tag === "RestSegment")
-  if (restIndex !== -1 && restIndex !== pathSegments.length - 1) {
+  const routeDir = matched[1]?.replace(/\/$/, "") ?? ""
+  const handle = matched[2] as "route" | "layer"
+  const routePathResult = PathPattern.fromFilePath(routeDir)
+  if (Either.isLeft(routePathResult)) {
     return null
   }
 
-  const routePathSegments = pathSegments.filter((seg) => seg._tag !== "GroupSegment")
-  const routePath = FilePathPattern.format(routePathSegments)
-
   return {
     handle,
-    modulePath: `/${path}`,
-    routePath,
-    segments: pathSegments,
+    modulePath: `/${normalizedPath}`,
+    routePath: routePathResult.right,
   }
 }
 
@@ -123,7 +105,7 @@ export function layer(
     treePath = NUrl.fileURLToPath(treePath)
   }
   if (NPath.extname(treePath) === "") {
-    treePath = NPath.join(treePath, "server.gen.ts")
+    treePath = NPath.join(treePath, ".server.ts")
   }
 
   const routesPath = NPath.dirname(treePath)
@@ -142,7 +124,7 @@ export function layer(
 
       // Watch for changes (only when Development service is available)
       yield* Function.pipe(
-        Development.stream(),
+        Development.events,
         Stream.filter((e) => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)),
         Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)),
         Effect.fork,
@@ -158,15 +140,30 @@ export function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.
     const mounts: RouteTree.InputRouteMap = {}
 
     for (const [path, loaders] of Object.entries(fileRoutes)) {
-      const modules = yield* Effect.forEach(loaders, (loader) => Effect.promise(() => loader()))
-
       const allRoutes: RouteTree.RouteTuple = [] as unknown as RouteTree.RouteTuple
 
-      for (const m of modules) {
-        if (Route.isRouteSet(m.default)) {
-          for (const route of m.default) {
+      for (const loader of loaders) {
+        const result = yield* Effect.either(
+          Effect.tryPromise({
+            try: () => loader(),
+            catch: (cause) => new FileRouterError({ reason: "Import", cause, path }),
+          }),
+        )
+
+        if (Either.isLeft(result)) {
+          const error = result.left
+          for (const route of Route.use(
+            Route.render((): Effect.Effect<string, FileRouterError> => Effect.fail(error)),
+          )) {
             ;(allRoutes as Array<any>).push(route)
           }
+        } else {
+          const m = result.right
+          if (Route.isRouteSet(m.default)) {
+            for (const route of m.default) {
+              ;(allRoutes as Array<any>).push(route)
+            }
+          }
         }
       }
 
@@ -179,11 +176,7 @@ export function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.
 
 export function walkRoutesDirectory(
   dir: string,
-): Effect.Effect<
-  OrderedFileRoutes,
-  PlatformError.PlatformError | FileRouterError,
-  FileSystem.FileSystem
-> {
+): Effect.Effect<OrderedFileRoutes, System.SystemError | FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem
     const files = yield* fs.readDirectory(dir, { recursive: true })
@@ -209,10 +202,14 @@ export function getFileRoutes(
       })
       .filter((route): route is FileRoute => route !== null)
       .toSorted((a, b) => {
-        const aDepth = a.segments.length
-        const bDepth = b.segments.length
-        const aHasRest = a.segments.some((seg) => seg._tag === "RestSegment")
-        const bHasRest = b.segments.some((seg) => seg._tag === "RestSegment")
+        const aDepth = a.modulePath.split("/").filter(Boolean).length - 1
+        const bDepth = b.modulePath.split("/").filter(Boolean).length - 1
+        const aHasRest = a.routePath
+          .split("/")
+          .some((seg) => seg.startsWith(":") && seg.endsWith("*"))
+        const bHasRest = b.routePath
+          .split("/")
+          .some((seg) => seg.startsWith(":") && seg.endsWith("*"))
 
         return (
           // rest is a dominant factor (routes with rest come last)

package/src/FileRouterCodegen.ts

@@ -1,11 +1,10 @@
 import * as FileSystem from "./FileSystem.ts"
 import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
 import * as Schema from "effect/Schema"
 import * as NPath from "node:path"
-import * as FilePathPattern from "./FilePathPattern.ts"
 import * as FileRouter from "./FileRouter.ts"
-import * as SchemaExtra from "./SchemaExtra.ts"
+import * as PathPattern from "./_PathPattern.ts"
+import * as SchemaExtra from "./_SchemaExtra.ts"
 
 export function validateRouteModule(module: unknown): module is FileRouter.RouteModule {
   if (typeof module !== "object" || module === null) {
@@ -20,17 +19,11 @@ export function validateRouteModule(module: unknown): module is FileRouter.Route
   return true
 }
 
-export function generatePathParamsSchema(
-  segments: ReadonlyArray<FilePathPattern.Segment>,
-): Schema.Struct<any> | null {
+export function generatePathParamsSchema(path: PathPattern.PathPattern): Schema.Struct<any> | null {
   const fields: Record<PropertyKey, Schema.Schema.Any | Schema.PropertySignature.All> = {}
 
-  for (const segment of segments) {
-    if (segment._tag === "ParamSegment") {
-      fields[segment.name] = Schema.String
-    } else if (segment._tag === "RestSegment") {
-      fields[segment.name] = Schema.optional(Schema.String)
-    }
+  for (const param of PathPattern.params(path)) {
+    fields[param.name] = param.optional ? Schema.optional(Schema.String) : Schema.String
   }
 
   if (Object.keys(fields).length === 0) {
@@ -54,7 +47,7 @@ export function validateRouteModules(
 
     for (const handle of routeHandles) {
       const routeModulePath = NPath.resolve(path, handle.modulePath)
-      const expectedSchema = generatePathParamsSchema(handle.segments)
+      const expectedSchema = generatePathParamsSchema(handle.routePath)
 
       const fileExists = yield* fs
         .exists(routeModulePath)
@@ -144,20 +137,13 @@ export function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string |
       currentPath = parentPath || "/"
     }
 
-    // Convert file-style path to colon-style PathPattern
-    const pathPatternResult = FilePathPattern.toPathPattern(path)
-    if (Either.isLeft(pathPatternResult)) {
-      continue
-    }
-    const pathPattern = pathPatternResult.right
-
     // Order: route first, then layers from innermost to outermost
     const loaders: Array<string> = [
       `() => import(".${route.modulePath}")`,
       ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
     ]
 
-    entries.push({ path: pathPattern, loaders })
+    entries.push({ path, loaders })
   }
 
   // No routes found - don't create file
@@ -188,7 +174,7 @@ ${routeEntries},
  */
 export function update(
   routesPath: string,
-  treePath = "server.gen.ts",
+  treePath = ".server.ts",
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function* () {
     treePath = NPath.resolve(routesPath, treePath)
@@ -259,7 +245,7 @@ export function update(
 
 export function dump(
   routesPath: string,
-  treePath = "server.gen.ts",
+  treePath = ".server.ts",
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function* () {
     treePath = NPath.resolve(routesPath, treePath)

package/src/FileSystem.ts

@@ -12,108 +12,93 @@ import * as Option from "effect/Option"
 import * as Sink from "effect/Sink"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.ts"
+import * as System from "./System.ts"
 
 export interface FileSystem {
   readonly access: (
     path: string,
     options?: AccessFileOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly copy: (
     fromPath: string,
     toPath: string,
     options?: CopyOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly copyFile: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
+  readonly chmod: (path: string, mode: number) => Effect.Effect<void, System.SystemError>
   readonly chown: (
     path: string,
     uid: number,
     gid: number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly exists: (path: string) => Effect.Effect<boolean, PlatformError.PlatformError>
-  readonly link: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly exists: (path: string) => Effect.Effect<boolean, System.SystemError>
+  readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
   readonly makeDirectory: (
     path: string,
     options?: MakeDirectoryOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly makeTempDirectory: (
     options?: MakeTempDirectoryOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
   readonly makeTempDirectoryScoped: (
     options?: MakeTempDirectoryOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<string, System.SystemError, Scope.Scope>
   readonly makeTempFile: (
     options?: MakeTempFileOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
   readonly makeTempFileScoped: (
     options?: MakeTempFileOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<string, System.SystemError, Scope.Scope>
   readonly open: (
     path: string,
     options?: OpenFileOptions,
-  ) => Effect.Effect<File, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<File, System.SystemError, Scope.Scope>
   readonly readDirectory: (
     path: string,
     options?: ReadDirectoryOptions,
-  ) => Effect.Effect<Array<string>, PlatformError.PlatformError>
-  readonly readFile: (path: string) => Effect.Effect<Uint8Array, PlatformError.PlatformError>
+  ) => Effect.Effect<Array<string>, System.SystemError>
+  readonly readFile: (path: string) => Effect.Effect<Uint8Array, System.SystemError>
   readonly readFileString: (
     path: string,
     encoding?: string,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly readLink: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly realPath: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
+  readonly readLink: (path: string) => Effect.Effect<string, System.SystemError>
+  readonly realPath: (path: string) => Effect.Effect<string, System.SystemError>
   readonly remove: (
     path: string,
     options?: RemoveOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly rename: (
-    oldPath: string,
-    newPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, System.SystemError>
   readonly sink: (
     path: string,
     options?: SinkOptions,
-  ) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
-  readonly stat: (path: string) => Effect.Effect<File.Info, PlatformError.PlatformError>
+  ) => Sink.Sink<void, Uint8Array, never, System.SystemError>
+  readonly stat: (path: string) => Effect.Effect<File.Info, System.SystemError>
   readonly stream: (
     path: string,
     options?: StreamOptions,
-  ) => Stream.Stream<Uint8Array, PlatformError.PlatformError>
-  readonly symlink: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly truncate: (
-    path: string,
-    length?: SizeInput,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Stream.Stream<Uint8Array, System.SystemError>
+  readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
+  readonly truncate: (path: string, length?: SizeInput) => Effect.Effect<void, System.SystemError>
   readonly utimes: (
     path: string,
     atime: Date | number,
     mtime: Date | number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly watch: (
     path: string,
     options?: WatchOptions,
-  ) => Stream.Stream<WatchEvent, PlatformError.PlatformError>
+  ) => Stream.Stream<WatchEvent, System.SystemError>
   readonly writeFile: (
     path: string,
     data: Uint8Array,
     options?: WriteFileOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly writeFileString: (
     path: string,
     data: string,
     options?: WriteFileStringOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
 }
 
 export const FileSystem: Context.Tag<FileSystem, FileSystem> = Context.GenericTag<FileSystem>(
@@ -202,16 +187,16 @@ export type FileTypeId = typeof FileTypeId
 export interface File {
   readonly [FileTypeId]: FileTypeId
   readonly fd: File.Descriptor
-  readonly stat: Effect.Effect<File.Info, PlatformError.PlatformError>
+  readonly stat: Effect.Effect<File.Info, System.SystemError>
   readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
-  readonly sync: Effect.Effect<void, PlatformError.PlatformError>
-  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
+  readonly sync: Effect.Effect<void, System.SystemError>
+  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, System.SystemError>
   readonly readAlloc: (
     size: SizeInput,
-  ) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>
-  readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
-  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<Option.Option<Uint8Array>, System.SystemError>
+  readonly truncate: (length?: SizeInput) => Effect.Effect<void, System.SystemError>
+  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, System.SystemError>
+  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, System.SystemError>
 }
 
 export declare namespace File {
@@ -282,7 +267,7 @@ export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/Watch
       path: string,
       stat: File.Info,
       options?: WatchOptions,
-    ) => Option.Option<Stream.Stream<WatchEvent, PlatformError.PlatformError>>
+    ) => Option.Option<Stream.Stream<WatchEvent, System.SystemError>>
   }
 >() {}
 
@@ -303,7 +288,8 @@ export const make = (
       Effect.tryMap(impl.readFile(path), {
         try: (_) => new TextDecoder(encoding).decode(_),
         catch: (cause) =>
-          new PlatformError.BadArgument({
+          new System.SystemError({
+            reason: "BadArgument",
             module: "FileSystem",
             method: "readFileString",
             description: "invalid encoding",
@@ -330,7 +316,8 @@ export const make = (
         Effect.try({
           try: () => new TextEncoder().encode(data),
           catch: (cause) =>
-            new PlatformError.BadArgument({
+            new System.SystemError({
+              reason: "BadArgument",
               module: "FileSystem",
               method: "writeFileString",
               description: "could not encode string",
@@ -348,14 +335,7 @@ const fileStream = (file: File, options: StreamOptions = {}) => {
 
   function loop(
     totalBytesRead: bigint,
-  ): Channel.Channel<
-    Chunk.Chunk<Uint8Array>,
-    unknown,
-    PlatformError.PlatformError,
-    unknown,
-    void,
-    unknown
-  > {
+  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, System.SystemError, unknown, void, unknown> {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
       return Channel.void
     }

package/src/GlobalLayer.ts

@@ -9,7 +9,7 @@ import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 
-import * as ChildProcess from "./ChildProcess.ts"
+import * as ChildProcess from "./_ChildProcess.ts"
 
 interface CacheEntry {
   readonly context: Context.Context<any>
@@ -67,7 +67,9 @@ export const globalLayer =
               )
               yield* Deferred.succeed(deferred, ctx)
               yield* Effect.never
-            }),
+            }).pipe(
+              Effect.catchAllCause((cause) => Deferred.failCause(deferred, cause)),
+            ),
           ),
         ) as Fiber.RuntimeFiber<void>