effect-start 0.19.0 → 0.20.1

package/src/FileRouterCodegen.ts

@@ -1,11 +1,10 @@
-import type { PlatformError } from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
 import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
+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 FileRouterPattern from "./FileRouterPattern.ts"
 import * as SchemaExtra from "./SchemaExtra.ts"
 
 export function validateRouteModule(
@@ -24,7 +23,7 @@ export function validateRouteModule(
 }
 
 export function generatePathParamsSchema(
-  segments: ReadonlyArray<FileRouterPattern.Segment>,
+  segments: ReadonlyArray<FilePathPattern.Segment>,
 ): Schema.Struct<any> | null {
   const fields: Record<
     PropertyKey,
@@ -32,13 +31,10 @@ export function generatePathParamsSchema(
   > = {}
 
   for (const segment of segments) {
-    if (
-      segment._tag === "ParamSegment"
-      || segment._tag === "RestSegment"
-    ) {
-      fields[segment.name] = segment.optional
-        ? Function.pipe(Schema.String, Schema.optional)
-        : Schema.String
+    if (segment._tag === "ParamSegment") {
+      fields[segment.name] = Schema.String
+    } else if (segment._tag === "RestSegment") {
+      fields[segment.name] = Schema.optional(Schema.String)
     }
   }
 
@@ -54,23 +50,33 @@ export function generatePathParamsSchema(
  */
 
 export function validateRouteModules(
-  routesPath: string,
-  handles: FileRouter.OrderedRouteHandles,
-): Effect.Effect<void, PlatformError, FileSystem.FileSystem> {
+  path: string,
+  routes: FileRouter.OrderedFileRoutes,
+): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
-    const routeHandles = handles.filter(h => h.handle === "route")
+    const routeHandles = routes.filter(h => h.handle === "route")
 
     for (const handle of routeHandles) {
-      const routeModulePath = NPath.resolve(routesPath, handle.modulePath)
+      const routeModulePath = NPath.resolve(path, handle.modulePath)
       const expectedSchema = generatePathParamsSchema(handle.segments)
 
-      const fileExists = yield* fs.exists(routeModulePath)
+      const fileExists = yield* fs.exists(routeModulePath).pipe(
+        Effect.catchAll(() => Effect.succeed(false)),
+      )
       if (!fileExists) {
         continue
       }
 
-      const module = yield* Effect.promise(() => import(routeModulePath))
+      const module = yield* Effect.tryPromise({
+        try: () => import(routeModulePath),
+        catch: (cause) =>
+          new FileRouter.FileRouterError({
+            reason: "Import",
+            cause,
+            path: routeModulePath,
+          }),
+      })
 
       if (!validateRouteModule(module)) {
         yield* Effect.logWarning(
@@ -100,50 +106,42 @@ export function validateRouteModules(
 }
 
 export function generateCode(
-  handles: FileRouter.OrderedRouteHandles,
-): string {
-  const routerModuleId = "effect-start"
-
+  fileRoutes: FileRouter.OrderedFileRoutes,
+): string | null {
   // Group routes by path to find layers
   const routesByPath = new Map<string, {
-    route?: FileRouter.RouteHandle
-    layers: FileRouter.RouteHandle[]
+    route?: FileRouter.FileRoute
+    layers: FileRouter.FileRoute[]
   }>()
 
-  for (const handle of handles) {
-    const existing = routesByPath.get(handle.routePath) || { layers: [] }
-    if (handle.handle === "route") {
-      existing.route = handle
-    } else if (handle.handle === "layer") {
-      existing.layers.push(handle)
+  for (const fileRoute of fileRoutes) {
+    const existing = routesByPath.get(fileRoute.routePath) || { layers: [] }
+    if (fileRoute.handle === "route") {
+      existing.route = fileRoute
+    } else if (fileRoute.handle === "layer") {
+      existing.layers.push(fileRoute)
     }
-    routesByPath.set(handle.routePath, existing)
+    routesByPath.set(fileRoute.routePath, existing)
   }
 
-  // Generate route definitions
-  const routes: string[] = []
-
   // Helper to check if layer's path is an ancestor of route's path
   const layerMatchesRoute = (
-    layer: FileRouter.RouteHandle,
-    route: FileRouter.RouteHandle,
+    layer: FileRouter.FileRoute,
+    route: FileRouter.FileRoute,
   ): boolean => {
-    // Get the directory of the layer (strip the filename like layer.tsx)
-    const layerDir = layer.modulePath.replace(/\/?(layer)\.(tsx?|jsx?)$/, "")
-
-    // Layer at root (empty layerDir) applies to all routes
-    if (layerDir === "") return true
-
-    // Route's modulePath must start with the layer's directory
+    const layerDir = layer.modulePath.replace(/\/(layer)\.(tsx?|jsx?)$/, "")
+    if (layerDir === "/") return true
     return route.modulePath.startsWith(layerDir + "/")
   }
 
-  // Find layers for each route by walking up the path hierarchy
+  // Build entries for each route path
+  const entries: Array<{ path: string; loaders: string[] }> = []
+
   for (const [path, { route }] of routesByPath) {
-    if (!route) continue // Skip paths that only have layers
+    if (!route) continue
 
     // Collect all parent layers that match the route's groups
-    const allLayers: FileRouter.RouteHandle[] = []
+    const allLayers: FileRouter.FileRoute[] = []
     let currentPath = path
 
     while (true) {
@@ -157,97 +155,142 @@ export function generateCode(
 
       if (currentPath === "/") break
 
-      // Move to parent path
       const parentPath = currentPath.substring(0, currentPath.lastIndexOf("/"))
       currentPath = parentPath || "/"
     }
 
-    // Generate layers array
-    const layersCode = allLayers.length > 0
-      ? `\n    layers: [\n      ${
-        allLayers.map(layer => `() => import("./${layer.modulePath}")`).join(
-          ",\n      ",
-        )
-      },\n    ],`
-      : ""
+    // Convert file-style path to colon-style PathPattern
+    const pathPatternResult = FilePathPattern.toPathPattern(path)
+    if (Either.isLeft(pathPatternResult)) {
+      continue
+    }
+    const pathPattern = pathPatternResult.right
 
-    const routeCode = `  {
-    path: "${path}",
-    load: () => import("./${route.modulePath}"),${layersCode}
-  },`
+    // Order: route first, then layers from innermost to outermost
+    const loaders: string[] = [
+      `() => import(".${route.modulePath}")`,
+      ...allLayers.reverse().map(layer =>
+        `() => import(".${layer.modulePath}")`
+      ),
+    ]
 
-    routes.push(routeCode)
+    entries.push({ path: pathPattern, loaders })
   }
 
-  const header = `/**
- * Auto-generated by effect-start.
- */`
+  // No routes found - don't create file
+  if (entries.length === 0) {
+    return null
+  }
 
-  const routesArray = routes.length > 0
-    ? `[\n${routes.join("\n")}\n]`
-    : "[]"
+  const routeEntries = entries
+    .map(({ path, loaders }) => {
+      const loadersCode = loaders.join(",\n    ")
+      return `  "${path}": [\n    ${loadersCode},\n  ]`
+    })
+    .join(",\n")
 
-  return `${header}
+  return `/**
+ * Auto-generated by effect-start.
+ */
 
-export const routes = ${routesArray} as const
+export default {
+${routeEntries},
+} satisfies import("effect-start/FileRouter").FileRoutes
 `
 }
 
 /**
- * Updates the manifest file only if the generated content differs from the existing file.
+ * Updates the tree file only if the generated content differs from the existing file.
  * This prevents infinite loops when watching for file changes.
  */
 export function update(
   routesPath: string,
-  manifestPath = "manifest.ts",
-): Effect.Effect<void, PlatformError, FileSystem.FileSystem> {
+  treePath = "server.gen.ts",
+): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function*() {
-    manifestPath = NPath.resolve(routesPath, manifestPath)
+    treePath = NPath.resolve(routesPath, treePath)
 
     const fs = yield* FileSystem.FileSystem
-    const files = yield* fs.readDirectory(routesPath, { recursive: true })
-    const handles = FileRouter.getRouteHandlesFromPaths(files)
+    const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
+      Effect.mapError((cause) =>
+        new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })
+      ),
+    )
+    const fileRoutes = yield* FileRouter.getFileRoutes(files)
 
     // Validate route modules
-    yield* validateRouteModules(routesPath, handles)
+    yield* validateRouteModules(routesPath, fileRoutes)
 
-    const newCode = generateCode(handles)
+    const newCode = generateCode(fileRoutes)
 
-    // Check if file exists and content differs
+    // Check if file exists (ok to fail - means file doesn't exist)
     const existingCode = yield* fs
-      .readFileString(manifestPath)
+      .readFileString(treePath)
       .pipe(Effect.catchAll(() => Effect.succeed(null)))
 
+    // No routes found
+    if (newCode === null) {
+      // If gen file exists, write empty export
+      if (existingCode !== null) {
+        const emptyCode = "export default {}\n"
+        if (existingCode !== emptyCode) {
+          yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`)
+          yield* fs.writeFileString(treePath, emptyCode).pipe(
+            Effect.mapError((cause) =>
+              new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })
+            ),
+          )
+        }
+      }
+      return
+    }
+
+    // Write if content differs
     if (existingCode !== newCode) {
-      yield* Effect.logDebug(`Updating file routes manifest: ${manifestPath}`)
-      yield* fs.writeFileString(manifestPath, newCode)
+      yield* Effect.logDebug(`Updating file routes tree: ${treePath}`)
+      yield* fs.writeFileString(treePath, newCode).pipe(
+        Effect.mapError((cause) =>
+          new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })
+        ),
+      )
     } else {
-      yield* Effect.logDebug(`File routes manifest unchanged: ${manifestPath}`)
+      yield* Effect.logDebug(`File routes tree unchanged: ${treePath}`)
     }
   })
 }
 
 export function dump(
   routesPath: string,
-  manifestPath = "manifest.ts",
-): Effect.Effect<void, PlatformError, FileSystem.FileSystem> {
+  treePath = "server.gen.ts",
+): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function*() {
-    manifestPath = NPath.resolve(routesPath, manifestPath)
+    treePath = NPath.resolve(routesPath, treePath)
 
     const fs = yield* FileSystem.FileSystem
-    const files = yield* fs.readDirectory(routesPath, { recursive: true })
-    const handles = FileRouter.getRouteHandlesFromPaths(files)
+    const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
+      Effect.mapError((cause) =>
+        new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })
+      ),
+    )
+    const fileRoutes = yield* FileRouter.getFileRoutes(files)
 
     // Validate route modules
-    yield* validateRouteModules(routesPath, handles)
+    yield* validateRouteModules(routesPath, fileRoutes)
 
-    const code = generateCode(handles)
+    const code = generateCode(fileRoutes)
+
+    // No routes found - don't create file
+    if (code === null) {
+      yield* Effect.logDebug(`No routes found, skipping: ${treePath}`)
+      return
+    }
 
-    yield* Effect.logDebug(`Generating file routes manifest: ${manifestPath}`)
+    yield* Effect.logDebug(`Generating file routes tree: ${treePath}`)
 
-    yield* fs.writeFileString(
-      manifestPath,
-      code,
+    yield* fs.writeFileString(treePath, code).pipe(
+      Effect.mapError((cause) =>
+        new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })
+      ),
     )
   })
 }

package/src/{node/PlatformError.ts → PlatformError.ts}

@@ -13,9 +13,13 @@ export const TypeId: typeof TypeId_ = TypeId_
 
 export type TypeId = typeof TypeId
 
-export const isPlatformError = (u: unknown): u is PlatformError => Predicate.hasProperty(u, TypeId)
+export const isPlatformError = (u: unknown): u is PlatformError =>
+  Predicate.hasProperty(u, TypeId)
 
-export const TypeIdError = <const TypeId extends symbol, const Tag extends string>(
+export const TypeIdError = <
+  const TypeId extends symbol,
+  const Tag extends string,
+>(
   typeId: TypeId,
   tag: Tag,
 ): new<A extends Record<string, any>>(
@@ -24,7 +28,8 @@ export const TypeIdError = <const TypeId extends symbol, const Tag extends strin
   & Cause.YieldableError
   & Record<TypeId, TypeId>
   & { readonly _tag: Tag }
-  & Readonly<A> => {
+  & Readonly<A> =>
+{
   class Base extends Data.Error<{}> {
     readonly _tag = tag
   }
@@ -44,17 +49,22 @@ export const Module = Schema.Literal(
 )
 
 export class BadArgument
-  extends Schema.TaggedError<BadArgument>("@effect/platform/Error/BadArgument")("BadArgument", {
-    module: Module,
-    method: Schema.String,
-    description: Schema.optional(Schema.String),
-    cause: Schema.optional(Schema.Defect),
-  })
+  extends Schema.TaggedError<BadArgument>("@effect/platform/Error/BadArgument")(
+    "BadArgument",
+    {
+      module: Module,
+      method: Schema.String,
+      description: Schema.optional(Schema.String),
+      cause: Schema.optional(Schema.Defect),
+    },
+  )
 {
   readonly [TypeId]: typeof TypeId = TypeId
 
   get message(): string {
-    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`
+    return `${this.module}.${this.method}${
+      this.description ? `: ${this.description}` : ""
+    }`
   }
 }
 
@@ -75,15 +85,20 @@ export const SystemErrorReason = Schema.Literal(
 export type SystemErrorReason = typeof SystemErrorReason.Type
 
 export class SystemError
-  extends Schema.TaggedError<SystemError>("@effect/platform/Error/SystemError")("SystemError", {
-    reason: SystemErrorReason,
-    module: Module,
-    method: Schema.String,
-    description: Schema.optional(Schema.String),
-    syscall: Schema.optional(Schema.String),
-    pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
-    cause: Schema.optional(Schema.Defect),
-  })
+  extends Schema.TaggedError<SystemError>("@effect/platform/Error/SystemError")(
+    "SystemError",
+    {
+      reason: SystemErrorReason,
+      module: Module,
+      method: Schema.String,
+      description: Schema.optional(Schema.String),
+      syscall: Schema.optional(Schema.String),
+      pathOrDescriptor: Schema.optional(
+        Schema.Union(Schema.String, Schema.Number),
+      ),
+      cause: Schema.optional(Schema.Defect),
+    },
+  )
 {
   readonly [TypeId]: typeof TypeId = TypeId
 

package/src/PlatformRuntime.ts

@@ -1,3 +1,100 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
+import * as FiberRef from "effect/FiberRef"
+import * as FiberRefs from "effect/FiberRefs"
+import * as Function from "effect/Function"
+import * as HashSet from "effect/HashSet"
+import * as Logger from "effect/Logger"
+
+export interface Teardown {
+  <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void
+}
+
+export const defaultTeardown: Teardown = <E, A>(
+  exit: Exit.Exit<E, A>,
+  onExit: (code: number) => void,
+) => {
+  onExit(Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause) ? 1 : 0)
+}
+
+export interface RunMain {
+  (
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly disablePrettyLogger?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    },
+  ): <E, A>(effect: Effect.Effect<A, E>) => void
+  <E, A>(
+    effect: Effect.Effect<A, E>,
+    options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly disablePrettyLogger?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    },
+  ): void
+}
+
+const addPrettyLogger = (
+  refs: FiberRefs.FiberRefs,
+  fiberId: FiberId.Runtime,
+) => {
+  const loggers = FiberRefs.getOrDefault(refs, FiberRef.currentLoggers)
+  if (!HashSet.has(loggers, Logger.defaultLogger)) {
+    return refs
+  }
+  return FiberRefs.updateAs(refs, {
+    fiberId,
+    fiberRef: FiberRef.currentLoggers,
+    value: loggers.pipe(
+      HashSet.remove(Logger.defaultLogger),
+      HashSet.add(Logger.prettyLoggerDefault),
+    ),
+  })
+}
+
+export const makeRunMain = (
+  f: <E, A>(
+    options: {
+      readonly fiber: Fiber.RuntimeFiber<A, E>
+      readonly teardown: Teardown
+    },
+  ) => void,
+): RunMain =>
+  Function.dual(
+    (args) => Effect.isEffect(args[0]),
+    (effect: Effect.Effect<any, any>, options?: {
+      readonly disableErrorReporting?: boolean | undefined
+      readonly disablePrettyLogger?: boolean | undefined
+      readonly teardown?: Teardown | undefined
+    }) => {
+      const fiber = options?.disableErrorReporting === true
+        ? Effect.runFork(effect, {
+          updateRefs: options?.disablePrettyLogger === true
+            ? undefined
+            : addPrettyLogger,
+        })
+        : Effect.runFork(
+          Effect.tapErrorCause(effect, (cause) => {
+            if (Cause.isInterruptedOnly(cause)) {
+              return Effect.void
+            }
+            return Effect.logError(cause)
+          }),
+          {
+            updateRefs: options?.disablePrettyLogger === true
+              ? undefined
+              : addPrettyLogger,
+          },
+        )
+      const teardown = options?.teardown ?? defaultTeardown
+      return f({ fiber, teardown })
+    },
+  )
+
 /**
  * Are we running within an agent harness, like Claude Code?
  */

package/src/RouteBody.ts

@@ -35,7 +35,7 @@ export type GeneratorHandler<B, A, Y> = (
   next: (
     context?: Partial<B> & Record<string, unknown>,
   ) => Entity.Entity<UnwrapStream<A>>,
-) => Generator<Y, A | Entity.Entity<A>, unknown>
+) => Generator<Y, A | Entity.Entity<A>, never>
 
 export type HandlerInput<B, A, E, R> =
   | A

package/src/RouteHttp.ts

@@ -391,7 +391,9 @@ export const toWebHandlerRuntime = <R>(
           if (exit._tag === "Success") {
             resolve(exit.value)
           } else if (isClientAbort(exit.cause)) {
-            resolve(respondError({ status: 499, message: "client closed request" }))
+            resolve(
+              respondError({ status: 499, message: "client closed request" }),
+            )
           } else {
             const status = getStatusFromCause(exit.cause)
             const message = Cause.pretty(exit.cause, { renderErrorCause: true })

package/src/Start.ts

@@ -1,9 +1,11 @@
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as BunHttpServer from "./bun/BunHttpServer.ts"
 import * as BunRuntime from "./bun/BunRuntime.ts"
-import * as StartApp from "./StartApp.ts"
+import * as BunServer from "./bun/BunServer.ts"
+import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 
 export function layer<
   Layers extends [
@@ -18,13 +20,56 @@ export function layer<
   return Layer.mergeAll(...layers)
 }
 
-export function serve<ROut, E>(
+/**
+ * Bundles layers together, wiring their dependencies automatically.
+ *
+ * Equivalent to chaining `Layer.provide` calls, but more concise.
+ *
+ * **Ordering: dependents first, dependencies last.**
+ *
+ * @example
+ * ```ts
+ * // UserRepo needs Database, Database needs Logger
+ * const AppLayer = Start.pack(
+ *   UserRepoLive,   // needs Database, Logger
+ *   DatabaseLive,   // needs Logger
+ *   LoggerLive,     // no deps
+ * )
+ * // Result: Layer<UserRepo | Database | Logger, never, never>
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function pack<
+  const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.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],
+  Exclude<
+    { [K in keyof Layers]: Layer.Layer.Context<Layers[K]> }[number],
+    { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
+  >
+> {
+  type AnyLayer = Layer.Layer<any, any, any>
+  const layerArray = layers as unknown as ReadonlyArray<AnyLayer>
+  const result: AnyLayer = layerArray.reduce(
+    (acc: AnyLayer, layer: AnyLayer) => Layer.provideMerge(acc, layer),
+    Layer.succeedContext(Context.empty()) as unknown as AnyLayer,
+  )
+
+  return result as AnyLayer
+}
+
+export function serve<
+  ROut,
+  E,
+  RIn extends BunServer.BunServer | FileSystem.FileSystem,
+>(
   load: () => Promise<{
-    default: Layer.Layer<
-      ROut,
-      E,
-      BunHttpServer.BunHttpServer
-    >
+    default: Layer.Layer<ROut, E, RIn>
   }>,
 ) {
   const appLayer = Function.pipe(
@@ -34,13 +79,15 @@ export function serve<ROut, E>(
     Layer.unwrapEffect,
   )
 
-  return Function.pipe(
-    BunHttpServer.layerAuto(),
+  const composed = Function.pipe(
+    BunServer.layer(),
+    BunServer.withLogAddress,
     Layer.provide(appLayer),
-    Layer.provide([
-      BunHttpServer.layer(),
-      StartApp.layer(),
-    ]),
+    Layer.provide(NodeFileSystem.layer),
+  ) as Layer.Layer<BunServer.BunServer, never, never>
+
+  return Function.pipe(
+    composed,
     Layer.launch,
     BunRuntime.runMain,
   )