effect-start 0.32.0 → 0.34.0

package/src/Entity.ts

@@ -20,7 +20,10 @@ function isBinary(v: unknown): v is Uint8Array | ArrayBuffer {
  * Header keys are guaranteed to be lowercase.
  */
 export type Headers = {
-  [header: string]: string | null | undefined
+  // `set-cookie` is the only header that supports multiple values (as an array),
+  // since it requires separate `Set-Cookie` headers per cookie (RFC 6265).
+  readonly "set-cookie"?: string | ReadonlyArray<string> | null
+  readonly [header: string]: string | ReadonlyArray<string> | null | undefined
 }
 
 export interface Entity<T = unknown, E = never> extends Effect.Effect<Entity<T, E>, E> {
@@ -50,6 +53,9 @@ export interface Entity<T = unknown, E = never> extends Effect.Effect<Entity<T,
         : [T] extends [Values.Json]
           ? Effect.Effect<T, ParseResult.ParseError | E>
           : Effect.Effect<unknown, ParseResult.ParseError | E>
+  readonly schemaJson: <A, I, R>(
+    schema: Schema.Schema<A, I, R>,
+  ) => Effect.Effect<A, ParseResult.ParseError | E, R>
   readonly bytes: Effect.Effect<Uint8Array, ParseResult.ParseError | E>
   readonly stream: T extends Stream.Stream<infer A, infer E1, any>
     ? Stream.Stream<A, ParseResult.ParseError | E | E1>
@@ -76,6 +82,16 @@ function parseJson(s: string): Effect.Effect<unknown, ParseResult.ParseError> {
   }
 }
 
+function isDirectJson(value: unknown): value is Exclude<Values.Json, string> {
+  return (
+    value === null ||
+    typeof value === "number" ||
+    typeof value === "boolean" ||
+    Array.isArray(value) ||
+    Values.isPlainObject(value)
+  )
+}
+
 function getText(
   self: Entity<unknown, unknown>,
 ): Effect.Effect<string, ParseResult.ParseError | unknown> {
@@ -123,7 +139,7 @@ function getJson(
         if (isEntity(inner)) {
           return inner.json
         }
-        if (typeof inner === "object" && inner !== null && !isBinary(inner)) {
+        if (isDirectJson(inner)) {
           return Effect.succeed(inner)
         }
         if (typeof inner === "string") {
@@ -136,7 +152,7 @@ function getJson(
       },
     )
   }
-  if (typeof v === "object" && v !== null && !isBinary(v)) {
+  if (isDirectJson(v)) {
     return Effect.succeed(v)
   }
   if (typeof v === "string") {
@@ -188,13 +204,20 @@ function getBytes(
   if (typeof v === "string") {
     return Effect.succeed(textEncoder.encode(v))
   }
-  // Allows entity.stream to work when body is a JSON object
-  if (typeof v === "object" && v !== null && !isBinary(v)) {
+  // Allows entity.stream to work when body is a JSON value.
+  if (isDirectJson(v)) {
     return Effect.succeed(textEncoder.encode(JSON.stringify(v)))
   }
   return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, v))
 }
 
+export function schemaJson<T, E, A, I, R>(
+  self: Entity<T, E>,
+  schema: Schema.Schema<A, I, R>,
+): Effect.Effect<A, ParseResult.ParseError | E, R> {
+  return Effect.flatMap(self.json, Schema.decodeUnknown(schema))
+}
+
 function getStream<A, E1, E2>(
   self: Entity<Stream.Stream<A, E1, never>, E2>,
 ): Stream.Stream<A, ParseResult.ParseError | E1 | E2>
@@ -234,6 +257,11 @@ const Proto: Proto = Object.defineProperties(Object.create(Effectable.CommitProt
       return getJson(this)
     },
   },
+  schemaJson: {
+    value(this: Entity<unknown, unknown>, schema: Schema.Schema.Any) {
+      return schemaJson(this, schema)
+    },
+  },
   bytes: {
     get(this: Entity<unknown, unknown>) {
       return getBytes(this)
@@ -278,6 +306,32 @@ export function effect<A, E, R>(body: Effect.Effect<Entity<A> | A, E, R>): Entit
   return make(body) as unknown as Entity<A, E>
 }
 
+function mergeSetCookie(
+  existing: string | ReadonlyArray<string> | null | undefined,
+  incoming: string | ReadonlyArray<string> | null | undefined,
+): string | ReadonlyArray<string> | undefined {
+  if (incoming == null) return existing ?? undefined
+  if (existing == null) return incoming
+  const a = Array.isArray(existing) ? existing : [existing]
+  const b = Array.isArray(incoming) ? incoming : [incoming]
+  return [...a, ...b]
+}
+
+export function merge<T, E>(entity: Entity<T, E>, options: Options): Entity<T, E> {
+  const headers: Headers = options.headers
+    ? {
+        ...entity.headers,
+        ...options.headers,
+        "set-cookie": mergeSetCookie(entity.headers["set-cookie"], options.headers["set-cookie"]),
+      }
+    : entity.headers
+  return make(entity.body, {
+    headers,
+    status: options.status ?? entity.status,
+    url: options.url ?? entity.url,
+  }) as Entity<T, E>
+}
+
 export function resolve<A, E>(entity: Entity<A, E>): Effect.Effect<Entity<A, E>, E, never> {
   const body = entity.body
   if (Effect.isEffect(body)) {
@@ -297,13 +351,13 @@ export function resolve<A, E>(entity: Entity<A, E>): Effect.Effect<Entity<A, E>,
 export function type(self: Entity): string {
   const h = self.headers
   if (h["content-type"]) {
-    return h["content-type"]
+    return h["content-type"] as string
   }
   const v = self.body
   if (typeof v === "string") {
     return "text/plain"
   }
-  if (typeof v === "object" && v !== null && !isBinary(v)) {
+  if (isDirectJson(v)) {
     return "application/json"
   }
   return "application/octet-stream"
@@ -312,7 +366,7 @@ export function type(self: Entity): string {
 export function length(self: Entity): number | undefined {
   const h = self.headers
   if (h["content-length"]) {
-    return parseInt(h["content-length"], 10)
+    return parseInt(h["content-length"] as string, 10)
   }
   const v = self.body
   if (typeof v === "string") {

package/src/Fetch.ts

@@ -232,7 +232,7 @@ export function followRedirects(options?: { readonly maxRedirects?: number }): M
             return entity
           }
 
-          const location = entity.headers["location"]
+          const location = entity.headers["location"] as string | undefined
           if (!location) {
             return entity
           }

package/src/FileRouterCodegen.ts

@@ -137,10 +137,10 @@ export function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string |
       currentPath = parentPath || "/"
     }
 
-    // Order: route first, then layers from innermost to outermost
+    // Order: layers from outermost to innermost, then route
     const loaders: Array<string> = [
+      ...allLayers.map((layer) => `() => import(".${layer.modulePath}")`),
       `() => import(".${route.modulePath}")`,
-      ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
     ]
 
     entries.push({ path, loaders })

package/src/Html.ts

@@ -1,28 +1,14 @@
-import type { JSX } from "./jsx.d.ts"
+import type { JSX, HtmlElement, HtmlElemenetProps, HtmlElementType, HtmlComponent } from "../src/jsx.d.ts"
+
+export type ElementType = HtmlElementType
+export type ElemenetProps = HtmlElemenetProps
+export type Component = HtmlComponent
+export type Element = HtmlElement
 
 export const TypeId = "~effect-start/HyperNode" as const
 
 const NoChildren: ReadonlyArray<never> = Object.freeze([])
 
-type Primitive = string | number | boolean | null | undefined
-
-export type ElementType = string | Component
-
-export type ElemenetProps = {
-  [key: string]:
-    | Primitive
-    | Element
-    | Iterable<Primitive | Element>
-    | Record<string, unknown>
-    | ((window: Window) => void)
-}
-
-export type Component = (props: ElemenetProps) => Element | Primitive
-
-export interface Element {
-  type: ElementType
-  props: ElemenetProps
-}
 
 export function make(type: ElementType, props: ElemenetProps): Element {
   return {
@@ -74,6 +60,27 @@ const RAW_TEXT_TAGS = ["script", "style"]
 
 const escapeRawText = (text: string) => text.replaceAll("</", "<\\/")
 
+const serializeObjectProperty = (value: unknown): string | undefined => {
+  if (value === undefined) return undefined
+  if (typeof value === "function") return value.toString()
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => serializeObjectProperty(item) ?? "null").join(",")}]`
+  }
+  if (value && typeof value === "object") {
+    const props = Object.entries(value)
+      .flatMap(([key, prop]) => {
+        const serialized = serializeObjectProperty(prop)
+        return serialized === undefined ? [] : [`${JSON.stringify(key)}:${serialized}`]
+      })
+      .join(",")
+    return `{${props}}`
+  }
+  return JSON.stringify(value)
+}
+
+const serializeDataAttributeObject = (key: string, value: Record<string, unknown>): string =>
+  key === "data-computed" ? serializeObjectProperty(value)! : JSON.stringify(value)
+
 export function renderToString(
   node: JSX.Children,
   hooks?: { onNode?: (node: Element) => void },
@@ -143,7 +150,7 @@ export function renderToString(
             if (key.startsWith("data-") && typeof value === "function") {
               result += ` ${esc(resolvedKey)}="${esc(value.toString())}"`
             } else if (key.startsWith("data-") && typeof value === "object") {
-              result += ` ${esc(resolvedKey)}='${escSQ(JSON.stringify(value))}'`
+              result += ` ${esc(resolvedKey)}='${escSQ(serializeDataAttributeObject(key, value))}'`
             } else {
               result += ` ${esc(resolvedKey)}="${esc(value)}"`
             }

package/src/Route.ts

@@ -10,7 +10,7 @@ import * as RouteBody from "./RouteBody.ts"
 import * as RouteTree from "./RouteTree.ts"
 import type * as Values from "./_Values.ts"
 import * as Html from "./Html.ts"
-import type { JSX } from "./jsx.d.ts"
+import type { JSX } from "../src/jsx.d.ts"
 
 export const render = RouteBody.render
 
@@ -204,7 +204,7 @@ export type ExtractContext<
 export * from "./RouteHook.ts"
 export * from "./RouteSchema.ts"
 
-export { add, del, get, head, options, patch, post, put, use } from "./RouteMount.ts"
+export { del, get, head, options, patch, post, put, use } from "./RouteMount.ts"
 
 export const text = RouteBody.build<string, "text">({
   format: "text",

package/src/RouteBody.ts

@@ -25,7 +25,7 @@ type YieldContext<T> = T extends Utils.YieldWrap<Effect.Effect<any, any, infer R
 
 type Next<B, A> = (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<UnwrapStream<A>>
 
-type HandlerReturn<A> = A | Entity.Entity<A> | ((self: Route.RouteSet.Any) => Route.RouteSet.Any)
+type HandlerReturn<A> = A | Entity.Entity<A, any> | ((self: Route.RouteSet.Any) => Route.RouteSet.Any)
 
 type HandlerFunction<B, A, E, R> = (
   context: Values.Simplify<B>,
@@ -41,7 +41,7 @@ export type GeneratorHandler<B, A, Y> = (
 
 export type HandlerInput<B, A, E, R> =
   | A
-  | Entity.Entity<A>
+  | Entity.Entity<A, any>
   | Effect.Effect<HandlerReturn<A>, E, R>
   | HandlerFunction<B, A, E, R>
 

package/src/RouteHttp.ts

@@ -76,7 +76,7 @@ const respondError = (
 
 function streamResponse(
   stream: Stream.Stream<unknown, unknown, unknown>,
-  headers: Record<string, string | null | undefined>,
+  headers: globalThis.Headers,
   status: number,
   runtime: Runtime.Runtime<any>,
 ): Response {
@@ -92,10 +92,27 @@ function streamResponse(
   )
   return new Response(Stream.toReadableStreamRuntime(byteStream, runtime), {
     status,
-    headers: headers as Record<string, string>,
+    headers,
   })
 }
 
+function toHeaders(entityHeaders: Entity.Headers, contentType: string): globalThis.Headers {
+  const headers = new Headers()
+  for (const key in entityHeaders) {
+    const value = entityHeaders[key]
+    if (value == null) continue
+    if (typeof value === "string") {
+      headers.set(key, value)
+    } else {
+      for (const v of value) headers.append(key, v)
+    }
+  }
+  if (!headers.has("content-type")) {
+    headers.set("content-type", contentType)
+  }
+  return headers
+}
+
 function toResponse(
   entity: Entity.Entity<any>,
   format: string | undefined,
@@ -103,7 +120,7 @@ function toResponse(
 ): Effect.Effect<Response, ParseResult.ParseError> {
   const contentType = Entity.type(entity)
   const status = entity.status ?? 200
-  const headers = { ...entity.headers, "content-type": contentType }
+  const headers = toHeaders(entity.headers, contentType)
 
   if (StreamExtra.isStream(entity.body)) {
     return Effect.succeed(streamResponse(entity.body, headers, status, runtime))
@@ -170,64 +187,45 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   const runFork = Runtime.runFork(runtime)
 
   return (routes: Iterable<UnboundedRouteWithMethod>): Http.WebHandler => {
-    const grouped = Object.groupBy(
-      routes,
-      (route) => Route.descriptor(route).method?.toUpperCase() ?? "*",
-    )
-    const wildcards = grouped["*"] ?? []
-    const methodGroups: {
-      [method in Http.Method]?: Array<UnboundedRouteWithMethod>
-    } = {
-      GET: undefined,
-      POST: undefined,
-      PUT: undefined,
-      PATCH: undefined,
-      DELETE: undefined,
-      HEAD: undefined,
-      OPTIONS: undefined,
-    }
-
-    for (const method in grouped) {
-      if (method !== "*") {
-        methodGroups[method] = grouped[method]
-      }
+    const allRoutes = Array.from(routes)
+    const methods = new Set<string>()
+    for (const route of allRoutes) {
+      const m = Route.descriptor(route).method?.toUpperCase()
+      if (m && m !== "*") methods.add(m)
     }
-
-    if (methodGroups["GET"] !== undefined && methodGroups["HEAD"] === undefined) {
-      methodGroups["HEAD"] = methodGroups["GET"]
+    if (methods.has("GET") && !methods.has("HEAD")) {
+      methods.add("HEAD")
     }
-
-    const allowedMethods = Object.keys(methodGroups)
-      .filter((m) => methodGroups[m] !== undefined && methodGroups[m]!.length > 0)
-      .join(", ")
+    const allowedMethods = Array.from(methods).join(", ")
 
     return (request) =>
       new Promise((resolve) => {
         const method = request.method.toUpperCase()
         const accept = request.headers.get("accept")
-        const methodRoutes = methodGroups[method] ?? []
+        const matchingRoutes = allRoutes.filter((route) => {
+          const m = Route.descriptor(route).method?.toUpperCase()
+          return m === "*" || m === method || (method === "HEAD" && m === "GET")
+        })
 
-        if (method === "OPTIONS" && methodRoutes.length === 0 && wildcards.length === 0) {
-          return resolve(
-            new Response(null, {
-              status: 204,
-              headers: { allow: allowedMethods },
-            }),
-          )
-        }
+        if (matchingRoutes.length === 0) {
+          if (method === "OPTIONS" || methods.size === 0) {
+            return resolve(
+              new Response(null, {
+                status: 204,
+                headers: { allow: allowedMethods },
+              }),
+            )
+          }
 
-        if (methodRoutes.length === 0 && wildcards.length === 0) {
           return resolve(
             respondError({ status: 405, message: "method not allowed" }, { allow: allowedMethods }),
           )
         }
-
-        const allRoutes = [...wildcards, ...methodRoutes]
-        const selectedFormat = determineSelectedFormat(accept, allRoutes)
+        const selectedFormat = determineSelectedFormat(accept, matchingRoutes)
 
         const specificFormats = new Set<string>()
         let hasWildcardFormatRoutes = false
-        for (const r of allRoutes) {
+        for (const r of matchingRoutes) {
           const format = Route.descriptor(r).format
           if (format === "*") hasWildcardFormatRoutes = true
           else if (format) specificFormats.add(format)
@@ -249,13 +247,13 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
               currentContext = passedContext
             }
 
-            if (index >= allRoutes.length) {
+            if (index >= matchingRoutes.length) {
               return Effect.succeed(
                 Entity.make({ status: 404, message: "route not found" }, { status: 404 }),
               )
             }
 
-            const route = allRoutes[index++]
+            const route = matchingRoutes[index++]
             const descriptor = Route.descriptor(route)
             const format = descriptor.format
             const handler = route.handler as unknown as Handler

package/src/RouteMount.ts

@@ -10,7 +10,7 @@ const RouteSetTypeId = "~effect-start/RouteSet" as const
 // oxlint-disable-next-line import/first, typescript/consistent-type-imports -- typeof import() is not an import statement
 type Module = typeof import("./RouteMount.ts")
 
-export type Self = RouteMount.Builder | Module
+export type Self = RouteMount.Builder<any, any> | Omit<RouteMount.Builder<any, any>, "use"> | Module
 
 export const use = makeMethodDescriber("*")
 export const get = makeMethodDescriber("GET")
@@ -21,28 +21,6 @@ export const patch = makeMethodDescriber("PATCH")
 export const head = makeMethodDescriber("HEAD")
 export const options = makeMethodDescriber("OPTIONS")
 
-export const add: RouteMount.Add = function (
-  this: Self,
-  path: string,
-  routes: Route.RouteSet.Any | ((self: RouteMount.Builder<{}, []>) => Route.RouteSet.Any),
-) {
-  const baseItems = Route.isRouteSet(this) ? Route.items(this) : ([] as const)
-
-  const routeSet = typeof routes === "function" ? routes(make<{}, []>([])) : routes
-  const routeItems = Route.items(routeSet)
-  const newItems = routeItems.map((item) => {
-    const itemDescriptor = Route.descriptor(item) as { path?: string }
-    const concatenatedPath =
-      typeof itemDescriptor?.path === "string" ? path + itemDescriptor.path : path
-    const newDescriptor = { ...itemDescriptor, path: concatenatedPath }
-    return Route.isRoute(item)
-      ? Route.make(item.handler as Route.Route.Handler<any, any, any, any>, newDescriptor)
-      : Route.set(Route.items(item), newDescriptor)
-  })
-
-  return make([...baseItems, ...newItems] as any)
-}
-
 const Proto = Object.assign(Object.create(null), {
   [RouteSetTypeId]: RouteSetTypeId,
   *[Symbol.iterator](this: Route.RouteSet.Any) {
@@ -56,7 +34,6 @@ const Proto = Object.assign(Object.create(null), {
   patch,
   head,
   options,
-  add,
 })
 
 function make<
@@ -116,7 +93,19 @@ export namespace RouteMount {
   export type MountSet = Route.RouteSet.RouteSet<{ method: Method }, {}, Route.Route.Tuple>
 
   export interface Builder<D extends {} = {}, I extends Route.Route.Tuple = []>
-    extends Route.RouteSet.RouteSet<D, {}, I>, Module {}
+    extends Route.RouteSet.RouteSet<D, {}, I> {
+    use: Describer<"*">
+    get: Describer<"GET">
+    post: Describer<"POST">
+    put: Describer<"PUT">
+    del: Describer<"DELETE">
+    patch: Describer<"PATCH">
+    head: Describer<"HEAD">
+    options: Describer<"OPTIONS">
+  }
+
+  export type BuilderAfter<M extends Method, I extends Route.Route.Tuple> =
+    M extends "*" ? Builder<{}, I> : Omit<Builder<{}, I>, "use">
 
   export type EmptySet<M extends Method, B = {}> = Route.RouteSet.RouteSet<{ method: M }, B, []>
 
@@ -142,37 +131,6 @@ export namespace RouteMount {
     }[number]
   >
 
-  type PrefixPathItem<Prefix extends string, T> =
-    T extends Route.Route.Route<infer D, infer B, infer A, infer E, infer R>
-      ? D extends { path: infer P extends string }
-        ? Route.Route.Route<Omit<D, "path"> & { path: `${Prefix}${P}` }, B, A, E, R>
-        : Route.Route.Route<D & { path: Prefix }, B, A, E, R>
-      : T
-
-  export type PrefixPath<Prefix extends string, I extends Route.Route.Tuple> = {
-    [K in keyof I]: PrefixPathItem<Prefix, I[K]>
-  } extends infer R extends Route.Route.Tuple
-    ? R
-    : never
-
-  export interface Add {
-    <S extends Self, P extends string, R extends Route.RouteSet.Any>(
-      this: S,
-      path: P,
-      routes: R,
-    ): Builder<{}, [...Items<S>, ...PrefixPath<P, Route.RouteSet.Items<R>>]>
-
-    <S extends Self, P extends string, R extends Route.RouteSet.Any>(
-      this: S,
-      path: P,
-      /**
-       * Callback form provides a builder seeded with higher-level bindings so
-       * nested routes can type-infer outer context when mounting.
-       */
-      routes: (self: Builder<{}, []>) => R,
-    ): Builder<{}, [...Items<S>, ...PrefixPath<P, Route.RouteSet.Items<R>>]>
-  }
-
   // Flatten items: merge method into descriptor and accumulate bindings through the chain
   // `request` is omitted from bindings since it's implicit (always available)
   export type FlattenItems<M extends Method, B, I extends Route.Route.Tuple> = I extends [
@@ -195,13 +153,13 @@ export namespace RouteMount {
     <S extends Self, A extends Route.RouteSet.Any>(
       this: S,
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<A>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<A>>]>
 
     <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any>(
       this: S,
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
       bc: (b: A) => B,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<B>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<B>>]>
 
     <
       S extends Self,
@@ -213,7 +171,7 @@ export namespace RouteMount {
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
       bc: (b: A) => B,
       cd: (c: B) => C,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<C>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<C>>]>
 
     <
       S extends Self,
@@ -227,7 +185,7 @@ export namespace RouteMount {
       bc: (b: A) => B,
       cd: (c: B) => C,
       de: (d: C) => D,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<D>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<D>>]>
 
     <
       S extends Self,
@@ -243,7 +201,7 @@ export namespace RouteMount {
       cd: (c: B) => C,
       de: (d: C) => D,
       ef: (e: D) => E,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<E>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<E>>]>
 
     <
       S extends Self,
@@ -261,7 +219,7 @@ export namespace RouteMount {
       de: (d: C) => D,
       ef: (e: D) => E,
       fg: (f: E) => F,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<F>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<F>>]>
 
     <
       S extends Self,
@@ -281,7 +239,7 @@ export namespace RouteMount {
       ef: (e: D) => E,
       fg: (f: E) => F,
       gh: (g: F) => G,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<G>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<G>>]>
 
     <
       S extends Self,
@@ -303,7 +261,7 @@ export namespace RouteMount {
       fg: (f: E) => F,
       gh: (g: F) => G,
       hi: (h: G) => H,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<H>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<H>>]>
 
     <
       S extends Self,
@@ -327,6 +285,6 @@ export namespace RouteMount {
       gh: (g: F) => G,
       hi: (h: G) => H,
       ij: (i: H) => I,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<I>>]>
+    ): BuilderAfter<M, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<I>>]>
   }
 }

package/src/Start.ts

@@ -1,4 +1,5 @@
 import type * as FileSystem from "./FileSystem.ts"
+import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
@@ -140,6 +141,9 @@ export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<L
               map.delete(layer)
               return map
             })
+            if (Cause.isDie(exit.cause) || Cause.isInterruptedOnly(exit.cause)) {
+              return yield* exit
+            }
           }
         }
       }

package/src/StaticFiles.ts

@@ -41,17 +41,14 @@ export const make = (directory: string) =>
         return emptyNotFound
       }
 
-      const headers: Entity.Headers = {
-        "content-length": String(info.size),
-        "content-type": Mime.fromPath(relativePath),
-      }
-
-      if (Option.isSome(info.mtime)) {
-        headers["last-modified"] = info.mtime.value.toUTCString()
-      }
-
       const bytes = yield* fs.readFile(absolutePath)
-      return Entity.make(bytes, { headers })
+      return Entity.make(bytes, {
+        headers: {
+          "content-length": String(info.size),
+          "content-type": Mime.fromPath(relativePath),
+          ...(Option.isSome(info.mtime) ? { "last-modified": info.mtime.value.toUTCString() } : {}),
+        },
+      })
     }),
   )