effect-start 0.18.0 → 0.20.0

package/src/RouteHttp.ts

@@ -17,14 +17,6 @@ import * as RouteMount from "./RouteMount.ts"
 import * as RouteTree from "./RouteTree.ts"
 import * as StreamExtra from "./StreamExtra.ts"
 
-export {
-  currentSpanNameGenerator,
-  currentTracerDisabledWhen,
-  parentSpanFromHeaders,
-  withSpanNameGenerator,
-  withTracerDisabledWhen,
-} from "./RouteHttpTracer.ts"
-
 type UnboundedRouteWithMethod = Route.Route.With<{
   method: RouteMount.RouteMount.Method
   format?: RouteBody.Format
@@ -74,6 +66,12 @@ const getStatusFromCause = (cause: Cause.Cause<unknown>): number => {
   return 500
 }
 
+const respondError = (options: { status: number; message: string }): Response =>
+  new Response(JSON.stringify(options, null, 2), {
+    status: options.status,
+    headers: { "content-type": "application/json" },
+  })
+
 function streamResponse(
   stream: Stream.Stream<unknown, unknown, unknown>,
   headers: Record<string, string | null | undefined>,
@@ -211,9 +209,7 @@ export const toWebHandlerRuntime = <R>(
 
       if (methodRoutes.length === 0 && wildcards.length === 0) {
         return Promise.resolve(
-          Response.json({ status: 405, message: "method not allowed" }, {
-            status: 405,
-          }),
+          respondError({ status: 405, message: "method not allowed" }),
         )
       }
 
@@ -234,9 +230,7 @@ export const toWebHandlerRuntime = <R>(
         && !hasWildcardFormatRoutes
       ) {
         return Promise.resolve(
-          Response.json({ status: 406, message: "not acceptable" }, {
-            status: 406,
-          }),
+          respondError({ status: 406, message: "not acceptable" }),
         )
       }
 
@@ -315,9 +309,7 @@ export const toWebHandlerRuntime = <R>(
               : Entity.make(result, { status: 200 })
 
             if (entity.status === 404 && entity.body === undefined) {
-              return Response.json({ status: 406, message: "not acceptable" }, {
-                status: 406,
-              })
+              return respondError({ status: 406, message: "not acceptable" })
             }
 
             return yield* toResponse(entity, selectedFormat, runtime)
@@ -380,9 +372,8 @@ export const toWebHandlerRuntime = <R>(
               Effect.gen(function*() {
                 yield* Effect.logError(cause)
                 const status = getStatusFromCause(cause)
-                return Response.json({ status, message: Cause.pretty(cause) }, {
-                  status,
-                })
+                const message = Cause.pretty(cause, { renderErrorCause: true })
+                return respondError({ status, message })
               })
             ),
           ),
@@ -401,17 +392,12 @@ export const toWebHandlerRuntime = <R>(
             resolve(exit.value)
           } else if (isClientAbort(exit.cause)) {
             resolve(
-              Response.json({ status: 499, message: "client closed request" }, {
-                status: 499,
-              }),
+              respondError({ status: 499, message: "client closed request" }),
             )
           } else {
             const status = getStatusFromCause(exit.cause)
-            resolve(
-              Response.json({ status, message: Cause.pretty(exit.cause) }, {
-                status,
-              }),
-            )
+            const message = Cause.pretty(exit.cause, { renderErrorCause: true })
+            resolve(respondError({ status, message }))
           }
         })
       })
@@ -438,6 +424,6 @@ export function* walkHandles(
 
   const toHandler = toWebHandlerRuntime(runtime)
   for (const [path, routes] of pathGroups) {
-    yield [path, toHandler(routes as Iterable<UnboundedRouteWithMethod>)]
+    yield [path, toHandler(routes)]
   }
 }

package/src/RouteMount.ts

@@ -142,7 +142,7 @@ export type MountedRoute = Route.Route.Route<
   {
     method: RouteMount.Method
     path: PathPattern.PathPattern
-    format?: string
+    format?: RouteBody.Format
   },
   {},
   any,

package/src/Start.ts

@@ -1,15 +1,11 @@
-import * as FetchHttpClient from "@effect/platform/FetchHttpClient"
 import * as FileSystem from "@effect/platform/FileSystem"
-import * as HttpClient from "@effect/platform/HttpClient"
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServer from "@effect/platform/HttpServer"
+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 NodeFileSystem from "./node/FileSystem.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 [
@@ -24,17 +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,
-      | HttpServer.HttpServer
-      | HttpClient.HttpClient
-      | HttpRouter.Default
-      | FileSystem.FileSystem
-      | BunHttpServer.BunHttpServer
-    >
+    default: Layer.Layer<ROut, E, RIn>
   }>,
 ) {
   const appLayer = Function.pipe(
@@ -44,17 +79,16 @@ export function serve<ROut, E>(
     Layer.unwrapEffect,
   )
 
-  return Function.pipe(
-    BunHttpServer.layerAuto(),
-    HttpServer.withLogAddress,
+  const composed = Function.pipe(
+    BunServer.layer(),
+    BunServer.withLogAddress,
     Layer.provide(appLayer),
-    Layer.provide([
-      FetchHttpClient.layer,
-      HttpRouter.Default.Live,
-      BunHttpServer.layer(),
-      NodeFileSystem.layer,
-      StartApp.layer(),
-    ]),
+    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(BunServer.layer()),
+  ) as Layer.Layer<BunServer.BunServer, never, never>
+
+  return Function.pipe(
+    composed,
     Layer.launch,
     BunRuntime.runMain,
   )

package/src/Unique.ts

@@ -0,0 +1,232 @@
+export const ALPHABET_BASE32_CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+export const ALPHABET_BASE32_RFC4648 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+export const ALPHABET_BASE64_URL =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+export const ALPHABET_HEX = "0123456789abcdef"
+
+/**
+ * Generate a random string for ids, session tokens, and API keys.
+ * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
+ *
+ * Minimal recommended length:
+ * - public ids: 16 chars (~80 bits)
+ * - API keys: 32 chars (~160 bits)
+ * - session tokens: 32-40 chars (~160-200 bits)
+ */
+export function token(length = 32): string {
+  if (length <= 0) return ""
+
+  const buf = new Uint8Array(length)
+  crypto.getRandomValues(buf)
+
+  let result = ""
+  for (let i = 0; i < buf.length; i++) {
+    result += ALPHABET_BASE32_CROCKFORD[buf[i] & 31]
+  }
+
+  return result
+}
+
+export function bytes(length: number): Uint8Array {
+  const buf = new Uint8Array(length)
+  crypto.getRandomValues(buf)
+  return buf
+}
+
+export const UUID_NIL = "00000000-0000-0000-0000-000000000000"
+
+export function uuid4(): string {
+  return formatUuid(uuid4bytes())
+}
+
+export function uuid7(time: number = Date.now()): string {
+  return formatUuid(uuid7Bytes(time))
+}
+
+function uuid4bytes(): Uint8Array {
+  const buf = bytes(16)
+  buf[6] = (buf[6] & 0x0f) | 0x40 // version 4
+  buf[8] = (buf[8] & 0x3f) | 0x80 // variant
+
+  return buf
+}
+
+/**
+ * Decode a 48-bit Unix timestamp (ms) from UUID7 or ULID.
+ *
+ * @example
+ * const bytes = Unique.uuid7Bytes()
+ * const timestamp = Unique.toTimestamp(bytes)
+ *
+ * @example
+ * const bytes = Unique.ulidBytes()
+ * const timestamp = Unique.toTimestamp(bytes)
+ */
+export function toTimestamp(bytes: Uint8Array): number {
+  if (bytes.length < 6) return 0
+
+  return (
+    bytes[0] * 0x10000000000
+    + bytes[1] * 0x100000000
+    + bytes[2] * 0x1000000
+    + bytes[3] * 0x10000
+    + bytes[4] * 0x100
+    + bytes[5]
+  )
+}
+
+export function uuid7Bytes(time: number = Date.now()): Uint8Array {
+  const buf = new Uint8Array(16)
+  const timestamp = BigInt(toSafeTime(time))
+
+  // 48-bit timestamp (6 bytes)
+  buf[0] = Number((timestamp >> 40n) & 0xffn)
+  buf[1] = Number((timestamp >> 32n) & 0xffn)
+  buf[2] = Number((timestamp >> 24n) & 0xffn)
+  buf[3] = Number((timestamp >> 16n) & 0xffn)
+  buf[4] = Number((timestamp >> 8n) & 0xffn)
+  buf[5] = Number(timestamp & 0xffn)
+
+  // 12-bit random A (1.5 bytes)
+  crypto.getRandomValues(buf.subarray(6, 8))
+  buf[6] = (buf[6] & 0x0f) | 0x70 // version 7
+
+  // 2-bit variant + 62-bit random B (8 bytes)
+  crypto.getRandomValues(buf.subarray(8, 16))
+  buf[8] = (buf[8] & 0x3f) | 0x80 // variant
+
+  return buf
+}
+
+/**
+ * Convert UUID bytes to canonical (RFC9562) representation.
+ *
+ * @example
+ * Unique.formatUuid(new Uint8Array(16))
+ */
+export function formatUuid(bytes: Uint8Array): string {
+  if (bytes.length === 0) return ""
+
+  let result = ""
+
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i]
+    result += ALPHABET_HEX[(byte >> 4) & 0x0f]
+    result += ALPHABET_HEX[byte & 0x0f]
+
+    if (i === 3 || i === 5 || i === 7 || i === 9) result += "-"
+  }
+
+  return result
+}
+
+export function ulid(time: number = Date.now()): string {
+  const bytes = ulidBytes(time)
+  return formatUlid(bytes)
+}
+
+export function ulidBytes(time: number = Date.now()): Uint8Array {
+  const buf = new Uint8Array(16)
+  const timestamp = BigInt(toSafeTime(time))
+
+  buf[0] = Number((timestamp >> 40n) & 0xffn)
+  buf[1] = Number((timestamp >> 32n) & 0xffn)
+  buf[2] = Number((timestamp >> 24n) & 0xffn)
+  buf[3] = Number((timestamp >> 16n) & 0xffn)
+  buf[4] = Number((timestamp >> 8n) & 0xffn)
+  buf[5] = Number(timestamp & 0xffn)
+
+  crypto.getRandomValues(buf.subarray(6, 16))
+
+  return buf
+}
+
+function formatUlid(bytes: Uint8Array): string {
+  if (bytes.length !== 16) return ""
+
+  const timestamp = toTimestamp(bytes)
+  const timePart = encodeUlidTime(timestamp)
+  const randomPart = toBase32(bytes.subarray(6, 16))
+
+  return `${timePart}${randomPart}`
+}
+
+function encodeUlidTime(time: number): string {
+  let value = BigInt(time)
+  const result = new Array<string>(10)
+
+  for (let i = 9; i >= 0; i--) {
+    result[i] = ALPHABET_BASE32_CROCKFORD[Number(value & 31n)]
+    value >>= 5n
+  }
+
+  return result.join("")
+}
+
+function toSafeTime(time: number): number {
+  if (!Number.isFinite(time)) return 0
+
+  return Math.max(0, Math.trunc(time))
+}
+
+/**
+ * Generate a nanoid-style random string.
+ *
+ * FUN_FACT: Original nanoid implementation uses base64url alphabet
+ * with non-standard custom order where charater form common words found
+ * in source code (like use, random, strict) to make gzip/brotli more efficient.
+ * It's qt lil opt from the times where web developers
+ * were competing to have the smallest possible bundle size.
+ */
+export function nanoid(
+  size = 21,
+  alphabet = ALPHABET_BASE64_URL,
+): string {
+  if (size <= 0 || alphabet.length === 0) return ""
+
+  const length = alphabet.length
+  const mask = (2 << Math.floor(Math.log2(length - 1))) - 1
+  const step = Math.ceil((1.6 * mask * size) / length)
+
+  let id = ""
+  while (id.length < size) {
+    const bytes = new Uint8Array(step)
+    crypto.getRandomValues(bytes)
+
+    for (let i = 0; i < step && id.length < size; i++) {
+      const index = bytes[i] & mask
+      if (index < length) id += alphabet[index]
+    }
+  }
+  return id
+}
+
+function toBase32(
+  bytes: Uint8Array,
+  alphabet = ALPHABET_BASE32_CROCKFORD,
+): string {
+  if (bytes.length === 0) return ""
+
+  let result = ""
+  let buffer = 0
+  let bits = 0
+
+  for (const byte of bytes) {
+    buffer = (buffer << 8) | byte
+    bits += 8
+
+    while (bits >= 5) {
+      bits -= 5
+      const index = (buffer >> bits) & 31
+      result += alphabet[index]
+      buffer &= (1 << bits) - 1
+    }
+  }
+
+  if (bits > 0) {
+    const index = (buffer << (5 - bits)) & 31
+    result += alphabet[index]
+  }
+
+  return result
+}

package/src/bun/BunPlatformHttpServer.ts

@@ -0,0 +1,88 @@
+import * as HttpApp from "@effect/platform/HttpApp"
+import * as HttpServer from "@effect/platform/HttpServer"
+import * as HttpServerError from "@effect/platform/HttpServerError"
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
+import type * as Bun from "bun"
+import * as Effect from "effect/Effect"
+import * as FiberSet from "effect/FiberSet"
+import type * as Scope from "effect/Scope"
+import * as BunServer from "./BunServer.ts"
+import * as BunServerRequest from "./BunServerRequest.ts"
+
+/**
+ * From times when we used @effect/platform
+ * Not used any more internally. Kept for the future,
+ * in case someone will need it for whatever reason. [2026]
+ */
+export const make: Effect.Effect<
+  HttpServer.HttpServer,
+  never,
+  Scope.Scope | BunServer.BunServer
+> = Effect.gen(function*() {
+  const bunServer = yield* BunServer.BunServer
+
+  return HttpServer.make({
+    address: {
+      _tag: "TcpAddress",
+      port: bunServer.server.port!,
+      hostname: bunServer.server.hostname!,
+    },
+    serve(httpApp, middleware) {
+      return Effect.gen(function*() {
+        const runFork = yield* FiberSet.makeRuntime<never>()
+        const runtime = yield* Effect.runtime<never>()
+        const app = HttpApp.toHandled(
+          httpApp,
+          (request, response) =>
+            Effect.sync(() => {
+              ;(request as BunServerRequest.ServerRequestImpl).resolve(
+                BunServerRequest.makeResponse(request, response, runtime),
+              )
+            }),
+          middleware,
+        )
+
+        function handler(
+          request: Request,
+          server: Bun.Server<BunServerRequest.WebSocketContext>,
+        ) {
+          return new Promise<Response>((resolve, _reject) => {
+            const fiber = runFork(Effect.provideService(
+              app,
+              HttpServerRequest.HttpServerRequest,
+              new BunServerRequest.ServerRequestImpl(
+                request,
+                resolve,
+                removeHost(request.url),
+                server,
+              ),
+            ))
+            request.signal.addEventListener("abort", () => {
+              runFork(
+                fiber.interruptAsFork(HttpServerError.clientAbortFiberId),
+              )
+            }, { once: true })
+          })
+        }
+
+        yield* Effect.acquireRelease(
+          Effect.sync(() => {
+            bunServer.pushHandler(handler)
+          }),
+          () =>
+            Effect.sync(() => {
+              bunServer.popHandler()
+            }),
+        )
+      })
+    },
+  })
+})
+
+const removeHost = (url: string) => {
+  if (url[0] === "/") {
+    return url
+  }
+  const index = url.indexOf("/", url.indexOf("//") + 2)
+  return index === -1 ? "/" : url.slice(index)
+}

package/src/bun/BunRoute.ts

@@ -4,12 +4,12 @@ import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Entity from "../Entity.ts"
+import * as FilePathPattern from "../FilePathPattern.ts"
 import * as Hyper from "../hyper/Hyper.ts"
 import * as HyperHtml from "../hyper/HyperHtml.ts"
-import * as Random from "../Random.ts"
 import * as Route from "../Route.ts"
-import * as RouterPattern from "../RouterPattern.ts"
-import * as BunHttpServer from "./BunHttpServer.ts"
+import * as Unique from "../Unique.ts"
+import * as BunServer from "./BunServer.ts"
 
 const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
 
@@ -25,7 +25,7 @@ export type BunDescriptors = {
 }
 
 export function descriptors(
-  route: Route.Route.Route,
+  route: Route.Route.Route<any, any, any, any, any>,
 ): BunDescriptors | undefined {
   const descriptor = Route.descriptor(route) as Partial<BunDescriptors>
   if (
@@ -40,7 +40,7 @@ export function descriptors(
 export function htmlBundle(
   load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
 ) {
-  const bunPrefix = `/.BunRoute-${Random.token(6)}`
+  const bunPrefix = `/.BunRoute-${Unique.token(10)}`
   const bunLoad = () => load().then(mod => "default" in mod ? mod.default : mod)
   const descriptors = { bunPrefix, bunLoad, format: "html" as const }
 
@@ -60,7 +60,7 @@ export function htmlBundle(
         { request: Request },
         string,
         BunRouteError,
-        BunHttpServer.BunHttpServer
+        BunServer.BunServer
       >,
     ]
   > {
@@ -68,7 +68,7 @@ export function htmlBundle(
       BunDescriptors & { format: "html" } & { request: Request },
       string,
       BunRouteError,
-      BunHttpServer.BunHttpServer
+      BunServer.BunServer
     > = (context, next) =>
       Effect.gen(function*() {
         const originalRequest = context.request
@@ -87,7 +87,7 @@ export function htmlBundle(
           )
         }
 
-        const bunServer = yield* BunHttpServer.BunHttpServer
+        const bunServer = yield* BunServer.BunServer
         const url = new URL(originalRequest.url)
 
         const internalPath = `${bunPrefix}${url.pathname}`
@@ -152,7 +152,7 @@ export function htmlBundle(
       { request: Request },
       string,
       BunRouteError,
-      BunHttpServer.BunHttpServer
+      BunServer.BunServer
     >(handler, descriptors)
 
     return Route.set(
@@ -181,9 +181,7 @@ export type BunRoutes = Record<string, BunServerRouteHandler>
  * - /exact        - Exact match
  * - /users/:id    - Full-segment named param
  * - /path/*       - Directory wildcard
- * - /*            - Catch-all
- * - /[[id]]       - Optional param (implemented via `/` and `/:id`)
- * - /[[...rest]]  - Optional rest param (implemented via `/` and `/*`)
+ * - /[[404]]      - Catch-all / Rest
  *
  * Unsupported patterns (cannot be implemented in Bun):
  * - /pk_[id]   - Prefix before param
@@ -196,24 +194,16 @@ export type BunRoutes = Record<string, BunServerRouteHandler>
 export function validateBunPattern(
   pattern: string,
 ): Option.Option<BunRouteError> {
-  const segments = RouterPattern.parse(pattern)
+  const segs = FilePathPattern.segments(pattern)
 
-  const unsupported = Array.findFirst(segments, (seg) => {
-    if (seg._tag === "ParamSegment") {
-      return seg.prefix !== undefined || seg.suffix !== undefined
-    }
+  const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment")
 
-    return false
-  })
-
-  if (Option.isSome(unsupported)) {
+  if (Option.isSome(invalid)) {
     return Option.some(
       new BunRouteError({
         reason: "UnsupportedPattern",
         pattern,
-        message:
-          `Pattern "${pattern}" uses prefixed/suffixed params (prefix_[param] or [param]_suffix) `
-          + `which cannot be implemented in Bun.serve.`,
+        message: `Pattern "${pattern}" contains invalid segment.`,
       }),
     )
   }

package/src/bun/BunRuntime.ts

@@ -1,11 +1,24 @@
-import { makeRunMain } from "@effect/platform/Runtime"
-import { constVoid } from "effect/Function"
+import type * as Fiber from "effect/Fiber"
+import * as GlobalValue from "effect/GlobalValue"
+import * as MutableRef from "effect/MutableRef"
+import * as PlatformRuntime from "../PlatformRuntime.ts"
 
-export const runMain = makeRunMain(({
+const mainFiber = GlobalValue.globalValue(
+  Symbol.for("effect-start/BunRuntime/existingFiber"),
+  () =>
+    MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(
+      undefined,
+    ),
+)
+
+export const runMain = PlatformRuntime.makeRunMain(({
   fiber,
   teardown,
 }) => {
-  const keepAlive = setInterval(constVoid, 2 ** 31 - 1)
+  const prevFiber = MutableRef.get(mainFiber)
+
+  MutableRef.set(mainFiber, fiber)
+
   let receivedSignal = false
 
   fiber.addObserver((exit) => {
@@ -13,7 +26,6 @@ export const runMain = makeRunMain(({
       process.removeListener("SIGINT", onSigint)
       process.removeListener("SIGTERM", onSigint)
     }
-    clearInterval(keepAlive)
     teardown(exit, (code) => {
       if (receivedSignal || code !== 0) {
         process.exit(code)
@@ -30,4 +42,8 @@ export const runMain = makeRunMain(({
 
   process.on("SIGINT", onSigint)
   process.on("SIGTERM", onSigint)
+
+  if (prevFiber) {
+    prevFiber.unsafeInterruptAsFork(prevFiber.id())
+  }
 })