effect-start 0.19.0 → 0.20.0

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 Unique from "../Unique.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"
 
@@ -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 unsupported = Array.findFirst(segments, (seg) => {
-    if (seg._tag === "ParamSegment") {
-      return seg.prefix !== undefined || seg.suffix !== undefined
-    }
+  const segs = FilePathPattern.segments(pattern)
 
-    return false
-  })
+  const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment")
 
-  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())
+  }
 })

package/src/bun/BunServer.ts

@@ -0,0 +1,228 @@
+import * as Socket from "@effect/platform/Socket"
+import * as Bun from "bun"
+import * as Config from "effect/Config"
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+import type * as Scope from "effect/Scope"
+import * as PathPattern from "../PathPattern.ts"
+import * as PlataformRuntime from "../PlatformRuntime.ts"
+import * as Route from "../Route.ts"
+import * as RouteHttp from "../RouteHttp.ts"
+import * as RouteMount from "../RouteMount.ts"
+import * as RouteTree from "../RouteTree.ts"
+import * as BunRoute from "./BunRoute.ts"
+import * as BunServerRequest from "./BunServerRequest.ts"
+
+type FetchHandler = (
+  request: Request,
+  server: Bun.Server<BunServerRequest.WebSocketContext>,
+) => Response | Promise<Response>
+
+/**
+ * Basically `Omit<Bun.Serve.Options, "fetch" | "error" | "websocket">`
+ * TypeScript 5.9 cannot verify discriminated union types used in
+ * {@link Bun.serve} so we need to define them explicitly.
+ */
+interface BunServeOptions {
+  readonly port?: number
+  readonly hostname?: string
+  readonly reusePort?: boolean
+  readonly ipv6Only?: boolean
+  readonly idleTimeout?: number
+  readonly development?: boolean
+}
+
+export type BunServer = {
+  readonly server: Bun.Server<BunServerRequest.WebSocketContext>
+  readonly pushHandler: (fetch: FetchHandler) => void
+  readonly popHandler: () => void
+}
+
+export const BunServer = Context.GenericTag<BunServer>(
+  "effect-start/BunServer",
+)
+
+export const make = (
+  options: BunServeOptions,
+): Effect.Effect<
+  BunServer,
+  never,
+  Scope.Scope
+> =>
+  Effect.gen(function*() {
+    const routes = yield* Effect.serviceOption(Route.Routes).pipe(
+      Effect.andThen(Option.getOrUndefined),
+    )
+
+    const port = yield* Config.number("PORT").pipe(
+      Effect.catchTag("ConfigError", () => {
+        return PlataformRuntime.isAgentHarness()
+          ? Effect.succeed(0) // random port
+          : Effect.succeed(3000)
+      }),
+    )
+    const hostname = yield* Config.string("HOSTNAME").pipe(
+      Effect.catchTag("ConfigError", () => Effect.succeed(undefined)),
+    )
+
+    const handlerStack: Array<FetchHandler> = [
+      function(_request, _server) {
+        return new Response("not found", { status: 404 })
+      },
+    ]
+
+    const service = BunServer.of({
+      // During the construction we need to create a service imlpementation
+      // first so we can provide it in the runtime that will be used in web
+      // handlers. After we create the runtime, we set it below so it's always
+      // available at runtime.
+      // An alternative approach would be to use Bun.Server.reload but I prefer
+      // to avoid it since it's badly documented and has bunch of bugs.
+      server: undefined as any,
+      pushHandler(fetch) {
+        handlerStack.push(fetch)
+        reload()
+      },
+      popHandler() {
+        handlerStack.pop()
+        reload()
+      },
+    })
+
+    const runtime = yield* Effect.runtime().pipe(
+      Effect.andThen(Runtime.provideService(BunServer, service)),
+    )
+
+    let currentRoutes: BunRoute.BunRoutes = routes
+      ? yield* walkBunRoutes(runtime, routes)
+      : {}
+
+    const websocket: Bun.WebSocketHandler<BunServerRequest.WebSocketContext> = {
+      open(ws) {
+        Deferred.unsafeDone(ws.data.deferred, Exit.succeed(ws))
+      },
+      message(ws, message) {
+        ws.data.run(message)
+      },
+      close(ws, code, closeReason) {
+        Deferred.unsafeDone(
+          ws.data.closeDeferred,
+          Socket.defaultCloseCodeIsError(code)
+            ? Exit.fail(
+              new Socket.SocketCloseError({
+                reason: "Close",
+                code,
+                closeReason,
+              }),
+            )
+            : Exit.void,
+        )
+      },
+    }
+
+    const server = Bun.serve({
+      port,
+      hostname,
+      ...options,
+      routes: currentRoutes,
+      fetch: handlerStack[0],
+      websocket,
+    })
+
+    // @ts-expect-error
+    service.server = server
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        server.stop()
+      })
+    )
+
+    const reload = () => {
+      server.reload({
+        fetch: handlerStack[handlerStack.length - 1],
+        routes: currentRoutes,
+        websocket,
+      })
+    }
+
+    const bunServer = BunServer.of({
+      server,
+      pushHandler(fetch) {
+        handlerStack.push(fetch)
+        reload()
+      },
+      popHandler() {
+        handlerStack.pop()
+        reload()
+      },
+    })
+
+    return bunServer
+  })
+
+/**
+ * Provides HttpServer using BunServer under the hood.
+ */
+export const layer = (
+  options?: BunServeOptions,
+): Layer.Layer<BunServer> =>
+  Layer.scoped(
+    BunServer,
+    make(options ?? {}),
+  )
+
+export const withLogAddress = <A, E, R>(
+  layer: Layer.Layer<A, E, R>,
+) =>
+  Layer
+    .effectDiscard(
+      BunServer.pipe(
+        Effect.andThen(server =>
+          Effect.log(
+            `Listening on ${server.server.hostname}:${server.server.port}`,
+          )
+        ),
+      ),
+    )
+    .pipe(
+      Layer.provideMerge(layer),
+    )
+
+function walkBunRoutes(
+  runtime: Runtime.Runtime<BunServer>,
+  tree: RouteTree.RouteTree,
+) {
+  return Effect.gen(function*() {
+    const bunRoutes: BunRoute.BunRoutes = {}
+    const pathGroups = new Map<string, RouteMount.MountedRoute[]>()
+    const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
+
+    for (const route of RouteTree.walk(tree)) {
+      const bunDescriptors = BunRoute.descriptors(route)
+      if (bunDescriptors) {
+        const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
+        bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
+      }
+
+      const path = Route.descriptor(route).path
+      const group = pathGroups.get(path) ?? []
+      group.push(route)
+      pathGroups.set(path, group)
+    }
+
+    for (const [path, routes] of pathGroups) {
+      const handler = toWebHandler(routes)
+      for (const bunPath of PathPattern.toBun(path)) {
+        bunRoutes[bunPath] = handler
+      }
+    }
+
+    return bunRoutes
+  })
+}

package/src/bun/index.ts

@@ -1,4 +1,4 @@
 export * as BunBundle from "./BunBundle.ts"
-export * as BunHttpServer from "./BunHttpServer.ts"
 export * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
 export * as BunRoute from "./BunRoute.ts"
+export * as BunServer from "./BunServer.ts"

package/src/datastar/README.md

@@ -0,0 +1,18 @@
+# Datastar
+
+This is a port of [Datastar](https://github.com/starfederation/datastar) of magnificent Star Federation.
+
+We experimentally place it inside Effect Start to have tighter integration with it and provide
+great out-of-the-box experience. After cleaning up the code, we're at around ~90kb of source code.
+We can probably cut it down by another ~10kb if we remove DataStar expression and use JS functions directly.
+
+Based on `812cbe9` (2025-02-05) following changes were made:
+
+- Path aliases converted to relative imports: `@engine/*` → `./engine/*`, etc.
+- Flattened `plugins/` directory: `plugins/actions/` → `actions/`, etc.
+- Deleted the `ALIAS` type declaration: removed `globals.d.ts`,
+  no alias conditional in `utils/text.ts` & `applyAttributePlugin` in `engine.ts`.
+- Removed plugin header comments.
+- Updated type declaration to conform to `erasableSyntaxOnly`:
+  - Converted `enum ReactiveFlags` and `enum EffectFlags` to `const` objects with `as const`
+  - Added type aliases `ReactiveFlags_X` to replace `ReactiveFlags.X` namespace types