effect-start 0.23.0 → 0.23.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.23.0",
+  "version": "0.23.1",
   "license": "MIT",
   "files": [
     "src/",

package/src/Start.ts

@@ -1,14 +1,15 @@
 import type * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
 import type * as ChildProcess from "./ChildProcess.ts"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
 import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.ts"
+import * as StartApp from "./StartApp.ts"
 
 export function layer<
   Layers extends [Layer.Layer<never, any, any>, ...Array<Layer.Layer<never, any, any>>],
@@ -66,12 +67,25 @@ export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<La
 export function serve<
   ROut,
   E,
-  RIn extends BunServer.BunServer | FileSystem.FileSystem | ChildProcess.ChildProcessSpawner,
+  RIn extends
+    | BunServer.BunServer
+    | FileSystem.FileSystem
+    | ChildProcess.ChildProcessSpawner
+    | StartApp.StartApp,
 >(
   load: () => Promise<{
     default: Layer.Layer<ROut, E, RIn>
   }>,
 ) {
+  const startAppLayer = Layer.effect(
+    StartApp.StartApp,
+    Deferred.make<BunServer.BunServer>().pipe(
+      Effect.map((server) => ({
+        server,
+      })),
+    ),
+  )
+
   const appLayer = Function.pipe(
     Effect.tryPromise(load),
     Effect.map((v) => v.default),
@@ -79,24 +93,15 @@ export function serve<
     Layer.unwrapEffect,
   )
 
-  const serverLayer = Layer.scoped(
-    BunServer.BunServer,
-    Effect.gen(function* () {
-      const existing = yield* Effect.serviceOption(BunServer.BunServer)
-      if (Option.isSome(existing)) return existing.value
-      return yield* BunServer.make({})
-    }),
-  )
-
   const appLayerResolved = Function.pipe(
     appLayer,
-    Layer.provide(serverLayer),
     Layer.provide(NodeFileSystem.layer),
     Layer.provide(BunChildProcessSpawner.layer),
+    Layer.provideMerge(startAppLayer),
   )
 
   const composed = Function.pipe(
-    serverLayer,
+    BunServer.layerStart(),
     BunServer.withLogAddress,
     Layer.provide(appLayerResolved),
   ) as Layer.Layer<BunServer.BunServer, never, never>

package/src/StartApp.ts

@@ -0,0 +1,11 @@
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import type * as BunServer from "./bun/BunServer.ts"
+
+export namespace StartApp {
+  export interface Service {
+    readonly server: Deferred.Deferred<BunServer.BunServer>
+  }
+}
+
+export class StartApp extends Context.Tag("effect-start/StartApp")<StartApp, StartApp.Service>() {}

package/src/bun/BunServer.ts

@@ -15,6 +15,7 @@ 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 StartApp from "../StartApp.ts"
 import type * as RouteMount from "../RouteMount.ts"
 import * as RouteTree from "../RouteTree.ts"
 import * as BunRoute from "./BunRoute.ts"
@@ -52,12 +53,11 @@ export type BunServer = {
 
 export const BunServer = Context.GenericTag<BunServer>("effect-start/BunServer")
 
-export const make = (options: BunServeOptions): Effect.Effect<BunServer, never, Scope.Scope> =>
+export const make = (
+  options: BunServeOptions,
+  tree?: RouteTree.RouteTree,
+): 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()
@@ -98,7 +98,7 @@ export const make = (options: BunServeOptions): Effect.Effect<BunServer, never,
       Effect.andThen(Runtime.provideService(BunServer, service)),
     )
 
-    let currentRoutes: BunRoute.BunRoutes = routes ? yield* walkBunRoutes(runtime, routes) : {}
+    let currentRoutes: BunRoute.BunRoutes = tree ? yield* walkBunRoutes(runtime, tree) : {}
 
     const websocket: Bun.WebSocketHandler<WebSocketContext> = {
       open(ws) {
@@ -170,6 +170,47 @@ export const make = (options: BunServeOptions): Effect.Effect<BunServer, never,
 export const layer = (options?: BunServeOptions): Layer.Layer<BunServer> =>
   Layer.scoped(BunServer, make(options ?? {}))
 
+export const layerRoutes = (
+  options?: BunServeOptions,
+): Layer.Layer<BunServer, never, Route.Routes> =>
+  Layer.scoped(
+    BunServer,
+    Effect.gen(function* () {
+      const routes = yield* Route.Routes
+      return yield* make(options ?? {}, routes)
+    }),
+  )
+
+/**
+ * Resolves the Bun server in one place for Start.serve so routes are available:
+ * 1) Reuse a user-provided BunServer when one already exists in context.
+ * 2) Otherwise create the server from Route.Routes when routes are available.
+ * 3) Otherwise create a fallback server with the default 404 handler.
+ */
+export const layerStart = (
+  options?: BunServeOptions,
+): Layer.Layer<BunServer, never, StartApp.StartApp> =>
+  Layer.scoped(
+    BunServer,
+    Effect.gen(function* () {
+      const app = yield* StartApp.StartApp
+      const existing = yield* Effect.serviceOption(BunServer)
+      if (Option.isSome(existing)) {
+        yield* Deferred.succeed(app.server, existing.value)
+        return existing.value
+      }
+      const routes = yield* Effect.serviceOption(Route.Routes)
+      if (Option.isSome(routes)) {
+        const server = yield* make(options ?? {}, routes.value)
+        yield* Deferred.succeed(app.server, server)
+        return server
+      }
+      const server = yield* make(options ?? {})
+      yield* Deferred.succeed(app.server, server)
+      return server
+    }),
+  )
+
 export const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>) =>
   Layer.effectDiscard(
     BunServer.pipe(

package/src/x/tailscale/TailscaleTunnel.ts

@@ -1,6 +1,7 @@
-import * as BunServer from "../../bun/BunServer.ts"
 import * as PlatformError from "../../PlatformError.ts"
+import * as StartApp from "../../StartApp.ts"
 import * as System from "../../System.ts"
+import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as LogLevel from "effect/LogLevel"
@@ -86,12 +87,13 @@ export const start = (opts: {
 export const layer = (opts?: { public?: boolean }) =>
   Layer.scopedDiscard(
     Effect.gen(function* () {
-      const { server } = yield* BunServer.BunServer
-      const port = server.port!
-      const command = "tailscale"
-
       yield* Effect.forkScoped(
         Effect.gen(function* () {
+          const app = yield* StartApp.StartApp
+          const { server } = yield* Deferred.await(app.server)
+          const port = server.port!
+          const command = "tailscale"
+
           yield* System.which(command)
           const status = yield* getStatus(command)
           const dnsName = status.Self?.DNSName?.replace(/\.$/, "")